]>
git.ipfire.org Git - thirdparty/git.git/blob - quote.c
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_quotef(struct strbuf
*dst
, const char *fmt
, ...)
48 struct strbuf src
= STRBUF_INIT
;
52 strbuf_vaddf(&src
, fmt
, ap
);
55 sq_quote_buf(dst
, src
.buf
);
59 void sq_quote_argv(struct strbuf
*dst
, const char** argv
, size_t maxlen
)
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 if (maxlen
&& dst
->len
> maxlen
)
69 die("Too many or long arguments");
73 static char *sq_dequote_step(char *arg
, char **next
)
89 /* We stepped out of sq */
98 * Allow backslashed characters outside of
99 * single-quotes only if they need escaping,
100 * and only if we resume the single-quoted part
103 if (need_bs_quote(src
[1]) && src
[2] == '\'') {
110 if (!next
|| !isspace(*src
))
114 } while (isspace(c
));
122 char *sq_dequote(char *arg
)
124 return sq_dequote_step(arg
, NULL
);
127 static int sq_dequote_to_argv_internal(char *arg
,
128 const char ***argv
, int *nr
, int *alloc
,
129 struct argv_array
*array
)
136 char *dequoted
= sq_dequote_step(next
, &next
);
140 ALLOC_GROW(*argv
, *nr
+ 1, *alloc
);
141 (*argv
)[(*nr
)++] = dequoted
;
144 argv_array_push(array
, dequoted
);
150 int sq_dequote_to_argv(char *arg
, const char ***argv
, int *nr
, int *alloc
)
152 return sq_dequote_to_argv_internal(arg
, argv
, nr
, alloc
, NULL
);
155 int sq_dequote_to_argv_array(char *arg
, struct argv_array
*array
)
157 return sq_dequote_to_argv_internal(arg
, NULL
, NULL
, NULL
, array
);
160 /* 1 means: quote as octal
161 * 0 means: quote as octal if (quote_path_fully)
162 * -1 means: never quote
165 #define X8(x) x, x, x, x, x, x, x, x
166 #define X16(x) X8(x), X8(x)
167 static signed char const sq_lookup
[256] = {
168 /* 0 1 2 3 4 5 6 7 */
169 /* 0x00 */ 1, 1, 1, 1, 1, 1, 1, 'a',
170 /* 0x08 */ 'b', 't', 'n', 'v', 'f', 'r', 1, 1,
172 /* 0x20 */ -1, -1, '"', -1, -1, -1, -1, -1,
173 /* 0x28 */ X16(-1), X16(-1), X16(-1),
174 /* 0x58 */ -1, -1, -1, -1,'\\', -1, -1, -1,
175 /* 0x60 */ X16(-1), X8(-1),
176 /* 0x78 */ -1, -1, -1, -1, -1, -1, -1, 1,
177 /* 0x80 */ /* set to 0 */
180 static inline int sq_must_quote(char c
)
182 return sq_lookup
[(unsigned char)c
] + quote_path_fully
> 0;
185 /* returns the longest prefix not needing a quote up to maxlen if positive.
186 This stops at the first \0 because it's marked as a character needing an
188 static size_t next_quote_pos(const char *s
, ssize_t maxlen
)
192 for (len
= 0; !sq_must_quote(s
[len
]); len
++);
194 for (len
= 0; len
< maxlen
&& !sq_must_quote(s
[len
]); len
++);
200 * C-style name quoting.
202 * (1) if sb and fp are both NULL, inspect the input name and counts the
203 * number of bytes that are needed to hold c_style quoted version of name,
204 * counting the double quotes around it but not terminating NUL, and
206 * However, if name does not need c_style quoting, it returns 0.
208 * (2) if sb or fp are not NULL, it emits the c_style quoted version
209 * of name, enclosed with double quotes if asked and needed only.
210 * Return value is the same as in (1).
212 static size_t quote_c_style_counted(const char *name
, ssize_t maxlen
,
213 struct strbuf
*sb
, FILE *fp
, int no_dq
)
218 if (sb) strbuf_addch(sb, (c)); \
219 if (fp) fputc((c), fp); \
222 #define EMITBUF(s, l) \
224 if (sb) strbuf_add(sb, (s), (l)); \
225 if (fp) fwrite((s), (l), 1, fp); \
229 size_t len
, count
= 0;
230 const char *p
= name
;
235 len
= next_quote_pos(p
, maxlen
);
236 if (len
== maxlen
|| (maxlen
< 0 && !p
[len
]))
239 if (!no_dq
&& p
== name
)
245 ch
= (unsigned char)*p
++;
248 if (sq_lookup
[ch
] >= ' ') {
251 EMIT(((ch
>> 6) & 03) + '0');
252 EMIT(((ch
>> 3) & 07) + '0');
253 EMIT(((ch
>> 0) & 07) + '0');
258 if (p
== name
) /* no ending quote needed */
266 size_t quote_c_style(const char *name
, struct strbuf
*sb
, FILE *fp
, int nodq
)
268 return quote_c_style_counted(name
, -1, sb
, fp
, nodq
);
271 void quote_two_c_style(struct strbuf
*sb
, const char *prefix
, const char *path
, int nodq
)
273 if (quote_c_style(prefix
, NULL
, NULL
, 0) ||
274 quote_c_style(path
, NULL
, NULL
, 0)) {
276 strbuf_addch(sb
, '"');
277 quote_c_style(prefix
, sb
, NULL
, 1);
278 quote_c_style(path
, sb
, NULL
, 1);
280 strbuf_addch(sb
, '"');
282 strbuf_addstr(sb
, prefix
);
283 strbuf_addstr(sb
, path
);
287 void write_name_quoted(const char *name
, FILE *fp
, int terminator
)
290 quote_c_style(name
, NULL
, fp
, 0);
294 fputc(terminator
, fp
);
297 void write_name_quoted_relative(const char *name
, const char *prefix
,
298 FILE *fp
, int terminator
)
300 struct strbuf sb
= STRBUF_INIT
;
302 name
= relative_path(name
, prefix
, &sb
);
303 write_name_quoted(name
, fp
, terminator
);
308 /* quote path as relative to the given prefix */
309 char *quote_path_relative(const char *in
, const char *prefix
,
312 struct strbuf sb
= STRBUF_INIT
;
313 const char *rel
= relative_path(in
, prefix
, &sb
);
315 quote_c_style_counted(rel
, strlen(rel
), out
, NULL
, 0);
322 * C-style name unquoting.
324 * Quoted should point at the opening double quote.
325 * + Returns 0 if it was able to unquote the string properly, and appends the
326 * result in the strbuf `sb'.
327 * + Returns -1 in case of error, and doesn't touch the strbuf. Though note
328 * that this function will allocate memory in the strbuf, so calling
329 * strbuf_release is mandatory whichever result unquote_c_style returns.
331 * Updates endp pointer to point at one past the ending double quote if given.
333 int unquote_c_style(struct strbuf
*sb
, const char *quoted
, const char **endp
)
335 size_t oldlen
= sb
->len
, len
;
338 if (*quoted
++ != '"')
342 len
= strcspn(quoted
, "\"\\");
343 strbuf_add(sb
, quoted
, len
);
357 switch ((ch
= *quoted
++)) {
358 case 'a': ch
= '\a'; break;
359 case 'b': ch
= '\b'; break;
360 case 'f': ch
= '\f'; break;
361 case 'n': ch
= '\n'; break;
362 case 'r': ch
= '\r'; break;
363 case 't': ch
= '\t'; break;
364 case 'v': ch
= '\v'; break;
367 break; /* verbatim */
369 /* octal values with first digit over 4 overflow */
370 case '0': case '1': case '2': case '3':
371 ac
= ((ch
- '0') << 6);
372 if ((ch
= *quoted
++) < '0' || '7' < ch
)
374 ac
|= ((ch
- '0') << 3);
375 if ((ch
= *quoted
++) < '0' || '7' < ch
)
383 strbuf_addch(sb
, ch
);
387 strbuf_setlen(sb
, oldlen
);
391 /* quoting as a string literal for other languages */
393 void perl_quote_buf(struct strbuf
*sb
, const char *src
)
395 const char sq
= '\'';
396 const char bq
= '\\';
399 strbuf_addch(sb
, sq
);
400 while ((c
= *src
++)) {
401 if (c
== sq
|| c
== bq
)
402 strbuf_addch(sb
, bq
);
405 strbuf_addch(sb
, sq
);
408 void python_quote_buf(struct strbuf
*sb
, const char *src
)
410 const char sq
= '\'';
411 const char bq
= '\\';
412 const char nl
= '\n';
415 strbuf_addch(sb
, sq
);
416 while ((c
= *src
++)) {
418 strbuf_addch(sb
, bq
);
419 strbuf_addch(sb
, 'n');
422 if (c
== sq
|| c
== bq
)
423 strbuf_addch(sb
, bq
);
426 strbuf_addch(sb
, sq
);
429 void tcl_quote_buf(struct strbuf
*sb
, const char *src
)
433 strbuf_addch(sb
, '"');
434 while ((c
= *src
++)) {
438 case '$': case '\\': case '"':
439 strbuf_addch(sb
, '\\');
444 strbuf_addstr(sb
, "\\f");
447 strbuf_addstr(sb
, "\\r");
450 strbuf_addstr(sb
, "\\n");
453 strbuf_addstr(sb
, "\\t");
456 strbuf_addstr(sb
, "\\v");
460 strbuf_addch(sb
, '"');
463 void basic_regex_quote_buf(struct strbuf
*sb
, const char *src
)
468 /* only beginning '^' is special and needs quoting */
469 strbuf_addch(sb
, '\\');
470 strbuf_addch(sb
, *src
++);
473 /* beginning '*' is not special, no quoting */
474 strbuf_addch(sb
, *src
++);
476 while ((c
= *src
++)) {
482 strbuf_addch(sb
, '\\');
487 /* only the end '$' is special and needs quoting */
489 strbuf_addch(sb
, '\\');