-const char parsers_rcs[] = "$Id: parsers.c,v 1.190 2009/07/05 20:43:14 ler762 Exp $";
+const char parsers_rcs[] = "$Id: parsers.c,v 1.249 2012/09/04 08:33:17 fabiankeil Exp $";
/*********************************************************************
*
* File : $Source: /cvsroot/ijbswa/current/parsers.c,v $
*
* Purpose : Declares functions to parse/crunch headers and pages.
- * Functions declared include:
- * `add_to_iob', `client_cookie_adder', `client_from',
- * `client_referrer', `client_send_cookie', `client_ua',
- * `client_uagent', `client_x_forwarded',
- * `client_x_forwarded_adder', `client_xtra_adder',
- * `content_type', `crumble', `destroy_list', `enlist',
- * `flush_socket', ``get_header', `sed', `filter_header'
- * `server_content_encoding', `server_content_disposition',
- * `server_last_modified', `client_accept_language',
- * `crunch_client_header', `client_if_modified_since',
- * `client_if_none_match', `get_destination_from_headers',
- * `parse_header_time', `decompress_iob' and `server_set_cookie'.
- *
- * Copyright : Written by and Copyright (C) 2001-2009 the
+ *
+ * Copyright : Written by and Copyright (C) 2001-2012 the
* Privoxy team. http://www.privoxy.org/
*
* Based on the Internet Junkbuster originally written
const char parsers_h_rcs[] = PARSERS_H_VERSION;
-/* Fix a problem with Solaris. There should be no effect on other
- * platforms.
- * Solaris's isspace() is a macro which uses its argument directly
- * as an array index. Therefore we need to make sure that high-bit
- * characters generate +ve values, and ideally we also want to make
- * the argument match the declared parameter type of "int".
- *
- * Why did they write a character function that can't take a simple
- * "char" argument? Doh!
- */
-#define ijb_isupper(__X) isupper((int)(unsigned char)(__X))
-#define ijb_tolower(__X) tolower((int)(unsigned char)(__X))
-
static char *get_header_line(struct iob *iob);
static jb_err scan_headers(struct client_state *csp);
static jb_err header_tagger(struct client_state *csp, char *header);
static jb_err crunch_server_header (struct client_state *csp, char **header);
static jb_err server_last_modified (struct client_state *csp, char **header);
static jb_err server_content_disposition(struct client_state *csp, char **header);
+#ifdef FEATURE_ZLIB
+static jb_err server_adjust_content_encoding(struct client_state *csp, char **header);
+#endif
#ifdef FEATURE_CONNECTION_KEEP_ALIVE
static jb_err server_save_content_length(struct client_state *csp, char **header);
static jb_err server_keep_alive(struct client_state *csp, char **header);
+static jb_err server_proxy_connection(struct client_state *csp, char **header);
static jb_err client_keep_alive(struct client_state *csp, char **header);
+static jb_err client_save_content_length(struct client_state *csp, char **header);
#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
static jb_err client_host_adder (struct client_state *csp);
static jb_err create_fake_referrer(char **header, const char *fake_referrer);
static jb_err handle_conditional_hide_referrer_parameter(char **header,
const char *host, const int parameter_conditional_block);
-static const char *get_appropiate_connection_header(const struct client_state *csp);
static void create_content_length_header(unsigned long long content_length,
char *header, size_t buffer_length);
{
/** The header prefix to match */
const char *str;
-
+
/** The length of the prefix to match */
const size_t len;
-
+
/** The function to apply to this line */
const parser_func_ptr parser;
};
{ "if-modified-since:", 18, client_if_modified_since },
#ifdef FEATURE_CONNECTION_KEEP_ALIVE
{ "Keep-Alive:", 11, client_keep_alive },
+ { "Content-Length:", 15, client_save_content_length },
#else
{ "Keep-Alive:", 11, crumble },
#endif
#ifdef FEATURE_CONNECTION_KEEP_ALIVE
{ "Content-Length:", 15, server_save_content_length },
{ "Keep-Alive:", 11, server_keep_alive },
+ { "Proxy-Connection:", 17, server_proxy_connection },
#else
{ "Keep-Alive:", 11, crumble },
#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
client_host_adder,
client_x_forwarded_for_adder,
client_xtra_adder,
- /* Temporarily disabled: client_accept_encoding_adder, */
client_connection_header_adder,
NULL
};
jb_err add_to_iob(struct client_state *csp, char *buf, long n)
{
struct iob *iob = csp->iob;
- size_t used, offset, need, want;
+ size_t used, offset, need;
char *p;
if (n <= 0) return JB_ERR_OK;
if (need > iob->size)
{
- for (want = csp->iob->size ? csp->iob->size : 512; want <= need;) want *= 2;
-
+ size_t want = csp->iob->size ? csp->iob->size : 512;
+
+ while (want <= need)
+ {
+ want *= 2;
+ }
+
if (want <= csp->config->buffer_limit && NULL != (p = (char *)realloc(iob->buf, want)))
{
iob->size = want;
jb_err decompress_iob(struct client_state *csp)
{
char *buf; /* new, uncompressed buffer */
- char *cur; /* Current iob position (to keep the original
+ char *cur; /* Current iob position (to keep the original
* iob->cur unmodified if we return early) */
size_t bufsize; /* allocated size of the new buffer */
size_t old_size; /* Content size before decompression */
*
* Fortunately, add_to_iob() has thoughtfully null-terminated
* the buffer; we can just increment the end pointer to include
- * the dummy byte.
+ * the dummy byte.
*/
csp->iob->eod++;
}
assert(bufsize >= skip_size);
memcpy(buf, csp->iob->buf, skip_size);
- zstr.avail_out = bufsize - skip_size;
+ zstr.avail_out = (uInt)(bufsize - skip_size);
zstr.next_out = (Bytef *)buf + skip_size;
/* Try to decompress the whole stream in one shot. */
}
/*
- * If we tried the limit and still didn't have enough
- * memory, just give up.
+ * If we reached the buffer limit and still didn't have enough
+ * memory, just give up. Due to the ceiling enforced by the next
+ * if block we could actually check for equality here, but as it
+ * can be easily mistaken for a bug we don't.
*/
- if (bufsize == csp->config->buffer_limit)
+ if (bufsize >= csp->config->buffer_limit)
{
log_error(LOG_LEVEL_ERROR, "Buffer limit reached while decompressing iob");
return JB_ERR_MEMORY;
{
bufsize = csp->config->buffer_limit;
}
-
+
/* Try to allocate the new buffer. */
tmpbuf = realloc(buf, bufsize);
if (NULL == tmpbuf)
* buffer, which may be in a location different from
* the old one.
*/
- zstr.avail_out += bufsize - oldbufsize;
+ zstr.avail_out += (uInt)(bufsize - oldbufsize);
zstr.next_out = (Bytef *)tmpbuf + bufsize - zstr.avail_out;
/*
*/
assert(zstr.avail_out == tmpbuf + bufsize - (char *)zstr.next_out);
assert((char *)zstr.next_out == tmpbuf + ((char *)oldnext_out - buf));
- assert(zstr.avail_out > 0U);
buf = tmpbuf;
}
csp->iob->cur = csp->iob->buf + skip_size;
csp->iob->eod = (char *)zstr.next_out;
csp->iob->size = bufsize;
-
+
/*
* Make sure the new uncompressed iob obeys some minimal
* consistency conditions.
while (*p != '\0')
{
- if (ijb_isspace(*p) && ijb_isspace(*(p+1)))
+ if (privoxy_isspace(*p) && privoxy_isspace(*(p+1)))
{
char *q = p+1;
- while (ijb_isspace(*q))
+ while (privoxy_isspace(*q))
{
q++;
}
}
p = strchr(header, ':');
- if ((p != NULL) && (p != header) && ijb_isspace(*(p-1)))
+ if ((p != NULL) && (p != header) && privoxy_isspace(*(p-1)))
{
/*
* There's still space before the colon.
* Header spans multiple lines, append the next one.
*/
char *continued_header;
-
+
continued_header = get_header_line(iob);
if ((continued_header == NULL) || (*continued_header == '\0'))
{
* Found: return pointer to start of value
*/
ret = cur_entry->str + length;
- while (*ret && ijb_isspace(*ret)) ret++;
+ while (*ret && privoxy_isspace(*ret)) ret++;
return ret;
}
}
}
- /*
+ /*
* Not found
*/
return NULL;
*
* Function : scan_headers
*
- * Description : Scans headers, applies tags and updates action bits.
+ * Description : Scans headers, applies tags and updates action bits.
*
* Parameters :
* 1 : csp = Current client state (buffers, headers, etc...)
}
+/*********************************************************************
+ *
+ * Function : enforce_header_order
+ *
+ * Description : Enforces a given header order.
+ *
+ * Parameters :
+ * 1 : headers = List of headers to order.
+ * 2 : ordered_headers = List of ordered header names.
+ *
+ * Returns : N/A
+ *
+ *********************************************************************/
+static void enforce_header_order(struct list *headers, const struct list *ordered_headers)
+{
+ struct list_entry *sorted_header;
+ struct list new_headers[1];
+ struct list_entry *header;
+
+ init_list(new_headers);
+
+ /* The request line is always the first "header" */
+
+ assert(NULL != headers->first->str);
+ enlist(new_headers, headers->first->str);
+ freez(headers->first->str)
+
+ /* Enlist the specified headers in the given order */
+
+ for (sorted_header = ordered_headers->first; sorted_header != NULL;
+ sorted_header = sorted_header->next)
+ {
+ const size_t sorted_header_length = strlen(sorted_header->str);
+ for (header = headers->first; header != NULL; header = header->next)
+ {
+ /* Header enlisted in previous run? -> ignore */
+ if (header->str == NULL) continue;
+
+ if (0 == strncmpic(sorted_header->str, header->str, sorted_header_length)
+ && (header->str[sorted_header_length] == ':'))
+ {
+ log_error(LOG_LEVEL_HEADER, "Enlisting sorted header %s", header->str);
+ if (JB_ERR_OK != enlist(new_headers, header->str))
+ {
+ log_error(LOG_LEVEL_HEADER, "Failed to enlist %s", header->str);
+ }
+ freez(header->str);
+ }
+ }
+ }
+
+ /* Enlist the rest of the headers behind the ordered ones */
+ for (header = headers->first; header != NULL; header = header->next)
+ {
+ /* Header enlisted in previous run? -> ignore */
+ if (header->str == NULL) continue;
+
+ log_error(LOG_LEVEL_HEADER,
+ "Enlisting left-over header %s", header->str);
+ if (JB_ERR_OK != enlist(new_headers, header->str))
+ {
+ log_error(LOG_LEVEL_HEADER, "Failed to enlist %s", header->str);
+ }
+ freez(header->str);
+ }
+
+ list_remove_all(headers);
+ list_duplicate(headers, new_headers);
+ list_remove_all(new_headers);
+
+ return;
+}
+
/*********************************************************************
*
* Function : sed
f++;
}
+ if (!filter_server_headers && !list_is_empty(csp->config->ordered_client_headers))
+ {
+ enforce_header_order(csp->headers, csp->config->ordered_client_headers);
+ }
+
return err;
}
{ "Content-Length:", 15, server_adjust_content_length },
{ "Transfer-Encoding:", 18, server_transfer_coding },
#ifdef FEATURE_ZLIB
- { "Content-Encoding:", 17, server_content_encoding },
+ { "Content-Encoding:", 17, server_adjust_content_encoding },
#endif /* def FEATURE_ZLIB */
{ NULL, 0, NULL }
};
}
#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
+#ifdef FEATURE_COMPRESSION
+ if ((JB_ERR_OK == err)
+ && (csp->flags & CSP_FLAG_BUFFERED_CONTENT_DEFLATED))
+ {
+ err = enlist_unique_header(csp->headers, "Content-Encoding", "deflate");
+ if (JB_ERR_OK == err)
+ {
+ log_error(LOG_LEVEL_HEADER, "Added header: Content-Encoding: deflate");
+ }
+ }
+#endif
+
return err;
}
struct re_filterfile_spec *b;
struct list_entry *tag_name;
- int found_filters = 0;
const size_t header_length = strlen(header);
if (csp->flags & CSP_FLAG_CLIENT_HEADER_PARSING_DONE)
multi_action_index = ACTION_MULTI_CLIENT_HEADER_TAGGER;
}
- /* Check if there are any filters */
- for (i = 0; i < MAX_AF_FILES; i++)
- {
- fl = csp->rlist[i];
- if (NULL != fl)
- {
- if (NULL != fl->f)
- {
- found_filters = 1;
- break;
- }
- }
- }
-
- if (0 == found_filters)
+ if (filters_available(csp) == FALSE)
{
log_error(LOG_LEVEL_ERROR, "Inconsistent configuration: "
"tagging enabled, but no taggers available.");
b->name);
continue;
}
-
+
if (!list_contains_item(csp->tags, tag))
{
if (JB_ERR_OK != enlist(csp->tags, tag))
struct re_filterfile_spec *b;
struct list_entry *filtername;
- int i, found_filters = 0;
+ int i;
int wanted_filter_type;
int multi_action_index;
multi_action_index = ACTION_MULTI_CLIENT_HEADER_FILTER;
}
- /*
- * Need to check the set of re_filterfiles...
- */
- for (i = 0; i < MAX_AF_FILES; i++)
- {
- fl = csp->rlist[i];
- if (NULL != fl)
- {
- if (NULL != fl->f)
- {
- found_filters = 1;
- break;
- }
- }
- }
-
- if (0 == found_filters)
+ if (filters_available(csp) == FALSE)
{
log_error(LOG_LEVEL_ERROR, "Inconsistent configuration: "
"header filtering enabled, but no matching filters available.");
for (job = joblist; NULL != job; job = job->next)
{
matches = pcrs_execute(job, *header, size, &newheader, &size);
- if ( 0 < matches )
+ if (0 < matches)
{
- current_hits += matches;
+ current_hits += matches;
log_error(LOG_LEVEL_HEADER, "Transforming \"%s\" to \"%s\"", *header, newheader);
freez(*header);
*header = newheader;
}
- else if ( 0 == matches )
+ else if (0 == matches)
{
/* Filter doesn't change header */
freez(newheader);
* to remove the header. This function frees the
* original string if necessary.
*
- * Returns : JB_ERR_OK on success, or
- * JB_ERR_MEMORY on out-of-memory error.
+ * Returns : JB_ERR_OK on success.
*
*********************************************************************/
static jb_err server_connection(struct client_state *csp, char **header)
#ifdef FEATURE_CONNECTION_KEEP_ALIVE
&& !(csp->flags & CSP_FLAG_SERVER_SOCKET_TAINTED)
#endif
- )
+ )
{
#ifdef FEATURE_CONNECTION_KEEP_ALIVE
if ((csp->config->feature_flags & RUNTIME_FEATURE_CONNECTION_KEEP_ALIVE))
{
char *old_header = *header;
- *header = strdup("Connection: close");
- if (header == NULL)
- {
- return JB_ERR_MEMORY;
- }
+ *header = strdup_or_die("Connection: close");
log_error(LOG_LEVEL_HEADER, "Replaced: \'%s\' with \'%s\'", old_header, *header);
freez(old_header);
}
"Server keep-alive timeout is %u. Sticking with %u.",
keep_alive_timeout, csp->server_connection.keep_alive_timeout);
}
+ csp->flags |= CSP_FLAG_SERVER_KEEP_ALIVE_TIMEOUT_SET;
}
return JB_ERR_OK;
}
+/*********************************************************************
+ *
+ * Function : server_proxy_connection
+ *
+ * Description : Figures out whether or not we should add a
+ * Proxy-Connection header.
+ *
+ * Parameters :
+ * 1 : csp = Current client state (buffers, headers, etc...)
+ * 2 : header = On input, pointer to header to modify.
+ * On output, pointer to the modified header, or NULL
+ * to remove the header. This function frees the
+ * original string if necessary.
+ *
+ * Returns : JB_ERR_OK.
+ *
+ *********************************************************************/
+static jb_err server_proxy_connection(struct client_state *csp, char **header)
+{
+ csp->flags |= CSP_FLAG_SERVER_PROXY_CONNECTION_HEADER_SET;
+ return JB_ERR_OK;
+}
+
+
/*********************************************************************
*
* Function : client_keep_alive
unsigned int keep_alive_timeout;
const char *timeout_position = strstr(*header, ": ");
+ if (!(csp->config->feature_flags & RUNTIME_FEATURE_CONNECTION_KEEP_ALIVE))
+ {
+ log_error(LOG_LEVEL_HEADER,
+ "keep-alive support is disabled. Crunching: %s.", *header);
+ freez(*header);
+ return JB_ERR_OK;
+ }
+
if ((NULL == timeout_position)
|| (1 != sscanf(timeout_position, ": %u", &keep_alive_timeout)))
{
return JB_ERR_OK;
}
+
+
+/*********************************************************************
+ *
+ * Function : get_content_length
+ *
+ * Description : Gets the content length specified in a
+ * Content-Length header.
+ *
+ * Parameters :
+ * 1 : header_value = The Content-Length header value.
+ * 2 : length = Storage to return the value.
+ *
+ * Returns : JB_ERR_OK on success, or
+ * JB_ERR_PARSE if no value is recognized.
+ *
+ *********************************************************************/
+static jb_err get_content_length(const char *header_value, unsigned long long *length)
+{
+#ifdef _WIN32
+ assert(sizeof(unsigned long long) > 4);
+ if (1 != sscanf(header_value, "%I64u", length))
+#else
+ if (1 != sscanf(header_value, "%llu", length))
+#endif
+ {
+ return JB_ERR_PARSE;
+ }
+
+ return JB_ERR_OK;
+}
+
+
+/*********************************************************************
+ *
+ * Function : client_save_content_length
+ *
+ * Description : Save the Content-Length sent by the client.
+ *
+ * Parameters :
+ * 1 : csp = Current client state (buffers, headers, etc...)
+ * 2 : header = On input, pointer to header to modify.
+ * On output, pointer to the modified header, or NULL
+ * to remove the header. This function frees the
+ * original string if necessary.
+ *
+ * Returns : JB_ERR_OK on success, or
+ * JB_ERR_MEMORY on out-of-memory error.
+ *
+ *********************************************************************/
+static jb_err client_save_content_length(struct client_state *csp, char **header)
+{
+ unsigned long long content_length = 0;
+ const char *header_value;
+
+ assert(*(*header+14) == ':');
+
+ header_value = *header + 15;
+ if (JB_ERR_OK != get_content_length(header_value, &content_length))
+ {
+ log_error(LOG_LEVEL_ERROR, "Crunching invalid header: %s", *header);
+ freez(*header);
+ }
+ else
+ {
+ csp->expected_client_content_length = content_length;
+ }
+
+ return JB_ERR_OK;
+}
#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
* Function : client_connection
*
* Description : Makes sure a proper "Connection:" header is
- * set and signals connection_header_adder
+ * set and signals connection_header_adder
* to do nothing.
*
* Parameters :
* to remove the header. This function frees the
* original string if necessary.
*
- * Returns : JB_ERR_OK on success, or
- * JB_ERR_MEMORY on out-of-memory error.
+ * Returns : JB_ERR_OK on success.
*
*********************************************************************/
static jb_err client_connection(struct client_state *csp, char **header)
{
- const char *wanted_header = get_appropiate_connection_header(csp);
+ static const char connection_close[] = "Connection: close";
- if (strcmpic(*header, wanted_header))
+ if (!strcmpic(*header, connection_close))
{
#ifdef FEATURE_CONNECTION_KEEP_ALIVE
- if (!(csp->config->feature_flags & RUNTIME_FEATURE_CONNECTION_SHARING))
+ if ((csp->config->feature_flags & RUNTIME_FEATURE_CONNECTION_SHARING)
+ && !(csp->flags & CSP_FLAG_SERVER_SOCKET_TAINTED))
{
- log_error(LOG_LEVEL_HEADER,
- "Keeping the client header '%s' around. "
- "The connection will not be kept alive.",
- *header);
+ if (!strcmpic(csp->http->ver, "HTTP/1.1"))
+ {
+ log_error(LOG_LEVEL_HEADER,
+ "Removing \'%s\' to imply keep-alive.", *header);
+ freez(*header);
+ /*
+ * While we imply keep-alive to the server,
+ * we have to remember that the client didn't.
+ */
+ csp->flags &= ~CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE;
+ }
+ else
+ {
+ char *old_header = *header;
+
+ *header = strdup_or_die("Connection: keep-alive");
+ log_error(LOG_LEVEL_HEADER,
+ "Replaced: \'%s\' with \'%s\'", old_header, *header);
+ freez(old_header);
+ }
}
else
-#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
{
- char *old_header = *header;
-
- *header = strdup(wanted_header);
- if (header == NULL)
- {
- return JB_ERR_MEMORY;
- }
log_error(LOG_LEVEL_HEADER,
- "Replaced: \'%s\' with \'%s\'", old_header, *header);
- freez(old_header);
+ "Keeping the client header '%s' around. "
+ "The connection will not be kept alive.",
+ *header);
+ csp->flags &= ~CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE;
}
}
-#ifdef FEATURE_CONNECTION_KEEP_ALIVE
- else
+ else if ((csp->config->feature_flags & RUNTIME_FEATURE_CONNECTION_KEEP_ALIVE)
+ && !(csp->flags & CSP_FLAG_SERVER_SOCKET_TAINTED))
{
log_error(LOG_LEVEL_HEADER,
"Keeping the client header '%s' around. "
"The server connection will be kept alive if possible.",
*header);
csp->flags |= CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE;
- }
#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
+ }
+ else
+ {
+ char *old_header = *header;
+
+ *header = strdup_or_die(connection_close);
+ log_error(LOG_LEVEL_HEADER,
+ "Replaced: \'%s\' with \'%s\'", old_header, *header);
+ freez(old_header);
+ }
/* Signal client_connection_adder() to return early. */
csp->flags |= CSP_FLAG_CLIENT_CONNECTION_HEADER_SET;
/* Is the current header the lucky one? */
if (strstr(*header, crunch_pattern))
{
- log_error(LOG_LEVEL_HEADER, "Crunching server header: %s (contains: %s)", *header, crunch_pattern);
+ log_error(LOG_LEVEL_HEADER, "Crunching server header: %s (contains: %s)", *header, crunch_pattern);
freez(*header);
}
}
* Function : server_content_type
*
* Description : Set the content-type for filterable types (text/.*,
- * .*xml.*, javascript and image/gif) unless filtering has been
+ * .*xml.*, .*script.* and image/gif) unless filtering has been
* forbidden (CT_TABOO) while parsing earlier headers.
* NOTE: Since text/plain is commonly used by web servers
* for files whose correct type is unknown, we don't
*/
if ((strstr(*header, "text/") && !strstr(*header, "plain"))
|| strstr(*header, "xml")
- || strstr(*header, "application/x-javascript"))
+ || strstr(*header, "script"))
{
csp->content_type |= CT_TEXT;
}
if (csp->action->flags & ACTION_CONTENT_TYPE_OVERWRITE)
{
/*
- * Make sure the user doesn't accidently
- * change the content type of binary documents.
+ * Make sure the user doesn't accidentally
+ * change the content type of binary documents.
*/
if ((csp->content_type & CT_TEXT) || (csp->action->flags & ACTION_FORCE_TEXT_MODE))
{
freez(*header);
- *header = strdup("Content-Type: ");
+ *header = strdup_or_die("Content-Type: ");
string_append(header, csp->action->string[ACTION_STRING_CONTENT_TYPE]);
if (header == NULL)
*
* Function : server_content_encoding
*
- * Description : This function is run twice for each request,
- * unless FEATURE_ZLIB and filtering are disabled.
+ * Description : Used to check if the content is compressed, and if
+ * FEATURE_ZLIB is disabled, filtering is disabled as
+ * well.
+ *
+ * If FEATURE_ZLIB is enabled and the compression type
+ * supported, the content is marked for decompression.
*
- * The first run is used to check if the content
- * is compressed, if FEATURE_ZLIB is disabled
- * filtering is then disabled as well, if FEATURE_ZLIB
- * is enabled the content is marked for decompression.
- *
- * The second run is used to remove the Content-Encoding
- * header if the decompression was successful.
+ * XXX: Doesn't properly deal with multiple or with
+ * unsupported but unknown encodings.
+ * Is case-sensitive but shouldn't be.
*
* Parameters :
* 1 : csp = Current client state (buffers, headers, etc...)
static jb_err server_content_encoding(struct client_state *csp, char **header)
{
#ifdef FEATURE_ZLIB
- if ((csp->flags & CSP_FLAG_MODIFIED)
- && (csp->content_type & (CT_GZIP | CT_DEFLATE)))
+ if (strstr(*header, "sdch"))
{
/*
- * We successfully decompressed the content,
- * and have to clean the header now, so the
- * client no longer expects compressed data..
- *
- * XXX: There is a difference between cleaning
- * and removing it completely.
+ * Shared Dictionary Compression over HTTP isn't supported,
+ * filtering it anyway is pretty much guaranteed to mess up
+ * the encoding.
*/
- log_error(LOG_LEVEL_HEADER, "Crunching: %s", *header);
- freez(*header);
+ csp->content_type |= CT_TABOO;
+
+ /*
+ * Log a warning if the user expects the content to be filtered.
+ */
+ if ((csp->rlist != NULL) &&
+ (!list_is_empty(csp->action->multi[ACTION_MULTI_FILTER])))
+ {
+ log_error(LOG_LEVEL_INFO,
+ "SDCH-compressed content detected, content filtering disabled. "
+ "Consider suppressing SDCH offers made by the client.");
+ }
}
else if (strstr(*header, "gzip"))
{
csp->content_type |= CT_TABOO;
}
#else /* !defined(FEATURE_ZLIB) */
- if (strstr(*header, "gzip") || strstr(*header, "compress") || strstr(*header, "deflate"))
+ /*
+ * XXX: Using a black list here isn't the right approach.
+ *
+ * In case of SDCH, building with zlib support isn't
+ * going to help.
+ */
+ if (strstr(*header, "gzip") ||
+ strstr(*header, "compress") ||
+ strstr(*header, "deflate") ||
+ strstr(*header, "sdch"))
{
/*
* Body is compressed, turn off pcrs and gif filtering.
}
+#ifdef FEATURE_ZLIB
+/*********************************************************************
+ *
+ * Function : server_adjust_content_encoding
+ *
+ * Description : Remove the Content-Encoding header if the
+ * decompression was successful and the content
+ * has been modifed.
+ *
+ * Parameters :
+ * 1 : csp = Current client state (buffers, headers, etc...)
+ * 2 : header = On input, pointer to header to modify.
+ * On output, pointer to the modified header, or NULL
+ * to remove the header. This function frees the
+ * original string if necessary.
+ *
+ * Returns : JB_ERR_OK on success, or
+ * JB_ERR_MEMORY on out-of-memory error.
+ *
+ *********************************************************************/
+static jb_err server_adjust_content_encoding(struct client_state *csp, char **header)
+{
+ if ((csp->flags & CSP_FLAG_MODIFIED)
+ && (csp->content_type & (CT_GZIP | CT_DEFLATE)))
+ {
+ /*
+ * We successfully decompressed the content,
+ * and have to clean the header now, so the
+ * client no longer expects compressed data.
+ *
+ * XXX: There is a difference between cleaning
+ * and removing it completely.
+ */
+ log_error(LOG_LEVEL_HEADER, "Crunching: %s", *header);
+ freez(*header);
+ }
+
+ return JB_ERR_OK;
+
+}
+#endif /* defined(FEATURE_ZLIB) */
+
+
/*********************************************************************
*
* Function : server_adjust_content_length
static jb_err server_save_content_length(struct client_state *csp, char **header)
{
unsigned long long content_length = 0;
+ const char *header_value;
assert(*(*header+14) == ':');
-#ifdef _WIN32
- if (1 != sscanf(*header+14, ": %I64u", &content_length))
-#else
- if (1 != sscanf(*header+14, ": %llu", &content_length))
-#endif
+ header_value = *header + 15;
+ if (JB_ERR_OK != get_content_length(header_value, &content_length))
{
log_error(LOG_LEVEL_ERROR, "Crunching invalid header: %s", *header);
freez(*header);
return JB_ERR_OK;
}
else
- {
+ {
/*
* Replacing Content-Disposition header
*/
static jb_err server_last_modified(struct client_state *csp, char **header)
{
const char *newval;
- char buf[BUFFER_SIZE];
-
+ time_t last_modified;
char newheader[50];
-#ifdef HAVE_GMTIME_R
- struct tm gmt;
-#endif
- struct tm *timeptr = NULL;
- time_t now, last_modified;
- long int days, hours, minutes, seconds;
-
+
/*
* Are we messing with the Last-Modified header?
*/
newval = csp->action->string[ACTION_STRING_LAST_MODIFIED];
- if (0 == strcmpic(newval, "block") )
+ if (0 == strcmpic(newval, "block"))
{
/*
* Blocking Last-Modified header. Useless but why not.
return JB_ERR_OK;
}
else if (0 == strcmpic(newval, "reset-to-request-time"))
- {
+ {
/*
* Setting Last-Modified Header to now.
*/
+ char buf[30];
get_http_time(0, buf, sizeof(buf));
freez(*header);
*header = strdup("Last-Modified: ");
- string_append(header, buf);
+ string_append(header, buf);
if (*header == NULL)
{
- log_error(LOG_LEVEL_HEADER, "Insufficient memory. Last-Modified header got lost, boohoo.");
+ log_error(LOG_LEVEL_HEADER, "Insufficient memory. Last-Modified header got lost, boohoo.");
}
else
{
const char *header_time = *header + sizeof("Last-Modified:");
log_error(LOG_LEVEL_HEADER, "Randomizing: %s", *header);
- now = time(NULL);
-#ifdef HAVE_GMTIME_R
- gmtime_r(&now, &gmt);
-#elif defined(MUTEX_LOCKS_AVAILABLE)
- privoxy_mutex_lock(&gmtime_mutex);
- gmtime(&now);
- privoxy_mutex_unlock(&gmtime_mutex);
-#else
- gmtime(&now);
-#endif
+
if (JB_ERR_OK != parse_header_time(header_time, &last_modified))
{
log_error(LOG_LEVEL_HEADER, "Couldn't parse: %s in %s (crunching!)", header_time, *header);
}
else
{
- long int rtime = (long int)difftime(now, last_modified);
+ time_t now;
+ struct tm *timeptr = NULL;
+ long int rtime;
+#ifdef HAVE_GMTIME_R
+ struct tm gmt;
+#endif
+ now = time(NULL);
+ rtime = (long int)difftime(now, last_modified);
if (rtime)
{
+ long int days, hours, minutes, seconds;
const int negative_delta = (rtime < 0);
if (negative_delta)
{
- rtime *= -1;
+ rtime *= -1;
log_error(LOG_LEVEL_HEADER, "Server time in the future.");
}
rtime = pick_from_range(rtime);
if (*header == NULL)
{
log_error(LOG_LEVEL_ERROR, "Insufficient memory, header crunched without replacement.");
- return JB_ERR_MEMORY;
+ return JB_ERR_MEMORY;
}
days = rtime / (3600 * 24);
*********************************************************************/
static jb_err client_accept_encoding(struct client_state *csp, char **header)
{
+#ifdef FEATURE_COMPRESSION
+ if ((csp->config->feature_flags & RUNTIME_FEATURE_COMPRESSION)
+ && strstr(*header, "deflate"))
+ {
+ csp->flags |= CSP_FLAG_CLIENT_SUPPORTS_DEFLATE;
+ }
+#endif
if ((csp->action->flags & ACTION_NO_COMPRESSION) != 0)
{
log_error(LOG_LEVEL_HEADER, "Suppressed offer to compress content");
-
freez(*header);
-
- /* Temporarily disable the correct behaviour to
- * work around a PHP bug.
- *
- * if (!strcmpic(csp->http->ver, "HTTP/1.1"))
- * {
- * *header = strdup("Accept-Encoding: identity;q=1.0, *;q=0");
- * if (*header == NULL)
- * {
- * return JB_ERR_MEMORY;
- * }
- * }
- *
- */
}
return JB_ERR_OK;
/* booleans for parameters we have to check multiple times */
int parameter_conditional_block;
int parameter_conditional_forge;
-
+
#ifdef FEATURE_FORCE_LOAD
/*
* Since the referrer can include the prefix even
newval = csp->action->string[ACTION_STRING_LANGUAGE];
- if ((newval == NULL) || (0 == strcmpic(newval, "block")) )
+ if ((newval == NULL) || (0 == strcmpic(newval, "block")))
{
/*
* Blocking Accept-Language header
return JB_ERR_OK;
}
else
- {
+ {
/*
* Replacing Accept-Language header
*/
freez(*header);
*header = strdup("Accept-Language: ");
- string_append(header, newval);
+ string_append(header, newval);
if (*header == NULL)
{
log_error(LOG_LEVEL_ERROR,
- "Insufficient memory. Accept-Language header crunched without replacement.");
+ "Insufficient memory. Accept-Language header crunched without replacement.");
}
else
{
/* Is the current header the lucky one? */
if (strstr(*header, crunch_pattern))
{
- log_error(LOG_LEVEL_HEADER, "Crunching client header: %s (contains: %s)", *header, crunch_pattern);
+ log_error(LOG_LEVEL_HEADER, "Crunching client header: %s (contains: %s)", *header, crunch_pattern);
freez(*header);
}
}
/*
* Are we blocking the e-mail address?
*/
- if ((newval == NULL) || (0 == strcmpic(newval, "block")) )
+ if ((newval == NULL) || (0 == strcmpic(newval, "block")))
{
log_error(LOG_LEVEL_HEADER, "crunched From!");
return JB_ERR_OK;
return JB_ERR_OK;
}
- if (!csp->http->hostport || (*csp->http->hostport == '*') ||
+ if (!csp->http->hostport || (*csp->http->hostport == '*') ||
*csp->http->hostport == ' ' || *csp->http->hostport == '\0')
{
-
- if (NULL == (p = strdup((*header)+6)))
- {
- return JB_ERR_MEMORY;
- }
+
+ p = strdup_or_die((*header)+6);
chomp(p);
- if (NULL == (q = strdup(p)))
- {
- freez(p);
- return JB_ERR_MEMORY;
- }
+ q = strdup_or_die(p);
freez(csp->http->hostport);
csp->http->hostport = p;
struct tm gmt;
#endif
struct tm *timeptr = NULL;
- time_t tm = 0;
+ time_t tm = 0;
const char *newval;
- long int hours, minutes, seconds;
char * endptr;
-
- if ( 0 == strcmpic(*header, "If-Modified-Since: Wed, 08 Jun 1955 12:00:00 GMT"))
+
+ if (0 == strcmpic(*header, "If-Modified-Since: Wed, 08 Jun 1955 12:00:00 GMT"))
{
- /*
+ /*
* The client got an error message because of a temporary problem,
* the problem is gone and the client now tries to revalidate our
* error message on the real server. The revalidation would always
}
else
{
+ long int hours, minutes, seconds;
long int rtime = strtol(newval, &endptr, 0);
const int negative_range = (rtime < 0);
*header, rtime, (rtime == 1 || rtime == -1) ? "e": "es");
if (negative_range)
{
- rtime *= -1;
+ rtime *= -1;
}
rtime *= 60;
rtime = pick_from_range(rtime);
if (*header == NULL)
{
log_error(LOG_LEVEL_HEADER, "Insufficient memory, header crunched without replacement.");
- return JB_ERR_MEMORY;
+ return JB_ERR_MEMORY;
}
hours = rtime / 3600;
static jb_err client_if_none_match(struct client_state *csp, char **header)
{
if (csp->action->flags & ACTION_CRUNCH_IF_NONE_MATCH)
- {
+ {
log_error(LOG_LEVEL_HEADER, "Crunching %s", *header);
freez(*header);
}
*********************************************************************/
jb_err client_x_filter(struct client_state *csp, char **header)
{
- if ( 0 == strcmpic(*header, "X-Filter: No"))
+ if (0 == strcmpic(*header, "X-Filter: No"))
{
if (!(csp->config->feature_flags & RUNTIME_FEATURE_HTTP_TOGGLE))
{
"force-text-mode overruled the client's request to fetch without filtering!");
}
else
- {
+ {
csp->content_type = CT_TABOO; /* XXX: This hack shouldn't be necessary */
csp->flags |= CSP_FLAG_NO_FILTERING;
log_error(LOG_LEVEL_HEADER, "Accepted the client's request to fetch without filtering.");
freez(*header);
}
}
- return JB_ERR_OK;
+ return JB_ERR_OK;
}
* Function : client_range
*
* Description : Removes Range, Request-Range and If-Range headers if
- * content filtering is enabled. If the client's version
- * of the document has been altered by Privoxy, the server
- * could interpret the range differently than the client
- * intended in which case the user could end up with
- * corrupted content.
+ * content filtering is enabled and the range doesn't
+ * start at byte 0.
+ *
+ * If the client's version of the document has been
+ * altered by Privoxy, the server could interpret the
+ * range differently than the client intended in which
+ * case the user could end up with corrupted content.
+ *
+ * If the range starts at byte 0 this isn't an issue
+ * so the header can pass. Partial requests like this
+ * are used to render preview images for videos without
+ * downloading the whole video.
+ *
+ * While HTTP doesn't require that range requests are
+ * honoured and the client could simply abort the download
+ * after receiving a sufficient amount of data, various
+ * clients don't handle complete responses to range
+ * requests gracefully and emit misleading error messages
+ * instead.
*
* Parameters :
* 1 : csp = Current client state (buffers, headers, etc...)
*********************************************************************/
static jb_err client_range(struct client_state *csp, char **header)
{
- if (content_filters_enabled(csp->action))
+ if (content_filters_enabled(csp->action)
+ && (0 != strncmpic(strstr(*header, ":"), ": bytes=0-", 10)))
{
log_error(LOG_LEVEL_HEADER, "Content filtering is enabled."
" Crunching: \'%s\' to prevent range-mismatch problems.", *header);
freez(*header);
}
- return JB_ERR_OK;
+ return JB_ERR_OK;
}
/* the following functions add headers directly to the header list */
return JB_ERR_OK;
}
- if ( !csp->http->hostport || !*(csp->http->hostport))
+ if (!csp->http->hostport || !*(csp->http->hostport))
{
/* XXX: When does this happen and why is it OK? */
log_error(LOG_LEVEL_INFO, "Weirdness in client_host_adder detected and ignored.");
/*
* remove 'user:pass@' from 'proto://user:pass@host'
*/
- if ( (p = strchr( csp->http->hostport, '@')) != NULL )
+ if ((p = strchr( csp->http->hostport, '@')) != NULL)
{
p++;
}
}
-#if 0
-/*********************************************************************
- *
- * Function : client_accept_encoding_adder
- *
- * Description : Add an Accept-Encoding header to the client's request
- * that disables compression if the action applies, and
- * the header is not already there. Called from `sed'.
- * Note: For HTTP/1.0, the absence of the header is enough.
- *
- * Parameters :
- * 1 : csp = Current client state (buffers, headers, etc...)
- *
- * Returns : JB_ERR_OK on success, or
- * JB_ERR_MEMORY on out-of-memory error.
- *
- *********************************************************************/
-static jb_err client_accept_encoding_adder(struct client_state *csp)
-{
- if ( ((csp->action->flags & ACTION_NO_COMPRESSION) != 0)
- && (!strcmpic(csp->http->ver, "HTTP/1.1")) )
- {
- return enlist_unique(csp->headers, "Accept-Encoding: identity;q=1.0, *;q=0", 16);
- }
-
- return JB_ERR_OK;
-}
-#endif
-
-
/*********************************************************************
*
* Function : client_xtra_adder
*
* Function : server_connection_adder
*
- * Description : Adds an appropiate "Connection:" header to csp->headers
+ * Description : Adds an appropriate "Connection:" header to csp->headers
* unless the header was already present. Called from `sed'.
*
* Parameters :
{
const unsigned int flags = csp->flags;
const char *response_status_line = csp->headers->first->str;
- const char *wanted_header = get_appropiate_connection_header(csp);
+ static const char connection_close[] = "Connection: close";
if ((flags & CSP_FLAG_CLIENT_HEADER_PARSING_DONE)
&& (flags & CSP_FLAG_SERVER_CONNECTION_HEADER_SET))
#ifdef FEATURE_CONNECTION_KEEP_ALIVE
&& !(csp->flags & CSP_FLAG_SERVER_SOCKET_TAINTED)
#endif
- && (csp->http->status == 200)
- )
+ )
{
- /*
- * XXX: not doing this for status codes other than 200 works
- * around problems with broken servers that will keep the
- * connection open, but terminate the connection when the
- * next request arrives. Once we are able to figure out which
- * requests are safe to send again, this will probably no
- * longer be necessary.
- */
log_error(LOG_LEVEL_HEADER, "A HTTP/1.1 response "
"without Connection header implies keep-alive.");
csp->flags |= CSP_FLAG_SERVER_CONNECTION_KEEP_ALIVE;
+ return JB_ERR_OK;
}
- log_error(LOG_LEVEL_HEADER, "Adding: %s", wanted_header);
+ log_error(LOG_LEVEL_HEADER, "Adding: %s", connection_close);
- return enlist(csp->headers, wanted_header);
+ return enlist(csp->headers, connection_close);
}
*
* Description : Adds a "Proxy-Connection: keep-alive" header to
* csp->headers if the client asked for keep-alive.
- * XXX: We should reuse existant ones.
+ * XXX: We should reuse existent ones.
*
* Parameters :
* 1 : csp = Current client state (buffers, headers, etc...)
jb_err err = JB_ERR_OK;
if ((csp->flags & CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE)
- && !(csp->flags & CSP_FLAG_SERVER_SOCKET_TAINTED))
+ && !(csp->flags & CSP_FLAG_SERVER_SOCKET_TAINTED)
+ && !(csp->flags & CSP_FLAG_SERVER_PROXY_CONNECTION_HEADER_SET))
{
log_error(LOG_LEVEL_HEADER, "Adding: %s", proxy_connection_header);
err = enlist(csp->headers, proxy_connection_header);
*********************************************************************/
static jb_err client_connection_header_adder(struct client_state *csp)
{
- const char *wanted_header = get_appropiate_connection_header(csp);
+ static const char connection_close[] = "Connection: close";
if (!(csp->flags & CSP_FLAG_CLIENT_HEADER_PARSING_DONE)
+ && !(csp->flags & CSP_FLAG_SERVER_SOCKET_TAINTED)
&& (csp->flags & CSP_FLAG_CLIENT_CONNECTION_HEADER_SET))
{
return JB_ERR_OK;
#ifdef FEATURE_CONNECTION_KEEP_ALIVE
if ((csp->config->feature_flags & RUNTIME_FEATURE_CONNECTION_KEEP_ALIVE)
+ && !(csp->flags & CSP_FLAG_SERVER_SOCKET_TAINTED)
&& (csp->http->ssl == 0)
&& !strcmpic(csp->http->ver, "HTTP/1.1"))
{
csp->flags |= CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE;
+ return JB_ERR_OK;
}
#endif /* FEATURE_CONNECTION_KEEP_ALIVE */
- log_error(LOG_LEVEL_HEADER, "Adding: %s", wanted_header);
+ log_error(LOG_LEVEL_HEADER, "Adding: %s", connection_close);
- return enlist(csp->headers, wanted_header);
+ return enlist(csp->headers, connection_close);
}
* Function : server_set_cookie
*
* Description : Handle the server "cookie" header properly.
- * Log cookie to the jar file. Then "crunch",
- * accept or rewrite it to a session cookie.
+ * Crunch, accept or rewrite it to a session cookie.
* Called from `sed'.
*
* TODO: Allow the user to specify a new expiration
static jb_err server_set_cookie(struct client_state *csp, char **header)
{
time_t now;
- time_t cookie_time;
+ time_t cookie_time;
time(&now);
cur_tag = *header + 11;
/* skip whitespace between "Set-Cookie:" and value */
- while (*cur_tag && ijb_isspace(*cur_tag))
+ while (*cur_tag && privoxy_isspace(*cur_tag))
{
cur_tag++;
}
next_tag++;
/* skip whitespace ";" and start of tag */
- while (*next_tag && ijb_isspace(*next_tag))
+ while (*next_tag && privoxy_isspace(*next_tag))
{
next_tag++;
}
{
char *expiration_date = cur_tag + 8; /* Skip "[Ee]xpires=" */
+ if ((expiration_date[0] == '"')
+ && (expiration_date[1] != '\0'))
+ {
+ /*
+ * Skip quotation mark. RFC 2109 10.1.2 seems to hint
+ * that the expiration date isn't supposed to be quoted,
+ * but some servers do it anyway.
+ */
+ expiration_date++;
+ }
+
/* Did we detect the date properly? */
if (JB_ERR_OK != parse_header_time(expiration_date, &cookie_time))
{
*
* Function : strclean
*
- * Description : In-Situ-Eliminate all occurances of substring in
+ * Description : In-Situ-Eliminate all occurrences of substring in
* string
*
* Parameters :
* to get the numerical respresentation.
*
* Parameters :
- * 1 : header_time = HTTP header time as string.
+ * 1 : header_time = HTTP header time as string.
* 2 : result = storage for header_time in seconds
*
* Returns : JB_ERR_OK if the time format was recognized, or
static jb_err parse_header_time(const char *header_time, time_t *result)
{
struct tm gmt;
-
/*
- * Zero out gmt to prevent time zone offsets.
- *
- * While this is only necessary on some platforms
- * (mingw32 for example), I don't know how to
- * detect these automatically and doing it everywhere
- * shouldn't hurt.
+ * Checking for two-digit years first in an
+ * attempt to work around GNU libc's strptime()
+ * reporting negative year values when using %Y.
*/
- memset(&gmt, 0, sizeof(gmt));
-
- /* Tue, 02 Jun 2037 20:00:00 */
- if ((NULL == strptime(header_time, "%a, %d %b %Y %H:%M:%S", &gmt))
- /* Tue, 02-Jun-2037 20:00:00 */
- && (NULL == strptime(header_time, "%a, %d-%b-%Y %H:%M:%S", &gmt))
- /* Tue, 02-Jun-37 20:00:00 */
- && (NULL == strptime(header_time, "%a, %d-%b-%y %H:%M:%S", &gmt))
- /* Tuesday, 02-Jun-2037 20:00:00 */
- && (NULL == strptime(header_time, "%A, %d-%b-%Y %H:%M:%S", &gmt))
- /* Tuesday Jun 02 20:00:00 2037 */
- && (NULL == strptime(header_time, "%A %b %d %H:%M:%S %Y", &gmt)))
+ static const char * const time_formats[] = {
+ /* Tue, 02-Jun-37 20:00:00 */
+ "%a, %d-%b-%y %H:%M:%S",
+ /* Tue, 02 Jun 2037 20:00:00 */
+ "%a, %d %b %Y %H:%M:%S",
+ /* Tue, 02-Jun-2037 20:00:00 */
+ "%a, %d-%b-%Y %H:%M:%S",
+ /* Tuesday, 02-Jun-2037 20:00:00 */
+ "%A, %d-%b-%Y %H:%M:%S",
+ /* Tuesday Jun 02 20:00:00 2037 */
+ "%A %b %d %H:%M:%S %Y"
+ };
+ unsigned int i;
+
+ for (i = 0; i < SZ(time_formats); i++)
{
- return JB_ERR_PARSE;
- }
+ /*
+ * Zero out gmt to prevent time zone offsets.
+ * Documented to be required for GNU libc.
+ */
+ memset(&gmt, 0, sizeof(gmt));
- *result = timegm(&gmt);
+ if (NULL != strptime(header_time, time_formats[i], &gmt))
+ {
+ /* Sanity check for GNU libc. */
+ if (gmt.tm_year < 0)
+ {
+ log_error(LOG_LEVEL_HEADER,
+ "Failed to parse '%s' using '%s'. Moving on.",
+ header_time, time_formats[i]);
+ continue;
+ }
+ *result = timegm(&gmt);
+ return JB_ERR_OK;
+ }
+ }
- return JB_ERR_OK;
+ return JB_ERR_PARSE;
}
* Parameters :
* 1 : headers = List of headers (one of them hopefully being
* the "Host:" header)
- * 2 : http = storage for the result (host, port and hostport).
+ * 2 : http = storage for the result (host, port and hostport).
*
- * Returns : JB_ERR_MEMORY in case of memory problems,
+ * Returns : JB_ERR_MEMORY (or terminates) in case of memory problems,
* JB_ERR_PARSE if the host header couldn't be found,
* JB_ERR_OK otherwise.
*
return JB_ERR_PARSE;
}
- if (NULL == (p = strdup((host))))
- {
- log_error(LOG_LEVEL_ERROR, "Out of memory while parsing \"Host:\" header");
- return JB_ERR_MEMORY;
- }
+ p = strdup_or_die(host);
chomp(p);
- if (NULL == (q = strdup(p)))
- {
- freez(p);
- log_error(LOG_LEVEL_ERROR, "Out of memory while parsing \"Host:\" header");
- return JB_ERR_MEMORY;
- }
+ q = strdup_or_die(p);
freez(http->hostport);
http->hostport = p;
* Function : create_forged_referrer
*
* Description : Helper for client_referrer to forge a referer as
- * 'http://[hostname:port/' to fool stupid
- * checks for in-site links
+ * 'http://hostname[:port]/' to fool stupid
+ * checks for in-site links
*
* Parameters :
* 1 : header = Pointer to header pointer
static jb_err handle_conditional_hide_referrer_parameter(char **header,
const char *host, const int parameter_conditional_block)
{
- char *referer = strdup(*header);
- const size_t hostlenght = strlen(host);
+ char *referer = strdup_or_die(*header);
+ const size_t hostlength = strlen(host);
const char *referer_url = NULL;
- if (NULL == referer)
- {
- freez(*header);
- return JB_ERR_MEMORY;
- }
-
/* referer begins with 'Referer: http[s]://' */
- if ((hostlenght+17) < strlen(referer))
+ if ((hostlength+17) < strlen(referer))
{
/*
* Shorten referer to make sure the referer is blocked
* if www.example.org/www.example.com-shall-see-the-referer/
* links to www.example.com/
*/
- referer[hostlenght+17] = '\0';
+ referer[hostlength+17] = '\0';
}
referer_url = strstr(referer, "http://");
if ((NULL == referer_url) || (NULL == strstr(referer_url, host)))
/*********************************************************************
*
- * Function : get_appropiate_connection_header
+ * Function : create_content_length_header
*
- * Description : Returns an appropiate Connection header
- * depending on whether or not we try to keep
- * the connection to the server alive.
+ * Description : Creates a Content-Length header.
*
* Parameters :
- * 1 : csp = Current client state (buffers, headers, etc...)
+ * 1 : content_length = The content length to be used in the header.
+ * 2 : header = Allocated space to safe the header.
+ * 3 : buffer_length = The length of the allocated space.
*
- * Returns : Pointer to statically allocated header buffer.
+ * Returns : void
*
*********************************************************************/
-static const char *get_appropiate_connection_header(const struct client_state *csp)
+static void create_content_length_header(unsigned long long content_length,
+ char *header, size_t buffer_length)
{
- static const char connection_keep_alive[] = "Connection: keep-alive";
- static const char connection_close[] = "Connection: close";
-
- if ((csp->config->feature_flags & RUNTIME_FEATURE_CONNECTION_KEEP_ALIVE)
-#ifdef FEATURE_CONNECTION_KEEP_ALIVE
- && !(csp->flags & CSP_FLAG_SERVER_SOCKET_TAINTED)
-#endif
- && (csp->http->ssl == 0))
- {
- return connection_keep_alive;
- }
- return connection_close;
+ snprintf(header, buffer_length, "Content-Length: %llu", content_length);
}
/*********************************************************************
*
- * Function : create_content_length_header
+ * Function : get_expected_content_length
*
- * Description : Creates a Content-Length header.
+ * Description : Figures out the content length from a list of headers.
*
* Parameters :
- * 1 : content_length = The content length to be used in the header.
- * 2 : header = Allocated space to safe the header.
- * 3 : buffer_length = The length of the allocated space.
+ * 1 : headers = List of headers
*
- * Returns : void
+ * Returns : Number of bytes to expect
*
*********************************************************************/
-static void create_content_length_header(unsigned long long content_length,
- char *header, size_t buffer_length)
+unsigned long long get_expected_content_length(struct list *headers)
{
- snprintf(header, buffer_length, "Content-Length: %llu", content_length);
+ const char *content_length_header;
+ unsigned long long content_length = 0;
+
+ content_length_header = get_header_value(headers, "Content-Length:");
+ if (content_length_header != NULL)
+ {
+ if (JB_ERR_OK != get_content_length(content_length_header, &content_length))
+ {
+ log_error(LOG_LEVEL_ERROR,
+ "Failed to get the Content-Length in %s", content_length_header);
+ /* XXX: The header will be removed later on */
+ return 0;
+ }
+ }
+
+ return content_length;
}