static enum listbox_match
match_cache_entry(struct listbox_item *item, struct terminal *term,
unsigned char *text)
{
struct cache_entry *cached = item->udata;
if (c_strcasestr(struri(cached->uri), text)
|| (cached->head && c_strcasestr(cached->head, text)))
return LISTBOX_MATCH_OK;
return LISTBOX_MATCH_NO;
}
static int
proxy_probe_no_proxy(unsigned char *url, unsigned char *no_proxy)
{
unsigned char *slash = (unsigned char *)strchr((char *)url, '/');
if (slash) *slash = '\0';
while (no_proxy && *no_proxy) {
unsigned char *jumper = (unsigned char *)strchr((char *)no_proxy, ',');
skip_space(no_proxy);
if (jumper) *jumper = '\0';
if (c_strcasestr((const char *)url, (const char *)no_proxy)) {
if (jumper) *jumper = ',';
if (slash) *slash = '/';
return 1;
}
no_proxy = jumper;
if (jumper) {
*jumper = ',';
no_proxy++;
}
}
if (slash) *slash = '/';
return 0;
}
/* Given a string containing "charset=XXX", return the encoding if found,
or NULL otherwise */
char *
parse_charset (const char *str)
{
const char *end;
char *charset;
if (!str || !*str)
return NULL;
str = c_strcasestr (str, "charset=");
if (!str)
return NULL;
str += 8;
end = str;
/* sXXXav: which chars should be banned ??? */
while (*end && !c_isspace (*end))
end++;
/* sXXXav: could strdupdelim return NULL ? */
charset = strdupdelim (str, end);
/* Do a minimum check on the charset value */
if (!check_encoding_name (charset))
{
xfree (charset);
return NULL;
}
/*logprintf (LOG_VERBOSE, "parse_charset: %s\n", quote (charset));*/
return charset;
}
static unsigned char *
get_fragment_content_type(struct cache_entry *cached)
{
struct fragment *fragment;
size_t length;
unsigned char *sample;
unsigned char *ctype = NULL;
if (list_empty(cached->frag))
return NULL;
fragment = cached->frag.next;
if (fragment->offset)
return NULL;
length = fragment->length > 1024 ? 1024 : fragment->length;
sample = memacpy(fragment->data, length);
if (!sample)
return NULL;
if (c_strcasestr((const char *)sample, "<html>"))
ctype = stracpy("text/html");
mem_free(sample);
return ctype;
}
/* Parse a link and return results in @link.
* It tries to identify known types. */
static int
html_link_parse(struct html_context *html_context, unsigned char *a,
struct hlink *link)
{
int i;
assert(a && link);
memset(link, 0, sizeof(*link));
link->href = get_url_val(a, (unsigned char *)"href", html_context->doc_cp);
if (!link->href) return 0;
link->lang = get_attr_val(a, (unsigned char *)"lang", html_context->doc_cp);
link->hreflang = get_attr_val(a, (unsigned char *)"hreflang", html_context->doc_cp);
link->title = get_attr_val(a, (unsigned char *)"title", html_context->doc_cp);
link->content_type = get_attr_val(a, (unsigned char *)"type", html_context->doc_cp);
link->media = get_attr_val(a, (unsigned char *)"media", html_context->doc_cp);
link->name = get_attr_val(a, (unsigned char *)"rel", html_context->doc_cp);
if (link->name) {
link->direction = LD_REL;
} else {
link->name = get_attr_val(a, (unsigned char *)"rev", html_context->doc_cp);
if (link->name) link->direction = LD_REV;
}
if (!link->name) return 1;
/* TODO: fastfind */
for (i = 0; lt_names[i].str; i++)
if (!c_strcasecmp((const char *)link->name, (const char *)lt_names[i].str)) {
link->type = lt_names[i].type;
return 1;
}
if (c_strcasestr((const char *)link->name, "icon") ||
(link->content_type && c_strcasestr((const char *)link->content_type, "icon"))) {
link->type = LT_ICON;
} else if (c_strcasestr((const char *)link->name, "alternate")) {
link->type = LT_ALTERNATE;
if (link->lang)
link->type = LT_ALTERNATE_LANG;
else if (c_strcasestr((const char *)link->name, "stylesheet") ||
(link->content_type && c_strcasestr((const char *)link->content_type, "css")))
link->type = LT_ALTERNATE_STYLESHEET;
else if (link->media)
link->type = LT_ALTERNATE_MEDIA;
} else if (link->content_type && c_strcasestr((const char *)link->content_type, "css")) {
link->type = LT_STYLESHEET;
}
return 1;
}
int
main ()
{
{
const char input[] = "foo";
const char *result = c_strcasestr (input, "");
ASSERT (result == input);
}
{
const char input[] = "foo";
const char *result = c_strcasestr (input, "O");
ASSERT (result == input + 1);
}
{
const char input[] = "ABC ABCDAB ABCDABCDABDE";
const char *result = c_strcasestr (input, "ABCDaBD");
ASSERT (result == input + 15);
}
{
const char input[] = "ABC ABCDAB ABCDABCDABDE";
const char *result = c_strcasestr (input, "ABCDaBE");
ASSERT (result == NULL);
}
{
const char input[] = "ABC ABCDAB ABCDABCDABDE";
const char *result = c_strcasestr (input, "ABCDaBCD");
ASSERT (result == input + 11);
}
/* 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"
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
char *haystack = (char *) malloc (m + 1);
if (haystack != NULL)
{
memset (haystack, 'A', m);
haystack[0] = 'B';
haystack[m] = '\0';
for (; repeat > 0; repeat--)
{
ASSERT (c_strcasestr (haystack, needle) == 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";
char *needle = (char *) malloc (m + 1);
if (needle != NULL)
{
memset (needle, 'A', m);
needle[m] = '\0';
for (; repeat > 0; repeat--)
{
ASSERT (c_strcasestr (haystack, needle) == NULL);
}
free (needle);
}
}
/* Check that the asymptotic worst-case complexity is not quadratic. */
{
size_t m = 1000000;
char *haystack = (char *) malloc (2 * m + 2);
char *needle = (char *) malloc (m + 2);
if (haystack != NULL && needle != NULL)
{
const char *result;
memset (haystack, 'A', 2 * m);
haystack[2 * m] = 'B';
haystack[2 * m + 1] = '\0';
memset (needle, 'a', m);
needle[m] = 'B';
needle[m + 1] = '\0';
result = c_strcasestr (haystack, needle);
ASSERT (result == haystack + m);
}
free (needle);
free (haystack);
}
return 0;
}
int
main ()
{
{
const char input[] = "foo";
const char *result = c_strcasestr (input, "");
ASSERT (result == input);
}
{
const char input[] = "foo";
const char *result = c_strcasestr (input, "O");
ASSERT (result == input + 1);
}
{
const char input[] = "ABC ABCDAB ABCDABCDABDE";
const char *result = c_strcasestr (input, "ABCDaBD");
ASSERT (result == input + 15);
}
{
const char input[] = "ABC ABCDAB ABCDABCDABDE";
const char *result = c_strcasestr (input, "ABCDaBE");
ASSERT (result == NULL);
}
{
const char input[] = "ABC ABCDAB ABCDABCDABDE";
const char *result = c_strcasestr (input, "ABCDaBCD");
ASSERT (result == input + 11);
}
/* 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 = c_strcasestr (input, 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 = c_strcasestr (input, 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"
"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
char *haystack = (char *) malloc (m + 1);
if (haystack != NULL)
{
memset (haystack, 'A', m);
haystack[0] = 'B';
haystack[m] = '\0';
for (; repeat > 0; repeat--)
{
ASSERT (c_strcasestr (haystack, needle) == 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";
char *needle = (char *) malloc (m + 1);
if (needle != NULL)
{
memset (needle, 'A', m);
needle[m] = '\0';
for (; repeat > 0; repeat--)
{
ASSERT (c_strcasestr (haystack, needle) == NULL);
}
free (needle);
}
}
/* Check that the asymptotic worst-case complexity is not quadratic. */
{
size_t m = 1000000;
char *haystack = (char *) malloc (2 * m + 2);
char *needle = (char *) malloc (m + 2);
if (haystack != NULL && needle != NULL)
{
const char *result;
memset (haystack, 'A', 2 * m);
haystack[2 * m] = 'B';
haystack[2 * m + 1] = '\0';
memset (needle, 'a', m);
needle[m] = 'B';
needle[m + 1] = '\0';
result = c_strcasestr (haystack, needle);
ASSERT (result == haystack + m);
}
free (needle);
free (haystack);
}
{
/* Ensure that with a barely periodic "short" needle, c_strcasestr's
search does not mistakenly skip just past the match point.
This use of c_strcasestr 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 = c_strcasestr (haystack, needle);
ASSERT (p - haystack == 114);
}
{
/* Same bug, shorter trigger. */
const char *haystack = "..wi.D.";
const char *needle = ".d.";
const char* p = c_strcasestr (haystack, 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, c_strcasestr 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 = c_strcasestr (haystack, needle);
ASSERT (p);
ASSERT (p - haystack == i);
}
}
return 0;
}