content/urldb.c

Bug Summary

File:	content/urldb.c
Warning:	line 481, column 7 Access to field 'children' results in a dereference of a null pointer (loaded from variable 'p')
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name urldb.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/var/lib/jenkins/workspace/scan-build-netsurf -resource-dir /usr/lib/llvm-14/lib/clang/14.0.6 -I . -I include -I build/Linux-monkey -I frontends -I content/handlers -D WITH_JPEG -U WITH_PDF_EXPORT -D LIBICONV_PLUG -I /var/lib/jenkins/artifacts-x86_64-linux-gnu/include -I /var/lib/jenkins/artifacts-x86_64-linux-gnu/include -I /var/lib/jenkins/artifacts-x86_64-linux-gnu/include -I /usr/include/x86_64-linux-gnu -D WITH_CURL -D WITH_OPENSSL -I /var/lib/jenkins/artifacts-x86_64-linux-gnu/include -D UTF8PROC_EXPORTS -D WITH_UTF8PROC -D WITH_WEBP -I /usr/include/libpng16 -D WITH_PNG -I /var/lib/jenkins/artifacts-x86_64-linux-gnu/include/ -D WITH_BMP -I /var/lib/jenkins/artifacts-x86_64-linux-gnu/include -D WITH_GIF -I /var/lib/jenkins/artifacts-x86_64-linux-gnu/include -D WITH_NSPSL -I /var/lib/jenkins/artifacts-x86_64-linux-gnu/include -D WITH_NSLOG -D NETSURF_UA_FORMAT_STRING="Mozilla/5.0 (%s) NetSurf/%d.%d" -D NETSURF_HOMEPAGE="about:welcome" -D NETSURF_LOG_LEVEL=VERBOSE -D NETSURF_BUILTIN_LOG_FILTER="(level:WARNING || cat:jserrors)" -D NETSURF_BUILTIN_VERBOSE_FILTER="(level:VERBOSE || cat:jserrors)" -D STMTEXPR=1 -D monkey -D nsmonkey -D MONKEY_RESPATH="/var/lib/jenkins/artifacts-x86_64-linux-gnu/share/netsurf/" -D _POSIX_C_SOURCE=200809L -D _XOPEN_SOURCE=700 -D _BSD_SOURCE -D _DEFAULT_SOURCE -D _NETBSD_SOURCE -D DUK_OPT_HAVE_CUSTOM_H -internal-isystem /usr/lib/llvm-14/lib/clang/14.0.6/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib/gcc/x86_64-linux-gnu/12/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wwrite-strings -Wno-unused-parameter -Wno-unused-but-set-variable -std=c99 -fconst-strings -fdebug-compilation-dir=/var/lib/jenkins/workspace/scan-build-netsurf -ferror-limit 19 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-display-progress -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /var/lib/jenkins/workspace/scan-build-netsurf/clangScanBuildReports/2024-11-15-160436-1696928-1 -x c content/urldb.c
1/*
* Copyright 2006 John M Bell <jmb202@ecs.soton.ac.uk>
* Copyright 2009 John Tytgat <joty@netsurf-browser.org>
*
* This file is part of NetSurf, http://www.netsurf-browser.org/
*
* NetSurf is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; version 2 of the License.
*
* NetSurf is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

20/**
* \file
* Unified URL information database implementation
*
* URLs are stored in a tree-based structure as follows:
*
* The host component is extracted from each URL and, if a FQDN, split on
* every '.'.The tree is constructed by inserting each FQDN segment in
* reverse order. Duplicate nodes are merged.
*
* If the host part of an URL is an IP address, then this is added to the
* tree verbatim (as if it were a TLD).
*
* This provides something looking like:
*
*			      root (a sentinel)
*				|
*	-------------------------------------------------
*	|	|	|	|	|	|	|
*     com     edu     gov  127.0.0.1  net     org     uk	TLDs
*	|	|	|		|	|	|
*    google   ...     ...             ...     ...     co	2LDs
*	|						|
*     www					       bbc  Hosts/Subdomains
*							|
*						       www	...
*
* Each of the nodes in this tree is a struct host_part. This stores the
* FQDN segment (or IP address) with which the node is concerned. Each node
* may contain further information about paths on a host (struct path_data)
* or SSL certificate processing on a host-wide basis
* (host_part::permit_invalid_certs).
*
* Path data is concerned with storing various metadata about the path in
* question. This includes global history data, HTTP authentication details
* and any associated HTTP cookies. This is stored as a tree of path segments
* hanging off the relevant host_part node.
*
* Therefore, to find the last visited time of the URL
* http://www.example.com/path/to/resource.html, the FQDN tree would be
* traversed in the order root -> "com" -> "example" -> "www". The "www"
* node would have attached to it a tree of struct path_data:
*
*			    (sentinel)
*				|
*			       path
*				|
*			       to
*				|
*			   resource.html
*
* This represents the absolute path "/path/to/resource.html". The leaf node
* "resource.html" contains the last visited time of the resource.
*
* The mechanism described above is, however, not particularly conducive to
* fast searching of the database for a given URL (or URLs beginning with a
* given prefix). Therefore, an anciliary data structure is used to enable
* fast searching. This structure simply reflects the contents of the
* database, with entries being added/removed at the same time as for the
* core database. In order to ensure that degenerate cases are kept to a
* minimum, we use an AAtree. This is an approximation of a Red-Black tree
* with similar performance characteristics, but with a significantly
* simpler implementation. Entries in this tree comprise pointers to the
* leaf nodes of the host tree described above.
*
* REALLY IMPORTANT NOTE: urldb expects all URLs to be normalised. Use of
* non-normalised URLs with urldb will result in undefined behaviour and
* potential crashes.
*/

90#include <assert.h>
91#include <stdbool.h>
92#include <stdio.h>
93#include <stdlib.h>
94#include <string.h>
95#include <strings.h>
96#include <time.h>
97#ifdef WITH_NSPSL1
98#include <nspsl.h>
99#endif

101#include "utils/inet.h"
102#include "utils/nsoption.h"
103#include "utils/log.h"
104#include "utils/corestrings.h"
105#include "utils/url.h"
106#include "utils/utils.h"
107#include "utils/bloom.h"
108#include "utils/time.h"
109#include "utils/nsurl.h"
110#include "utils/ascii.h"
111#include "utils/http.h"
112#include "netsurf/bitmap.h"
113#include "desktop/cookie_manager.h"

115#include "content/content.h"
116#include "content/urldb.h"

118/**
* cookie entry.
*
* \warning This *must* be kept in sync with the public interface in
*   netsurf/cookie_db.h
*/
124struct cookie_internal_data {
struct cookie_internal_data *prev;	/**< Previous in list */
struct cookie_internal_data *next;	/**< Next in list */

char *name;		/**< Cookie name */
char *value;		/**< Cookie value */
bool_Bool value_was_quoted;	/**< Value was quoted in Set-Cookie: */
char *comment;		/**< Cookie comment */
bool_Bool domain_from_set;	/**< Domain came from Set-Cookie: header */
char *domain;		/**< Domain */
bool_Bool path_from_set;	/**< Path came from Set-Cookie: header */
char *path;		/**< Path */
time_t expires;		/**< Expiry timestamp, or -1 for session */
time_t last_used;	/**< Last used time */
bool_Bool secure;		/**< Only send for HTTPS requests */
bool_Bool http_only;		/**< Only expose to HTTP(S) requests */
enum cookie_version version;	/**< Specification compliance */
bool_Bool no_destroy;	/**< Never destroy this cookie,
		 * unless it's expired */

144};


147/**
* A protection space
*
* This is defined as a tuple canonical_root_url and realm.  This
* structure lives as linked list element in a leaf host_part struct
* so we need additional scheme and port to have a canonical_root_url.
*/
154struct prot_space_data {
/**
* URL scheme of canonical hostname of this protection space.
*/
lwc_string *scheme;
/**
* Port number of canonical hostname of this protection
* space. When 0, it means the default port for given scheme,
* i.e. 80 (http), 443 (https).
*/
unsigned int port;
/** Protection realm */
char *realm;

/**
* Authentication details for this protection space in form
* username:password
*/
char *auth;
/** Next sibling */
struct prot_space_data *next;
175};


178/**
* meta data about a url
*
* \warning must be kept in sync with url_data structure in netsurf/url_db.h
*/
183struct url_internal_data {
char *title;		/**< Resource title */
unsigned int visits;	/**< Visit count */
time_t last_visit;	/**< Last visit time */
content_type type;	/**< Type of resource */
188};


191/**
* data entry for url
*/
194struct path_data {
nsurl *url;		/**< Full URL */
lwc_string *scheme;	/**< URL scheme for data */
unsigned int port;	/**< Port number for data. When 0, it means
		 * the default port for given scheme, i.e.
		 * 80 (http), 443 (https). */
char *segment;		/**< Path segment for this node */
unsigned int frag_cnt;	/**< Number of entries in path_data::fragment */
char **fragment;	/**< Array of fragments */
bool_Bool persistent;	/**< This entry should persist */

struct url_internal_data urld;	/**< URL data for resource */

/**
* Protection space to which this resource belongs too. Can be
* NULL when it does not belong to a protection space or when
* it is not known. No ownership (is with struct host_part::prot_space).
*/
const struct prot_space_data *prot_space;
/** Cookies associated with resource */
struct cookie_internal_data *cookies;
/** Last cookie in list */
struct cookie_internal_data *cookies_end;

struct path_data *next;	/**< Next sibling */
struct path_data *prev;	/**< Previous sibling */
struct path_data *parent; /**< Parent path segment */
struct path_data *children; /**< Child path segments */
struct path_data *last; /**< Last child */
223};

225struct hsts_data {
time_t expires; /**< Expiry time */
bool_Bool include_sub_domains; /**< Whether to include subdomains */
228};

230struct host_part {
/**
* Known paths on this host. This _must_ be first so that
* struct host_part *h = (struct host_part *)mypath; works
*/
struct path_data paths;
/**
* Allow access to SSL protected resources on this host
* without verifying certificate authenticity
*/
bool_Bool permit_invalid_certs;
/* HSTS data */
struct hsts_data hsts;

/**
* Part of host string
*/
char *part;

/**
* Linked list of all known proctection spaces known for this
* host and all its schems and ports.
*/
struct prot_space_data *prot_space;

struct host_part *next;	/**< Next sibling */
struct host_part *prev;	/**< Previous sibling */
struct host_part *parent; /**< Parent host part */
struct host_part *children; /**< Child host parts */
259};


262/**
* search index node
*/
265struct search_node {
const struct host_part *data;	/**< Host tree entry */

unsigned int level;		/**< Node level */

struct search_node *left;	/**< Left subtree */
struct search_node *right;	/**< Right subtree */
272};

274/** Root database handle */
275static struct host_part db_root;

277/** Search trees - one per letter + 1 for IPs + 1 for Everything Else */
278#define NUM_SEARCH_TREES28 28
279#define ST_IP0 0
280#define ST_EE1 1
281#define ST_DN2 2
282static struct search_node empty = { 0, 0, &empty, &empty };
283static struct search_node *search_trees[NUM_SEARCH_TREES28] = {
&empty, &empty, &empty, &empty, &empty, &empty, &empty, &empty,
&empty, &empty, &empty, &empty, &empty, &empty, &empty, &empty,
&empty, &empty, &empty, &empty, &empty, &empty, &empty, &empty,
&empty, &empty, &empty, &empty
288};

290/** Minimum cookie database file version */
291#define MIN_COOKIE_FILE_VERSION100 100
292/** Current cookie database file version */
293#define COOKIE_FILE_VERSION102 102
294/** loaded cookie file version */
295static int loaded_cookie_file_version;

297/** Minimum URL database file version */
298#define MIN_URL_FILE_VERSION106 106
299/** Current URL database file version */
300#define URL_FILE_VERSION107 107

302/**
* filter for url presence in database
*
* Bloom filter used for short-circuting the false case of "is this
* URL in the database?".  BLOOM_SIZE controls how large the filter is
* in bytes.  Primitive experimentation shows that for a filter of X
* bytes filled with X items, searching for X items not in the filter
* has a 5% false-positive rate.  We set it to 32kB, which should be
* enough for all but the largest databases, while not being
* shockingly wasteful on memory.
*/
313static struct bloom_filter *url_bloom;
314/**
* Size of url filter
*/
317#define BLOOM_SIZE(1024 * 32) (1024 * 32)


320/**
* write a time_t to a file portably
*
* \param fp File to write to
* \param val the unix time value to output
* \return NSERROR_OK on success
*/
327static nserror urldb_write_timet(FILE *fp, time_t val)
328{
int use;
char op[32];

use = nsc_sntimet(op, 32, &val);
if (use == 0) {
fprintf(fp, "%i\n", (int)val);
} else {
fprintf(fp, "%.*s\n", use, op);
}
return NSERROR_OK;
339}

341/**
* Write paths associated with a host
*
* \param parent Root of (sub)tree to write
* \param host Current host name
* \param fp File to write to
* \param path Current path string
* \param path_alloc Allocated size of path
* \param path_used Used size of path
* \param expiry Expiry time of URLs
*/
352static void
353urldb_write_paths(const struct path_data *parent,
  const char *host,
  FILE *fp,
  char **path,
  int *path_alloc,
  int *path_used,
  time_t expiry)
360{
const struct path_data *p = parent;
int i;

do {
int seglen = p->segment != NULL((void*)0) ? strlen(p->segment) : 0;
int len = *path_used + seglen + 1;

if (*path_alloc < len) {
	char *temp;
	temp = realloc(*path,
		       (len > 64) ? len : *path_alloc + 64);
	if (!temp) {
		return;
	}
	*path = temp;
	*path_alloc = (len > 64) ? len : *path_alloc + 64;
}

if (p->segment != NULL((void*)0)) {
	memcpy(*path + *path_used - 1, p->segment, seglen);
}

if (p->children != NULL((void*)0)) {
	(*path)[*path_used + seglen - 1] = '/';
	(*path)[*path_used + seglen] = '\0';
} else {
	(*path)[*path_used + seglen - 1] = '\0';
	len -= 1;
}

*path_used = len;

if (p->children != NULL((void*)0)) {
	/* Drill down into children */
	p = p->children;
} else {
	/* leaf node */
	if (p->persistent ||
	    ((p->urld.last_visit > expiry) &&
	     (p->urld.visits > 0))) {
		fprintf(fp, "%s\n", lwc_string_data(p->scheme)({((p->scheme != ((void*)0)) ? (void) (0) : __assert_fail (
"p->scheme != NULL", "content/urldb.c", 401, __extension__
 __PRETTY_FUNCTION__)); (const char *)((p->scheme)+1);}));

		if (p->port) {
			fprintf(fp,"%d\n", p->port);
		} else {
			fprintf(fp, "\n");
		}

		fprintf(fp, "%s\n", *path);

		/** \todo handle fragments? */

		/* number of visits */
		fprintf(fp, "%i\n", p->urld.visits);

		/* time entry was last used */
		urldb_write_timet(fp, p->urld.last_visit);

		/* entry type */
		fprintf(fp, "%i\n", (int)p->urld.type);

		fprintf(fp, "\n");

		if (p->urld.title) {
			uint8_t *s = (uint8_t *) p->urld.title;

			for (i = 0; s[i] != '\0'; i++)
				if (s[i] < 32)
					s[i] = ' ';
			for (--i; ((i > 0) && (s[i] == ' '));
			     i--)
				s[i] = '\0';
			fprintf(fp, "%s\n", p->urld.title);
		} else {
			fprintf(fp, "\n");
		}
	}

	/* Now, find next node to process. */
	while (p != parent) {
		int seglen = p->segment != NULL((void*)0)
			? strlen(p->segment) : 0;

		/* Remove our segment from the path */
		*path_used -= seglen;
		(*path)[*path_used - 1] = '\0';

		if (p->next != NULL((void*)0)) {
			/* Have a sibling, process that */
			p = p->next;
			break;
		}

		/* Going up, so remove '/' */
		*path_used -= 1;
		(*path)[*path_used - 1] = '\0';

		/* Ascend tree */
		p = p->parent;
	}
}
} while (p != parent);
463}


466/**
* Count number of URLs associated with a host
*
* \param root Root of path data tree
* \param expiry Expiry time for URLs
* \param count Pointer to count
*/
473static void
474urldb_count_urls(const struct path_data *root,
 time_t expiry,
 unsigned int *count)
477{
const struct path_data *p = root;
30
←
'p' initialized to a null pointer value→

do {
if (p->children != NULL((void*)0)) {
31
←
Access to field 'children' results in a dereference of a null pointer (loaded from variable 'p')
	/* Drill down into children */
	p = p->children;
} else {
	/* No more children, increment count if required */
	if (p->persistent ||
	    ((p->urld.last_visit > expiry) &&
	     (p->urld.visits > 0))) {
		(*count)++;
	}

	/* Now, find next node to process. */
	while (p != root) {
		if (p->next != NULL((void*)0)) {
			/* Have a sibling, process that */
			p = p->next;
			break;
		}

		/* Ascend tree */
		p = p->parent;
	}
}
} while (p != root);
505}


508/**
* Save a search (sub)tree
*
* \param parent root node of search tree to save.
* \param fp File to write to
*/
514static void urldb_save_search_tree(struct search_node *parent, FILE *fp)
515{
char host[256];
const struct host_part *h;
unsigned int path_count = 0;
char *path, *p, *end;
int path_alloc = 64, path_used = 1;
time_t expiry, hsts_expiry = 0;
int hsts_include_subdomains = 0;

expiry = time(NULL((void*)0)) - ((60 * 60 * 24) * nsoption_int(expire_url)(nsoptions[NSOPTION_expire_url].value.i));

if (parent == &empty)
7
←
Assuming the condition is false→
8
←
Taking false branch→
10
←
Assuming the condition is false→
11
←
Taking false branch→
13
←
Assuming the condition is false→
14
←
Taking false branch→
16
←
Assuming the condition is false→
17
←
Taking false branch→
return;

urldb_save_search_tree(parent->left, fp);
9
←
Calling 'urldb_save_search_tree'→
12
←
Calling 'urldb_save_search_tree'→
15
←
Calling 'urldb_save_search_tree'→
24
←
Returning from 'urldb_save_search_tree'→

path = malloc(path_alloc);
if (!path)
18
←
Assuming 'path' is non-null→
19
←
Taking false branch→
25
←
Assuming 'path' is non-null→
26
←
Taking false branch→
return;

path[0] = '\0';

for (h = parent->data, p = host, end = host + sizeof host;
    h && h != &db_root && p < end; h = h->parent) {
20
←
Assuming 'h' is null→
27
←
Assuming 'h' is null→
int written = snprintf(p, end - p, "%s%s", h->part,
		       (h->parent && h->parent->parent) ? "." : "");
if (written < 0) {
	free(path);
	return;
}
p += written;
}

h = parent->data;
if (h20.1
'h' is null
1
'h' is null
 && h->hsts.expires > expiry) {
hsts_expiry = h->hsts.expires;
hsts_include_subdomains = h->hsts.include_sub_domains;
}

urldb_count_urls(&parent->data->paths, expiry, &path_count);
28
←
Passing null pointer value via 1st parameter 'root'→
29
←
Calling 'urldb_count_urls'→

if (path_count > 0) {
21
←
Assuming 'path_count' is <= 0→
22
←
Taking false branch→
fprintf(fp, "%s %i ", host, hsts_include_subdomains);
urldb_write_timet(fp, hsts_expiry);
fprintf(fp, "%i\n", path_count);

urldb_write_paths(&parent->data->paths, host, fp,
		  &path, &path_alloc, &path_used, expiry);
} else if (hsts_expiry22.1
'hsts_expiry' is 0
) {
23
←
Taking false branch→
fprintf(fp, "%s %i ", host, hsts_include_subdomains);
urldb_write_timet(fp, hsts_expiry);
fprintf(fp, "0\n");
}

free(path);

urldb_save_search_tree(parent->right, fp);
572}


