Functions to quote and unquote pathnames in C-style.
[git] / quote.c
1 #include "cache.h"
2 #include "quote.h"
3
4 /* Help to copy the thing properly quoted for the shell safety.
5  * any single quote is replaced with '\'', and the caller is
6  * expected to enclose the result within a single quote pair.
7  *
8  * E.g.
9  *  original     sq_quote     result
10  *  name     ==> name      ==> 'name'
11  *  a b      ==> a b       ==> 'a b'
12  *  a'b      ==> a'\''b    ==> 'a'\''b'
13  */
14 char *sq_quote(const char *src)
15 {
16         static char *buf = NULL;
17         int cnt, c;
18         const char *cp;
19         char *bp;
20
21         /* count bytes needed to store the quoted string. */
22         for (cnt = 3, cp = src; *cp; cnt++, cp++)
23                 if (*cp == '\'')
24                         cnt += 3;
25
26         buf = xmalloc(cnt);
27         bp = buf;
28         *bp++ = '\'';
29         while ((c = *src++)) {
30                 if (c != '\'')
31                         *bp++ = c;
32                 else {
33                         bp = strcpy(bp, "'\\''");
34                         bp += 4;
35                 }
36         }
37         *bp++ = '\'';
38         *bp = 0;
39         return buf;
40 }
41
42 /*
43  * C-style name quoting.
44  *
45  * Does one of three things:
46  *
47  * (1) if outbuf and outfp are both NULL, inspect the input name and
48  *     counts the number of bytes that are needed to hold c_style
49  *     quoted version of name, counting the double quotes around
50  *     it but not terminating NUL, and returns it.  However, if name
51  *     does not need c_style quoting, it returns 0.
52  *
53  * (2) if outbuf is not NULL, it must point at a buffer large enough
54  *     to hold the c_style quoted version of name, enclosing double
55  *     quotes, and terminating NUL.  Fills outbuf with c_style quoted
56  *     version of name enclosed in double-quote pair.  Return value
57  *     is undefined.
58  *
59  * (3) if outfp is not NULL, outputs c_style quoted version of name,
60  *     but not enclosed in double-quote pair.  Return value is undefined.
61  */
62
63 int quote_c_style(const char *name, char *outbuf, FILE *outfp, int no_dq)
64 {
65 #undef EMIT
66 #define EMIT(c) \
67         (outbuf ? (*outbuf++ = (c)) : outfp ? fputc(c, outfp) : (count++))
68
69 #define EMITQ() EMIT('\\')
70
71         const char *sp;
72         int ch, count = 0, needquote = 0;
73
74         if (!no_dq)
75                 EMIT('"');
76         for (sp = name; (ch = *sp++); ) {
77
78                 if ((ch <= ' ') || (ch == '"') ||
79                     (ch == '\\') || (ch == 0177)) {
80                         needquote = 1;
81                         switch (ch) {
82                         case '\a': EMITQ(); ch = 'a'; break;
83                         case '\b': EMITQ(); ch = 'b'; break;
84                         case '\f': EMITQ(); ch = 'f'; break;
85                         case '\n': EMITQ(); ch = 'n'; break;
86                         case '\r': EMITQ(); ch = 'r'; break;
87                         case '\t': EMITQ(); ch = 't'; break;
88                         case '\v': EMITQ(); ch = 'v'; break;
89
90                         case '\\': /* fallthru */
91                         case '"': EMITQ(); break;
92                         case ' ':
93                                 break;
94                         default:
95                                 /* octal */
96                                 EMITQ();
97                                 EMIT(((ch >> 6) & 03) + '0');
98                                 EMIT(((ch >> 3) & 07) + '0');
99                                 ch = (ch & 07) + '0';
100                                 break;
101                         }
102                 }
103                 EMIT(ch);
104         }
105         if (!no_dq)
106                 EMIT('"');
107         if (outbuf)
108                 *outbuf = 0;
109
110         return needquote ? count : 0;
111 }
112
113 /*
114  * C-style name unquoting.
115  *
116  * Quoted should point at the opening double quote.  Returns
117  * an allocated memory that holds unquoted name, which the caller
118  * should free when done.  Updates endp pointer to point at
119  * one past the ending double quote if given.
120  */
121
122 char *unquote_c_style(const char *quoted, const char **endp)
123 {
124         const char *sp;
125         char *name = NULL, *outp = NULL;
126         int count = 0, ch, ac;
127
128 #undef EMIT
129 #define EMIT(c) (outp ? (*outp++ = (c)) : (count++))
130
131         if (*quoted++ != '"')
132                 return NULL;
133
134         while (1) {
135                 /* first pass counts and allocates, second pass fills */
136                 for (sp = quoted; (ch = *sp++) != '"'; ) {
137                         if (ch == '\\') {
138                                 switch (ch = *sp++) {
139                                 case 'a': ch = '\a'; break;
140                                 case 'b': ch = '\b'; break;
141                                 case 'f': ch = '\f'; break;
142                                 case 'n': ch = '\n'; break;
143                                 case 'r': ch = '\r'; break;
144                                 case 't': ch = '\t'; break;
145                                 case 'v': ch = '\v'; break;
146
147                                 case '\\': case '"':
148                                         break; /* verbatim */
149
150                                 case '0'...'7':
151                                         /* octal */
152                                         ac = ((ch - '0') << 6);
153                                         if ((ch = *sp++) < '0' || '7' < ch)
154                                                 return NULL;
155                                         ac |= ((ch - '0') << 3);
156                                         if ((ch = *sp++) < '0' || '7' < ch)
157                                                 return NULL;
158                                         ac |= (ch - '0');
159                                         ch = ac;
160                                         break;
161                                 default:
162                                         return NULL; /* malformed */
163                                 }
164                         }
165                         EMIT(ch);
166                 }
167
168                 if (name) {
169                         *outp = 0;
170                         if (endp)
171                                 *endp = sp;
172                         return name;
173                 }
174                 outp = name = xmalloc(count + 1);
175         }
176 }
177
178 void write_name_quoted(const char *prefix, const char *name,
179                        int quote, FILE *out)
180 {
181         int needquote;
182
183         if (!quote) {
184         no_quote:
185                 if (prefix && prefix[0])
186                         fputs(prefix, out);
187                 fputs(name, out);
188                 return;
189         }
190
191         needquote = 0;
192         if (prefix && prefix[0])
193                 needquote = quote_c_style(prefix, NULL, NULL, 0);
194         if (!needquote)
195                 needquote = quote_c_style(name, NULL, NULL, 0);
196         if (needquote) {
197                 fputc('"', out);
198                 if (prefix && prefix[0])
199                         quote_c_style(prefix, NULL, out, 1);
200                 quote_c_style(name, NULL, out, 1);
201                 fputc('"', out);
202         }
203         else
204                 goto no_quote;
205 }