3 #include "argv-array.h"
5 int quote_path_fully = 1;
7 static inline int need_bs_quote(char c)
9 return (c == '\'' || c == '!');
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
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'
24 void sq_quote_buf(struct strbuf *dst, const char *src)
29 to_free = strbuf_detach(dst, NULL);
31 strbuf_addch(dst, '\'');
33 size_t len = strcspn(src, "'!");
34 strbuf_add(dst, src, len);
36 while (need_bs_quote(*src)) {
37 strbuf_addstr(dst, "'\\");
38 strbuf_addch(dst, *src++);
39 strbuf_addch(dst, '\'');
42 strbuf_addch(dst, '\'');
46 void sq_quote_argv(struct strbuf *dst, const char** argv, size_t maxlen)
50 /* Copy into destination buffer. */
51 strbuf_grow(dst, 255);
52 for (i = 0; argv[i]; ++i) {
53 strbuf_addch(dst, ' ');
54 sq_quote_buf(dst, argv[i]);
55 if (maxlen && dst->len > maxlen)
56 die("Too many or long arguments");
60 static char *sq_dequote_step(char *arg, char **next)
76 /* We stepped out of sq */
85 if (need_bs_quote(c) && *++src == '\'') {
91 if (!next || !isspace(*src))
103 char *sq_dequote(char *arg)
105 return sq_dequote_step(arg, NULL);
108 static int sq_dequote_to_argv_internal(char *arg,
109 const char ***argv, int *nr, int *alloc,
110 struct argv_array *array)
117 char *dequoted = sq_dequote_step(next, &next);
121 ALLOC_GROW(*argv, *nr + 1, *alloc);
122 (*argv)[(*nr)++] = dequoted;
125 argv_array_push(array, dequoted);
131 int sq_dequote_to_argv(char *arg, const char ***argv, int *nr, int *alloc)
133 return sq_dequote_to_argv_internal(arg, argv, nr, alloc, NULL);
136 int sq_dequote_to_argv_array(char *arg, struct argv_array *array)
138 return sq_dequote_to_argv_internal(arg, NULL, NULL, NULL, array);
141 /* 1 means: quote as octal
142 * 0 means: quote as octal if (quote_path_fully)
143 * -1 means: never quote
146 #define X8(x) x, x, x, x, x, x, x, x
147 #define X16(x) X8(x), X8(x)
148 static signed char const sq_lookup[256] = {
149 /* 0 1 2 3 4 5 6 7 */
150 /* 0x00 */ 1, 1, 1, 1, 1, 1, 1, 'a',
151 /* 0x08 */ 'b', 't', 'n', 'v', 'f', 'r', 1, 1,
153 /* 0x20 */ -1, -1, '"', -1, -1, -1, -1, -1,
154 /* 0x28 */ X16(-1), X16(-1), X16(-1),
155 /* 0x58 */ -1, -1, -1, -1,'\\', -1, -1, -1,
156 /* 0x60 */ X16(-1), X8(-1),
157 /* 0x78 */ -1, -1, -1, -1, -1, -1, -1, 1,
158 /* 0x80 */ /* set to 0 */
161 static inline int sq_must_quote(char c)
163 return sq_lookup[(unsigned char)c] + quote_path_fully > 0;
166 /* returns the longest prefix not needing a quote up to maxlen if positive.
167 This stops at the first \0 because it's marked as a character needing an
169 static size_t next_quote_pos(const char *s, ssize_t maxlen)
173 for (len = 0; !sq_must_quote(s[len]); len++);
175 for (len = 0; len < maxlen && !sq_must_quote(s[len]); len++);
181 * C-style name quoting.
183 * (1) if sb and fp are both NULL, inspect the input name and counts the
184 * number of bytes that are needed to hold c_style quoted version of name,
185 * counting the double quotes around it but not terminating NUL, and
187 * However, if name does not need c_style quoting, it returns 0.
189 * (2) if sb or fp are not NULL, it emits the c_style quoted version
190 * of name, enclosed with double quotes if asked and needed only.
191 * Return value is the same as in (1).
193 static size_t quote_c_style_counted(const char *name, ssize_t maxlen,
194 struct strbuf *sb, FILE *fp, int no_dq)
199 if (sb) strbuf_addch(sb, (c)); \
200 if (fp) fputc((c), fp); \
203 #define EMITBUF(s, l) \
205 if (sb) strbuf_add(sb, (s), (l)); \
206 if (fp) fwrite((s), (l), 1, fp); \
210 size_t len, count = 0;
211 const char *p = name;
216 len = next_quote_pos(p, maxlen);
217 if (len == maxlen || (maxlen < 0 && !p[len]))
220 if (!no_dq && p == name)
226 ch = (unsigned char)*p++;
229 if (sq_lookup[ch] >= ' ') {
232 EMIT(((ch >> 6) & 03) + '0');
233 EMIT(((ch >> 3) & 07) + '0');
234 EMIT(((ch >> 0) & 07) + '0');
239 if (p == name) /* no ending quote needed */
247 size_t quote_c_style(const char *name, struct strbuf *sb, FILE *fp, int nodq)
249 return quote_c_style_counted(name, -1, sb, fp, nodq);
252 void quote_two_c_style(struct strbuf *sb, const char *prefix, const char *path, int nodq)
254 if (quote_c_style(prefix, NULL, NULL, 0) ||
255 quote_c_style(path, NULL, NULL, 0)) {
257 strbuf_addch(sb, '"');
258 quote_c_style(prefix, sb, NULL, 1);
259 quote_c_style(path, sb, NULL, 1);
261 strbuf_addch(sb, '"');
263 strbuf_addstr(sb, prefix);
264 strbuf_addstr(sb, path);
268 void write_name_quoted(const char *name, FILE *fp, int terminator)
271 quote_c_style(name, NULL, fp, 0);
275 fputc(terminator, fp);
278 void write_name_quoted_relative(const char *name, const char *prefix,
279 FILE *fp, int terminator)
281 struct strbuf sb = STRBUF_INIT;
283 name = relative_path(name, prefix, &sb);
284 write_name_quoted(name, fp, terminator);
289 /* quote path as relative to the given prefix */
290 char *quote_path_relative(const char *in, const char *prefix,
293 struct strbuf sb = STRBUF_INIT;
294 const char *rel = relative_path(in, prefix, &sb);
296 quote_c_style_counted(rel, strlen(rel), out, NULL, 0);
303 * C-style name unquoting.
305 * Quoted should point at the opening double quote.
306 * + Returns 0 if it was able to unquote the string properly, and appends the
307 * result in the strbuf `sb'.
308 * + Returns -1 in case of error, and doesn't touch the strbuf. Though note
309 * that this function will allocate memory in the strbuf, so calling
310 * strbuf_release is mandatory whichever result unquote_c_style returns.
312 * Updates endp pointer to point at one past the ending double quote if given.
314 int unquote_c_style(struct strbuf *sb, const char *quoted, const char **endp)
316 size_t oldlen = sb->len, len;
319 if (*quoted++ != '"')
323 len = strcspn(quoted, "\"\\");
324 strbuf_add(sb, quoted, len);
338 switch ((ch = *quoted++)) {
339 case 'a': ch = '\a'; break;
340 case 'b': ch = '\b'; break;
341 case 'f': ch = '\f'; break;
342 case 'n': ch = '\n'; break;
343 case 'r': ch = '\r'; break;
344 case 't': ch = '\t'; break;
345 case 'v': ch = '\v'; break;
348 break; /* verbatim */
350 /* octal values with first digit over 4 overflow */
351 case '0': case '1': case '2': case '3':
352 ac = ((ch - '0') << 6);
353 if ((ch = *quoted++) < '0' || '7' < ch)
355 ac |= ((ch - '0') << 3);
356 if ((ch = *quoted++) < '0' || '7' < ch)
364 strbuf_addch(sb, ch);
368 strbuf_setlen(sb, oldlen);
372 /* quoting as a string literal for other languages */
374 void perl_quote_buf(struct strbuf *sb, const char *src)
376 const char sq = '\'';
377 const char bq = '\\';
380 strbuf_addch(sb, sq);
381 while ((c = *src++)) {
382 if (c == sq || c == bq)
383 strbuf_addch(sb, bq);
386 strbuf_addch(sb, sq);
389 void python_quote_buf(struct strbuf *sb, const char *src)
391 const char sq = '\'';
392 const char bq = '\\';
393 const char nl = '\n';
396 strbuf_addch(sb, sq);
397 while ((c = *src++)) {
399 strbuf_addch(sb, bq);
400 strbuf_addch(sb, 'n');
403 if (c == sq || c == bq)
404 strbuf_addch(sb, bq);
407 strbuf_addch(sb, sq);
410 void tcl_quote_buf(struct strbuf *sb, const char *src)
414 strbuf_addch(sb, '"');
415 while ((c = *src++)) {
419 case '$': case '\\': case '"':
420 strbuf_addch(sb, '\\');
425 strbuf_addstr(sb, "\\f");
428 strbuf_addstr(sb, "\\r");
431 strbuf_addstr(sb, "\\n");
434 strbuf_addstr(sb, "\\t");
437 strbuf_addstr(sb, "\\v");
441 strbuf_addch(sb, '"');