/* Copies the quoted string to p and returns the incremented p.
There must be room for shell_quote_length (string) + 1 bytes at p. */
char *
shell_quote_copy (char *p, const char *string)
{
if (sh_quoting_options == NULL)
init_sh_quoting_options ();
return p + quotearg_buffer (p, (size_t)(-1), string, strlen (string),
sh_quoting_options);
}
/* Returns the number of bytes needed for the quoted string. */
size_t
shell_quote_length (const char *string)
{
if (sh_quoting_options == NULL)
init_sh_quoting_options ();
return quotearg_buffer (NULL, 0, string, strlen (string),
sh_quoting_options);
}
static char *
use_quotearg_buffer (const char *str, size_t *len)
{
static char buf[100];
size_t size;
memset (buf, 0xa5, 100);
size = quotearg_buffer (buf, 100, str, *len, NULL);
*len = size;
ASSERT ((unsigned char) buf[size + 1] == 0xa5);
return buf;
}
/*
* Print S according to the format FORMAT, but if the destination is a tty,
* convert any potentially-dangerous characters. The logic in this function
* was taken from ls.c in coreutils (at Sun Jun 5 20:42:51 2005 UTC).
*/
void
print_quoted (FILE *fp,
const struct quoting_options *qopts,
bool dest_is_tty,
const char *format,
const char *s)
{
if (dest_is_tty)
{
char smallbuf[BUFSIZ];
size_t len = quotearg_buffer (smallbuf, sizeof smallbuf, s, -1, qopts);
char *buf;
if (len < sizeof smallbuf)
buf = smallbuf;
else
{
/* The original coreutils code uses alloca(), but I don't
* want to take on the anguish of introducing alloca() to
* 'find'.
*/
buf = xmalloc (len + 1);
quotearg_buffer (buf, len + 1, s, -1, qopts);
}
/* Replace any remaining funny characters with '?'. */
len = qmark_chars(buf, len);
fprintf(fp, format, buf); /* Print the quoted version */
if (buf != smallbuf)
{
free(buf);
buf = NULL;
}
}
else
{
/* no need to quote things. */
fprintf(fp, format, s);
}
}
int
main (int argc _GL_UNUSED, char *argv[])
{
int i;
bool ascii_only = MB_CUR_MAX == 1 && !isprint ((unsigned char) LQ[0]);
set_program_name (argv[0]);
/* This part of the program is hard-wired to the C locale since it
does not call setlocale. However, according to POSIX, the use of
8-bit bytes in a character context in the C locale gives
unspecified results (that is, the C locale charset is allowed to
be unibyte with 8-bit bytes rejected [ASCII], unibyte with 8-bit
bytes being characters [often ISO-8859-1], or multibyte [often
UTF-8]). We assume that the latter two cases will be
indistinguishable in this test - that is, the LQ and RQ sequences
will pass through unchanged in either type of charset. So when
testing for quoting of str7, use the ascii_only flag to decide
what to expect for the 8-bit data being quoted. */
ASSERT (!isprint ('\033'));
for (i = literal_quoting_style; i <= clocale_quoting_style; i++)
{
set_quoting_style (NULL, (enum quoting_style) i);
if (!(i == locale_quoting_style || i == clocale_quoting_style)
|| (strcmp (locale_charset (), "ASCII") == 0
|| strcmp (locale_charset (), "ANSI_X3.4-1968") == 0))
{
compare_strings (use_quotearg_buffer, &results_g[i].group1,
ascii_only);
compare_strings (use_quotearg, &results_g[i].group2,
ascii_only);
if (i == c_quoting_style)
compare_strings (use_quote_double_quotes, &results_g[i].group2,
ascii_only);
compare_strings (use_quotearg_colon, &results_g[i].group3,
ascii_only);
}
}
set_quoting_style (NULL, literal_quoting_style);
ASSERT (set_quoting_flags (NULL, QA_ELIDE_NULL_BYTES) == 0);
compare_strings (use_quotearg_buffer, &flag_results[0].group1, ascii_only);
compare_strings (use_quotearg, &flag_results[0].group2, ascii_only);
compare_strings (use_quotearg_colon, &flag_results[0].group3, ascii_only);
set_quoting_style (NULL, c_quoting_style);
ASSERT (set_quoting_flags (NULL, QA_ELIDE_OUTER_QUOTES)
== QA_ELIDE_NULL_BYTES);
compare_strings (use_quotearg_buffer, &flag_results[1].group1, ascii_only);
compare_strings (use_quotearg, &flag_results[1].group2, ascii_only);
compare_strings (use_quote_double_quotes, &flag_results[1].group2,
ascii_only);
compare_strings (use_quotearg_colon, &flag_results[1].group3, ascii_only);
ASSERT (set_quoting_flags (NULL, QA_SPLIT_TRIGRAPHS)
== QA_ELIDE_OUTER_QUOTES);
compare_strings (use_quotearg_buffer, &flag_results[2].group1, ascii_only);
compare_strings (use_quotearg, &flag_results[2].group2, ascii_only);
compare_strings (use_quote_double_quotes, &flag_results[2].group2,
ascii_only);
compare_strings (use_quotearg_colon, &flag_results[2].group3, ascii_only);
ASSERT (set_quoting_flags (NULL, 0) == QA_SPLIT_TRIGRAPHS);
for (i = 0; i < sizeof custom_quotes / sizeof *custom_quotes; ++i)
{
set_custom_quoting (NULL,
custom_quotes[i][0], custom_quotes[i][1]);
compare_strings (use_quotearg_buffer, &custom_results[i].group1,
ascii_only);
compare_strings (use_quotearg, &custom_results[i].group2, ascii_only);
compare_strings (use_quotearg_colon, &custom_results[i].group3,
ascii_only);
}
{
/* Trigger the bug whereby quotearg_buffer would read beyond the NUL
that defines the end of the string being quoted. Use an input
string whose NUL is the last byte before an unreadable page. */
char *z = zerosize_ptr ();
if (z)
{
size_t q_len = 1024;
char *q = malloc (q_len + 1);
char buf[10];
memset (q, 'Q', q_len);
q[q_len] = 0;
/* Z points to the boundary between a readable/writable page
and one that is neither readable nor writable. Position
our string so its NUL is at the end of the writable one. */
char const *str = "____";
size_t s_len = strlen (str);
z -= s_len + 1;
memcpy (z, str, s_len + 1);
set_custom_quoting (NULL, q, q);
/* Whether this actually triggers a SEGV depends on the
implementation of memcmp: whether it compares only byte-at-
a-time, and from left to right (no SEGV) or some other way. */
size_t n = quotearg_buffer (buf, sizeof buf, z, SIZE_MAX, NULL);
ASSERT (n == s_len + 2 * q_len);
ASSERT (memcmp (buf, q, sizeof buf) == 0);
free (q);
}
}
quotearg_free ();
return 0;
}