/*
* Unquote the content of a (potentially) quoted string.
* Return: newly allocated unquoted content.
*
* Arguments:
* valuep: pointer to a pointer to the first char.
*
* Preconditions:
* *valuep points to a correctly quoted and escaped string.
*
* Postconditions:
* *valuep points to the first not processed char.
*
*/
static Dstr *Auth_unquote_value(char **valuep)
{
char c, quoted;
char *value = *valuep;
Dstr *result;
while (*value == ' ' || *value == '\t')
value++;
if ((quoted = *value == '"'))
value++;
result = dStr_new(NULL);
while ((c = *value) &&
(( quoted && c != '"') ||
(!quoted && Auth_is_token_char(c)))) {
dStr_append_c(result, (c == '\\' && value[1]) ? *++value : c);
value++;
}
if (quoted && *value == '\"')
value++;
*valuep = value;
return result;
}
/*
* Decode gzipped data
*/
static Dstr *Decode_gzip(Decode *dc, const char *instr, int inlen)
{
int rc = Z_OK;
z_stream *zs = (z_stream *)dc->state;
int inputConsumed = 0;
Dstr *output = dStr_new("");
while ((rc == Z_OK) && (inputConsumed < inlen)) {
zs->next_in = (Bytef *)instr + inputConsumed;
zs->avail_in = inlen - inputConsumed;
zs->next_out = (Bytef *)dc->buffer;
zs->avail_out = bufsize;
rc = inflate(zs, Z_SYNC_FLUSH);
dStr_append_l(output, dc->buffer, zs->total_out);
if ((rc == Z_OK) || (rc == Z_STREAM_END)) {
// Z_STREAM_END at end of file
inputConsumed += zs->total_in;
zs->total_out = 0;
zs->total_in = 0;
} else if (rc == Z_DATA_ERROR) {
MSG_ERR("gzip decompression error\n");
}
}
return output;
}
/*
* If the url belongs to a dpi server, return its name.
*/
static int Capi_url_uses_dpi(DilloUrl *url, char **server_ptr)
{
char *p, *server = NULL, *url_str = URL_STR(url);
Dstr *tmp;
if ((dStrncasecmp(url_str, "http:", 5) == 0) ||
(dStrncasecmp(url_str, "about:", 6) == 0)) {
/* URL doesn't use dpi (server = NULL) */
} else if (dStrncasecmp(url_str, "dpi:/", 5) == 0) {
/* dpi prefix, get this server's name */
if ((p = strchr(url_str + 5, '/')) != NULL) {
server = dStrndup(url_str + 5, (uint_t)(p - url_str - 5));
} else {
server = dStrdup("?");
}
if (strcmp(server, "bm") == 0) {
dFree(server);
server = dStrdup("bookmarks");
}
} else if ((p = strchr(url_str, ':')) != NULL) {
tmp = dStr_new("proto.");
dStr_append_l(tmp, url_str, p - url_str);
server = tmp->str;
dStr_free(tmp, 0);
}
return ((*server_ptr = server) ? 1 : 0);
}
/*
* Generate Content-Type header value for a POST query.
*/
static Dstr *Http_make_content_type(const DilloUrl *url)
{
Dstr *dstr;
if (URL_FLAGS(url) & URL_MultipartEnc) {
MSG("submitting multipart/form-data!\n");
dstr = dStr_new("multipart/form-data; boundary=\"");
if (URL_DATA(url)->len > 2) {
/* boundary lines have "--" prepended. Skip that. */
const char *start = URL_DATA(url)->str + 2;
char *eol = strchr(start, '\r');
if (eol)
dStr_append_l(dstr, start, eol - start);
} else {
/* Zero parts; arbitrary boundary */
dStr_append_c(dstr, '0');
}
dStr_append_c(dstr,'"');
} else {
dstr = dStr_new("application/x-www-form-urlencoded");
}
return dstr;
}
/*
* Initialize transfer decoder. Currently handles "chunked".
*/
Decode *a_Decode_transfer_init(const char *format)
{
Decode *dc = NULL;
if (format && !dStrAsciiCasecmp(format, "chunked")) {
int *chunk_remaining = dNew(int, 1);
*chunk_remaining = 0;
dc = dNew(Decode, 1);
dc->leftover = dStr_new("");
dc->state = chunk_remaining;
dc->decode = Decode_chunked;
dc->free = Decode_chunked_free;
dc->buffer = NULL; /* not used */
_MSG("chunked!\n");
}
/*
* Initialize dicache data
*/
void a_Cache_init(void)
{
ClientQueue = dList_new(32);
DelayedQueue = dList_new(32);
CachedURLs = dList_new(256);
/* inject the splash screen in the cache */
{
DilloUrl *url = a_Url_new("about:splash", NULL);
Dstr *ds = dStr_new(AboutSplash);
Cache_entry_inject(url, ds);
dStr_free(ds, 1);
a_Url_free(url);
}
}
/*
* Set safe values for a new cache entry
*/
static void Cache_entry_init(CacheEntry_t *NewEntry, const DilloUrl *Url)
{
NewEntry->Url = a_Url_dup(Url);
NewEntry->TypeDet = NULL;
NewEntry->TypeHdr = NULL;
NewEntry->TypeMeta = NULL;
NewEntry->TypeNorm = NULL;
NewEntry->Header = dStr_new("");
NewEntry->Location = NULL;
NewEntry->Auth = NULL;
NewEntry->Data = dStr_sized_new(8*1024);
NewEntry->UTF8Data = NULL;
NewEntry->DataRefcount = 0;
NewEntry->TransferDecoder = NULL;
NewEntry->ContentDecoder = NULL;
NewEntry->CharsetDecoder = NULL;
NewEntry->ExpectedSize = 0;
NewEntry->TransferSize = 0;
NewEntry->Flags = CA_IsEmpty;
}
/*
* Translate to desired character set (UTF-8)
*/
static Dstr *Decode_charset(Decode *dc, const char *instr, int inlen)
{
inbuf_t *inPtr;
char *outPtr;
size_t inLeft, outRoom;
Dstr *output = dStr_new("");
int rc = 0;
dStr_append_l(dc->leftover, instr, inlen);
inPtr = dc->leftover->str;
inLeft = dc->leftover->len;
while ((rc != EINVAL) && (inLeft > 0)) {
outPtr = dc->buffer;
outRoom = bufsize;
rc = iconv((iconv_t)dc->state, &inPtr, &inLeft, &outPtr, &outRoom);
// iconv() on success, number of bytes converted
// -1, errno == EILSEQ illegal byte sequence found
// EINVAL partial character ends source buffer
// E2BIG destination buffer is full
dStr_append_l(output, dc->buffer, bufsize - outRoom);
if (rc == -1)
rc = errno;
if (rc == EILSEQ){
inPtr++;
inLeft--;
dStr_append_l(output, utf8_replacement_char,
sizeof(utf8_replacement_char) - 1);
}
}
dStr_erase(dc->leftover, 0, dc->leftover->len - inLeft);
return output;
}
/*
* Return a new string for the request used to tunnel HTTPS through a proxy.
* As of 2009, the best reference appears to be section 5 of RFC 2817.
*/
char *a_Http_make_connect_str(const DilloUrl *url)
{
Dstr *dstr;
const char *auth1;
int auth_len;
char *auth2, *proxy_auth, *retstr;
dReturn_val_if_fail(Http_must_use_proxy(url), NULL);
dstr = dStr_new("");
auth1 = URL_AUTHORITY(url);
auth_len = strlen(auth1);
if (auth_len > 0 && !isdigit(auth1[auth_len - 1]))
/* if no port number, add HTTPS port */
auth2 = dStrconcat(auth1, ":443", NULL);
else
auth2 = dStrdup(auth1);
proxy_auth = HTTP_Proxy_Auth_base64 ?
dStrconcat ("Proxy-Authorization: Basic ",
HTTP_Proxy_Auth_base64, "\r\n", NULL) :
dStrdup("");
dStr_sprintfa(
dstr,
"CONNECT %s HTTP/1.1\r\n"
"Host: %s\r\n"
"%s"
"\r\n",
auth2,
auth2,
proxy_auth);
dFree(auth2);
dFree(proxy_auth);
retstr = dstr->str;
dStr_free(dstr, 0);
return retstr;
}
/*
* Make the http query string
*/
Dstr *a_Http_make_query_str(const DilloUrl *url, const DilloUrl *requester,
bool_t use_proxy)
{
char *ptr, *cookies, *referer, *auth;
Dstr *query = dStr_new(""),
*request_uri = dStr_new(""),
*proxy_auth = dStr_new("");
if (use_proxy) {
dStr_sprintfa(request_uri, "%s%s",
URL_STR(url),
(URL_PATH_(url) || URL_QUERY_(url)) ? "" : "/");
if ((ptr = strrchr(request_uri->str, '#')))
dStr_truncate(request_uri, ptr - request_uri->str);
if (HTTP_Proxy_Auth_base64)
dStr_sprintf(proxy_auth, "Proxy-Authorization: Basic %s\r\n",
HTTP_Proxy_Auth_base64);
} else {
dStr_sprintfa(request_uri, "%s%s%s%s",
URL_PATH(url),
URL_QUERY_(url) ? "?" : "",
URL_QUERY(url),
(URL_PATH_(url) || URL_QUERY_(url)) ? "" : "/");
}
cookies = a_Cookies_get_query(url, requester);
auth = a_Auth_get_auth_str(url, request_uri->str);
referer = Http_get_referer(url);
if (URL_FLAGS(url) & URL_Post) {
Dstr *content_type = Http_make_content_type(url);
dStr_sprintfa(
query,
"POST %s HTTP/1.1\r\n"
"Connection: close\r\n"
"Accept: text/*,image/*,*/*;q=0.2\r\n"
"Accept-Charset: utf-8,*;q=0.8\r\n"
"Accept-Encoding: gzip\r\n"
"%s" /* language */
"%s" /* auth */
"Host: %s\r\n"
"%s"
"%s"
"User-Agent: %s\r\n"
"Content-Length: %ld\r\n"
"Content-Type: %s\r\n"
"%s" /* cookies */
"\r\n",
request_uri->str, HTTP_Language_hdr, auth ? auth : "",
URL_AUTHORITY(url), proxy_auth->str, referer, prefs.http_user_agent,
(long)URL_DATA(url)->len, content_type->str,
cookies);
dStr_append_l(query, URL_DATA(url)->str, URL_DATA(url)->len);
dStr_free(content_type, TRUE);
} else {
dStr_sprintfa(
query,
"GET %s HTTP/1.1\r\n"
"%s"
"Connection: close\r\n"
"Accept: text/*,image/*,*/*;q=0.2\r\n"
"Accept-Charset: utf-8,*;q=0.8\r\n"
"Accept-Encoding: gzip\r\n"
"%s" /* language */
"%s" /* auth */
"Host: %s\r\n"
"%s"
"%s"
"User-Agent: %s\r\n"
"%s" /* cookies */
"\r\n",
request_uri->str,
(URL_FLAGS(url) & URL_E2EQuery) ?
"Cache-Control: no-cache\r\nPragma: no-cache\r\n" : "",
HTTP_Language_hdr, auth ? auth : "", URL_AUTHORITY(url),
proxy_auth->str, referer, prefs.http_user_agent, cookies);
}
dFree(referer);
dFree(cookies);
dFree(auth);
dStr_free(request_uri, TRUE);
dStr_free(proxy_auth, TRUE);
_MSG("Query: {%s}\n", dStr_printable(query, 8192));
return query;
}
/*
* Scan, allocate, and set things according to header info.
* (This function needs the whole header to work)
*/
static void Cache_parse_header(CacheEntry_t *entry)
{
char *header = entry->Header->str;
char *Length, *Type, *location_str, *encoding;
#ifndef DISABLE_COOKIES
Dlist *Cookies;
#endif
Dlist *warnings;
void *data;
int i;
_MSG("Cache_parse_header\n");
if (entry->Header->len > 12) {
if (header[9] == '1' && header[10] == '0' && header[11] == '0') {
/* 100: Continue. The "real" header has not come yet. */
MSG("An actual 100 Continue header!\n");
entry->Flags &= ~CA_GotHeader;
dStr_free(entry->Header, 1);
entry->Header = dStr_new("");
return;
}
if (header[9] == '3' && header[10] == '0' &&
(location_str = Cache_parse_field(header, "Location"))) {
/* 30x: URL redirection */
DilloUrl *location_url = a_Url_new(location_str,URL_STR_(entry->Url));
if (prefs.filter_auto_requests == PREFS_FILTER_SAME_DOMAIN &&
!a_Url_same_organization(entry->Url, location_url)) {
/* don't redirect; just show body like usual (if any) */
MSG("Redirection not followed from %s to %s\n",
URL_HOST(entry->Url), URL_STR(location_url));
a_Url_free(location_url);
} else {
entry->Flags |= CA_Redirect;
if (header[11] == '1')
entry->Flags |= CA_ForceRedirect; /* 301 Moved Permanently */
else if (header[11] == '2')
entry->Flags |= CA_TempRedirect; /* 302 Temporary Redirect */
if (URL_FLAGS(location_url) & (URL_Post + URL_Get) &&
dStrAsciiCasecmp(URL_SCHEME(location_url), "dpi") == 0 &&
dStrAsciiCasecmp(URL_SCHEME(entry->Url), "dpi") != 0) {
/* Forbid dpi GET and POST from non dpi-generated urls */
MSG("Redirection Denied! '%s' -> '%s'\n",
URL_STR(entry->Url), URL_STR(location_url));
a_Url_free(location_url);
} else {
entry->Location = location_url;
}
}
dFree(location_str);
} else if (strncmp(header + 9, "401", 3) == 0) {
entry->Auth =
Cache_parse_multiple_fields(header, "WWW-Authenticate");
} else if (strncmp(header + 9, "404", 3) == 0) {
entry->Flags |= CA_NotFound;
}
}
if ((warnings = Cache_parse_multiple_fields(header, "Warning"))) {
for (i = 0; (data = dList_nth_data(warnings, i)); ++i) {
MSG_HTTP("%s\n", (char *)data);
dFree(data);
}
dList_free(warnings);
}
/*
* Get Transfer-Encoding and initialize decoder
*/
encoding = Cache_parse_field(header, "Transfer-Encoding");
entry->TransferDecoder = a_Decode_transfer_init(encoding);
if ((Length = Cache_parse_field(header, "Content-Length")) != NULL) {
if (encoding) {
/*
* If Transfer-Encoding is present, Content-Length must be ignored.
* If the Transfer-Encoding is non-identity, it is an error.
*/
if (dStrAsciiCasecmp(encoding, "identity"))
MSG_HTTP("Content-Length and non-identity Transfer-Encoding "
"headers both present.\n");
} else {
entry->Flags |= CA_GotLength;
entry->ExpectedSize = MAX(strtol(Length, NULL, 10), 0);
}
dFree(Length);
}
dFree(encoding); /* free Transfer-Encoding */
#ifndef DISABLE_COOKIES
if ((Cookies = Cache_parse_multiple_fields(header, "Set-Cookie"))) {
CacheClient_t *client;
for (i = 0; (client = dList_nth_data(ClientQueue, i)); ++i) {
if (client->Url == entry->Url) {
DilloWeb *web = client->Web;
if (!web->requester ||
a_Url_same_organization(entry->Url, web->requester)) {
char *server_date = Cache_parse_field(header, "Date");
a_Cookies_set(Cookies, entry->Url, server_date);
dFree(server_date);
break;
}
}
}
if (i >= dList_length(ClientQueue)) {
MSG("Cache: cookies not accepted from '%s'\n", URL_STR(entry->Url));
}
for (i = 0; (data = dList_nth_data(Cookies, i)); ++i)
dFree(data);
dList_free(Cookies);
}
#endif /* !DISABLE_COOKIES */
/*
* Get Content-Encoding and initialize decoder
*/
encoding = Cache_parse_field(header, "Content-Encoding");
entry->ContentDecoder = a_Decode_content_init(encoding);
dFree(encoding);
if (entry->ExpectedSize > 0) {
if (entry->ExpectedSize > HUGE_FILESIZE) {
entry->Flags |= CA_HugeFile;
}
/* Avoid some reallocs. With MAX_INIT_BUF we avoid a SEGFAULT
* with huge files (e.g. iso files).
* Note: the buffer grows automatically. */
dStr_free(entry->Data, 1);
entry->Data = dStr_sized_new(MIN(entry->ExpectedSize, MAX_INIT_BUF));
}
/* Get Content-Type */
if ((Type = Cache_parse_field(header, "Content-Type"))) {
/* This HTTP Content-Type is not trusted. It's checked against real data
* in Cache_process_queue(); only then CA_GotContentType becomes true. */
a_Cache_set_content_type(entry->Url, Type, "http");
_MSG("TypeHdr {%s} {%s}\n", Type, URL_STR(entry->Url));
_MSG("TypeMeta {%s}\n", entry->TypeMeta);
dFree(Type);
}
Cache_ref_data(entry);
}