575/**
* Path data iterator (internal)
*
* \param parent Root of subtree to iterate over
* \param url_callback Callback function
* \param cookie_callback Callback function
* \return true to continue, false otherwise
*/
583static bool_Bool
584urldb_iterate_entries_path(const struct path_data *parent,
bool_Bool (*url_callback)(nsurl *url, const struct url_data *data),
bool_Bool (*cookie_callback)(const struct cookie_data *data))
587{
const struct path_data *p = parent;
const struct cookie_data *c;

do {
if (p->children != NULL((void*)0)) {
	/* Drill down into children */
	p = p->children;
} else {
	/* All leaf nodes in the path tree should have an URL or
	 * cookies attached to them. If this is not the case, it
	 * indicates that there's a bug in the file loader/URL
	 * insertion code. Therefore, assert this here. */
	assert(url_callback || cookie_callback)((url_callback || cookie_callback) ? (void) (0) : __assert_fail
 ("url_callback || cookie_callback", "content/urldb.c", 600, __extension__
 __PRETTY_FUNCTION__));

	/** \todo handle fragments? */
	if (url_callback) {
		const struct url_internal_data *u = &p->urld;

		assert(p->url)((p->url) ? (void) (0) : __assert_fail ("p->url", "content/urldb.c"
, 606, __extension__ __PRETTY_FUNCTION__));

		if (!url_callback(p->url,
				  (const struct url_data *) u))
			return false0;
	} else {
		c = (const struct cookie_data *)p->cookies;
		for (; c != NULL((void*)0); c = c->next) {
			if (!cookie_callback(c))
				return false0;
		}
	}

	/* Now, find next node to process. */
	while (p != parent) {
		if (p->next != NULL((void*)0)) {
			/* Have a sibling, process that */
			p = p->next;
			break;
		}

		/* Ascend tree */
		p = p->parent;
	}
}
} while (p != parent);

return true1;
634}


637/**
* Check whether a host string is an IP address.
*
* This call detects IPv4 addresses (all of dotted-quad or subsets,
* decimal or hexadecimal notations) and IPv6 addresses (including
* those containing embedded IPv4 addresses.)
*
* \param host a hostname terminated by '\0'
* \return true if the hostname is an IP address, false otherwise
*/
647static bool_Bool urldb__host_is_ip_address(const char *host)
648{
struct in_addr ipv4;
size_t host_len = strlen(host);
const char *sane_host;
const char *slash;
653#ifndef NO_IPV6
struct in6_addr ipv6;
char ipv6_addr[64];
unsigned int ipv6_addr_len;
657#endif
/**
* @todo FIXME Some parts of urldb.c make confusions between hosts
* and "prefixes", we can sometimes be erroneously passed more than
* just a host.  Sometimes we may be passed trailing slashes, or even
* whole path segments.  A specific criminal in this class is
* urldb_iterate_partial, which takes a prefix to search for, but
* passes that prefix to functions that expect only hosts.
*
* For the time being, we will accept such calls; we check if there
* is a / in the host parameter, and if there is, we take a copy and
* replace the / with a \0.  This is not a permanent solution; we
* should search through NetSurf and find all the callers that are
* in error and fix them.  When doing this task, it might be wise
* to replace the hideousness below with code that doesn't have to do
* this, and add assert(strchr(host, '/') == NULL); somewhere.
* -- rjek - 2010-11-04
*/

slash = strchr(host, '/');
if (slash == NULL((void*)0)) {
sane_host = host;
} else {
char *c = strdup(host);
c[slash - host] = '\0';
sane_host = c;
host_len = slash - host;
NSLOG(netsurf, INFO, "WARNING: called with non-host '%s'",do { if (NSLOG_LEVEL_INFO >= NSLOG_LEVEL_VERBOSE) { static
 nslog_entry_context_t _nslog_ctx = { &__nslog_category_netsurf
, NSLOG_LEVEL_INFO, "content/urldb.c", sizeof("content/urldb.c"
) - 1, __PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1, 685
, }; nslog__log(&_nslog_ctx, "WARNING: called with non-host '%s'"
, host); } } while(0)
      host)do { if (NSLOG_LEVEL_INFO >= NSLOG_LEVEL_VERBOSE) { static
 nslog_entry_context_t _nslog_ctx = { &__nslog_category_netsurf
, NSLOG_LEVEL_INFO, "content/urldb.c", sizeof("content/urldb.c"
) - 1, __PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1, 685
, }; nslog__log(&_nslog_ctx, "WARNING: called with non-host '%s'"
, host); } } while(0);
}

if (strspn(sane_host, "0123456789abcdefABCDEF[].:") < host_len)
goto out_false;

if (inet_aton(sane_host, &ipv4) != 0) {
/* This can only be a sane IPv4 address if it contains 3 dots.
 * Helpfully, inet_aton is happy to treat "a", "a.b", "a.b.c",
 * and "a.b.c.d" as valid IPv4 address strings where we only
 * support the full, dotted-quad, form.
 */
int num_dots = 0;
size_t index;

for (index = 0; index < host_len; index++) {
	if (sane_host[index] == '.')
		num_dots++;
}

if (num_dots == 3)
	goto out_true;
else
	goto out_false;
}

711#ifndef NO_IPV6
if ((host_len < 6) ||
   (sane_host[0] != '[') ||
   (sane_host[host_len - 1] != ']')) {
goto out_false;
}

ipv6_addr_len = host_len - 2;
if (ipv6_addr_len >= sizeof(ipv6_addr)) {
ipv6_addr_len = sizeof(ipv6_addr) - 1;
}
strncpy(ipv6_addr, sane_host + 1, ipv6_addr_len);
ipv6_addr[ipv6_addr_len] = '\0';

if (inet_pton(AF_INET610, ipv6_addr, &ipv6) == 1)
goto out_true;
727#endif

729out_false:
if (slash != NULL((void*)0)) free((void *)sane_host);
return false0;

733out_true:
if (slash != NULL((void*)0)) free((void *)sane_host);
return true1;
736}


739/**
* Compare host_part with prefix
*
* \param a host part
* \param b prefix
* \return 0 if match, non-zero, otherwise
*/
746static int urldb_search_match_prefix(const struct host_part *a, const char *b)
747{
const char *end, *dot;
int plen, ret;

assert(a && a != &db_root && b)((a && a != &db_root && b) ? (void) (0) :
 __assert_fail ("a && a != &db_root && b"
, "content/urldb.c", 751, __extension__ __PRETTY_FUNCTION__));

if (urldb__host_is_ip_address(b)) {
/* IP address */
return strncasecmp(a->part, b, strlen(b));
}

end = b + strlen(b) + 1;

while (b < end && a && a != &db_root) {
dot = strchr(b, '.');
if (!dot) {
	/* last segment */
	dot = end - 1;
}

/* Compare strings (length limited) */
if ((ret = strncasecmp(a->part, b, dot - b)) != 0)
	/* didn't match => return difference */
	return ret;

/* The strings matched */
if (dot < end - 1) {
	/* Consider segment lengths only in the case
	 * where the prefix contains segments */
	plen = strlen(a->part);
	if (plen > dot - b) {
		/* len(a) > len(b) */
		return 1;
	} else if (plen < dot - b) {
		/* len(a) < len(b) */
		return -1;
	}
}

b = dot + 1;
a = a->parent;
}

/* If we get here then either:
*    a) The path lengths differ
* or b) The hosts are identical
*/
if (a && a != &db_root && b >= end) {
/* len(a) > len(b) => prefix matches */
return 0;
} else if ((!a || a == &db_root) && b < end) {
/* len(a) < len(b) => prefix does not match */
return -1;
}

/* Identical */
return 0;
804}


807/**
* Partial host iterator (internal)
*
* \param root Root of (sub)tree to traverse
* \param prefix Prefix to match
* \param callback Callback function
* \return true to continue, false otherwise
*/
815static bool_Bool
816urldb_iterate_partial_host(struct search_node *root,
const char *prefix,
bool_Bool (*callback)(nsurl *url, const struct url_data *data))
819{
int c;

assert(root && prefix && callback)((root && prefix && callback) ? (void) (0) : __assert_fail
 ("root && prefix && callback", "content/urldb.c"
, 822, __extension__ __PRETTY_FUNCTION__));

if (root == &empty)
return true1;

c = urldb_search_match_prefix(root->data, prefix);

if (c > 0) {
/* No match => look in left subtree */
return urldb_iterate_partial_host(root->left,
				  prefix,
				  callback);
} else if (c < 0) {
/* No match => look in right subtree */
return urldb_iterate_partial_host(root->right,
				  prefix,
				  callback);
} else {
/* Match => iterate over l/r subtrees & process this node */
if (!urldb_iterate_partial_host(root->left,
				prefix,
				callback)) {
	return false0;
}

if (root->data->paths.children) {
	/* and extract all paths attached to this host */
	if (!urldb_iterate_entries_path(&root->data->paths,
					callback,
					NULL((void*)0))) {
		return false0;
	}
}

if (!urldb_iterate_partial_host(root->right,
				prefix,
				callback)) {
	return false0;
}
}

return true1;
864}


867/**
* Partial path iterator (internal)
*
* Given: http://www.example.org/a/b/c/d//e
* and assuming a path tree:
*     ^
*    /	\
*   a1 b1
*  / \
* a2 b2
*    /|\
*   a b c
*   3 3 |
*       d
*       |
*       e
*      / \
*      f g
*
* Prefix will be:	p will be:
*
* a/b/c/d//e		a1
*   b/c/d//e		a2
*   b/c/d//e		b3
*     c/d//e		a3
*     c/d//e		b3
*     c/d//e		c
*       d//e		d
*         /e		e		(skip /)
*          e		e
*
* I.E. perform a breadth-first search of the tree.
*
* \param parent Root of (sub)tree to traverse
* \param prefix Prefix to match
* \param callback Callback function
* \return true to continue, false otherwise
*/
905static bool_Bool
906urldb_iterate_partial_path(const struct path_data *parent,
const char *prefix,
bool_Bool (*callback)(nsurl *url, const struct url_data *data))
909{
const struct path_data *p = parent->children;
const char *slash, *end = prefix + strlen(prefix);

do {
slash = strchr(prefix, '/');
if (!slash) {
	slash = end;
}

if (slash == prefix && *prefix == '/') {
	/* Ignore "//" */
	prefix++;
	continue;
}

if (strncasecmp(p->segment, prefix, slash - prefix) == 0) {
	/* prefix matches so far */
	if (slash == end) {
		/* we've run out of prefix, so all
		 * paths below this one match */
		if (!urldb_iterate_entries_path(p,
						callback,
						NULL((void*)0))) {
			return false0;
		}

		/* Progress to next sibling */
		p = p->next;
	} else {
		/* Skip over this segment */
		prefix = slash + 1;

		p = p->children;
	}
} else {
	/* Doesn't match this segment, try next sibling */
	p = p->next;
}
} while (p != NULL((void*)0));

return true1;
951}


954/**
* Host data iterator (internal)
*
* \param parent Root of subtree to iterate over
* \param url_callback Callback function
* \param cookie_callback Callback function
* \return true to continue, false otherwise
*/
962static bool_Bool
963urldb_iterate_entries_host(struct search_node *parent,
bool_Bool (*url_callback)(nsurl *url, const struct url_data *data),
bool_Bool (*cookie_callback)(const struct cookie_data *data))
966{
if (parent == &empty) {
return true1;
}

if (!urldb_iterate_entries_host(parent->left,
			url_callback,
			cookie_callback)) {
return false0;
}

if ((parent->data->paths.children) ||
   ((cookie_callback) &&
    (parent->data->paths.cookies))) {
/* We have paths (or domain cookies), so iterate them */
if (!urldb_iterate_entries_path(&parent->data->paths,
				url_callback,
				cookie_callback)) {
	return false0;
}
}

if (!urldb_iterate_entries_host(parent->right,
			url_callback,
			cookie_callback)) {
return false0;
}

return true1;
995}


998/**
* Add a host node to the tree
*
* \param part Host segment to add (or whole IP address) (copied)
* \param parent Parent node to add to
* \return Pointer to added node, or NULL on memory exhaustion
*/
1005static struct host_part *
1006urldb_add_host_node(const char *part, struct host_part *parent)
1007{
struct host_part *d;

assert(part && parent)((part && parent) ? (void) (0) : __assert_fail ("part && parent"
, "content/urldb.c", 1010, __extension__ __PRETTY_FUNCTION__)
);

d = calloc(1, sizeof(struct host_part));
if (!d) {
return NULL((void*)0);
}

d->part = strdup(part);
if (!d->part) {
free(d);
return NULL((void*)0);
}

d->next = parent->children;
if (parent->children) {
parent->children->prev = d;
}
d->parent = parent;
parent->children = d;

return d;
1031}


1034/**
* Fragment comparator callback for qsort
*
* \param a first value
* \param b second value
* \return 0 for equal else positive or negative value on comparison
*/
1041static int urldb_add_path_fragment_cmp(const void *a, const void *b)
1042{
return strcasecmp(*((const char **) a), *((const char **) b));
1044}


1047/**
* Add a fragment to a path segment
*
* \param segment Path segment to add to
* \param fragment Fragment to add (copied), or NULL
* \return segment or NULL on memory exhaustion
*/
1054static struct path_data *
1055urldb_add_path_fragment(struct path_data *segment, lwc_string *fragment)
1056{
char **temp;

assert(segment)((segment) ? (void) (0) : __assert_fail ("segment", "content/urldb.c"
, 1059, __extension__ __PRETTY_FUNCTION__));

/* If no fragment, this function is a NOP
* This may seem strange, but it makes the rest
* of the code cleaner */
if (!fragment)
return segment;

temp = realloc(segment->fragment,
       (segment->frag_cnt + 1) * sizeof(char *));
if (!temp)
return NULL((void*)0);

segment->fragment = temp;
segment->fragment[segment->frag_cnt] =
strdup(lwc_string_data(fragment)({((fragment != ((void*)0)) ? (void) (0) : __assert_fail ("fragment != NULL"
, "content/urldb.c", 1074, __extension__ __PRETTY_FUNCTION__)
); (const char *)((fragment)+1);}));
if (!segment->fragment[segment->frag_cnt]) {
/* Don't free temp - it's now our buffer */
return NULL((void*)0);
}

segment->frag_cnt++;

/* We want fragments in alphabetical order, so sort them
* It may prove better to insert in alphabetical order instead */
qsort(segment->fragment,
     segment->frag_cnt,
     sizeof (char *),
     urldb_add_path_fragment_cmp);

return segment;
1090}


1093/**
* Add a path node to the tree
*
* \param scheme URL scheme associated with path (copied)
* \param port Port number on host associated with path
* \param segment Path segment to add (copied)
* \param fragment URL fragment (copied), or NULL
* \param parent Parent node to add to
* \return Pointer to added node, or NULL on memory exhaustion
*/
1103static struct path_data *
1104urldb_add_path_node(lwc_string *scheme,
    unsigned int port,
    const char *segment,
    lwc_string *fragment,
    struct path_data *parent)
