sq_quote_argv: drop maxlen parameter
[git/git.git] / quote.c
1 #include "cache.h"
2 #include "quote.h"
3 #include "argv-array.h"
4
5 int quote_path_fully = 1;
6
7 static inline int need_bs_quote(char c)
8 {
9 return (c == '\'' || c == '!');
10 }
11
12 /* Help to copy the thing properly quoted for the shell safety.
13 * any single quote is replaced with '\'', any exclamation point
14 * is replaced with '\!', and the whole thing is enclosed in a
15 * single quote pair.
16 *
17 * E.g.
18 * original sq_quote result
19 * name ==> name ==> 'name'
20 * a b ==> a b ==> 'a b'
21 * a'b ==> a'\''b ==> 'a'\''b'
22 * a!b ==> a'\!'b ==> 'a'\!'b'
23 */
24 void sq_quote_buf(struct strbuf *dst, const char *src)
25 {
26 char *to_free = NULL;
27
28 if (dst->buf == src)
29 to_free = strbuf_detach(dst, NULL);
30
31 strbuf_addch(dst, '\'');
32 while (*src) {
33 size_t len = strcspn(src, "'!");
34 strbuf_add(dst, src, len);
35 src += len;
36 while (need_bs_quote(*src)) {
37 strbuf_addstr(dst, "'\\");
38 strbuf_addch(dst, *src++);
39 strbuf_addch(dst, '\'');
40 }
41 }
42 strbuf_addch(dst, '\'');
43 free(to_free);
44 }
45
46 void sq_quotef(struct strbuf *dst, const char *fmt, ...)
47 {
48 struct strbuf src = STRBUF_INIT;
49
50 va_list ap;
51 va_start(ap, fmt);
52 strbuf_vaddf(&src, fmt, ap);
53 va_end(ap);
54
55 sq_quote_buf(dst, src.buf);
56 strbuf_release(&src);
57 }
58
59 void sq_quote_argv(struct strbuf *dst, const char **argv)
60 {
61 int i;
62
63 /* Copy into destination buffer. */
64 strbuf_grow(dst, 255);
65 for (i = 0; argv[i]; ++i) {
66 strbuf_addch(dst, ' ');
67 sq_quote_buf(dst, argv[i]);
68 }
69 }
70
71 static char *sq_dequote_step(char *arg, char **next)
72 {
73 char *dst = arg;
74 char *src = arg;
75 char c;
76
77 if (*src != '\'')
78 return NULL;
79 for (;;) {
80 c = *++src;
81 if (!c)
82 return NULL;
83 if (c != '\'') {
84 *dst++ = c;
85 continue;
86 }
87 /* We stepped out of sq */
88 switch (*++src) {
89 case '\0':
90 *dst = 0;
91 if (next)
92 *next = NULL;
93 return arg;
94 case '\\':
95 c = *++src;
96 if (need_bs_quote(c) && *++src == '\'') {
97 *dst++ = c;
98 continue;
99 }
100 /* Fallthrough */
101 default:
102 if (!next || !isspace(*src))
103 return NULL;
104 do {
105 c = *++src;
106 } while (isspace(c));
107 *dst = 0;
108 *next = src;
109 return arg;
110 }
111 }
112 }
113
114 char *sq_dequote(char *arg)
115 {
116 return sq_dequote_step(arg, NULL);
117 }
118
119 static int sq_dequote_to_argv_internal(char *arg,
120 const char ***argv, int *nr, int *alloc,
121 struct argv_array *array)
122 {
123 char *next = arg;
124
125 if (!*arg)
126 return 0;
127 do {
128 char *dequoted = sq_dequote_step(next, &next);
129 if (!dequoted)
130 return -1;
131 if (argv) {
132 ALLOC_GROW(*argv, *nr + 1, *alloc);
133 (*argv)[(*nr)++] = dequoted;
134 }
135 if (array)
136 argv_array_push(array, dequoted);
137 } while (next);
138
139 return 0;
140 }
141
142 int sq_dequote_to_argv(char *arg, const char ***argv, int *nr, int *alloc)
143 {
144 return sq_dequote_to_argv_internal(arg, argv, nr, alloc, NULL);
145 }
146
147 int sq_dequote_to_argv_array(char *arg, struct argv_array *array)
148 {
149 return sq_dequote_to_argv_internal(arg, NULL, NULL, NULL, array);
150 }
151
152 /* 1 means: quote as octal
153 * 0 means: quote as octal if (quote_path_fully)
154 * -1 means: never quote
155 * c: quote as "\\c"
156 */
157 #define X8(x) x, x, x, x, x, x, x, x
158 #define X16(x) X8(x), X8(x)
159 static signed char const sq_lookup[256] = {
160 /* 0 1 2 3 4 5 6 7 */
161 /* 0x00 */ 1, 1, 1, 1, 1, 1, 1, 'a',
162 /* 0x08 */ 'b', 't', 'n', 'v', 'f', 'r', 1, 1,
163 /* 0x10 */ X16(1),
164 /* 0x20 */ -1, -1, '"', -1, -1, -1, -1, -1,
165 /* 0x28 */ X16(-1), X16(-1), X16(-1),
166 /* 0x58 */ -1, -1, -1, -1,'\\', -1, -1, -1,
167 /* 0x60 */ X16(-1), X8(-1),
168 /* 0x78 */ -1, -1, -1, -1, -1, -1, -1, 1,
169 /* 0x80 */ /* set to 0 */
170 };
171
172 static inline int sq_must_quote(char c)
173 {
174 return sq_lookup[(unsigned char)c] + quote_path_fully > 0;
175 }
176
177 /* returns the longest prefix not needing a quote up to maxlen if positive.
178 This stops at the first \0 because it's marked as a character needing an
179 escape */
180 static size_t next_quote_pos(const char *s, ssize_t maxlen)
181 {
182 size_t len;
183 if (maxlen < 0) {
184 for (len = 0; !sq_must_quote(s[len]); len++);
185 } else {
186 for (len = 0; len < maxlen && !sq_must_quote(s[len]); len++);
187 }
188 return len;
189 }
190
191 /*
192 * C-style name quoting.
193 *
194 * (1) if sb and fp are both NULL, inspect the input name and counts the
195 * number of bytes that are needed to hold c_style quoted version of name,
196 * counting the double quotes around it but not terminating NUL, and
197 * returns it.
198 * However, if name does not need c_style quoting, it returns 0.
199 *
200 * (2) if sb or fp are not NULL, it emits the c_style quoted version
201 * of name, enclosed with double quotes if asked and needed only.
202 * Return value is the same as in (1).
203 */
204 static size_t quote_c_style_counted(const char *name, ssize_t maxlen,
205 struct strbuf *sb, FILE *fp, int no_dq)
206 {
207 #undef EMIT
208 #define EMIT(c) \
209 do { \
210 if (sb) strbuf_addch(sb, (c)); \
211 if (fp) fputc((c), fp); \
212 count++; \
213 } while (0)
214 #define EMITBUF(s, l) \
215 do { \
216 if (sb) strbuf_add(sb, (s), (l)); \
217 if (fp) fwrite((s), (l), 1, fp); \
218 count += (l); \
219 } while (0)
220
221 size_t len, count = 0;
222 const char *p = name;
223
224 for (;;) {
225 int ch;
226
227 len = next_quote_pos(p, maxlen);
228 if (len == maxlen || (maxlen < 0 && !p[len]))
229 break;
230
231 if (!no_dq && p == name)
232 EMIT('"');
233
234 EMITBUF(p, len);
235 EMIT('\\');
236 p += len;
237 ch = (unsigned char)*p++;
238 if (maxlen >= 0)
239 maxlen -= len + 1;
240 if (sq_lookup[ch] >= ' ') {
241 EMIT(sq_lookup[ch]);
242 } else {
243 EMIT(((ch >> 6) & 03) + '0');
244 EMIT(((ch >> 3) & 07) + '0');
245 EMIT(((ch >> 0) & 07) + '0');
246 }
247 }
248
249 EMITBUF(p, len);
250 if (p == name) /* no ending quote needed */
251 return 0;
252
253 if (!no_dq)
254 EMIT('"');
255 return count;
256 }
257
258 size_t quote_c_style(const char *name, struct strbuf *sb, FILE *fp, int nodq)
259 {
260 return quote_c_style_counted(name, -1, sb, fp, nodq);
261 }
262
263 void quote_two_c_style(struct strbuf *sb, const char *prefix, const char *path, int nodq)
264 {
265 if (quote_c_style(prefix, NULL, NULL, 0) ||
266 quote_c_style(path, NULL, NULL, 0)) {
267 if (!nodq)
268 strbuf_addch(sb, '"');
269 quote_c_style(prefix, sb, NULL, 1);
270 quote_c_style(path, sb, NULL, 1);
271 if (!nodq)
272 strbuf_addch(sb, '"');
273 } else {
274 strbuf_addstr(sb, prefix);
275 strbuf_addstr(sb, path);
276 }
277 }
278
279 void write_name_quoted(const char *name, FILE *fp, int terminator)
280 {
281 if (terminator) {
282 quote_c_style(name, NULL, fp, 0);
283 } else {
284 fputs(name, fp);
285 }
286 fputc(terminator, fp);
287 }
288
289 void write_name_quoted_relative(const char *name, const char *prefix,
290 FILE *fp, int terminator)
291 {
292 struct strbuf sb = STRBUF_INIT;
293
294 name = relative_path(name, prefix, &sb);
295 write_name_quoted(name, fp, terminator);
296
297 strbuf_release(&sb);
298 }
299
300 /* quote path as relative to the given prefix */
301 char *quote_path_relative(const char *in, const char *prefix,
302 struct strbuf *out)
303 {
304 struct strbuf sb = STRBUF_INIT;
305 const char *rel = relative_path(in, prefix, &sb);
306 strbuf_reset(out);
307 quote_c_style_counted(rel, strlen(rel), out, NULL, 0);
308 strbuf_release(&sb);
309
310 return out->buf;
311 }
312
313 /*
314 * C-style name unquoting.
315 *
316 * Quoted should point at the opening double quote.
317 * + Returns 0 if it was able to unquote the string properly, and appends the
318 * result in the strbuf `sb'.
319 * + Returns -1 in case of error, and doesn't touch the strbuf. Though note
320 * that this function will allocate memory in the strbuf, so calling
321 * strbuf_release is mandatory whichever result unquote_c_style returns.
322 *
323 * Updates endp pointer to point at one past the ending double quote if given.
324 */
325 int unquote_c_style(struct strbuf *sb, const char *quoted, const char **endp)
326 {
327 size_t oldlen = sb->len, len;
328 int ch, ac;
329
330 if (*quoted++ != '"')
331 return -1;
332
333 for (;;) {
334 len = strcspn(quoted, "\"\\");
335 strbuf_add(sb, quoted, len);
336 quoted += len;
337
338 switch (*quoted++) {
339 case '"':
340 if (endp)
341 *endp = quoted;
342 return 0;
343 case '\\':
344 break;
345 default:
346 goto error;
347 }
348
349 switch ((ch = *quoted++)) {
350 case 'a': ch = '\a'; break;
351 case 'b': ch = '\b'; break;
352 case 'f': ch = '\f'; break;
353 case 'n': ch = '\n'; break;
354 case 'r': ch = '\r'; break;
355 case 't': ch = '\t'; break;
356 case 'v': ch = '\v'; break;
357
358 case '\\': case '"':
359 break; /* verbatim */
360
361 /* octal values with first digit over 4 overflow */
362 case '0': case '1': case '2': case '3':
363 ac = ((ch - '0') << 6);
364 if ((ch = *quoted++) < '0' || '7' < ch)
365 goto error;
366 ac |= ((ch - '0') << 3);
367 if ((ch = *quoted++) < '0' || '7' < ch)
368 goto error;
369 ac |= (ch - '0');
370 ch = ac;
371 break;
372 default:
373 goto error;
374 }
375 strbuf_addch(sb, ch);
376 }
377
378 error:
379 strbuf_setlen(sb, oldlen);
380 return -1;
381 }
382
383 /* quoting as a string literal for other languages */
384
385 void perl_quote_buf(struct strbuf *sb, const char *src)
386 {
387 const char sq = '\'';
388 const char bq = '\\';
389 char c;
390
391 strbuf_addch(sb, sq);
392 while ((c = *src++)) {
393 if (c == sq || c == bq)
394 strbuf_addch(sb, bq);
395 strbuf_addch(sb, c);
396 }
397 strbuf_addch(sb, sq);
398 }
399
400 void python_quote_buf(struct strbuf *sb, const char *src)
401 {
402 const char sq = '\'';
403 const char bq = '\\';
404 const char nl = '\n';
405 char c;
406
407 strbuf_addch(sb, sq);
408 while ((c = *src++)) {
409 if (c == nl) {
410 strbuf_addch(sb, bq);
411 strbuf_addch(sb, 'n');
412 continue;
413 }
414 if (c == sq || c == bq)
415 strbuf_addch(sb, bq);
416 strbuf_addch(sb, c);
417 }
418 strbuf_addch(sb, sq);
419 }
420
421 void tcl_quote_buf(struct strbuf *sb, const char *src)
422 {
423 char c;
424
425 strbuf_addch(sb, '"');
426 while ((c = *src++)) {
427 switch (c) {
428 case '[': case ']':
429 case '{': case '}':
430 case '$': case '\\': case '"':
431 strbuf_addch(sb, '\\');
432 /* fallthrough */
433 default:
434 strbuf_addch(sb, c);
435 break;
436 case '\f':
437 strbuf_addstr(sb, "\\f");
438 break;
439 case '\r':
440 strbuf_addstr(sb, "\\r");
441 break;
442 case '\n':
443 strbuf_addstr(sb, "\\n");
444 break;
445 case '\t':
446 strbuf_addstr(sb, "\\t");
447 break;
448 case '\v':
449 strbuf_addstr(sb, "\\v");
450 break;
451 }
452 }
453 strbuf_addch(sb, '"');
454 }
455
456 void basic_regex_quote_buf(struct strbuf *sb, const char *src)
457 {
458 char c;
459
460 if (*src == '^') {
461 /* only beginning '^' is special and needs quoting */
462 strbuf_addch(sb, '\\');
463 strbuf_addch(sb, *src++);
464 }
465 if (*src == '*')
466 /* beginning '*' is not special, no quoting */
467 strbuf_addch(sb, *src++);
468
469 while ((c = *src++)) {
470 switch (c) {
471 case '[':
472 case '.':
473 case '\\':
474 case '*':
475 strbuf_addch(sb, '\\');
476 strbuf_addch(sb, c);
477 break;
478
479 case '$':
480 /* only the end '$' is special and needs quoting */
481 if (*src == '\0')
482 strbuf_addch(sb, '\\');
483 strbuf_addch(sb, c);
484 break;
485
486 default:
487 strbuf_addch(sb, c);
488 break;
489 }
490 }
491 }