void test_jump_to_address_zero(void) {
/*
* "volatile" tells Clang/LLVM not to optimize this call away and
* replace it with an illegal instruction, which produces different
* behaviour (SIGILL rather than SIGSEGV).
*/
void (*volatile null_ptr)(void) = NULL;
null_ptr();
}
int main(int argc, char *argv[])
{
(void) argc; (void) argv;
qDebug() << "div" << div_by_zero(argc);
qDebug() << "ptr" << null_ptr((int *)argv);
qDebug() << "esc" << escape_stack();
qDebug() << "ini" << uninitialized_var();
qDebug() << "del" << use_after_delete();
return 0;
}
static void
test_errors (int fd, const char *slave)
{
char buffer[256];
size_t len;
size_t buflen_max;
size_t buflen;
int result;
len = strlen (slave);
buflen_max = len + 5;
if (buflen_max > sizeof buffer)
buflen_max = sizeof buffer;
for (buflen = 0; buflen <= buflen_max; buflen++)
{
memset (buffer, 'X', sizeof buffer);
errno = 0;
result = ptsname_r (fd, buffer, buflen);
if (buflen > len)
{
ASSERT (result == 0);
ASSERT (buffer[0] == '/');
}
else
{
ASSERT (result != 0);
ASSERT (result == errno);
ASSERT (errno == ERANGE);
ASSERT (buffer[0] == 'X');
}
}
errno = 0;
result = ptsname_r (fd, null_ptr (), 0);
ASSERT (result != 0);
ASSERT (result == errno);
ASSERT (errno == EINVAL);
}
int
main (int argc, char *argv[])
{
#if HAVE_DECL_ALARM
/* Declare failure if test takes too long, by using default abort
caused by SIGALRM. All known platforms that lack alarm also lack
memmem, and the replacement memmem is known to not take too
long. */
signal (SIGALRM, SIG_DFL);
alarm (100);
#endif
{
const char input[] = "foo";
const char *result = memmem (input, strlen (input), "", 0);
ASSERT (result == input);
}
{
const char input[] = "foo";
const char *result = memmem (input, strlen (input), "o", 1);
ASSERT (result == input + 1);
}
{
const char input[] = "ABC ABCDAB ABCDABCDABDE";
const char *result = memmem (input, strlen (input), "ABCDABD", 7);
ASSERT (result == input + 15);
}
{
const char input[] = "ABC ABCDAB ABCDABCDABDE";
const char *result = memmem (input, strlen (input), "ABCDABE", 7);
ASSERT (result == NULL);
}
{
const char input[] = "ABC ABCDAB ABCDABCDABDE";
const char *result = memmem (input, strlen (input), "ABCDABCD", 8);
ASSERT (result == input + 11);
}
/* Check that length 0 does not dereference the pointer. */
{
const char *result = memmem (zerosize_ptr (), 0, "foo", 3);
ASSERT (result == NULL);
}
{
const char input[] = "foo";
const char *result = memmem (input, strlen (input), null_ptr (), 0);
ASSERT (result == input);
}
/* Check that a long periodic needle does not cause false positives. */
{
const char input[] = ("F_BD_CE_BD_EF_BF_BD_EF_BF_BD_EF_BF_BD_EF_BF_BD"
"_C3_88_20_EF_BF_BD_EF_BF_BD_EF_BF_BD"
"_C3_A7_20_EF_BF_BD");
const char need[] = "_EF_BF_BD_EF_BF_BD_EF_BF_BD_EF_BF_BD_EF_BF_BD";
const char *result = memmem (input, strlen (input), need, strlen (need));
ASSERT (result == NULL);
}
{
const char input[] = ("F_BD_CE_BD_EF_BF_BD_EF_BF_BD_EF_BF_BD_EF_BF_BD"
"_C3_88_20_EF_BF_BD_EF_BF_BD_EF_BF_BD"
"_C3_A7_20_EF_BF_BD_DA_B5_C2_A6_20"
"_EF_BF_BD_EF_BF_BD_EF_BF_BD_EF_BF_BD_EF_BF_BD");
const char need[] = "_EF_BF_BD_EF_BF_BD_EF_BF_BD_EF_BF_BD_EF_BF_BD";
const char *result = memmem (input, strlen (input), need, strlen (need));
ASSERT (result == input + 115);
}
/* Check that a very long haystack is handled quickly if the needle is
short and occurs near the beginning. */
{
size_t repeat = 10000;
size_t m = 1000000;
const char *needle =
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
size_t n = strlen (needle);
char *haystack = (char *) malloc (m + 1);
if (haystack != NULL)
{
memset (haystack, 'A', m);
haystack[0] = 'B';
for (; repeat > 0; repeat--)
{
ASSERT (memmem (haystack, m, needle, n) == haystack + 1);
}
free (haystack);
}
}
/* Check that a very long needle is discarded quickly if the haystack is
short. */
{
size_t repeat = 10000;
size_t m = 1000000;
const char *haystack =
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
"ABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABAB";
size_t n = strlen (haystack);
char *needle = (char *) malloc (m + 1);
if (needle != NULL)
{
memset (needle, 'A', m);
for (; repeat > 0; repeat--)
{
ASSERT (memmem (haystack, n, needle, m) == NULL);
}
free (needle);
}
}
/* Check that the asymptotic worst-case complexity is not quadratic. */
{
size_t m = 1000000;
char *haystack = (char *) malloc (2 * m + 1);
char *needle = (char *) malloc (m + 1);
if (haystack != NULL && needle != NULL)
{
const char *result;
memset (haystack, 'A', 2 * m);
haystack[2 * m] = 'B';
memset (needle, 'A', m);
needle[m] = 'B';
result = memmem (haystack, 2 * m + 1, needle, m + 1);
ASSERT (result == haystack + m);
}
free (needle);
free (haystack);
}
/* Check that long needles not present in a haystack can be handled
with sublinear speed. */
{
size_t repeat = 10000;
size_t m = 1000000;
size_t n = 1000;
char *haystack = (char *) malloc (m);
char *needle = (char *) malloc (n);
if (haystack != NULL && needle != NULL)
{
const char *result;
memset (haystack, 'A', m);
memset (needle, 'B', n);
for (; repeat > 0; repeat--)
{
result = memmem (haystack, m, needle, n);
ASSERT (result == NULL);
}
}
free (haystack);
free (needle);
}
return 0;
}
/**
* gedit_utils_decode_uri:
* @uri: the uri to decode
* @scheme: (out) (allow-none): return value pointer for the uri's
* scheme (e.g. http, sftp, ...), or %NULL
* @user: (out) (allow-none): return value pointer for the uri user info, or %NULL
* @port: (out) (allow-none): return value pointer for the uri port, or %NULL
* @host: (out) (allow-none): return value pointer for the uri host, or %NULL
* @path: (out) (allow-none): return value pointer for the uri path, or %NULL
*
* Parse and break an uri apart in its individual components like the uri
* scheme, user info, port, host and path. The return value pointer can be
* %NULL to ignore certain parts of the uri. If the function returns %TRUE, then
* all return value pointers should be freed using g_free
*
* Return value: %TRUE if the uri could be properly decoded, %FALSE otherwise.
*/
gboolean
gedit_utils_decode_uri (const gchar *uri,
gchar **scheme,
gchar **user,
gchar **host,
gchar **port,
gchar **path)
{
/* Largely copied from glib/gio/gdummyfile.c:_g_decode_uri. This
* functionality should be in glib/gio, but for now we implement it
* ourselves (see bug #546182) */
const char *p, *in, *hier_part_start, *hier_part_end;
char *out;
char c;
/* From RFC 3986 Decodes:
* URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
*/
p = uri;
null_ptr (scheme);
null_ptr (user);
null_ptr (port);
null_ptr (host);
null_ptr (path);
/* Decode scheme:
* scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
*/
if (!g_ascii_isalpha (*p))
return FALSE;
while (1)
{
c = *p++;
if (c == ':')
break;
if (!(g_ascii_isalnum(c) ||
c == '+' ||
c == '-' ||
c == '.'))
{
return FALSE;
}
}
if (scheme)
{
*scheme = g_malloc (p - uri);
out = *scheme;
for (in = uri; in < p - 1; in++)
{
*out++ = g_ascii_tolower (*in);
}
*out = '\0';
}
hier_part_start = p;
hier_part_end = p + strlen (p);
if (hier_part_start[0] == '/' && hier_part_start[1] == '/')
{
const char *authority_start, *authority_end;
const char *userinfo_start, *userinfo_end;
const char *host_start, *host_end;
const char *port_start;
authority_start = hier_part_start + 2;
/* authority is always followed by / or nothing */
authority_end = memchr (authority_start, '/', hier_part_end - authority_start);
if (authority_end == NULL)
authority_end = hier_part_end;
/* 3.2:
* authority = [ userinfo "@" ] host [ ":" port ]
*/
userinfo_end = memchr (authority_start, '@', authority_end - authority_start);
if (userinfo_end)
{
userinfo_start = authority_start;
if (user)
*user = g_uri_unescape_segment (userinfo_start, userinfo_end, NULL);
if (user && *user == NULL)
{
if (scheme)
g_free (*scheme);
return FALSE;
}
host_start = userinfo_end + 1;
}
else
{
host_start = authority_start;
}
port_start = memchr (host_start, ':', authority_end - host_start);
if (port_start)
{
host_end = port_start++;
if (port)
*port = g_strndup (port_start, authority_end - port_start);
}
else
{
host_end = authority_end;
}
if (host)
*host = g_strndup (host_start, host_end - host_start);
hier_part_start = authority_end;
}
if (path)
*path = g_uri_unescape_segment (hier_part_start, hier_part_end, "/");
return TRUE;
}
int
main (void)
{
#if GNULIB_TEST_CANONICALIZE
/* No need to test canonicalize-lgpl module if canonicalize is also
in use. */
return 0;
#endif
/* Setup some hierarchy to be used by this test. Start by removing
any leftovers from a previous partial run. */
{
int fd;
ignore_value (system ("rm -rf " BASE " ise"));
ASSERT (mkdir (BASE, 0700) == 0);
fd = creat (BASE "/tra", 0600);
ASSERT (0 <= fd);
ASSERT (close (fd) == 0);
}
/* Check for ., .., intermediate // handling, and for error cases. */
{
char *result = canonicalize_file_name (BASE "//./..//" BASE "/tra");
ASSERT (result != NULL);
ASSERT (strstr (result, "/" BASE "/tra")
== result + strlen (result) - strlen ("/" BASE "/tra"));
free (result);
errno = 0;
result = canonicalize_file_name ("");
ASSERT (result == NULL);
ASSERT (errno == ENOENT);
errno = 0;
result = canonicalize_file_name (null_ptr ());
ASSERT (result == NULL);
ASSERT (errno == EINVAL);
}
/* Check that a non-directory with trailing slash yields NULL. */
{
char *result;
errno = 0;
result = canonicalize_file_name (BASE "/tra/");
ASSERT (result == NULL);
ASSERT (errno == ENOTDIR);
}
/* Check that a missing directory yields NULL. */
{
char *result;
errno = 0;
result = canonicalize_file_name (BASE "/zzz/..");
ASSERT (result == NULL);
ASSERT (errno == ENOENT);
}
/* From here on out, tests involve symlinks. */
if (symlink (BASE "/ket", "ise") != 0)
{
ASSERT (remove (BASE "/tra") == 0);
ASSERT (rmdir (BASE) == 0);
fputs ("skipping test: symlinks not supported on this file system\n",
stderr);
return 77;
}
ASSERT (symlink ("bef", BASE "/plo") == 0);
ASSERT (symlink ("tra", BASE "/huk") == 0);
ASSERT (symlink ("lum", BASE "/bef") == 0);
ASSERT (symlink ("wum", BASE "/ouk") == 0);
ASSERT (symlink ("../ise", BASE "/ket") == 0);
ASSERT (mkdir (BASE "/lum", 0700) == 0);
ASSERT (symlink ("//.//../..", BASE "/droot") == 0);
/* Check that the symbolic link to a file can be resolved. */
{
char *result1 = canonicalize_file_name (BASE "/huk");
char *result2 = canonicalize_file_name (BASE "/tra");
ASSERT (result1 != NULL);
ASSERT (result2 != NULL);
ASSERT (strcmp (result1, result2) == 0);
ASSERT (strcmp (result1 + strlen (result1) - strlen ("/" BASE "/tra"),
"/" BASE "/tra") == 0);
free (result1);
free (result2);
}
/* Check that the symbolic link to a directory can be resolved. */
{
char *result1 = canonicalize_file_name (BASE "/plo");
char *result2 = canonicalize_file_name (BASE "/bef");
char *result3 = canonicalize_file_name (BASE "/lum");
ASSERT (result1 != NULL);
ASSERT (result2 != NULL);
ASSERT (result3 != NULL);
ASSERT (strcmp (result1, result2) == 0);
ASSERT (strcmp (result2, result3) == 0);
ASSERT (strcmp (result1 + strlen (result1) - strlen ("/" BASE "/lum"),
"/" BASE "/lum") == 0);
free (result1);
free (result2);
free (result3);
}
/* Check that a symbolic link to a nonexistent file yields NULL. */
{
char *result;
errno = 0;
result = canonicalize_file_name (BASE "/ouk");
ASSERT (result == NULL);
ASSERT (errno == ENOENT);
}
/* Check that a non-directory symlink with trailing slash yields NULL. */
{
char *result;
errno = 0;
result = canonicalize_file_name (BASE "/huk/");
ASSERT (result == NULL);
ASSERT (errno == ENOTDIR);
}
/* Check that a missing directory via symlink yields NULL. */
{
char *result;
errno = 0;
result = canonicalize_file_name (BASE "/ouk/..");
ASSERT (result == NULL);
ASSERT (errno == ENOENT);
}
/* Check that a loop of symbolic links is detected. */
{
char *result;
errno = 0;
result = canonicalize_file_name ("ise");
ASSERT (result == NULL);
ASSERT (errno == ELOOP);
}
/* Check that leading // is honored correctly. */
{
struct stat st1;
struct stat st2;
char *result1 = canonicalize_file_name ("//.");
char *result2 = canonicalize_file_name (BASE "/droot");
ASSERT (result1);
ASSERT (result2);
ASSERT (stat ("/", &st1) == 0);
ASSERT (stat ("//", &st2) == 0);
if (SAME_INODE (st1, st2))
{
ASSERT (strcmp (result1, "/") == 0);
ASSERT (strcmp (result2, "/") == 0);
}
else
{
ASSERT (strcmp (result1, "//") == 0);
ASSERT (strcmp (result2, "//") == 0);
}
free (result1);
free (result2);
}
/* Cleanup. */
ASSERT (remove (BASE "/droot") == 0);
ASSERT (remove (BASE "/plo") == 0);
ASSERT (remove (BASE "/huk") == 0);
ASSERT (remove (BASE "/bef") == 0);
ASSERT (remove (BASE "/ouk") == 0);
ASSERT (remove (BASE "/ket") == 0);
ASSERT (remove (BASE "/lum") == 0);
ASSERT (remove (BASE "/tra") == 0);
ASSERT (remove (BASE) == 0);
ASSERT (remove ("ise") == 0);
return 0;
}
int
main (int argc, char *argv[])
{
#if HAVE_DECL_ALARM
/* Declare failure if test takes too long, by using default abort
caused by SIGALRM. All known platforms that lack alarm also lack
memmem, and the replacement memmem is known to not take too
long. */
int alarm_value = 100;
signal (SIGALRM, SIG_DFL);
alarm (alarm_value);
#endif
{
const char input[] = "foo";
const char *result = memmem (input, strlen (input), "", 0);
ASSERT (result == input);
}
{
const char input[] = "foo";
const char *result = memmem (input, strlen (input), "o", 1);
ASSERT (result == input + 1);
}
{
const char input[] = "ABC ABCDAB ABCDABCDABDE";
const char *result = memmem (input, strlen (input), "ABCDABD", 7);
ASSERT (result == input + 15);
}
{
const char input[] = "ABC ABCDAB ABCDABCDABDE";
const char *result = memmem (input, strlen (input), "ABCDABE", 7);
ASSERT (result == NULL);
}
{
const char input[] = "ABC ABCDAB ABCDABCDABDE";
const char *result = memmem (input, strlen (input), "ABCDABCD", 8);
ASSERT (result == input + 11);
}
/* Check that length 0 does not dereference the pointer. */
{
const char *result = memmem (zerosize_ptr (), 0, "foo", 3);
ASSERT (result == NULL);
}
{
const char input[] = "foo";
const char *result = memmem (input, strlen (input), null_ptr (), 0);
ASSERT (result == input);
}
/* Check that a long periodic needle does not cause false positives. */
{
const char input[] = ("F_BD_CE_BD_EF_BF_BD_EF_BF_BD_EF_BF_BD_EF_BF_BD"
"_C3_88_20_EF_BF_BD_EF_BF_BD_EF_BF_BD"
"_C3_A7_20_EF_BF_BD");
const char need[] = "_EF_BF_BD_EF_BF_BD_EF_BF_BD_EF_BF_BD_EF_BF_BD";
const char *result = memmem (input, strlen (input), need, strlen (need));
ASSERT (result == NULL);
}
{
const char input[] = ("F_BD_CE_BD_EF_BF_BD_EF_BF_BD_EF_BF_BD_EF_BF_BD"
"_C3_88_20_EF_BF_BD_EF_BF_BD_EF_BF_BD"
"_C3_A7_20_EF_BF_BD_DA_B5_C2_A6_20"
"_EF_BF_BD_EF_BF_BD_EF_BF_BD_EF_BF_BD_EF_BF_BD");
const char need[] = "_EF_BF_BD_EF_BF_BD_EF_BF_BD_EF_BF_BD_EF_BF_BD";
const char *result = memmem (input, strlen (input), need, strlen (need));
ASSERT (result == input + 115);
}
/* Check that a very long haystack is handled quickly if the needle is
short and occurs near the beginning. */
{
size_t repeat = 10000;
size_t m = 1000000;
const char *needle =
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
size_t n = strlen (needle);
char *haystack = (char *) malloc (m + 1);
if (haystack != NULL)
{
memset (haystack, 'A', m);
haystack[0] = 'B';
for (; repeat > 0; repeat--)
{
ASSERT (memmem (haystack, m, needle, n) == haystack + 1);
}
free (haystack);
}
}
/* Check that a very long needle is discarded quickly if the haystack is
short. */
{
size_t repeat = 10000;
size_t m = 1000000;
const char *haystack =
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
"ABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABAB";
size_t n = strlen (haystack);
char *needle = (char *) malloc (m + 1);
if (needle != NULL)
{
memset (needle, 'A', m);
for (; repeat > 0; repeat--)
{
ASSERT (memmem (haystack, n, needle, m) == NULL);
}
free (needle);
}
}
/* Check that the asymptotic worst-case complexity is not quadratic. */
{
size_t m = 1000000;
char *haystack = (char *) malloc (2 * m + 1);
char *needle = (char *) malloc (m + 1);
if (haystack != NULL && needle != NULL)
{
const char *result;
memset (haystack, 'A', 2 * m);
haystack[2 * m] = 'B';
memset (needle, 'A', m);
needle[m] = 'B';
result = memmem (haystack, 2 * m + 1, needle, m + 1);
ASSERT (result == haystack + m);
}
free (needle);
free (haystack);
}
/* Check that long needles not present in a haystack can be handled
with sublinear speed. */
{
size_t repeat = 10000;
size_t m = 1000000;
size_t n = 1000;
char *haystack = (char *) malloc (m);
char *needle = (char *) malloc (n);
if (haystack != NULL && needle != NULL)
{
const char *result;
memset (haystack, 'A', m);
memset (needle, 'B', n);
for (; repeat > 0; repeat--)
{
result = memmem (haystack, m, needle, n);
ASSERT (result == NULL);
}
}
free (haystack);
free (needle);
}
{
/* Ensure that with a barely periodic "short" needle, memmem's
search does not mistakenly skip just past the match point.
This use of memmem would mistakenly return NULL before
gnulib v0.0-4927. */
const char *haystack =
"\n"
"with_build_libsubdir\n"
"with_local_prefix\n"
"with_gxx_include_dir\n"
"with_cpp_install_dir\n"
"enable_generated_files_in_srcdir\n"
"with_gnu_ld\n"
"with_ld\n"
"with_demangler_in_ld\n"
"with_gnu_as\n"
"with_as\n"
"enable_largefile\n"
"enable_werror_always\n"
"enable_checking\n"
"enable_coverage\n"
"enable_gather_detailed_mem_stats\n"
"enable_build_with_cxx\n"
"with_stabs\n"
"enable_multilib\n"
"enable___cxa_atexit\n"
"enable_decimal_float\n"
"enable_fixed_point\n"
"enable_threads\n"
"enable_tls\n"
"enable_objc_gc\n"
"with_dwarf2\n"
"enable_shared\n"
"with_build_sysroot\n"
"with_sysroot\n"
"with_specs\n"
"with_pkgversion\n"
"with_bugurl\n"
"enable_languages\n"
"with_multilib_list\n";
const char *needle = "\n"
"with_gnu_ld\n";
const char* p = memmem (haystack, strlen (haystack),
needle, strlen (needle));
ASSERT (p - haystack == 114);
}
{
/* Same bug, shorter trigger. */
const char *haystack = "..wi.d.";
const char *needle = ".d.";
const char* p = memmem (haystack, strlen (haystack),
needle, strlen (needle));
ASSERT (p - haystack == 4);
}
{
/* Like the above, but trigger the flaw in two_way_long_needle
by using a needle of length LONG_NEEDLE_THRESHOLD (32) or greater.
Rather than trying to find the right alignment manually, I've
arbitrarily chosen the following needle and template for the
haystack, and ensure that for each placement of the needle in
that haystack, memmem finds it. */
const char *needle = "\nwith_gnu_ld-extend-to-len-32-b\n";
const char *h =
"\n"
"with_build_libsubdir\n"
"with_local_prefix\n"
"with_gxx_include_dir\n"
"with_cpp_install_dir\n"
"with_e_\n"
"..............................\n"
"with_FGHIJKLMNOPQRSTUVWXYZ\n"
"with_567890123456789\n"
"with_multilib_list\n";
size_t h_len = strlen (h);
char *haystack = malloc (h_len + 1);
size_t i;
ASSERT (haystack);
for (i = 0; i < h_len - strlen (needle); i++)
{
const char *p;
memcpy (haystack, h, h_len + 1);
memcpy (haystack + i, needle, strlen (needle) + 1);
p = memmem (haystack, strlen (haystack), needle, strlen (needle));
ASSERT (p);
ASSERT (p - haystack == i);
}
}
return 0;
}