1109{
struct path_data *d, *e;

assert(scheme && segment && parent)((scheme && segment && parent) ? (void) (0) :
 __assert_fail ("scheme && segment && parent"
, "content/urldb.c", 1112, __extension__ __PRETTY_FUNCTION__)
);

d = calloc(1, sizeof(struct path_data));
if (!d)
return NULL((void*)0);

d->scheme = lwc_string_ref(scheme)({lwc_string *__lwc_s = (scheme); ((__lwc_s != ((void*)0)) ? (
void) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c"
, 1118, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt
++; __lwc_s;});

d->port = port;

d->segment = strdup(segment);
if (!d->segment) {
lwc_string_unref(d->scheme){ lwc_string *__lwc_s = (d->scheme); ((__lwc_s != ((void*)
0)) ? (void) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c"
, 1124, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt
--; if ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1
) && (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy
(__lwc_s); };
free(d);
return NULL((void*)0);
}

if (fragment) {
if (!urldb_add_path_fragment(d, fragment)) {
	free(d->segment);
	lwc_string_unref(d->scheme){ lwc_string *__lwc_s = (d->scheme); ((__lwc_s != ((void*)
0)) ? (void) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c"
, 1132, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt
--; if ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1
) && (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy
(__lwc_s); };
	free(d);
	return NULL((void*)0);
}
}

for (e = parent->children; e; e = e->next) {
if (strcmp(e->segment, d->segment) > 0)
	break;
}

if (e) {
d->prev = e->prev;
d->next = e;
if (e->prev)
	e->prev->next = d;
else
	parent->children = d;
e->prev = d;
} else if (!parent->children) {
d->prev = d->next = NULL((void*)0);
parent->children = parent->last = d;
} else {
d->next = NULL((void*)0);
d->prev = parent->last;
parent->last->next = d;
parent->last = d;
}
d->parent = parent;

return d;
1163}


1166/**
* Get the search tree for a particular host
*
* \param host the host to lookup
* \return the corresponding search tree
*/
1172static struct search_node **urldb_get_search_tree_direct(const char *host)
1173{
assert(host)((host) ? (void) (0) : __assert_fail ("host", "content/urldb.c"
, 1174, __extension__ __PRETTY_FUNCTION__));

if (urldb__host_is_ip_address(host)) {
return &search_trees[ST_IP0];
} else if (ascii_is_alpha(*host)) {
return &search_trees[ST_DN2 + ascii_to_lower(*host) - 'a'];
}
return &search_trees[ST_EE1];
1182}


1185/**
* Get the search tree for a particular host
*
* \param host the host to lookup
* \return the corresponding search tree
*/
1191static struct search_node *urldb_get_search_tree(const char *host)
1192{
return *urldb_get_search_tree_direct(host);
1194}


1197/**
* Compare host part with a string
*
* \param a host part
* \param b string to compare
* \return 0 if match, non-zero, otherwise
*/
1204static int urldb_search_match_string(const struct host_part *a, const char *b)
1205{
const char *end, *dot;
int plen, ret;

assert(a && a != &db_root && b)((a && a != &db_root && b) ? (void) (0) :
 __assert_fail ("a && a != &db_root && b"
, "content/urldb.c", 1209, __extension__ __PRETTY_FUNCTION__)
);

if (urldb__host_is_ip_address(b)) {
/* IP address */
return strcasecmp(a->part, b);
}

end = b + strlen(b) + 1;

while (b < end && a && a != &db_root) {
dot = strchr(b, '.');
if (!dot) {
	/* last segment */
	dot = end - 1;
}

/* Compare strings (length limited) */
if ((ret = strncasecmp(a->part, b, dot - b)) != 0)
	/* didn't match => return difference */
	return ret;

/* The strings matched, now check that the lengths do, too */
plen = strlen(a->part);

if (plen > dot - b) {
	/* len(a) > len(b) */
	return 1;
} else if (plen < dot - b) {
	/* len(a) < len(b) */
	return -1;
}

b = dot + 1;
a = a->parent;
}

/* If we get here then either:
*    a) The path lengths differ
* or b) The hosts are identical
*/
if (a && a != &db_root && b >= end) {
/* len(a) > len(b) */
return 1;
} else if ((!a || a == &db_root) && b < end) {
/* len(a) < len(b) */
return -1;
}

/* Identical */
return 0;
1259}


1262/**
* Find a node in a search tree
*
* \param root Tree to look in
* \param host Host to find
* \return Pointer to host tree node, or NULL if not found
*/
1269static const struct host_part *
1270urldb_search_find(struct search_node *root, const char *host)
1271{
int c;

assert(root && host)((root && host) ? (void) (0) : __assert_fail ("root && host"
, "content/urldb.c", 1274, __extension__ __PRETTY_FUNCTION__)
);

if (root == &empty) {
return NULL((void*)0);
}

c = urldb_search_match_string(root->data, host);

if (c > 0) {
return urldb_search_find(root->left, host);
} else if (c < 0) {
return urldb_search_find(root->right, host);
}

return root->data;
1289}


1292/**
* Match a path string
*
* \param parent Path (sub)tree to look in
* \param path The path to search for
* \param scheme The URL scheme associated with the path
* \param port The port associated with the path
* \return Pointer to path data or NULL if not found.
*/
1301static struct path_data *
1302urldb_match_path(const struct path_data *parent,
 const char *path,
 lwc_string *scheme,
 unsigned short port)
1306{
const struct path_data *p;
const char *slash;
bool_Bool match;

assert(parent != NULL)((parent != ((void*)0)) ? (void) (0) : __assert_fail ("parent != NULL"
, "content/urldb.c", 1311, __extension__ __PRETTY_FUNCTION__)
);
assert(parent->segment == NULL)((parent->segment == ((void*)0)) ? (void) (0) : __assert_fail
 ("parent->segment == NULL", "content/urldb.c", 1312, __extension__
 __PRETTY_FUNCTION__));

if (path[0] != '/') {
NSLOG(netsurf, INFO, "path is %s", path)do { if (NSLOG_LEVEL_INFO >= NSLOG_LEVEL_VERBOSE) { static
 nslog_entry_context_t _nslog_ctx = { &__nslog_category_netsurf
, NSLOG_LEVEL_INFO, "content/urldb.c", sizeof("content/urldb.c"
) - 1, __PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1, 1315
, }; nslog__log(&_nslog_ctx, "path is %s", path); } } while
(0);
}

assert(path[0] == '/')((path[0] == '/') ? (void) (0) : __assert_fail ("path[0] == '/'"
, "content/urldb.c", 1318, __extension__ __PRETTY_FUNCTION__)
);

/* Start with children, as parent has no segment */
p = parent->children;

while (p != NULL((void*)0)) {
slash = strchr(path + 1, '/');
if (!slash) {
	slash = path + strlen(path);
}

if (strncmp(p->segment, path + 1, slash - path - 1) == 0 &&
    lwc_string_isequal(p->scheme, scheme, &match)((*(&match) = ((p->scheme) == (scheme))), lwc_error_ok
) == lwc_error_ok &&
    match == true1 &&
    p->port == port) {
	if (*slash == '\0') {
		/* Complete match */
		return (struct path_data *) p;
	}

	/* Match so far, go down tree */
	p = p->children;

	path = slash;
} else {
	/* No match, try next sibling */
	p = p->next;
}
}

return NULL((void*)0);
1349}


1352/**
* Find an URL in the database
*
* \param url Absolute URL to find
* \return Pointer to path data, or NULL if not found
*/
1358static struct path_data *urldb_find_url(nsurl *url)
1359{
const struct host_part *h;
struct path_data *p;
struct search_node *tree;
char *plq;
const char *host_str;
lwc_string *scheme, *host, *port;
size_t len = 0;
unsigned int port_int;
bool_Bool match;

assert(url)((url) ? (void) (0) : __assert_fail ("url", "content/urldb.c"
, 1370, __extension__ __PRETTY_FUNCTION__));

if (url_bloom != NULL((void*)0)) {
if (bloom_search_hash(url_bloom, nsurl_hash(url)) == false0) {
	return NULL((void*)0);
}
}

scheme = nsurl_get_component(url, NSURL_SCHEME);
if (scheme == NULL((void*)0))
return NULL((void*)0);

if (lwc_string_isequal(scheme, corestring_lwc_mailto, &match)((*(&match) = ((scheme) == (corestring_lwc_mailto))), lwc_error_ok
) ==
   lwc_error_ok && match == true1) {
lwc_string_unref(scheme){ lwc_string *__lwc_s = (scheme); ((__lwc_s != ((void*)0)) ? (
void) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c"
, 1384, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt
--; if ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1
) && (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy
(__lwc_s); };
return NULL((void*)0);
}

host = nsurl_get_component(url, NSURL_HOST);
if (host != NULL((void*)0)) {
host_str = lwc_string_data(host)({((host != ((void*)0)) ? (void) (0) : __assert_fail ("host != NULL"
, "content/urldb.c", 1390, __extension__ __PRETTY_FUNCTION__)
); (const char *)((host)+1);});
lwc_string_unref(host){ lwc_string *__lwc_s = (host); ((__lwc_s != ((void*)0)) ? (void
) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c", 1391
, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt--; if
 ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1) &&
 (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy(__lwc_s
); };

} else if (lwc_string_isequal(scheme, corestring_lwc_file, &match)((*(&match) = ((scheme) == (corestring_lwc_file))), lwc_error_ok
) ==
   lwc_error_ok && match == true1) {
host_str = "localhost";

} else {
lwc_string_unref(scheme){ lwc_string *__lwc_s = (scheme); ((__lwc_s != ((void*)0)) ? (
void) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c"
, 1398, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt
--; if ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1
) && (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy
(__lwc_s); };
return NULL((void*)0);
}

tree = urldb_get_search_tree(host_str);
h = urldb_search_find(tree, host_str);
if (!h) {
lwc_string_unref(scheme){ lwc_string *__lwc_s = (scheme); ((__lwc_s != ((void*)0)) ? (
void) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c"
, 1405, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt
--; if ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1
) && (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy
(__lwc_s); };
return NULL((void*)0);
}

/* generate plq (path, leaf, query) */
if (nsurl_get(url, NSURL_PATH | NSURL_QUERY, &plq, &len) != NSERROR_OK) {
lwc_string_unref(scheme){ lwc_string *__lwc_s = (scheme); ((__lwc_s != ((void*)0)) ? (
void) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c"
, 1411, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt
--; if ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1
) && (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy
(__lwc_s); };
return NULL((void*)0);
}

/* Get port */
port = nsurl_get_component(url, NSURL_PORT);
if (port != NULL((void*)0)) {
port_int = atoi(lwc_string_data(port)({((port != ((void*)0)) ? (void) (0) : __assert_fail ("port != NULL"
, "content/urldb.c", 1418, __extension__ __PRETTY_FUNCTION__)
); (const char *)((port)+1);}));
lwc_string_unref(port){ lwc_string *__lwc_s = (port); ((__lwc_s != ((void*)0)) ? (void
) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c", 1419
, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt--; if
 ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1) &&
 (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy(__lwc_s
); };
} else {
port_int = 0;
}

p = urldb_match_path(&h->paths, plq, scheme, port_int);

free(plq);
lwc_string_unref(scheme){ lwc_string *__lwc_s = (scheme); ((__lwc_s != ((void*)0)) ? (
void) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c"
, 1427, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt
--; if ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1
) && (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy
(__lwc_s); };

return p;
1430}


1433/**
* Dump URL database paths to stderr
*
* \param parent Parent node of tree to dump
*/
1438static void urldb_dump_paths(struct path_data *parent)
1439{
const struct path_data *p = parent;
unsigned int i;

do {
if (p->segment != NULL((void*)0)) {
	NSLOG(netsurf, INFO, "\t%s : %u",do { if (NSLOG_LEVEL_INFO >= NSLOG_LEVEL_VERBOSE) { static
 nslog_entry_context_t _nslog_ctx = { &__nslog_category_netsurf
, NSLOG_LEVEL_INFO, "content/urldb.c", sizeof("content/urldb.c"
) - 1, __PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1, 1446
, }; nslog__log(&_nslog_ctx, "\t%s : %u", ({((p->scheme
 != ((void*)0)) ? (void) (0) : __assert_fail ("p->scheme != NULL"
, "content/urldb.c", 1446, __extension__ __PRETTY_FUNCTION__)
); (const char *)((p->scheme)+1);}), p->port); } } while
(0)
	      lwc_string_data(p->scheme), p->port)do { if (NSLOG_LEVEL_INFO >= NSLOG_LEVEL_VERBOSE) { static
 nslog_entry_context_t _nslog_ctx = { &__nslog_category_netsurf
, NSLOG_LEVEL_INFO, "content/urldb.c", sizeof("content/urldb.c"
) - 1, __PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1, 1446
, }; nslog__log(&_nslog_ctx, "\t%s : %u", ({((p->scheme
 != ((void*)0)) ? (void) (0) : __assert_fail ("p->scheme != NULL"
, "content/urldb.c", 1446, __extension__ __PRETTY_FUNCTION__)
); (const char *)((p->scheme)+1);}), p->port); } } while
(0);

	NSLOG(netsurf, INFO, "\t\t'%s'", p->segment)do { if (NSLOG_LEVEL_INFO >= NSLOG_LEVEL_VERBOSE) { static
 nslog_entry_context_t _nslog_ctx = { &__nslog_category_netsurf
, NSLOG_LEVEL_INFO, "content/urldb.c", sizeof("content/urldb.c"
) - 1, __PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1, 1448
, }; nslog__log(&_nslog_ctx, "\t\t'%s'", p->segment); }
 } while(0);

	for (i = 0; i != p->frag_cnt; i++) {
		NSLOG(netsurf, INFO, "\t\t\t#%s",do { if (NSLOG_LEVEL_INFO >= NSLOG_LEVEL_VERBOSE) { static
 nslog_entry_context_t _nslog_ctx = { &__nslog_category_netsurf
, NSLOG_LEVEL_INFO, "content/urldb.c", sizeof("content/urldb.c"
) - 1, __PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1, 1452
, }; nslog__log(&_nslog_ctx, "\t\t\t#%s", p->fragment[
i]); } } while(0)
		      p->fragment[i])do { if (NSLOG_LEVEL_INFO >= NSLOG_LEVEL_VERBOSE) { static
 nslog_entry_context_t _nslog_ctx = { &__nslog_category_netsurf
, NSLOG_LEVEL_INFO, "content/urldb.c", sizeof("content/urldb.c"
) - 1, __PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1, 1452
, }; nslog__log(&_nslog_ctx, "\t\t\t#%s", p->fragment[
i]); } } while(0);
	}
}

if (p->children != NULL((void*)0)) {
	p = p->children;
} else {
	while (p != parent) {
		if (p->next != NULL((void*)0)) {
			p = p->next;
			break;
		}

		p = p->parent;
	}
}
} while (p != parent);
1469}


1472/**
* Dump URL database hosts to stderr
*
* \param parent Parent node of tree to dump
*/
1477static void urldb_dump_hosts(struct host_part *parent)
1478{
struct host_part *h;

if (parent->part) {
NSLOG(netsurf, INFO, "%s", parent->part)do { if (NSLOG_LEVEL_INFO >= NSLOG_LEVEL_VERBOSE) { static
 nslog_entry_context_t _nslog_ctx = { &__nslog_category_netsurf
, NSLOG_LEVEL_INFO, "content/urldb.c", sizeof("content/urldb.c"
) - 1, __PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1, 1482
, }; nslog__log(&_nslog_ctx, "%s", parent->part); } } while
(0);

NSLOG(netsurf, INFO, "\t%s invalid SSL certs",do { if (NSLOG_LEVEL_INFO >= NSLOG_LEVEL_VERBOSE) { static
 nslog_entry_context_t _nslog_ctx = { &__nslog_category_netsurf
, NSLOG_LEVEL_INFO, "content/urldb.c", sizeof("content/urldb.c"
) - 1, __PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1, 1485
, }; nslog__log(&_nslog_ctx, "\t%s invalid SSL certs", parent
->permit_invalid_certs ? "Permits" : "Denies"); } } while(
0)
      parent->permit_invalid_certs ? "Permits" : "Denies")do { if (NSLOG_LEVEL_INFO >= NSLOG_LEVEL_VERBOSE) { static
 nslog_entry_context_t _nslog_ctx = { &__nslog_category_netsurf
, NSLOG_LEVEL_INFO, "content/urldb.c", sizeof("content/urldb.c"
) - 1, __PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1, 1485
, }; nslog__log(&_nslog_ctx, "\t%s invalid SSL certs", parent
->permit_invalid_certs ? "Permits" : "Denies"); } } while(
0);
}

/* Dump path data */
urldb_dump_paths(&parent->paths);

/* and recurse */
for (h = parent->children; h; h = h->next) {
urldb_dump_hosts(h);
}
1495}


1498/**
* Dump search tree
*
* \param parent Parent node of tree to dump
* \param depth Tree depth
*/
1504static void urldb_dump_search(struct search_node *parent, int depth)
1505{
const struct host_part *h;
int i; /* index into string */
char s[1024];
int r;
int sl = sizeof(s) - 2;

if (parent == &empty)
return;

urldb_dump_search(parent->left, depth + 1);

for (i = 0; i != depth; i++) {
s[i] = ' ';
}

for (h = parent->data; h; h = h->parent) {
if (h->part) {
	r = snprintf(&s[i], sl - i, "%s", h->part);
	if (r < 0) {
		break;
	}
	if ((i + r) >= sl) {
		break;
	}
	i += r;
}

if (h->parent && h->parent->parent) {
	s[i]='.';
	i++;
}
}
s[i]= 0;

NSLOG(netsurf, INFO, "%s", s)do { if (NSLOG_LEVEL_INFO >= NSLOG_LEVEL_VERBOSE) { static
 nslog_entry_context_t _nslog_ctx = { &__nslog_category_netsurf
, NSLOG_LEVEL_INFO, "content/urldb.c", sizeof("content/urldb.c"
) - 1, __PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1, 1540
, }; nslog__log(&_nslog_ctx, "%s", s); } } while(0);

urldb_dump_search(parent->right, depth + 1);
1543}


1546/**
* Compare a pair of host parts
*
* \param a first host part
* \param b second host part
* \return 0 if match, non-zero, otherwise
*/
1553static int
1554urldb_search_match_host(const struct host_part *a, const struct host_part *b)
1555{
int ret;

assert(a && b)((a && b) ? (void) (0) : __assert_fail ("a && b"
, "content/urldb.c", 1558, __extension__ __PRETTY_FUNCTION__)
);

/* traverse up tree to root, comparing parts as we go. */
for (; a && a != &db_root && b && b != &db_root;
    a = a->parent, b = b->parent) {
if ((ret = strcasecmp(a->part, b->part)) != 0) {
	/* They differ => return the difference here */
	return ret;
}
}

/* If we get here then either:
*    a) The path lengths differ
* or b) The hosts are identical
*/
if (a && a != &db_root && (!b || b == &db_root)) {
/* len(a) > len(b) */
return 1;
} else if ((!a || a == &db_root) && b && b != &db_root) {
/* len(a) < len(b) */
return -1;
}

/* identical */
return 0;
1583}


1586/**
* Rotate a subtree right
*
* \param root Root of subtree to rotate
* \return new root of subtree
*/
1592static struct search_node *urldb_search_skew(struct search_node *root)
1593{
assert(root)((root) ? (void) (0) : __assert_fail ("root", "content/urldb.c"
, 1594, __extension__ __PRETTY_FUNCTION__));

if (root->left->level == root->level) {
struct search_node *temp;

temp = root->left;
root->left = temp->right;
temp->right = root;
root = temp;
}

return root;
1606}


1609/**
* Rotate a node left, increasing the parent's level
*
* \param root Root of subtree to rotate
* \return New root of subtree
*/
1615static struct search_node *urldb_search_split(struct search_node *root)
1616{
assert(root)((root) ? (void) (0) : __assert_fail ("root", "content/urldb.c"
, 1617, __extension__ __PRETTY_FUNCTION__));

if (root->right->right->level == root->level) {
struct search_node *temp;

temp = root->right;
root->right = temp->left;
temp->left = root;
root = temp;

root->level++;
}

return root;
1631}


1634/**
* Insert node into search tree
*
* \param root Root of (sub)tree to insert into
* \param n Node to insert
* \return Pointer to updated root
*/
1641static struct search_node *
1642urldb_search_insert_internal(struct search_node *root, struct search_node *n)
1643{
assert(root && n)((root && n) ? (void) (0) : __assert_fail ("root && n"
, "content/urldb.c", 1644, __extension__ __PRETTY_FUNCTION__)
);

if (root == &empty) {
root = n;
} else {
int c = urldb_search_match_host(root->data, n->data);

if (c > 0) {
	root->left = urldb_search_insert_internal(
		root->left, n);
} else if (c < 0) {
	root->right = urldb_search_insert_internal(
		root->right, n);
} else {
	/* exact match */
	free(n);
	return root;
}

root = urldb_search_skew(root);
root = urldb_search_split(root);
}

return root;
1668}


1671/**
* Insert a node into the search tree
*
* \param root Root of tree to insert into
* \param data User data to insert
* \return Pointer to updated root, or NULL if failed
*/
1678static struct search_node *
1679urldb_search_insert(struct search_node *root, const struct host_part *data)
1680{
struct search_node *n;

assert(root && data)((root && data) ? (void) (0) : __assert_fail ("root && data"
, "content/urldb.c", 1683, __extension__ __PRETTY_FUNCTION__)
);

n = malloc(sizeof(struct search_node));
if (!n)
return NULL((void*)0);

n->level = 1;
n->data = data;
n->left = n->right = &empty;

root = urldb_search_insert_internal(root, n);

return root;
1696}


1699/**
* Parse a cookie avpair
*
* \param c Cookie struct to populate
* \param n Name component
* \param v Value component
* \param was_quoted Whether \a v was quoted in the input
* \return true on success, false on memory exhaustion
*/
1708static bool_Bool
1709urldb_parse_avpair(struct cookie_internal_data *c,
   char *n,
   char *v,
   bool_Bool was_quoted)
1713{
int vlen;

assert(c && n && v)((c && n && v) ? (void) (0) : __assert_fail (
"c && n && v", "content/urldb.c", 1716, __extension__
 __PRETTY_FUNCTION__));

/* Strip whitespace from start of name */
for (; *n; n++) {
if (*n != ' ' && *n != '\t')
	break;
}

/* Strip whitespace from end of name */
for (vlen = strlen(n); vlen; vlen--) {
if (n[vlen] == ' ' || n[vlen] == '\t')
	n[vlen] = '\0';
else
	break;
}

/* Strip whitespace from start of value */
for (; *v; v++) {
if (*v != ' ' && *v != '\t')
	break;
}

/* Strip whitespace from end of value */
for (vlen = strlen(v); vlen; vlen--) {
if (v[vlen] == ' ' || v[vlen] == '\t')
	v[vlen] = '\0';
else
	break;
}

if (!c->comment && strcasecmp(n, "Comment") == 0) {
c->comment = strdup(v);
if (!c->comment)
	return false0;
} else if (!c->domain && strcasecmp(n, "Domain") == 0) {
if (v[0] == '.') {
	/* Domain must start with a dot */
	c->domain_from_set = true1;
	c->domain = strdup(v);
	if (!c->domain)
		return false0;
}
} else if (strcasecmp(n, "Max-Age") == 0) {
int temp = atoi(v);
if (temp == 0)
	/* Special case - 0 means delete */
	c->expires = 0;
else
	c->expires = time(NULL((void*)0)) + temp;
} else if (!c->path && strcasecmp(n, "Path") == 0) {
c->path_from_set = true1;
c->path = strdup(v);
if (!c->path)
	return false0;
} else if (strcasecmp(n, "Version") == 0) {
c->version = atoi(v);
} else if (strcasecmp(n, "Expires") == 0) {
char *datenoday;
time_t expires;
nserror res;

/* Strip dayname from date (these are hugely variable
 * and liable to break the parser.  They also serve no
 * useful purpose) */
for (datenoday = v;
     *datenoday && !ascii_is_digit(*datenoday);
     datenoday++) {
	/* do nothing */
}

res = nsc_strntimet(datenoday, strlen(datenoday), &expires);
if (res != NSERROR_OK) {
	/* assume we have an unrepresentable date =>
	 * force it to the maximum possible value of a
	 * 32bit time_t (this may break in 2038. We'll
	 * deal with that once we come to it) */
	expires = (time_t)0x7fffffff;
}
c->expires = expires;
} else if (strcasecmp(n, "Secure") == 0) {
c->secure = true1;
} else if (strcasecmp(n, "HttpOnly") == 0) {
c->http_only = true1;
} else if (!c->name) {
c->name = strdup(n);
c->value = strdup(v);
c->value_was_quoted = was_quoted;
if (!c->name || !c->value) {
	return false0;
}
}

return true1;
1809}


1812/**
* Free a cookie
*
* \param c The cookie to free
*/
1817static void urldb_free_cookie(struct cookie_internal_data *c)
1818{
assert(c)((c) ? (void) (0) : __assert_fail ("c", "content/urldb.c", 1819
, __extension__ __PRETTY_FUNCTION__));

free(c->comment);
free(c->domain);
free(c->path);
free(c->name);
free(c->value);
free(c);
1827}


1830/**
* Parse a cookie
*
* \param url URL being fetched
* \param cookie Pointer to cookie string (updated on exit)
* \return Pointer to cookie structure (on heap, caller frees) or NULL
*/
1837static struct cookie_internal_data *
1838urldb_parse_cookie(nsurl *url, const char **cookie)
1839{
struct cookie_internal_data *c;
const char *cur;
char name[1024], value[4096];
char *n = name, *v = value;
bool_Bool in_value = false0;
bool_Bool had_value_data = false0;
bool_Bool value_verbatim = false0;
bool_Bool quoted = false0;
bool_Bool was_quoted = false0;

assert(url && cookie && *cookie)((url && cookie && *cookie) ? (void) (0) : __assert_fail
 ("url && cookie && *cookie", "content/urldb.c"
, 1850, __extension__ __PRETTY_FUNCTION__));

c = calloc(1, sizeof(struct cookie_internal_data));
if (c == NULL((void*)0))
return NULL((void*)0);

c->expires = -1;

name[0] = '\0';
value[0] = '\0';

for (cur = *cookie; *cur; cur++) {
if (*cur == '\r' && *(cur + 1) == '\n') {
	/* End of header */
	if (quoted) {
		/* Unmatched quote encountered */

		/* Match Firefox 2.0.0.11 */
		value[0] = '\0';

	}

	break;
} else if (*cur == '\r') {
	/* Spurious linefeed */
	continue;
} else if (*cur == '\n') {
	/* Spurious newline */
	continue;
}

if (in_value && !had_value_data) {
	if (*cur == ' ' || *cur == '\t') {
		/* Strip leading whitespace from value */
		continue;
	} else {
		had_value_data = true1;

		/* Value is taken verbatim if first non-space
		 * character is not a " */
		if (*cur != '"') {
			value_verbatim = true1;
		}
	}
}

if (in_value && !value_verbatim && (*cur == '"')) {
	/* Only non-verbatim values may be quoted */
	if (cur == *cookie || *(cur - 1) != '\\') {
		/* Only unescaped quotes count */
		was_quoted = quoted;
		quoted = !quoted;

		continue;
	}
}

if (!quoted && !in_value && *cur == '=') {
	/* First equals => attr-value separator */
	in_value = true1;
	continue;
}

if (!quoted && (was_quoted || *cur == ';')) {
	/* Semicolon or after quoted value
	 * => end of current avpair */

	/* NUL-terminate tokens */
	*n = '\0';
	*v = '\0';

	if (!urldb_parse_avpair(c, name, value, was_quoted)) {
		/* Memory exhausted */
		urldb_free_cookie(c);
		return NULL((void*)0);
	}

	/* And reset to start */
	n = name;
	v = value;
	in_value = false0;
	had_value_data = false0;
	value_verbatim = false0;
	was_quoted = false0;

	/* Now, if the current input is anything other than a
	 * semicolon, we must be sure to reprocess it */
	if (*cur != ';') {
		cur--;
	}

	continue;
}

/* And now handle commas. These are a pain as they may mean
 * any of the following:
 *
 * + End of cookie
 * + Day separator in Expires avpair
 * + (Invalid) comma in unquoted value
 *
 * Therefore, in order to handle all 3 cases (2 and 3 are
 * identical, the difference being that 2 is in the spec and
 * 3 isn't), we need to determine where the comma actually
 * lies. We use the following heuristic:
 *
 *   Given a comma at the current input position, find the
 *   immediately following semicolon (or end of input if none
 *   found). Then, consider the input characters between
 *   these two positions. If any of these characters is an
 *   '=', we must assume that the comma signified the end of
 *   the current cookie.
 *
 * This holds as the first avpair of any cookie must be
 * NAME=VALUE, so the '=' is guaranteed to appear in the
 * case where the comma marks the end of a cookie.
 *
 * This will fail, however, in the case where '=' appears in
 * the value of the current avpair after the comma or the
 * subsequent cookie does not start with NAME=VALUE. Neither
 * of these is particularly likely and if they do occur, the
 * website is more broken than we can be bothered to handle.
 */
if (!quoted && *cur == ',') {
	/* Find semi-colon, if any */
	const char *p;
	const char *semi = strchr(cur + 1, ';');
	if (!semi)
		semi = cur + strlen(cur) - 2 /* CRLF */;

	/* Look for equals sign between comma and semi */
	for (p = cur + 1; p < semi; p++)
		if (*p == '=')
			break;

	if (p == semi) {
		/* none found => comma internal to value */
		/* do nothing */
	} else {
		/* found one => comma marks end of cookie */
		cur++;
		break;
	}
}

/* Accumulate into buffers, always leaving space for a NUL */
/** \todo is silently truncating overlong names/values wise? */
if (!in_value) {
	if (n < name + (sizeof(name) - 1))
		*n++ = *cur;
} else {
	if (v < value + (sizeof(value) - 1))
		*v++ = *cur;
}
}

/* Parse final avpair */
*n = '\0';
*v = '\0';

if (!urldb_parse_avpair(c, name, value, was_quoted)) {
/* Memory exhausted */
urldb_free_cookie(c);
return NULL((void*)0);
}

/* Now fix-up default values */
if (c->domain == NULL((void*)0)) {
lwc_string *host = nsurl_get_component(url, NSURL_HOST);
if (host == NULL((void*)0)) {
	urldb_free_cookie(c);
	return NULL((void*)0);
}
c->domain = strdup(lwc_string_data(host)({((host != ((void*)0)) ? (void) (0) : __assert_fail ("host != NULL"
, "content/urldb.c", 2023, __extension__ __PRETTY_FUNCTION__)
); (const char *)((host)+1);}));
lwc_string_unref(host){ lwc_string *__lwc_s = (host); ((__lwc_s != ((void*)0)) ? (void
) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c", 2024
, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt--; if
 ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1) &&
 (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy(__lwc_s
); };
}

if (c->path == NULL((void*)0)) {
const char *path_data;
char *path, *slash;
lwc_string *path_lwc;

path_lwc = nsurl_get_component(url, NSURL_PATH);
if (path_lwc == NULL((void*)0)) {
	urldb_free_cookie(c);
	return NULL((void*)0);
}
path_data = lwc_string_data(path_lwc)({((path_lwc != ((void*)0)) ? (void) (0) : __assert_fail ("path_lwc != NULL"
, "content/urldb.c", 2037, __extension__ __PRETTY_FUNCTION__)
); (const char *)((path_lwc)+1);});

/* Strip leafname and trailing slash (4.3.1) */
slash = strrchr(path_data, '/');
if (slash != NULL((void*)0)) {
	/* Special case: retain first slash in path */
	if (slash == path_data)
		slash++;

	slash = strndup(path_data, slash - path_data);
	if (slash == NULL((void*)0)) {
		lwc_string_unref(path_lwc){ lwc_string *__lwc_s = (path_lwc); ((__lwc_s != ((void*)0)) ?
 (void) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c"
, 2048, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt
--; if ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1
) && (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy
(__lwc_s); };
		urldb_free_cookie(c);
		return NULL((void*)0);
	}

	path = slash;
	lwc_string_unref(path_lwc){ lwc_string *__lwc_s = (path_lwc); ((__lwc_s != ((void*)0)) ?
 (void) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c"
, 2054, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt
--; if ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1
) && (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy
(__lwc_s); };
} else {
	path = strdup(lwc_string_data(path_lwc)({((path_lwc != ((void*)0)) ? (void) (0) : __assert_fail ("path_lwc != NULL"
, "content/urldb.c", 2056, __extension__ __PRETTY_FUNCTION__)
); (const char *)((path_lwc)+1);}));
	lwc_string_unref(path_lwc){ lwc_string *__lwc_s = (path_lwc); ((__lwc_s != ((void*)0)) ?
 (void) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c"
, 2057, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt
--; if ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1
) && (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy
(__lwc_s); };
	if (path == NULL((void*)0)) {
		urldb_free_cookie(c);
		return NULL((void*)0);
	}
}

c->path = path;
}

/* Write back current position */
*cookie = cur;

return c;
2071}


2074/**
* Add a path to the database, creating any intermediate entries
*
* \param scheme URL scheme associated with path
* \param port Port number on host associated with path
* \param host Host tree node to attach to
* \param path_query Absolute path plus query to add (freed)
* \param fragment URL fragment, or NULL
* \param url URL (fragment ignored)
* \return Pointer to leaf node, or NULL on memory exhaustion
*/
2085static struct path_data *
2086urldb_add_path(lwc_string *scheme,
      unsigned int port,
      const struct host_part *host,
      char *path_query,
      lwc_string *fragment,
      nsurl *url)
2092{
struct path_data *d, *e;
char *buf = path_query;
char *segment, *slash;
bool_Bool match;

assert(scheme && host && url)((scheme && host && url) ? (void) (0) : __assert_fail
 ("scheme && host && url", "content/urldb.c",
 2098, __extension__ __PRETTY_FUNCTION__));

d = (struct path_data *) &host->paths;

/* skip leading '/' */
segment = buf;
if (*segment == '/')
segment++;

/* Process path segments */
do {
slash = strchr(segment, '/');
if (!slash) {
	/* last segment */
	/* look for existing entry */
	for (e = d->children; e; e = e->next)
		if (strcmp(segment, e->segment) == 0 &&
		    lwc_string_isequal(scheme,((*(&match) = ((scheme) == (e->scheme))), lwc_error_ok
)
				       e->scheme, &match)((*(&match) = ((scheme) == (e->scheme))), lwc_error_ok
) ==
		    lwc_error_ok &&
		    match == true1 &&
		    e->port == port)
			break;

	d = e ? urldb_add_path_fragment(e, fragment) :
		urldb_add_path_node(scheme, port,
				    segment, fragment, d);
	break;
}

*slash = '\0';

/* look for existing entry */
for (e = d->children; e; e = e->next)
	if (strcmp(segment, e->segment) == 0 &&
	    lwc_string_isequal(scheme, e->scheme,((*(&match) = ((scheme) == (e->scheme))), lwc_error_ok
)
			       &match)((*(&match) = ((scheme) == (e->scheme))), lwc_error_ok
) == lwc_error_ok &&
	    match == true1 &&
	    e->port == port)
		break;

d = e ? e : urldb_add_path_node(scheme, port, segment, NULL((void*)0), d);
if (!d)
	break;

segment = slash + 1;
} while (1);

free(path_query);

if (d && !d->url) {
/* Insert defragmented URL */
if (nsurl_defragment(url, &d->url) != NSERROR_OK)
	return NULL((void*)0);
}

return d;
2155}


2158/**
* Add a host to the database, creating any intermediate entries
*
* \param host Hostname to add
* \return Pointer to leaf node, or NULL on memory exhaustion
*/
2164static struct host_part *urldb_add_host(const char *host)
2165{
struct host_part *d = (struct host_part *) &db_root, *e;
struct search_node *s;
char buf[256]; /* 256 bytes is sufficient - domain names are
	* limited to 255 chars. */
char *part;

assert(host)((host) ? (void) (0) : __assert_fail ("host", "content/urldb.c"
, 2172, __extension__ __PRETTY_FUNCTION__));

if (urldb__host_is_ip_address(host)) {
/* Host is an IP, so simply add as TLD */

/* Check for existing entry */
for (e = d->children; e; e = e->next)
	if (strcasecmp(host, e->part) == 0)
		/* found => return it */
		return e;

d = urldb_add_host_node(host, d);

s = urldb_search_insert(search_trees[ST_IP0], d);
if (!s) {
	/* failed */
	d = NULL((void*)0);
} else {
	search_trees[ST_IP0] = s;
}

return d;
}

/* Copy host string, so we can corrupt it */
strncpy(buf, host, sizeof buf);
buf[sizeof buf - 1] = '\0';

/* Process FQDN segments backwards */
do {
part = strrchr(buf, '.');
if (!part) {
	/* last segment */
	/* Check for existing entry */
	for (e = d->children; e; e = e->next)
		if (strcasecmp(buf, e->part) == 0)
			break;

	if (e) {
		d = e;
	} else {
		d = urldb_add_host_node(buf, d);
	}

	/* And insert into search tree */
	if (d) {
		struct search_node **r;

		r = urldb_get_search_tree_direct(buf);
		s = urldb_search_insert(*r, d);
		if (!s) {
			/* failed */
			d = NULL((void*)0);
		} else {
			*r = s;
		}
	}
	break;
}

/* Check for existing entry */
for (e = d->children; e; e = e->next)
	if (strcasecmp(part + 1, e->part) == 0)
		break;

d = e ? e : urldb_add_host_node(part + 1, d);
if (!d)
	break;

*part = '\0';
} while (1);

return d;
2245}


2248/**
* Insert a cookie into the database
*
* \param c The cookie to insert
* \param scheme URL scheme associated with cookie path
* \param url URL (sans fragment) associated with cookie
* \return true on success, false on memory exhaustion (c will be freed)
*/
2256static bool_Bool
2257urldb_insert_cookie(struct cookie_internal_data *c,
    lwc_string *scheme,
    nsurl *url)
2260{
struct cookie_internal_data *d;
const struct host_part *h;
struct path_data *p;
time_t now = time(NULL((void*)0));

assert(c)((c) ? (void) (0) : __assert_fail ("c", "content/urldb.c", 2266
, __extension__ __PRETTY_FUNCTION__));

if (c->domain[0] == '.') {
h = urldb_search_find(
	urldb_get_search_tree(&(c->domain[1])),
	c->domain + 1);
if (!h) {
	h = urldb_add_host(c->domain + 1);
	if (!h) {
		urldb_free_cookie(c);
		return false0;
	}
}

p = (struct path_data *) &h->paths;
} else {
/* Need to have a URL and scheme, if it's not a domain cookie */
assert(url != NULL)((url != ((void*)0)) ? (void) (0) : __assert_fail ("url != NULL"
, "content/urldb.c", 2283, __extension__ __PRETTY_FUNCTION__)
);
assert(scheme != NULL)((scheme != ((void*)0)) ? (void) (0) : __assert_fail ("scheme != NULL"
, "content/urldb.c", 2284, __extension__ __PRETTY_FUNCTION__)
);

h = urldb_search_find(
	urldb_get_search_tree(c->domain),
	c->domain);

if (!h) {
	h = urldb_add_host(c->domain);
	if (!h) {
		urldb_free_cookie(c);
		return false0;
	}
}

/* find path */
p = urldb_add_path(scheme, 0, h,
		   strdup(c->path), NULL((void*)0), url);
if (!p) {
	urldb_free_cookie(c);
	return false0;
}
}

/* add cookie */
for (d = p->cookies; d; d = d->next) {
if (!strcmp(d->domain, c->domain) &&
    !strcmp(d->path, c->path) &&
    !strcmp(d->name, c->name))
	break;
}

if (d) {
if (c->expires != -1 && c->expires < now) {
	/* remove cookie */
	if (d->next)
		d->next->prev = d->prev;
	else
		p->cookies_end = d->prev;
	if (d->prev)
		d->prev->next = d->next;
	else
		p->cookies = d->next;

	cookie_manager_remove((struct cookie_data *)d);

	urldb_free_cookie(d);
	urldb_free_cookie(c);
} else {
	/* replace d with c */
	c->prev = d->prev;
	c->next = d->next;
	if (c->next)
		c->next->prev = c;
	else
		p->cookies_end = c;
	if (c->prev)
		c->prev->next = c;
	else
		p->cookies = c;

	cookie_manager_remove((struct cookie_data *)d);
	urldb_free_cookie(d);

	cookie_manager_add((struct cookie_data *)c);
}
} else {
c->prev = p->cookies_end;
c->next = NULL((void*)0);
if (p->cookies_end)
	p->cookies_end->next = c;
else
	p->cookies = c;
p->cookies_end = c;

cookie_manager_add((struct cookie_data *)c);
}

return true1;
2362}


2365/**
* Concatenate a cookie into the provided buffer
*
* \param c Cookie to concatenate
* \param version The version of the cookie string to output
* \param used Pointer to amount of buffer used (updated)
* \param alloc Pointer to allocated size of buffer (updated)
* \param buf Pointer to Pointer to buffer (updated)
* \return true on success, false on memory exhaustion
*/
2375static bool_Bool
2376urldb_concat_cookie(struct cookie_internal_data *c,
    int version,
    int *used,
    int *alloc,
    char **buf)
2381{
/* Combined (A)BNF for the Cookie: request header:
*
* CHAR           = <any US-ASCII character (octets 0 - 127)>
* CTL            = <any US-ASCII control character
*                  (octets 0 - 31) and DEL (127)>
* CR             = <US-ASCII CR, carriage return (13)>
* LF             = <US-ASCII LF, linefeed (10)>
* SP             = <US-ASCII SP, space (32)>
* HT             = <US-ASCII HT, horizontal-tab (9)>
* <">            = <US-ASCII double-quote mark (34)>
*
* CRLF           = CR LF
*
* LWS            = [CRLF] 1*( SP | HT )
*
* TEXT           = <any OCTET except CTLs,
*                  but including LWS>
*
* token          = 1*<any CHAR except CTLs or separators>
* separators     = "(" | ")" | "<" | ">" | "@"
*                | "," | ";" | ":" | "\" | <">
*                | "/" | "[" | "]" | "?" | "="
*                | "{" | "}" | SP | HT
*
* quoted-string  = ( <"> *(qdtext | quoted-pair ) <"> )
* qdtext         = <any TEXT except <">>
* quoted-pair    = "\" CHAR
*
* attr            =       token
* value           =       word
* word            =       token | quoted-string
*
* cookie          =       "Cookie:" cookie-version
*                         1*((";" | ",") cookie-value)
* cookie-value    =       NAME "=" VALUE [";" path] [";" domain]
* cookie-version  =       "$Version" "=" value
* NAME            =       attr
* VALUE           =       value
* path            =       "$Path" "=" value
* domain          =       "$Domain" "=" value
*
* A note on quoted-string handling:
*   The cookie data stored in the db is verbatim (i.e. sans enclosing
*   <">, if any, and with all quoted-pairs intact) thus all that we
*   need to do here is ensure that value strings which were quoted
*   in Set-Cookie or which include any of the separators are quoted
*   before use.
*
* A note on cookie-value separation:
*   We use semicolons for all separators, including between
*   cookie-values. This simplifies things and is backwards compatible.
*/
const char * const separators = "()<>@,;:\\\"/[]?={} \t";

int max_len;

assert(c && used && alloc && buf && *buf)((c && used && alloc && buf &&
 *buf) ? (void) (0) : __assert_fail ("c && used && alloc && buf && *buf"
, "content/urldb.c", 2438, __extension__ __PRETTY_FUNCTION__)
);

/* "; " cookie-value
* We allow for the possibility that values are quoted
*/
max_len = 2 + strlen(c->name) + 1 + strlen(c->value) + 2 +
(c->path_from_set ?
 8 + strlen(c->path) + 2 : 0) +
(c->domain_from_set ?
 10 + strlen(c->domain) + 2 : 0);

if (*used + max_len >= *alloc) {
char *temp = realloc(*buf, *alloc + 4096);
if (!temp) {
	return false0;
}
*buf = temp;
*alloc += 4096;
}

if (version == COOKIE_NETSCAPE) {
/* Original Netscape cookie */
sprintf(*buf + *used - 1, "; %s=", c->name);
*used += 2 + strlen(c->name) + 1;

/* The Netscape spec doesn't mention quoting of cookie values.
 * RFC 2109 $10.1.3 indicates that values must not be quoted.
 *
 * However, other browsers preserve quoting, so we should, too
 */
if (c->value_was_quoted) {
	sprintf(*buf + *used - 1, "\"%s\"", c->value);
	*used += 1 + strlen(c->value) + 1;
} else {
	/** \todo should we %XX-encode [;HT,SP] ? */
	/** \todo Should we strip escaping backslashes? */
	sprintf(*buf + *used - 1, "%s", c->value);
	*used += strlen(c->value);
}

/* We don't send path/domain information -- that's what the
 * Netscape spec suggests we should do, anyway. */
} else {
/* RFC2109 or RFC2965 cookie */
sprintf(*buf + *used - 1, "; %s=", c->name);
*used += 2 + strlen(c->name) + 1;

/* Value needs quoting if it contains any separator or if
 * it needs preserving from the Set-Cookie header */
if (c->value_was_quoted ||
    strpbrk(c->value, separators) != NULL((void*)0)) {
	sprintf(*buf + *used - 1, "\"%s\"", c->value);
	*used += 1 + strlen(c->value) + 1;
} else {
	sprintf(*buf + *used - 1, "%s", c->value);
	*used += strlen(c->value);
}

if (c->path_from_set) {
	/* Path, quoted if necessary */
	sprintf(*buf + *used - 1, "; $Path=");
	*used += 8;

	if (strpbrk(c->path, separators) != NULL((void*)0)) {
		sprintf(*buf + *used - 1, "\"%s\"", c->path);
		*used += 1 + strlen(c->path) + 1;
	} else {
		sprintf(*buf + *used - 1, "%s", c->path);
		*used += strlen(c->path);
	}
}

if (c->domain_from_set) {
	/* Domain, quoted if necessary */
	sprintf(*buf + *used - 1, "; $Domain=");
	*used += 10;

	if (strpbrk(c->domain, separators) != NULL((void*)0)) {
		sprintf(*buf + *used - 1, "\"%s\"", c->domain);
		*used += 1 + strlen(c->domain) + 1;
	} else {
		sprintf(*buf + *used - 1, "%s", c->domain);
		*used += strlen(c->domain);
	}
}
}

return true1;
2526}


2529/**
* deletes paths from a cookie.
*
* \param domain the cookie domain
* \param path the cookie path
* \param name The cookie name
* \param parent The url data of the cookie
*/
2537static void
2538urldb_delete_cookie_paths(const char *domain,
	  const char *path,
	  const char *name,
	  struct path_data *parent)
2542{
struct cookie_internal_data *c;
struct path_data *p = parent;

assert(parent)((parent) ? (void) (0) : __assert_fail ("parent", "content/urldb.c"
, 2546, __extension__ __PRETTY_FUNCTION__));

do {
for (c = p->cookies; c; c = c->next) {
	if (strcmp(c->domain, domain) == 0 &&
	    strcmp(c->path, path) == 0 &&
	    strcmp(c->name, name) == 0) {
		if (c->prev) {
			c->prev->next = c->next;
		} else {
			p->cookies = c->next;
		}

		if (c->next) {
			c->next->prev = c->prev;
		} else {
			p->cookies_end = c->prev;
		}

		urldb_free_cookie(c);

		return;
	}
}

if (p->children) {
	p = p->children;
} else {
	while (p != parent) {
		if (p->next != NULL((void*)0)) {
			p = p->next;
			break;
		}

		p = p->parent;
	}
}
} while (p != parent);
2584}


2587/**
* Deletes cookie hosts and their assoicated paths
*
* \param domain the cookie domain
* \param path the cookie path
* \param name The cookie name
* \param parent The url data of the cookie
*/
2595static void
2596urldb_delete_cookie_hosts(const char *domain,
	  const char *path,
	  const char *name,
	  struct host_part *parent)
2600{
struct host_part *h;
assert(parent)((parent) ? (void) (0) : __assert_fail ("parent", "content/urldb.c"
, 2602, __extension__ __PRETTY_FUNCTION__));

urldb_delete_cookie_paths(domain, path, name, &parent->paths);

for (h = parent->children; h; h = h->next) {
urldb_delete_cookie_hosts(domain, path, name, h);
}
2609}


2612/**
* Save a path subtree's cookies
*
* \param fp File pointer to write to
* \param parent Parent path
*/
2618static void urldb_save_cookie_paths(FILE *fp, struct path_data *parent)
2619{
struct path_data *p = parent;
time_t now = time(NULL((void*)0));

assert(fp && parent)((fp && parent) ? (void) (0) : __assert_fail ("fp && parent"
, "content/urldb.c", 2623, __extension__ __PRETTY_FUNCTION__)
);

do {
if (p->cookies != NULL((void*)0)) {
	struct cookie_internal_data *c;

	for (c = p->cookies; c != NULL((void*)0); c = c->next) {
		if (c->expires == -1 || c->expires < now) {
			/* Skip expired & session cookies */
			continue;
		}

		fprintf(fp,
			"%d\t%s\t%d\t%s\t%d\t%d\t%d\t%d\t%d\t%d\t"
			"%s\t%s\t%d\t%s\t%s\t%s\n",
			c->version, c->domain,
			c->domain_from_set, c->path,
			c->path_from_set, c->secure,
			c->http_only,
			(int)c->expires, (int)c->last_used,
			c->no_destroy, c->name, c->value,
			c->value_was_quoted,
			p->scheme ? lwc_string_data(p->scheme)({((p->scheme != ((void*)0)) ? (void) (0) : __assert_fail (
"p->scheme != NULL", "content/urldb.c", 2645, __extension__
 __PRETTY_FUNCTION__)); (const char *)((p->scheme)+1);}) :
			"unused",
			p->url ? nsurl_access(p->url) :
			"unused",
			c->comment ? c->comment : "");
	}
}

if (p->children != NULL((void*)0)) {
	p = p->children;
} else {
	while (p != parent) {
		if (p->next != NULL((void*)0)) {
			p = p->next;
			break;
		}

		p = p->parent;
	}
}
} while (p != parent);
2666}


2669/**
* Save a host subtree's cookies
*
* \param fp File pointer to write to
* \param parent Parent host
*/
2675static void urldb_save_cookie_hosts(FILE *fp, struct host_part *parent)
2676{
struct host_part *h;
assert(fp && parent)((fp && parent) ? (void) (0) : __assert_fail ("fp && parent"
, "content/urldb.c", 2678, __extension__ __PRETTY_FUNCTION__)
);

urldb_save_cookie_paths(fp, &parent->paths);

for (h = parent->children; h; h = h->next)
urldb_save_cookie_hosts(fp, h);
2684}


2687/**
* Destroy a cookie node
*
* \param c Cookie to destroy
*/
2692static void urldb_destroy_cookie(struct cookie_internal_data *c)
2693{
free(c->name);
free(c->value);
free(c->comment);
free(c->domain);
free(c->path);

free(c);
2701}


2704/**
* Destroy the contents of a path node
*
* \param node Node to destroy contents of (does not destroy node)
*/
2709static void urldb_destroy_path_node_content(struct path_data *node)
2710{
struct cookie_internal_data *a, *b;
unsigned int i;

if (node->url != NULL((void*)0)) {
nsurl_unref(node->url);
}

if (node->scheme != NULL((void*)0)) {
lwc_string_unref(node->scheme){ lwc_string *__lwc_s = (node->scheme); ((__lwc_s != ((void
*)0)) ? (void) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c"
, 2719, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt
--; if ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1
) && (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy
(__lwc_s); };
}

free(node->segment);
for (i = 0; i < node->frag_cnt; i++)
free(node->fragment[i]);
free(node->fragment);

free(node->urld.title);

for (a = node->cookies; a; a = b) {
b = a->next;
urldb_destroy_cookie(a);
}
2733}


2736/**
* Destroy protection space data
*
* \param space Protection space to destroy
*/
2741static void urldb_destroy_prot_space(struct prot_space_data *space)
2742{
lwc_string_unref(space->scheme){ lwc_string *__lwc_s = (space->scheme); ((__lwc_s != ((void
*)0)) ? (void) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c"
, 2743, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt
--; if ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1
) && (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy
(__lwc_s); };
free(space->realm);
free(space->auth);

free(space);
2748}


2751/**
* Destroy a path tree
*
* \param root Root node of tree to destroy
*/
2756static void urldb_destroy_path_tree(struct path_data *root)
2757{
struct path_data *p = root;

do {
if (p->children != NULL((void*)0)) {
	p = p->children;
} else {
	struct path_data *q = p;

	while (p != root) {
		if (p->next != NULL((void*)0)) {
			p = p->next;
			break;
		}

		p = p->parent;

		urldb_destroy_path_node_content(q);
		free(q);

		q = p;
	}

	urldb_destroy_path_node_content(q);
	free(q);
}
} while (p != root);
2784}


2787/**
* Destroy a host tree
*
* \param root Root node of tree to destroy
*/
2792static void urldb_destroy_host_tree(struct host_part *root)
2793{
struct host_part *a, *b;
struct path_data *p, *q;
struct prot_space_data *s, *t;

/* Destroy children */
for (a = root->children; a; a = b) {
b = a->next;
urldb_destroy_host_tree(a);
}

/* Now clean up paths */
for (p = root->paths.children; p; p = q) {
q = p->next;
urldb_destroy_path_tree(p);
}

/* Root path */
urldb_destroy_path_node_content(&root->paths);

/* Proctection space data */
for (s = root->prot_space; s; s = t) {
t = s->next;
urldb_destroy_prot_space(s);
}

/* And ourselves */
free(root->part);
free(root);
2822}


2825/**
* Destroy a search tree
*
* \param root Root node of tree to destroy
*/
2830static void urldb_destroy_search_tree(struct search_node *root)
2831{
/* Destroy children */
if (root->left != &empty)
urldb_destroy_search_tree(root->left);
if (root->right != &empty)
urldb_destroy_search_tree(root->right);

/* And destroy ourselves */
free(root);
2840}


2843/*************** External interface ***************/


2846/* exported interface documented in content/urldb.h */
2847void urldb_destroy(void)
2848{
struct host_part *a, *b;
int i;

/* Clean up search trees */
for (i = 0; i < NUM_SEARCH_TREES28; i++) {
if (search_trees[i] != &empty) {
	urldb_destroy_search_tree(search_trees[i]);
	search_trees[i] = &empty;
}
}

/* And database */
for (a = db_root.children; a; a = b) {
b = a->next;
urldb_destroy_host_tree(a);
}
memset(&db_root, 0, sizeof(db_root));

/* And the bloom filter */
if (url_bloom != NULL((void*)0)) {
bloom_destroy(url_bloom);
url_bloom = NULL((void*)0);
}
2872}


2875/* exported interface documented in netsurf/url_db.h */
2876nserror urldb_load(const char *filename)
2877{
2878#define MAXIMUM_URL_LENGTH 4096
char s[MAXIMUM_URL_LENGTH];
char host[256];
struct host_part *h;
int urls;
int i;
int version;
int length;
FILE *fp;

assert(filename)((filename) ? (void) (0) : __assert_fail ("filename", "content/urldb.c"
, 2888, __extension__ __PRETTY_FUNCTION__));

NSLOG(netsurf, INFO, "Loading URL file %s", filename)do { if (NSLOG_LEVEL_INFO >= NSLOG_LEVEL_VERBOSE) { static
 nslog_entry_context_t _nslog_ctx = { &__nslog_category_netsurf
, NSLOG_LEVEL_INFO, "content/urldb.c", sizeof("content/urldb.c"
) - 1, __PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1, 2890
, }; nslog__log(&_nslog_ctx, "Loading URL file %s", filename
); } } while(0);

if (url_bloom == NULL((void*)0))
url_bloom = bloom_create(BLOOM_SIZE(1024 * 32));

fp = fopen(filename, "r");
if (!fp) {
NSLOG(netsurf, INFO, "Failed to open file '%s' for reading",do { if (NSLOG_LEVEL_INFO >= NSLOG_LEVEL_VERBOSE) { static
 nslog_entry_context_t _nslog_ctx = { &__nslog_category_netsurf
, NSLOG_LEVEL_INFO, "content/urldb.c", sizeof("content/urldb.c"
) - 1, __PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1, 2898
, }; nslog__log(&_nslog_ctx, "Failed to open file '%s' for reading"
, filename); } } while(0)
      filename)do { if (NSLOG_LEVEL_INFO >= NSLOG_LEVEL_VERBOSE) { static
 nslog_entry_context_t _nslog_ctx = { &__nslog_category_netsurf
, NSLOG_LEVEL_INFO, "content/urldb.c", sizeof("content/urldb.c"
) - 1, __PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1, 2898
, }; nslog__log(&_nslog_ctx, "Failed to open file '%s' for reading"
, filename); } } while(0);
return NSERROR_NOT_FOUND;
}

if (!fgets(s, MAXIMUM_URL_LENGTH, fp)) {
fclose(fp);
return NSERROR_NEED_DATA;
}

version = atoi(s);
if (version < MIN_URL_FILE_VERSION106) {
NSLOG(netsurf, INFO, "Unsupported URL file version.")do { if (NSLOG_LEVEL_INFO >= NSLOG_LEVEL_VERBOSE) { static
 nslog_entry_context_t _nslog_ctx = { &__nslog_category_netsurf
, NSLOG_LEVEL_INFO, "content/urldb.c", sizeof("content/urldb.c"
) - 1, __PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1, 2909
, }; nslog__log(&_nslog_ctx, "Unsupported URL file version."
); } } while(0);
fclose(fp);
return NSERROR_INVALID;
}
if (version > URL_FILE_VERSION107) {
NSLOG(netsurf, INFO, "Unknown URL file version.")do { if (NSLOG_LEVEL_INFO >= NSLOG_LEVEL_VERBOSE) { static
 nslog_entry_context_t _nslog_ctx = { &__nslog_category_netsurf
, NSLOG_LEVEL_INFO, "content/urldb.c", sizeof("content/urldb.c"
) - 1, __PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1, 2914
, }; nslog__log(&_nslog_ctx, "Unknown URL file version.")
; } } while(0);
fclose(fp);
return NSERROR_INVALID;
}

while (fgets(host, sizeof host, fp)) {
time_t hsts_expiry = 0;
int hsts_include_sub_domains = 0;

/* get the hostname */
length = strlen(host) - 1;
host[length] = '\0';

/* skip data that has ended up with a host of '' */
if (length == 0) {
	if (!fgets(s, MAXIMUM_URL_LENGTH, fp))
		break;
	urls = atoi(s);
	/* Eight fields/url */
	for (i = 0; i < (8 * urls); i++) {
		if (!fgets(s, MAXIMUM_URL_LENGTH, fp))
			break;
	}
	continue;
}

if (version >= 107) {
	char *p = host;
	while (*p && *p != ' ') p++;
	while (*p && *p == ' ') { *p = '\0'; p++; }
	hsts_include_sub_domains = (*p == '1');
	while (*p && *p != ' ') p++;
	while (*p && *p == ' ') p++;
	nsc_snptimet(p, strlen(p), &hsts_expiry);
}

h = urldb_add_host(host);
if (!h) {
	NSLOG(netsurf, INFO, "Failed adding host: '%s'", host)do { if (NSLOG_LEVEL_INFO >= NSLOG_LEVEL_VERBOSE) { static
 nslog_entry_context_t _nslog_ctx = { &__nslog_category_netsurf
, NSLOG_LEVEL_INFO, "content/urldb.c", sizeof("content/urldb.c"
) - 1, __PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1, 2952
, }; nslog__log(&_nslog_ctx, "Failed adding host: '%s'", host
); } } while(0);
	fclose(fp);
	return NSERROR_NOMEM;
}
h->hsts.expires = hsts_expiry;
h->hsts.include_sub_domains = hsts_include_sub_domains;

/* read number of URLs */
if (!fgets(s, MAXIMUM_URL_LENGTH, fp))
	break;
urls = atoi(s);

/* no URLs => try next host */
if (urls == 0) {
	NSLOG(netsurf, INFO, "No URLs for '%s'", host)do { if (NSLOG_LEVEL_INFO >= NSLOG_LEVEL_VERBOSE) { static
 nslog_entry_context_t _nslog_ctx = { &__nslog_category_netsurf
, NSLOG_LEVEL_INFO, "content/urldb.c", sizeof("content/urldb.c"
) - 1, __PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1, 2966
, }; nslog__log(&_nslog_ctx, "No URLs for '%s'", host); }
 } while(0);
	continue;
}

/* load the non-corrupt data */
for (i = 0; i < urls; i++) {
	struct path_data *p = NULL((void*)0);
	char scheme[64], ports[10];
	char url[64 + 3 + 256 + 6 + 4096 + 1 + 1];
	unsigned int port;
	bool_Bool is_file = false0;
	nsurl *nsurl;
	lwc_string *scheme_lwc, *fragment_lwc;
	char *path_query;
	size_t len;

	if (!fgets(scheme, sizeof scheme, fp))
		break;
	length = strlen(scheme) - 1;
	scheme[length] = '\0';

	if (!fgets(ports, sizeof ports, fp))
		break;
	length = strlen(ports) - 1;
	ports[length] = '\0';
	port = atoi(ports);

	if (!fgets(s, MAXIMUM_URL_LENGTH, fp))
		break;
	length = strlen(s) - 1;
	s[length] = '\0';

	if (!strcasecmp(host, "localhost") &&
	    !strcasecmp(scheme, "file"))
		is_file = true1;

	snprintf(url, sizeof url, "%s://%s%s%s%s",
		 scheme,
		 /* file URLs have no host */
		 (is_file ? "" : host),
		 (port ? ":" : ""),
		 (port ? ports : ""),
		 s);

	/* TODO: store URLs in pre-parsed state, and make
	 *       a nsurl_load to generate the nsurl more
	 *       swiftly.
	 *       Need a nsurl_save too.
	 */
	if (nsurl_create(url, &nsurl) != NSERROR_OK) {
		NSLOG(netsurf, INFO, "Failed inserting '%s'",do { if (NSLOG_LEVEL_INFO >= NSLOG_LEVEL_VERBOSE) { static
 nslog_entry_context_t _nslog_ctx = { &__nslog_category_netsurf
, NSLOG_LEVEL_INFO, "content/urldb.c", sizeof("content/urldb.c"
) - 1, __PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1, 3017
, }; nslog__log(&_nslog_ctx, "Failed inserting '%s'", url
); } } while(0)
		      url)do { if (NSLOG_LEVEL_INFO >= NSLOG_LEVEL_VERBOSE) { static
 nslog_entry_context_t _nslog_ctx = { &__nslog_category_netsurf
, NSLOG_LEVEL_INFO, "content/urldb.c", sizeof("content/urldb.c"
) - 1, __PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1, 3017
, }; nslog__log(&_nslog_ctx, "Failed inserting '%s'", url
); } } while(0);
		fclose(fp);
		return NSERROR_NOMEM;
	}

	if (url_bloom != NULL((void*)0)) {
		uint32_t hash = nsurl_hash(nsurl);
		bloom_insert_hash(url_bloom, hash);
	}

	/* Copy and merge path/query strings */
	if (nsurl_get(nsurl, NSURL_PATH | NSURL_QUERY,
		      &path_query, &len) != NSERROR_OK) {
		NSLOG(netsurf, INFO, "Failed inserting '%s'",do { if (NSLOG_LEVEL_INFO >= NSLOG_LEVEL_VERBOSE) { static
 nslog_entry_context_t _nslog_ctx = { &__nslog_category_netsurf
, NSLOG_LEVEL_INFO, "content/urldb.c", sizeof("content/urldb.c"
) - 1, __PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1, 3031
, }; nslog__log(&_nslog_ctx, "Failed inserting '%s'", url
); } } while(0)
		      url)do { if (NSLOG_LEVEL_INFO >= NSLOG_LEVEL_VERBOSE) { static
 nslog_entry_context_t _nslog_ctx = { &__nslog_category_netsurf
, NSLOG_LEVEL_INFO, "content/urldb.c", sizeof("content/urldb.c"
) - 1, __PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1, 3031
, }; nslog__log(&_nslog_ctx, "Failed inserting '%s'", url
); } } while(0);
		fclose(fp);
		return NSERROR_NOMEM;
	}

	scheme_lwc = nsurl_get_component(nsurl, NSURL_SCHEME);
	fragment_lwc = nsurl_get_component(nsurl,
					   NSURL_FRAGMENT);
	p = urldb_add_path(scheme_lwc, port, h, path_query,
			   fragment_lwc, nsurl);
	if (!p) {
		NSLOG(netsurf, INFO, "Failed inserting '%s'",do { if (NSLOG_LEVEL_INFO >= NSLOG_LEVEL_VERBOSE) { static
 nslog_entry_context_t _nslog_ctx = { &__nslog_category_netsurf
, NSLOG_LEVEL_INFO, "content/urldb.c", sizeof("content/urldb.c"
) - 1, __PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1, 3043
, }; nslog__log(&_nslog_ctx, "Failed inserting '%s'", url
); } } while(0)
		      url)do { if (NSLOG_LEVEL_INFO >= NSLOG_LEVEL_VERBOSE) { static
 nslog_entry_context_t _nslog_ctx = { &__nslog_category_netsurf
, NSLOG_LEVEL_INFO, "content/urldb.c", sizeof("content/urldb.c"
) - 1, __PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1, 3043
, }; nslog__log(&_nslog_ctx, "Failed inserting '%s'", url
); } } while(0);
		fclose(fp);
		return NSERROR_NOMEM;
	}
	nsurl_unref(nsurl);
	lwc_string_unref(scheme_lwc){ lwc_string *__lwc_s = (scheme_lwc); ((__lwc_s != ((void*)0)
) ? (void) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c"
, 3048, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt
--; if ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1
) && (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy
(__lwc_s); };
	if (fragment_lwc != NULL((void*)0))
		lwc_string_unref(fragment_lwc){ lwc_string *__lwc_s = (fragment_lwc); ((__lwc_s != ((void*)
0)) ? (void) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c"
, 3050, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt
--; if ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1
) && (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy
(__lwc_s); };

	if (!fgets(s, MAXIMUM_URL_LENGTH, fp))
		break;
	if (p)
		p->urld.visits = (unsigned int)atoi(s);

	/* entry last use time */
	if (!fgets(s, MAXIMUM_URL_LENGTH, fp)) {
		break;
	}
	if (p) {
		nsc_snptimet(s, strlen(s) - 1, &p->urld.last_visit);
	}

	if (!fgets(s, MAXIMUM_URL_LENGTH, fp))
		break;
	if (p)
		p->urld.type = (content_type)atoi(s);

	if (!fgets(s, MAXIMUM_URL_LENGTH, fp))
		break;


	if (!fgets(s, MAXIMUM_URL_LENGTH, fp))
		break;
	length = strlen(s) - 1;
	if (p && length > 0) {
		s[length] = '\0';
		p->urld.title = malloc(length + 1);
		if (p->urld.title)
			memcpy(p->urld.title, s, length + 1);
	}
}
}

fclose(fp);
NSLOG(netsurf, INFO, "Successfully loaded URL file")do { if (NSLOG_LEVEL_INFO >= NSLOG_LEVEL_VERBOSE) { static
 nslog_entry_context_t _nslog_ctx = { &__nslog_category_netsurf
, NSLOG_LEVEL_INFO, "content/urldb.c", sizeof("content/urldb.c"
) - 1, __PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1, 3087
, }; nslog__log(&_nslog_ctx, "Successfully loaded URL file"
); } } while(0);
3088#undef MAXIMUM_URL_LENGTH

return NSERROR_OK;
3091}

3093/* exported interface documented in netsurf/url_db.h */
3094nserror urldb_save(const char *filename)
3095{
FILE *fp;
int i;

assert(filename)((filename) ? (void) (0) : __assert_fail ("filename", "content/urldb.c"
, 3099, __extension__ __PRETTY_FUNCTION__));
1
Assuming 'filename' is non-null→
2
←
'?' condition is true→

fp = fopen(filename, "w");
if (!fp) {
3
←
Assuming 'fp' is non-null→
4
←
Taking false branch→
NSLOG(netsurf, INFO, "Failed to open file '%s' for writing",do { if (NSLOG_LEVEL_INFO >= NSLOG_LEVEL_VERBOSE) { static
 nslog_entry_context_t _nslog_ctx = { &__nslog_category_netsurf
, NSLOG_LEVEL_INFO, "content/urldb.c", sizeof("content/urldb.c"
) - 1, __PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1, 3104
, }; nslog__log(&_nslog_ctx, "Failed to open file '%s' for writing"
, filename); } } while(0)
      filename)do { if (NSLOG_LEVEL_INFO >= NSLOG_LEVEL_VERBOSE) { static
 nslog_entry_context_t _nslog_ctx = { &__nslog_category_netsurf
, NSLOG_LEVEL_INFO, "content/urldb.c", sizeof("content/urldb.c"
) - 1, __PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1, 3104
, }; nslog__log(&_nslog_ctx, "Failed to open file '%s' for writing"
, filename); } } while(0);
return NSERROR_SAVE_FAILED;
}

/* file format version number */
fprintf(fp, "%d\n", URL_FILE_VERSION107);

for (i = 0; i != NUM_SEARCH_TREES28; i++) {
5
←
Loop condition is true.  Entering loop body→
urldb_save_search_tree(search_trees[i], fp);
6
←
Calling 'urldb_save_search_tree'→
}

fclose(fp);

return NSERROR_OK;
3118}


3121/* exported interface documented in content/urldb.h */
3122nserror urldb_set_url_persistence(nsurl *url, bool_Bool persist)
3123{
struct path_data *p;

assert(url)((url) ? (void) (0) : __assert_fail ("url", "content/urldb.c"
, 3126, __extension__ __PRETTY_FUNCTION__));

p = urldb_find_url(url);
if (!p) {
return NSERROR_NOT_FOUND;
}

p->persistent = persist;

return NSERROR_OK;
3136}


3139/* exported interface documented in content/urldb.h */
3140bool_Bool urldb_add_url(nsurl *url)
3141{
struct host_part *h;
struct path_data *p;
lwc_string *scheme;
lwc_string *port;
lwc_string *host;
lwc_string *fragment;
const char *host_str;
char *path_query = NULL((void*)0);
size_t len;
bool_Bool match;
unsigned int port_int;

assert(url)((url) ? (void) (0) : __assert_fail ("url", "content/urldb.c"
, 3154, __extension__ __PRETTY_FUNCTION__));

if (url_bloom == NULL((void*)0))
url_bloom = bloom_create(BLOOM_SIZE(1024 * 32));

if (url_bloom != NULL((void*)0)) {
uint32_t hash = nsurl_hash(url);
bloom_insert_hash(url_bloom, hash);
}

/* Copy and merge path/query strings */
if (nsurl_get(url, NSURL_PATH | NSURL_QUERY, &path_query, &len) !=
   NSERROR_OK) {
return false0;
}
assert(path_query != NULL)((path_query != ((void*)0)) ? (void) (0) : __assert_fail ("path_query != NULL"
, "content/urldb.c", 3169, __extension__ __PRETTY_FUNCTION__)
);

scheme = nsurl_get_component(url, NSURL_SCHEME);
if (scheme == NULL((void*)0)) {
free(path_query);
return false0;
}

host = nsurl_get_component(url, NSURL_HOST);
if (host != NULL((void*)0)) {
host_str = lwc_string_data(host)({((host != ((void*)0)) ? (void) (0) : __assert_fail ("host != NULL"
, "content/urldb.c", 3179, __extension__ __PRETTY_FUNCTION__)
); (const char *)((host)+1);});
lwc_string_unref(host){ lwc_string *__lwc_s = (host); ((__lwc_s != ((void*)0)) ? (void
) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c", 3180
, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt--; if
 ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1) &&
 (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy(__lwc_s
); };

} else if (lwc_string_isequal(scheme, corestring_lwc_file, &match)((*(&match) = ((scheme) == (corestring_lwc_file))), lwc_error_ok
) ==
   lwc_error_ok && match == true1) {
host_str = "localhost";

} else {
lwc_string_unref(scheme){ lwc_string *__lwc_s = (scheme); ((__lwc_s != ((void*)0)) ? (
void) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c"
, 3187, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt
--; if ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1
) && (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy
(__lwc_s); };
free(path_query);
return false0;
}

fragment = nsurl_get_component(url, NSURL_FRAGMENT);

port = nsurl_get_component(url, NSURL_PORT);
if (port != NULL((void*)0)) {
port_int = atoi(lwc_string_data(port)({((port != ((void*)0)) ? (void) (0) : __assert_fail ("port != NULL"
, "content/urldb.c", 3196, __extension__ __PRETTY_FUNCTION__)
); (const char *)((port)+1);}));
lwc_string_unref(port){ lwc_string *__lwc_s = (port); ((__lwc_s != ((void*)0)) ? (void
) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c", 3197
, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt--; if
 ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1) &&
 (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy(__lwc_s
); };
} else {
port_int = 0;
}

/* Get host entry */
h = urldb_add_host(host_str);

/* Get path entry */
if (h != NULL((void*)0)) {
p = urldb_add_path(scheme,
		   port_int,
		   h,
		   path_query,
		   fragment,
		   url);
} else {
p = NULL((void*)0);
}

lwc_string_unref(scheme){ lwc_string *__lwc_s = (scheme); ((__lwc_s != ((void*)0)) ? (
void) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c"
, 3217, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt
--; if ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1
) && (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy
(__lwc_s); };
if (fragment != NULL((void*)0))
lwc_string_unref(fragment){ lwc_string *__lwc_s = (fragment); ((__lwc_s != ((void*)0)) ?
 (void) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c"
, 3219, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt
--; if ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1
) && (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy
(__lwc_s); };

return (p != NULL((void*)0));
3222}


3225/* exported interface documented in content/urldb.h */
3226nserror urldb_set_url_title(nsurl *url, const char *title)
3227{
struct path_data *p;
char *temp;

assert(url)((url) ? (void) (0) : __assert_fail ("url", "content/urldb.c"
, 3231, __extension__ __PRETTY_FUNCTION__));

p = urldb_find_url(url);
if (p == NULL((void*)0)) {
return NSERROR_NOT_FOUND;
}

/* copy the parameter if necessary */
if (title != NULL((void*)0)) {
temp = strdup(title);
if (temp == NULL((void*)0)) {
	return NSERROR_NOMEM;
}
} else {
temp = NULL((void*)0);
}

free(p->urld.title);
p->urld.title = temp;

return NSERROR_OK;
3252}


3255/* exported interface documented in content/urldb.h */
3256nserror urldb_set_url_content_type(nsurl *url, content_type type)
3257{
struct path_data *p;

assert(url)((url) ? (void) (0) : __assert_fail ("url", "content/urldb.c"
, 3260, __extension__ __PRETTY_FUNCTION__));

p = urldb_find_url(url);
if (!p) {
return NSERROR_NOT_FOUND;
}

p->urld.type = type;

return NSERROR_OK;
3270}


3273/* exported interface documented in content/urldb.h */
3274nserror urldb_update_url_visit_data(nsurl *url)
3275{
struct path_data *p;

assert(url)((url) ? (void) (0) : __assert_fail ("url", "content/urldb.c"
, 3278, __extension__ __PRETTY_FUNCTION__));

p = urldb_find_url(url);
if (!p) {
return NSERROR_NOT_FOUND;
}

p->urld.last_visit = time(NULL((void*)0));
p->urld.visits++;

return NSERROR_OK;
3289}


3292/* exported interface documented in content/urldb.h */
3293void urldb_reset_url_visit_data(nsurl *url)
3294{
struct path_data *p;

assert(url)((url) ? (void) (0) : __assert_fail ("url", "content/urldb.c"
, 3297, __extension__ __PRETTY_FUNCTION__));

p = urldb_find_url(url);
if (!p)
return;

p->urld.last_visit = (time_t)0;
p->urld.visits = 0;
3305}


3308/* exported interface documented in netsurf/url_db.h */
3309const struct url_data *urldb_get_url_data(nsurl *url)
3310{
struct path_data *p;
struct url_internal_data *u;

assert(url)((url) ? (void) (0) : __assert_fail ("url", "content/urldb.c"
, 3314, __extension__ __PRETTY_FUNCTION__));

p = urldb_find_url(url);
if (!p)
return NULL((void*)0);

u = &p->urld;

return (const struct url_data *) u;
3323}


3326/* exported interface documented in content/urldb.h */
3327nsurl *urldb_get_url(nsurl *url)
3328{
struct path_data *p;

assert(url)((url) ? (void) (0) : __assert_fail ("url", "content/urldb.c"
, 3331, __extension__ __PRETTY_FUNCTION__));

p = urldb_find_url(url);
if (!p)
return NULL((void*)0);

return p->url;
3338}


3341/* exported interface documented in netsurf/url_db.h */
3342void urldb_set_auth_details(nsurl *url, const char *realm, const char *auth)
3343{
struct path_data *p, *pi;
struct host_part *h;
struct prot_space_data *space, *space_alloc;
char *realm_alloc, *auth_alloc;
bool_Bool match;

assert(url && realm && auth)((url && realm && auth) ? (void) (0) : __assert_fail
 ("url && realm && auth", "content/urldb.c", 3350
, __extension__ __PRETTY_FUNCTION__));

/* add url, in case it's missing */
urldb_add_url(url);

p = urldb_find_url(url);

if (!p)
return;

/* Search for host_part */
for (pi = p; pi->parent != NULL((void*)0); pi = pi->parent)
;
h = (struct host_part *)pi;

/* Search if given URL belongs to a protection space we already know of. */
for (space = h->prot_space; space; space = space->next) {
if (!strcmp(space->realm, realm) &&
    lwc_string_isequal(space->scheme, p->scheme,((*(&match) = ((space->scheme) == (p->scheme))), lwc_error_ok
)
		       &match)((*(&match) = ((space->scheme) == (p->scheme))), lwc_error_ok
) == lwc_error_ok &&
    match == true1 &&
    space->port == p->port)
	break;
}

if (space != NULL((void*)0)) {
/* Overrule existing auth. */
free(space->auth);
space->auth = strdup(auth);
} else {
/* Create a new protection space. */
space = space_alloc = malloc(sizeof(struct prot_space_data));
realm_alloc = strdup(realm);
auth_alloc = strdup(auth);

if (!space_alloc || !realm_alloc || !auth_alloc) {
	free(space_alloc);
	free(realm_alloc);
	free(auth_alloc);
	return;
}

space->scheme = lwc_string_ref(p->scheme)({lwc_string *__lwc_s = (p->scheme); ((__lwc_s != ((void*)
0)) ? (void) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c"
, 3392, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt
++; __lwc_s;});
space->port = p->port;
space->realm = realm_alloc;
space->auth = auth_alloc;
space->next = h->prot_space;
h->prot_space = space;
}

p->prot_space = space;
3401}


3404/* exported interface documented in netsurf/url_db.h */
3405const char *urldb_get_auth_details(nsurl *url, const char *realm)
3406{
struct path_data *p, *p_cur, *p_top;

assert(url)((url) ? (void) (0) : __assert_fail ("url", "content/urldb.c"
, 3409, __extension__ __PRETTY_FUNCTION__));

/* add to the db, so our lookup will work */
urldb_add_url(url);

p = urldb_find_url(url);
if (!p)
return NULL((void*)0);

/* Check for any auth details attached to the path_data node or any of
* its parents.
*/
for (p_cur = p; p_cur != NULL((void*)0); p_top = p_cur, p_cur = p_cur->parent) {
if (p_cur->prot_space) {
	return p_cur->prot_space->auth;
}
}

/* Only when we have a realm (and canonical root of given URL), we can
* uniquely locate the protection space.
*/
if (realm != NULL((void*)0)) {
const struct host_part *h = (const struct host_part *)p_top;
const struct prot_space_data *space;
bool_Bool match;

/* Search for a possible matching protection space. */
for (space = h->prot_space; space != NULL((void*)0);
     space = space->next) {
	if (!strcmp(space->realm, realm) &&
	    lwc_string_isequal(space->scheme,((*(&match) = ((space->scheme) == (p->scheme))), lwc_error_ok
)
			       p->scheme, &match)((*(&match) = ((space->scheme) == (p->scheme))), lwc_error_ok
) ==
	    lwc_error_ok &&
	    match == true1 &&
	    space->port == p->port) {
		p->prot_space = space;
		return p->prot_space->auth;
	}
}
}

return NULL((void*)0);
3451}


3454/* exported interface documented in netsurf/url_db.h */
3455void urldb_set_cert_permissions(nsurl *url, bool_Bool permit)
3456{
struct path_data *p;
struct host_part *h;

assert(url)((url) ? (void) (0) : __assert_fail ("url", "content/urldb.c"
, 3460, __extension__ __PRETTY_FUNCTION__));

/* add url, in case it's missing */
urldb_add_url(url);

p = urldb_find_url(url);
if (!p)
return;

for (; p && p->parent; p = p->parent)
/* do nothing */;
assert(p)((p) ? (void) (0) : __assert_fail ("p", "content/urldb.c", 3471
, __extension__ __PRETTY_FUNCTION__));

h = (struct host_part *)p;

h->permit_invalid_certs = permit;
3476}


3479/* exported interface documented in content/urldb.h */
3480bool_Bool urldb_get_cert_permissions(nsurl *url)
3481{
struct path_data *p;
const struct host_part *h;

assert(url)((url) ? (void) (0) : __assert_fail ("url", "content/urldb.c"
, 3485, __extension__ __PRETTY_FUNCTION__));

p = urldb_find_url(url);
if (!p)
return false0;

for (; p && p->parent; p = p->parent)
/* do nothing */;
assert(p)((p) ? (void) (0) : __assert_fail ("p", "content/urldb.c", 3493
, __extension__ __PRETTY_FUNCTION__));

h = (const struct host_part *)p;

return h->permit_invalid_certs;
3498}


3501/* exported interface documented in content/urldb.h */
3502bool_Bool urldb_set_hsts_policy(struct nsurl *url, const char *header)
3503{
struct path_data *p;
struct host_part *h;
lwc_string *host;
time_t now = time(NULL((void*)0));
http_strict_transport_security *sts;
uint32_t max_age = 0;
nserror error;

assert(url)((url) ? (void) (0) : __assert_fail ("url", "content/urldb.c"
, 3512, __extension__ __PRETTY_FUNCTION__));

host = nsurl_get_component(url, NSURL_HOST);
if (host != NULL((void*)0)) {
if (urldb__host_is_ip_address(lwc_string_data(host)({((host != ((void*)0)) ? (void) (0) : __assert_fail ("host != NULL"
, "content/urldb.c", 3516, __extension__ __PRETTY_FUNCTION__)
); (const char *)((host)+1);}))) {
	/* Host is IP: ignore */
	lwc_string_unref(host){ lwc_string *__lwc_s = (host); ((__lwc_s != ((void*)0)) ? (void
) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c", 3518
, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt--; if
 ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1) &&
 (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy(__lwc_s
); };
	return true1;
} else if (lwc_string_length(host)({((host != ((void*)0)) ? (void) (0) : __assert_fail ("host != NULL"
, "content/urldb.c", 3520, __extension__ __PRETTY_FUNCTION__)
); (host)->len;}) == 0) {
	/* Host is blank: ignore */
	lwc_string_unref(host){ lwc_string *__lwc_s = (host); ((__lwc_s != ((void*)0)) ? (void
) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c", 3522
, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt--; if
 ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1) &&
 (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy(__lwc_s
); };
	return true1;
}

lwc_string_unref(host){ lwc_string *__lwc_s = (host); ((__lwc_s != ((void*)0)) ? (void
) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c", 3526
, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt--; if
 ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1) &&
 (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy(__lwc_s
); };
} else {
/* No host part: ignore */
return true1;
}

/* add url, in case it's missing */
urldb_add_url(url);

p = urldb_find_url(url);
if (!p)
return false0;

for (; p && p->parent; p = p->parent)
/* do nothing */;
assert(p)((p) ? (void) (0) : __assert_fail ("p", "content/urldb.c", 3541
, __extension__ __PRETTY_FUNCTION__));

h = (struct host_part *)p;
if (h->permit_invalid_certs) {
/* Transport is tainted: ignore */
return true1;
}

error = http_parse_strict_transport_security(header, &sts);
if (error != NSERROR_OK) {
/* Parse failed: ignore */
return true1;
}

h->hsts.include_sub_domains =
http_strict_transport_security_include_subdomains(sts);

max_age = http_strict_transport_security_max_age(sts);
if (max_age == 0) {
h->hsts.expires = 0;
h->hsts.include_sub_domains = false0;
} else if ((time_t) (now + max_age) > h->hsts.expires) {
h->hsts.expires = now + max_age;
}

http_strict_transport_security_destroy(sts);

return true1;
3569}


3572/* exported interface documented in content/urldb.h */
3573bool_Bool urldb_get_hsts_enabled(struct nsurl *url)
3574{
struct path_data *p;
const struct host_part *h;
lwc_string *host;
time_t now = time(NULL((void*)0));

assert(url)((url) ? (void) (0) : __assert_fail ("url", "content/urldb.c"
, 3580, __extension__ __PRETTY_FUNCTION__));

host = nsurl_get_component(url, NSURL_HOST);
if (host != NULL((void*)0)) {
if (urldb__host_is_ip_address(lwc_string_data(host)({((host != ((void*)0)) ? (void) (0) : __assert_fail ("host != NULL"
, "content/urldb.c", 3584, __extension__ __PRETTY_FUNCTION__)
); (const char *)((host)+1);}))) {
	/* Host is IP: not enabled */
	lwc_string_unref(host){ lwc_string *__lwc_s = (host); ((__lwc_s != ((void*)0)) ? (void
) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c", 3586
, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt--; if
 ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1) &&
 (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy(__lwc_s
); };
	return false0;
} else if (lwc_string_length(host)({((host != ((void*)0)) ? (void) (0) : __assert_fail ("host != NULL"
, "content/urldb.c", 3588, __extension__ __PRETTY_FUNCTION__)
); (host)->len;}) == 0) {
	/* Host is blank: not enabled */
	lwc_string_unref(host){ lwc_string *__lwc_s = (host); ((__lwc_s != ((void*)0)) ? (void
) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c", 3590
, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt--; if
 ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1) &&
 (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy(__lwc_s
); };
	return false0;
}

lwc_string_unref(host){ lwc_string *__lwc_s = (host); ((__lwc_s != ((void*)0)) ? (void
) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c", 3594
, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt--; if
 ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1) &&
 (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy(__lwc_s
); };
} else {
/* No host part: not enabled */
return false0;
}

/* The URL must exist in the db in order to find HSTS policy, since
* we search up the tree from the URL node, and policy from further
* up may also apply. */
urldb_add_url(url);

p = urldb_find_url(url);
if (!p)
return false0;

for (; p && p->parent; p = p->parent)
/* do nothing */;
assert(p)((p) ? (void) (0) : __assert_fail ("p", "content/urldb.c", 3611
, __extension__ __PRETTY_FUNCTION__));

h = (const struct host_part *)p;

/* Consult record for this host */
if (h->hsts.expires > now) {
/* Not expired */
return true1;
}

/* Consult parent domains */
for (h = h->parent; h && h != &db_root; h = h->parent) {
if (h->hsts.expires > now && h->hsts.include_sub_domains) {
	/* Not expired and subdomains included */
	return true1;
}
}

return false0;
3630}


3633/* exported interface documented in netsurf/url_db.h */
3634void
3635urldb_iterate_partial(const char *prefix,
      bool_Bool (*callback)(nsurl *url, const struct url_data *data))
3637{
char host[256];
char buf[260]; /* max domain + "www." */
const char *slash, *scheme_sep;
struct search_node *tree;
const struct host_part *h;

assert(prefix && callback)((prefix && callback) ? (void) (0) : __assert_fail ("prefix && callback"
, "content/urldb.c", 3644, __extension__ __PRETTY_FUNCTION__)
);

/* strip scheme */
scheme_sep = strstr(prefix, "://");
if (scheme_sep)
prefix = scheme_sep + 3;

slash = strchr(prefix, '/');
tree = urldb_get_search_tree(prefix);

if (slash) {
/* if there's a slash in the input, then we can
 * assume that we're looking for a path */
snprintf(host, sizeof host, "%.*s",
	 (int) (slash - prefix), prefix);

h = urldb_search_find(tree, host);
if (!h) {
	int len = slash - prefix;

	if (len <= 3 || strncasecmp(host, "www.", 4) != 0) {
		snprintf(buf, sizeof buf, "www.%s", host);
		h = urldb_search_find(
			search_trees[ST_DN2 + 'w' - 'a'],
			buf);
		if (!h)
			return;
	} else
		return;
}

if (h->paths.children) {
	/* Have paths, iterate them */
	urldb_iterate_partial_path(&h->paths, slash + 1,
				   callback);
}

} else {
int len = strlen(prefix);

/* looking for hosts */
if (!urldb_iterate_partial_host(tree, prefix, callback))
	return;

if (len <= 3 || strncasecmp(prefix, "www.", 4) != 0) {
	/* now look for www.prefix */
	snprintf(buf, sizeof buf, "www.%s", prefix);
	if(!urldb_iterate_partial_host(
		   search_trees[ST_DN2 + 'w' - 'a'],
		   buf, callback))
		return;
}
}
3697}


3700/* exported interface documented in netsurf/url_db.h */
3701void
3702urldb_iterate_entries(bool_Bool (*callback)(nsurl *url, const struct url_data *data))
3703{
int i;

assert(callback)((callback) ? (void) (0) : __assert_fail ("callback", "content/urldb.c"
, 3706, __extension__ __PRETTY_FUNCTION__));

for (i = 0; i < NUM_SEARCH_TREES28; i++) {
if (!urldb_iterate_entries_host(search_trees[i],
				callback,
				NULL((void*)0))) {
	break;
}
}
3715}


3718/* exported interface documented in content/urldb.h */
3719void urldb_iterate_cookies(bool_Bool (*callback)(const struct cookie_data *data))
3720{
int i;

assert(callback)((callback) ? (void) (0) : __assert_fail ("callback", "content/urldb.c"
, 3723, __extension__ __PRETTY_FUNCTION__));

for (i = 0; i < NUM_SEARCH_TREES28; i++) {
if (!urldb_iterate_entries_host(search_trees[i],
				NULL((void*)0), callback))
	break;
}
3730}


3733/* exported interface documented in content/urldb.h */
3734bool_Bool urldb_set_cookie(const char *header, nsurl *url, nsurl *referer)
3735{
const char *cur = header, *end;
lwc_string *path, *host, *scheme;
nsurl *urlt;
bool_Bool match;

assert(url && header)((url && header) ? (void) (0) : __assert_fail ("url && header"
, "content/urldb.c", 3741, __extension__ __PRETTY_FUNCTION__)
);

/* Get defragmented URL, as 'urlt' */
if (nsurl_defragment(url, &urlt) != NSERROR_OK)
return NULL((void*)0);

scheme = nsurl_get_component(url, NSURL_SCHEME);
if (scheme == NULL((void*)0)) {
nsurl_unref(urlt);
return false0;
}

path = nsurl_get_component(url, NSURL_PATH);
if (path == NULL((void*)0)) {
lwc_string_unref(scheme){ lwc_string *__lwc_s = (scheme); ((__lwc_s != ((void*)0)) ? (
void) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c"
, 3755, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt
--; if ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1
) && (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy
(__lwc_s); };
nsurl_unref(urlt);
return false0;
}

host = nsurl_get_component(url, NSURL_HOST);
if (host == NULL((void*)0)) {
lwc_string_unref(path){ lwc_string *__lwc_s = (path); ((__lwc_s != ((void*)0)) ? (void
) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c", 3762
, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt--; if
 ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1) &&
 (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy(__lwc_s
); };
lwc_string_unref(scheme){ lwc_string *__lwc_s = (scheme); ((__lwc_s != ((void*)0)) ? (
void) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c"
, 3763, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt
--; if ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1
) && (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy
(__lwc_s); };
nsurl_unref(urlt);
return false0;
}

if (referer) {
lwc_string *rhost;

/* Ensure that url's host name domain matches
 * referer's (4.3.5) */
rhost = nsurl_get_component(referer, NSURL_HOST);
if (rhost == NULL((void*)0)) {
	goto error;
}

/* Domain match host names */
if (lwc_string_isequal(host, rhost, &match)((*(&match) = ((host) == (rhost))), lwc_error_ok) == lwc_error_ok &&
    match == false0) {
	const char *hptr;
	const char *rptr;
	const char *dot;
	const char *host_data = lwc_string_data(host)({((host != ((void*)0)) ? (void) (0) : __assert_fail ("host != NULL"
, "content/urldb.c", 3784, __extension__ __PRETTY_FUNCTION__)
); (const char *)((host)+1);});
	const char *rhost_data = lwc_string_data(rhost)({((rhost != ((void*)0)) ? (void) (0) : __assert_fail ("rhost != NULL"
, "content/urldb.c", 3785, __extension__ __PRETTY_FUNCTION__)
); (const char *)((rhost)+1);});

	/* Ensure neither host nor rhost are IP addresses */
	if (urldb__host_is_ip_address(host_data) ||
	    urldb__host_is_ip_address(rhost_data)) {
		/* IP address, so no partial match */
		lwc_string_unref(rhost){ lwc_string *__lwc_s = (rhost); ((__lwc_s != ((void*)0)) ? (
void) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c"
, 3791, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt
--; if ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1
) && (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy
(__lwc_s); };
		goto error;
	}

	/* Not exact match, so try the following:
	 *
	 * 1) Find the longest common suffix of host and rhost
	 *    (may be all of host/rhost)
	 * 2) Discard characters from the start of the suffix
	 *    until the suffix starts with a dot
	 *    (prevents foobar.com matching bar.com)
	 * 3) Ensure the suffix is non-empty and contains
	 *    embedded dots (to avoid permitting .com as a
	 *    suffix)
	 *
	 * Note that the above in no way resembles the
	 * domain matching algorithm found in RFC2109.
	 * It does, however, model the real world rather
	 * more accurately.
	 */

	/** \todo In future, we should consult a TLD service
	 * instead of just looking for embedded dots.
	 */

	hptr = host_data + lwc_string_length(host)({((host != ((void*)0)) ? (void) (0) : __assert_fail ("host != NULL"
, "content/urldb.c", 3816, __extension__ __PRETTY_FUNCTION__)
); (host)->len;}) - 1;
	rptr = rhost_data + lwc_string_length(rhost)({((rhost != ((void*)0)) ? (void) (0) : __assert_fail ("rhost != NULL"
, "content/urldb.c", 3817, __extension__ __PRETTY_FUNCTION__)
); (rhost)->len;}) - 1;

	/* 1 */
	while (hptr >= host_data && rptr >= rhost_data) {
		if (*hptr != *rptr)
			break;
		hptr--;
		rptr--;
	}
	/* Ensure we end up pointing at the start of the
	 * common suffix. The above loop will exit pointing
	 * to the byte before the start of the suffix. */
	hptr++;

	/* 2 */
	while (*hptr != '\0' && *hptr != '.')
		hptr++;

	/* 3 */
	if (*hptr == '\0' ||
	    (dot = strchr(hptr + 1, '.')) == NULL((void*)0) ||
	    *(dot + 1) == '\0') {
		lwc_string_unref(rhost){ lwc_string *__lwc_s = (rhost); ((__lwc_s != ((void*)0)) ? (
void) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c"
, 3839, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt
--; if ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1
) && (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy
(__lwc_s); };
		goto error;
	}
}

lwc_string_unref(rhost){ lwc_string *__lwc_s = (rhost); ((__lwc_s != ((void*)0)) ? (
void) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c"
, 3844, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt
--; if ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1
) && (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy
(__lwc_s); };
}

end = cur + strlen(cur) - 2 /* Trailing CRLF */;

do {
struct cookie_internal_data *c;
char *dot;
size_t len;
3853#ifdef WITH_NSPSL1
const char *suffix;
3855#endif

c = urldb_parse_cookie(url, &cur);
if (!c) {
	/* failed => stop parsing */
	goto error;
}

/* validate cookie */

/* 4.2.2:i Cookie must have NAME and VALUE */
if (!c->name || !c->value) {
	urldb_free_cookie(c);
	goto error;
}

/* 4.3.2:i Cookie path must be a prefix of URL path */
len = strlen(c->path);
if (len > lwc_string_length(path)({((path != ((void*)0)) ? (void) (0) : __assert_fail ("path != NULL"
, "content/urldb.c", 3873, __extension__ __PRETTY_FUNCTION__)
); (path)->len;}) ||
    strncmp(c->path, lwc_string_data(path)({((path != ((void*)0)) ? (void) (0) : __assert_fail ("path != NULL"
, "content/urldb.c", 3874, __extension__ __PRETTY_FUNCTION__)
); (const char *)((path)+1);}),
	    len) != 0) {
	urldb_free_cookie(c);
	goto error;
}

3880#ifdef WITH_NSPSL1
/* check domain is not a public suffix */
dot = c->domain;
if (*dot == '.') {
	dot++;
}
suffix = nspsl_getpublicsuffix(dot);
if (suffix == NULL((void*)0)) {
	NSLOG(netsurf, INFO,do { if (NSLOG_LEVEL_INFO >= NSLOG_LEVEL_VERBOSE) { static
 nslog_entry_context_t _nslog_ctx = { &__nslog_category_netsurf
, NSLOG_LEVEL_INFO, "content/urldb.c", sizeof("content/urldb.c"
) - 1, __PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1, 3889
, }; nslog__log(&_nslog_ctx, "domain %s was a public suffix domain"
, dot); } } while(0)
	      "domain %s was a public suffix domain", dot)do { if (NSLOG_LEVEL_INFO >= NSLOG_LEVEL_VERBOSE) { static
 nslog_entry_context_t _nslog_ctx = { &__nslog_category_netsurf
, NSLOG_LEVEL_INFO, "content/urldb.c", sizeof("content/urldb.c"
) - 1, __PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1, 3889
, }; nslog__log(&_nslog_ctx, "domain %s was a public suffix domain"
, dot); } } while(0);
	urldb_free_cookie(c);
	goto error;
}
3893#else
/* 4.3.2:ii Cookie domain must contain embedded dots */
dot = strchr(c->domain + 1, '.');
if (!dot || *(dot + 1) == '\0') {
	/* no embedded dots */
	urldb_free_cookie(c);
	goto error;
}
3901#endif

/* Domain match fetch host with cookie domain */
if (strcasecmp(lwc_string_data(host)({((host != ((void*)0)) ? (void) (0) : __assert_fail ("host != NULL"
, "content/urldb.c", 3904, __extension__ __PRETTY_FUNCTION__)
); (const char *)((host)+1);}), c->domain) != 0) {
	int hlen, dlen;
	char *domain = c->domain;

	/* c->domain must be a domain cookie here because:
	 * c->domain is either:
	 *   + specified in the header as a domain cookie
	 *     (non-domain cookies in the header are ignored
	 *      by urldb_parse_cookie / urldb_parse_avpair)
	 *   + defaulted to the URL's host part
	 *     (by urldb_parse_cookie if no valid domain was
	 *      specified in the header)
	 *
	 * The latter will pass the strcasecmp above, which
	 * leaves the former (i.e. a domain cookie)
	 */
	assert(c->domain[0] == '.')((c->domain[0] == '.') ? (void) (0) : __assert_fail ("c->domain[0] == '.'"
, "content/urldb.c", 3920, __extension__ __PRETTY_FUNCTION__)
);

	/* 4.3.2:iii */
	if (urldb__host_is_ip_address(lwc_string_data(host)({((host != ((void*)0)) ? (void) (0) : __assert_fail ("host != NULL"
, "content/urldb.c", 3923, __extension__ __PRETTY_FUNCTION__)
); (const char *)((host)+1);}))) {
		/* IP address, so no partial match */
		urldb_free_cookie(c);
		goto error;
	}

	hlen = lwc_string_length(host)({((host != ((void*)0)) ? (void) (0) : __assert_fail ("host != NULL"
, "content/urldb.c", 3929, __extension__ __PRETTY_FUNCTION__)
); (host)->len;});
	dlen = strlen(c->domain);

	if (hlen <= dlen && hlen != dlen - 1) {
		/* Partial match not possible */
		urldb_free_cookie(c);
		goto error;
	}

	if (hlen == dlen - 1) {
		/* Relax matching to allow
		 * host a.com to match .a.com */
		domain++;
		dlen--;
	}

	if (strcasecmp(lwc_string_data(host)({((host != ((void*)0)) ? (void) (0) : __assert_fail ("host != NULL"
, "content/urldb.c", 3945, __extension__ __PRETTY_FUNCTION__)
); (const char *)((host)+1);}) + (hlen - dlen),
		       domain)) {
		urldb_free_cookie(c);
		goto error;
	}

	/* 4.3.2:iv Ensure H contains no dots
	 *
	 * If you believe the spec, H should contain no
	 * dots in _any_ cookie. Unfortunately, however,
	 * reality differs in that many sites send domain
	 * cookies of the form .foo.com from hosts such
	 * as bar.bat.foo.com and then expect domain
	 * matching to work. Thus we have to do what they
	 * expect, regardless of any potential security
	 * implications.
	 *
	 * This is what code conforming to the spec would
	 * look like:
	 *
	 * for (int i = 0; i < (hlen - dlen); i++) {
	 *	if (host[i] == '.') {
	 *		urldb_free_cookie(c);
	 *		goto error;
	 *	}
	 * }
	 */
}

/* Now insert into database */
if (!urldb_insert_cookie(c, scheme, urlt))
	goto error;
} while (cur < end);

lwc_string_unref(host){ lwc_string *__lwc_s = (host); ((__lwc_s != ((void*)0)) ? (void
) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c", 3979
, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt--; if
 ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1) &&
 (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy(__lwc_s
); };
lwc_string_unref(path){ lwc_string *__lwc_s = (path); ((__lwc_s != ((void*)0)) ? (void
) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c", 3980
, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt--; if
 ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1) &&
 (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy(__lwc_s
); };
lwc_string_unref(scheme){ lwc_string *__lwc_s = (scheme); ((__lwc_s != ((void*)0)) ? (
void) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c"
, 3981, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt
--; if ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1
) && (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy
(__lwc_s); };
nsurl_unref(urlt);

return true1;

3986error:
lwc_string_unref(host){ lwc_string *__lwc_s = (host); ((__lwc_s != ((void*)0)) ? (void
) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c", 3987
, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt--; if
 ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1) &&
 (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy(__lwc_s
); };
lwc_string_unref(path){ lwc_string *__lwc_s = (path); ((__lwc_s != ((void*)0)) ? (void
) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c", 3988
, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt--; if
 ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1) &&
 (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy(__lwc_s
); };
lwc_string_unref(scheme){ lwc_string *__lwc_s = (scheme); ((__lwc_s != ((void*)0)) ? (
void) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c"
, 3989, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt
--; if ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1
) && (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy
(__lwc_s); };
nsurl_unref(urlt);

return false0;
3993}


3996/* exported interface documented in content/urldb.h */
3997char *urldb_get_cookie(nsurl *url, bool_Bool include_http_only)
3998{
const struct path_data *p, *q;
const struct host_part *h;
lwc_string *path_lwc;
struct cookie_internal_data *c;
int count = 0, version = COOKIE_RFC2965;
struct cookie_internal_data **matched_cookies;
int matched_cookies_size = 20;
int ret_alloc = 4096, ret_used = 1;
const char *path;
char *ret;
lwc_string *scheme;
time_t now;
int i;
bool_Bool match;

assert(url != NULL)((url != ((void*)0)) ? (void) (0) : __assert_fail ("url != NULL"
, "content/urldb.c", 4014, __extension__ __PRETTY_FUNCTION__)
);

/* The URL must exist in the db in order to find relevant cookies, since
* we search up the tree from the URL node, and cookies from further
* up also apply. */
urldb_add_url(url);

p = urldb_find_url(url);
if (!p)
return NULL((void*)0);

scheme = p->scheme;

matched_cookies = malloc(matched_cookies_size *
		 sizeof(struct cookie_internal_data *));
if (!matched_cookies)
return NULL((void*)0);

4032#define GROW_MATCHED_COOKIES						\
do {								\
if (count == matched_cookies_size) {			\
	struct cookie_internal_data **temp;		\
	temp = realloc(matched_cookies,			\
		       (matched_cookies_size + 20) *	\
		       sizeof(struct cookie_internal_data *)); \
							\
	if (temp == NULL((void*)0)) {				\
		free(ret);				\
		free(matched_cookies);			\
		return NULL((void*)0);				\
	}						\
							\
	matched_cookies = temp;				\
	matched_cookies_size += 20;			\
}							\
} while(0)

ret = malloc(ret_alloc);
if (!ret) {
free(matched_cookies);
return NULL((void*)0);
}

ret[0] = '\0';

path_lwc = nsurl_get_component(url, NSURL_PATH);
if (path_lwc == NULL((void*)0)) {
free(ret);
free(matched_cookies);
return NULL((void*)0);
}
path = lwc_string_data(path_lwc)({((path_lwc != ((void*)0)) ? (void) (0) : __assert_fail ("path_lwc != NULL"
, "content/urldb.c", 4065, __extension__ __PRETTY_FUNCTION__)
); (const char *)((path_lwc)+1);});
lwc_string_unref(path_lwc){ lwc_string *__lwc_s = (path_lwc); ((__lwc_s != ((void*)0)) ?
 (void) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c"
, 4066, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt
--; if ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1
) && (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy
(__lwc_s); };

now = time(NULL((void*)0));

if (*(p->segment) != '\0') {
/* Match exact path, unless directory, when prefix matching
 * will handle this case for us. */
for (q = p->parent->children; q; q = q->next) {
	if (strcmp(q->segment, p->segment))
		continue;

	/* Consider all cookies associated with
	 * this exact path */
	for (c = q->cookies; c; c = c->next) {
		if (c->expires != -1 && c->expires < now)
			/* cookie has expired => ignore */
			continue;

		if (c->secure && lwc_string_isequal(((*(&match) = ((q->scheme) == (corestring_lwc_https)))
, lwc_error_ok)
			    q->scheme,((*(&match) = ((q->scheme) == (corestring_lwc_https)))
, lwc_error_ok)
			    corestring_lwc_https,((*(&match) = ((q->scheme) == (corestring_lwc_https)))
, lwc_error_ok)
			    &match)((*(&match) = ((q->scheme) == (corestring_lwc_https)))
, lwc_error_ok) &&
		    match == false0)
			/* secure cookie for insecure host.
			 * ignore */
			continue;

		if (c->http_only && !include_http_only)
			/* Ignore HttpOnly */
			continue;

		matched_cookies[count++] = c;

		GROW_MATCHED_COOKIES;

		if (c->version < (unsigned int)version)
			version = c->version;

		c->last_used = now;

		cookie_manager_add((struct cookie_data *)c);
	}
}
}

/* Now consider cookies whose paths prefix-match ours */
for (p = p->parent; p; p = p->parent) {
/* Find directory's path entry(ies) */
/* There are potentially multiple due to differing schemes */
for (q = p->children; q; q = q->next) {
	if (*(q->segment) != '\0')
		continue;

	for (c = q->cookies; c; c = c->next) {
		if (c->expires != -1 && c->expires < now)
			/* cookie has expired => ignore */
			continue;

		if (c->secure && lwc_string_isequal(((*(&match) = ((q->scheme) == (corestring_lwc_https)))
, lwc_error_ok)
			    q->scheme,((*(&match) = ((q->scheme) == (corestring_lwc_https)))
, lwc_error_ok)
			    corestring_lwc_https,((*(&match) = ((q->scheme) == (corestring_lwc_https)))
, lwc_error_ok)
			    &match)((*(&match) = ((q->scheme) == (corestring_lwc_https)))
, lwc_error_ok) &&
		    match == false0)
			/* Secure cookie for insecure server
			 * => ignore */
			continue;

		matched_cookies[count++] = c;

		GROW_MATCHED_COOKIES;

		if (c->version < (unsigned int) version)
			version = c->version;

		c->last_used = now;

		cookie_manager_add((struct cookie_data *)c);
	}
}

if (!p->parent) {
	/* No parent, so bail here. This can't go in
	 * the loop exit condition as we also want to
	 * process the top-level node.
	 *
	 * If p->parent is NULL then p->cookies are
	 * the domain cookies and thus we don't even
	 * try matching against them.
	 */
	break;
}

/* Consider p itself - may be the result of Path=/foo */
for (c = p->cookies; c; c = c->next) {
	if (c->expires != -1 && c->expires < now)
		/* cookie has expired => ignore */
		continue;

	/* Ensure cookie path is a prefix of the resource */
	if (strncmp(c->path, path, strlen(c->path)) != 0)
		/* paths don't match => ignore */
		continue;

	if (c->secure && lwc_string_isequal(p->scheme,((*(&match) = ((p->scheme) == (corestring_lwc_https)))
, lwc_error_ok)
					    corestring_lwc_https,((*(&match) = ((p->scheme) == (corestring_lwc_https)))
, lwc_error_ok)
					    &match)((*(&match) = ((p->scheme) == (corestring_lwc_https)))
, lwc_error_ok) &&
	    match == false0)
		/* Secure cookie for insecure server
		 * => ignore */
		continue;

	matched_cookies[count++] = c;

	GROW_MATCHED_COOKIES;

	if (c->version < (unsigned int) version)
		version = c->version;

	c->last_used = now;

	cookie_manager_add((struct cookie_data *)c);
}

}

/* Finally consider domain cookies for hosts which domain match ours */
for (h = (const struct host_part *)p; h && h != &db_root;
    h = h->parent) {
for (c = h->paths.cookies; c; c = c->next) {
	if (c->expires != -1 && c->expires < now)
		/* cookie has expired => ignore */
		continue;

	/* Ensure cookie path is a prefix of the resource */
	if (strncmp(c->path, path, strlen(c->path)) != 0)
		/* paths don't match => ignore */
		continue;

	if (c->secure && lwc_string_isequal(scheme,((*(&match) = ((scheme) == (corestring_lwc_https))), lwc_error_ok
)
					    corestring_lwc_https,((*(&match) = ((scheme) == (corestring_lwc_https))), lwc_error_ok
)
					    &match)((*(&match) = ((scheme) == (corestring_lwc_https))), lwc_error_ok
) &&
	    match == false0)
		/* secure cookie for insecure host. ignore */
		continue;

	matched_cookies[count++] = c;

	GROW_MATCHED_COOKIES;

	if (c->version < (unsigned int)version)
		version = c->version;

	c->last_used = now;

	cookie_manager_add((struct cookie_data *)c);
}
}

if (count == 0) {
/* No cookies found */
free(ret);
free(matched_cookies);
return NULL((void*)0);
}

/* and build output string */
if (version > COOKIE_NETSCAPE) {
sprintf(ret, "$Version=%d", version);
ret_used = strlen(ret) + 1;
}

for (i = 0; i < count; i++) {
if (!urldb_concat_cookie(matched_cookies[i], version,
			 &ret_used, &ret_alloc, &ret)) {
	free(ret);
	free(matched_cookies);
	return NULL((void*)0);
}
}

if (version == COOKIE_NETSCAPE) {
/* Old-style cookies => no version & skip "; " */
memmove(ret, ret + 2, ret_used - 2);
ret_used -= 2;
}

/* Now, shrink the output buffer to the required size */
{
char *temp = realloc(ret, ret_used);
if (!temp) {
	free(ret);
	free(matched_cookies);
	return NULL((void*)0);
}

ret = temp;
}

free(matched_cookies);

return ret;

4268#undef GROW_MATCHED_COOKIES
4269}


4272/* exported interface documented in content/urldb.h */
4273void urldb_delete_cookie(const char *domain, const char *path,
	 const char *name)
4275{
urldb_delete_cookie_hosts(domain, path, name, &db_root);
4277}


4280/* exported interface documented in content/urldb.h */
4281void urldb_load_cookies(const char *filename)
4282{
FILE *fp;
char s[16*1024];

assert(filename)((filename) ? (void) (0) : __assert_fail ("filename", "content/urldb.c"
, 4286, __extension__ __PRETTY_FUNCTION__));

fp = fopen(filename, "r");
if (!fp)
return;

4292#define FIND_T {				\
for (; *p && *p != '\t'; p++)	\
	; /* do nothing */	\
if (p >= end) {			\
	NSLOG(netsurf, INFO, "Overran input")do { if (NSLOG_LEVEL_INFO >= NSLOG_LEVEL_VERBOSE) { static
 nslog_entry_context_t _nslog_ctx = { &__nslog_category_netsurf
, NSLOG_LEVEL_INFO, "content/urldb.c", sizeof("content/urldb.c"
) - 1, __PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1, 4296
, }; nslog__log(&_nslog_ctx, "Overran input"); } } while(
0);	\
	continue;		\
}				\
*p++ = '\0';			\
}

4302#define SKIP_T {				\
for (; *p && *p == '\t'; p++)	\
	; /* do nothing */	\
if (p >= end) {			\
	NSLOG(netsurf, INFO, "Overran input")do { if (NSLOG_LEVEL_INFO >= NSLOG_LEVEL_VERBOSE) { static
 nslog_entry_context_t _nslog_ctx = { &__nslog_category_netsurf
, NSLOG_LEVEL_INFO, "content/urldb.c", sizeof("content/urldb.c"
) - 1, __PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1, 4306
, }; nslog__log(&_nslog_ctx, "Overran input"); } } while(
0);	\
	continue;		\
}				\
}

while (fgets(s, sizeof s, fp)) {
char *p = s, *end = 0,
	*domain, *path, *name, *value, *scheme, *url,
	*comment;
int version, domain_specified, path_specified,
	secure, http_only, no_destroy, value_quoted;
time_t expires, last_used;
struct cookie_internal_data *c;

if(s[0] == 0 || s[0] == '#')
	/* Skip blank lines or comments */
	continue;

s[strlen(s) - 1] = '\0'; /* lose terminating newline */
end = s + strlen(s);

/* Look for file version first
 * (all input is ignored until this is read)
 */
if (strncasecmp(s, "Version:", 8) == 0) {
	FIND_T; SKIP_T; loaded_cookie_file_version = atoi(p);

	if (loaded_cookie_file_version <
	    MIN_COOKIE_FILE_VERSION100) {
		NSLOG(netsurf, INFO,do { if (NSLOG_LEVEL_INFO >= NSLOG_LEVEL_VERBOSE) { static
 nslog_entry_context_t _nslog_ctx = { &__nslog_category_netsurf
, NSLOG_LEVEL_INFO, "content/urldb.c", sizeof("content/urldb.c"
) - 1, __PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1, 4336
, }; nslog__log(&_nslog_ctx, "Unsupported Cookie file version"
); } } while(0)
		      "Unsupported Cookie file version")do { if (NSLOG_LEVEL_INFO >= NSLOG_LEVEL_VERBOSE) { static
 nslog_entry_context_t _nslog_ctx = { &__nslog_category_netsurf
, NSLOG_LEVEL_INFO, "content/urldb.c", sizeof("content/urldb.c"
) - 1, __PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1, 4336
, }; nslog__log(&_nslog_ctx, "Unsupported Cookie file version"
); } } while(0);
		break;
	}

	continue;
} else if (loaded_cookie_file_version == 0) {
	/* Haven't yet seen version; skip this input */
	continue;
}

/* One cookie/line */

/* Parse input */
FIND_T; version = atoi(s);
SKIP_T; domain = p; FIND_T;
SKIP_T; domain_specified = atoi(p); FIND_T;
SKIP_T; path = p; FIND_T;
SKIP_T; path_specified = atoi(p); FIND_T;
SKIP_T; secure = atoi(p); FIND_T;
if (loaded_cookie_file_version > 101) {
	/* Introduced in version 1.02 */
	SKIP_T; http_only = atoi(p); FIND_T;
} else {
	http_only = 0;
}
SKIP_T; expires = (time_t)atoi(p); FIND_T;
SKIP_T; last_used = (time_t)atoi(p); FIND_T;
SKIP_T; no_destroy = atoi(p); FIND_T;
SKIP_T; name = p; FIND_T;
SKIP_T; value = p; FIND_T;
if (loaded_cookie_file_version > 100) {
	/* Introduced in version 1.01 */
	SKIP_T;	value_quoted = atoi(p); FIND_T;
} else {
	value_quoted = 0;
}
SKIP_T; scheme = p; FIND_T;
SKIP_T; url = p; FIND_T;

/* Comment may have no content, so don't
 * use macros as they'll break */
for (; *p && *p == '\t'; p++)
	; /* do nothing */
comment = p;

assert(p <= end)((p <= end) ? (void) (0) : __assert_fail ("p <= end", "content/urldb.c"
, 4381, __extension__ __PRETTY_FUNCTION__));

/* Now create cookie */
c = malloc(sizeof(struct cookie_internal_data));
if (!c)
	break;

c->name = strdup(name);
c->value = strdup(value);
c->value_was_quoted = value_quoted;
c->comment = strdup(comment);
c->domain_from_set = domain_specified;
c->domain = strdup(domain);
c->path_from_set = path_specified;
c->path = strdup(path);
c->expires = expires;
c->last_used = last_used;
c->secure = secure;
c->http_only = http_only;
c->version = version;
c->no_destroy = no_destroy;

if (!(c->name && c->value && c->comment &&
      c->domain && c->path)) {
	urldb_free_cookie(c);
	break;
}

if (c->domain[0] != '.') {
	lwc_string *scheme_lwc = NULL((void*)0);
	nsurl *url_nsurl = NULL((void*)0);

	assert(scheme[0] != 'u')((scheme[0] != 'u') ? (void) (0) : __assert_fail ("scheme[0] != 'u'"
, "content/urldb.c", 4413, __extension__ __PRETTY_FUNCTION__)
);

	if (nsurl_create(url, &url_nsurl) != NSERROR_OK) {
		urldb_free_cookie(c);
		break;
	}
	scheme_lwc = nsurl_get_component(url_nsurl,
					 NSURL_SCHEME);

	/* And insert it into database */
	if (!urldb_insert_cookie(c, scheme_lwc, url_nsurl)) {
		/* Cookie freed for us */
		nsurl_unref(url_nsurl);
		lwc_string_unref(scheme_lwc){ lwc_string *__lwc_s = (scheme_lwc); ((__lwc_s != ((void*)0)
) ? (void) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c"
, 4426, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt
--; if ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1
) && (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy
(__lwc_s); };
		break;
	}
	nsurl_unref(url_nsurl);
	lwc_string_unref(scheme_lwc){ lwc_string *__lwc_s = (scheme_lwc); ((__lwc_s != ((void*)0)
) ? (void) (0) : __assert_fail ("__lwc_s != NULL", "content/urldb.c"
, 4430, __extension__ __PRETTY_FUNCTION__)); __lwc_s->refcnt
--; if ((__lwc_s->refcnt == 0) || ((__lwc_s->refcnt == 1
) && (__lwc_s->insensitive == __lwc_s))) lwc_string_destroy
(__lwc_s); };

} else {
	if (!urldb_insert_cookie(c, NULL((void*)0), NULL((void*)0))) {
		/* Cookie freed for us */
		break;
	}
}
}

4440#undef SKIP_T
4441#undef FIND_T

fclose(fp);
4444}


4447/* exported interface documented in content/urldb.h */
4448void urldb_save_cookies(const char *filename)
4449{
FILE *fp;
int cookie_file_version = max(loaded_cookie_file_version,(((loaded_cookie_file_version)>(102))?(loaded_cookie_file_version
):(102))
		      COOKIE_FILE_VERSION)(((loaded_cookie_file_version)>(102))?(loaded_cookie_file_version
):(102));

assert(filename)((filename) ? (void) (0) : __assert_fail ("filename", "content/urldb.c"
, 4454, __extension__ __PRETTY_FUNCTION__));

fp = fopen(filename, "w");
if (!fp)
return;

fprintf(fp, "# NetSurf cookies file.\n"
"#\n"
"# Lines starting with a '#' are comments, "
"blank lines are ignored.\n"
"#\n"
"# All lines prior to \"Version:\t%d\" are discarded.\n"
"#\n"
"# Version\tDomain\tDomain from Set-Cookie\tPath\t"
"Path from Set-Cookie\tSecure\tHTTP-Only\tExpires\tLast used\t"
"No destroy\tName\tValue\tValue was quoted\tScheme\t"
"URL\tComment\n",
cookie_file_version);
fprintf(fp, "Version:\t%d\n", cookie_file_version);

urldb_save_cookie_hosts(fp, &db_root);

fclose(fp);
4477}


4480/* exported interface documented in netsurf/url_db.h */
4481void urldb_dump(void)
4482{
int i;

urldb_dump_hosts(&db_root);

for (i = 0; i != NUM_SEARCH_TREES28; i++) {
urldb_dump_search(search_trees[i], 0);
}
4490}



