X-Git-Url: http://www.privoxy.org/gitweb/?p=privoxy.git;a=blobdiff_plain;f=parsers.c;h=85137fe8c4b9fed72fb058ac116f8a5188929f7c;hp=15153026bc336415acff10419d5a25c4455c4dbc;hb=4be442c71bb5a72c4fc9816a627fdc04f1f73c0c;hpb=bfecdd8c6594a6f26607224ee44d8e4add36ecb0 diff --git a/parsers.c b/parsers.c index 15153026..85137fe8 100644 --- a/parsers.c +++ b/parsers.c @@ -1,4 +1,4 @@ -const char parsers_rcs[] = "$Id: parsers.c,v 1.100 2007/04/30 15:53:11 fabiankeil Exp $"; +const char parsers_rcs[] = "$Id: parsers.c,v 1.151 2009/02/15 14:46:35 fabiankeil Exp $"; /********************************************************************* * * File : $Source: /cvsroot/ijbswa/current/parsers.c,v $ @@ -17,7 +17,7 @@ const char parsers_rcs[] = "$Id: parsers.c,v 1.100 2007/04/30 15:53:11 fabiankei * `client_if_none_match', `get_destination_from_headers', * `parse_header_time', `decompress_iob' and `server_set_cookie'. * - * Copyright : Written by and Copyright (C) 2001-2007 the SourceForge + * Copyright : Written by and Copyright (C) 2001-2009 the * Privoxy team. http://www.privoxy.org/ * * Based on the Internet Junkbuster originally written @@ -44,6 +44,208 @@ const char parsers_rcs[] = "$Id: parsers.c,v 1.100 2007/04/30 15:53:11 fabiankei * * Revisions : * $Log: parsers.c,v $ + * Revision 1.151 2009/02/15 14:46:35 fabiankeil + * Don't let hide-referrer{conditional-*}} pass + * Referer headers without http URLs. + * + * Revision 1.150 2008/12/04 18:12:19 fabiankeil + * Fix some cparser warnings. + * + * Revision 1.149 2008/11/21 18:39:53 fabiankeil + * In case of CONNECT requests there's no point + * in trying to keep the connection alive. + * + * Revision 1.148 2008/11/16 12:43:49 fabiankeil + * Turn keep-alive support into a runtime feature + * that is disabled by setting keep-alive-timeout + * to a negative value. + * + * Revision 1.147 2008/11/04 17:20:31 fabiankeil + * HTTP/1.1 responses without Connection + * header imply keep-alive. Act accordingly. + * + * Revision 1.146 2008/10/12 16:46:35 fabiankeil + * Remove obsolete warning about delayed delivery with chunked + * transfer encoding and FEATURE_CONNECTION_KEEP_ALIVE enabled. + * + * Revision 1.145 2008/10/09 18:21:41 fabiankeil + * Flush work-in-progress changes to keep outgoing connections + * alive where possible. Incomplete and mostly #ifdef'd out. + * + * Revision 1.144 2008/09/21 13:59:33 fabiankeil + * Treat unknown change-x-forwarded-for parameters as fatal errors. + * + * Revision 1.143 2008/09/21 13:36:52 fabiankeil + * If change-x-forwarded-for{add} is used and the client + * sends multiple X-Forwarded-For headers, append the client's + * IP address to each one of them. "Traditionally" we would + * lose all but the last one. + * + * Revision 1.142 2008/09/20 10:04:33 fabiankeil + * Remove hide-forwarded-for-headers action which has + * been obsoleted by change-x-forwarded-for{block}. + * + * Revision 1.141 2008/09/19 15:26:28 fabiankeil + * Add change-x-forwarded-for{} action to block or add + * X-Forwarded-For headers. Mostly based on code removed + * before 3.0.7. + * + * Revision 1.140 2008/09/12 17:51:43 fabiankeil + * - A few style fixes. + * - Remove a pointless cast. + * + * Revision 1.139 2008/09/04 08:13:58 fabiankeil + * Prepare for critical sections on Windows by adding a + * layer of indirection before the pthread mutex functions. + * + * Revision 1.138 2008/08/30 12:03:07 fabiankeil + * Remove FEATURE_COOKIE_JAR. + * + * Revision 1.137 2008/05/30 15:50:08 fabiankeil + * Remove questionable micro-optimizations + * whose usefulness has never been measured. + * + * Revision 1.136 2008/05/26 16:02:24 fabiankeil + * s@Insufficent@Insufficient@ + * + * Revision 1.135 2008/05/21 20:12:10 fabiankeil + * The whole point of strclean() is to modify the + * first parameter, so don't mark it immutable, + * even though the compiler lets us get away with it. + * + * Revision 1.134 2008/05/21 19:27:25 fabiankeil + * As the wafer actions are gone, we can stop including encode.h. + * + * Revision 1.133 2008/05/21 15:50:47 fabiankeil + * Ditch cast from (char **) to (char **). + * + * Revision 1.132 2008/05/21 15:47:14 fabiankeil + * Streamline sed()'s prototype and declare + * the header parse and add structures static. + * + * Revision 1.131 2008/05/20 20:13:30 fabiankeil + * Factor update_server_headers() out of sed(), ditch the + * first_run hack and make server_patterns_light static. + * + * Revision 1.130 2008/05/19 17:18:04 fabiankeil + * Wrap memmove() calls in string_move() + * to document the purpose in one place. + * + * Revision 1.129 2008/05/17 14:02:07 fabiankeil + * Normalize linear header white space. + * + * Revision 1.128 2008/05/16 16:39:03 fabiankeil + * If a header is split across multiple lines, + * merge them to a single line before parsing them. + * + * Revision 1.127 2008/05/10 13:23:38 fabiankeil + * Don't provide get_header() with the whole client state + * structure when it only needs access to csp->iob. + * + * Revision 1.126 2008/05/03 16:40:45 fabiankeil + * Change content_filters_enabled()'s parameter from + * csp->action to action so it can be also used in the + * CGI code. Don't bother checking if there are filters + * loaded, as that's somewhat besides the point. + * + * Revision 1.125 2008/04/17 14:40:49 fabiankeil + * Provide get_http_time() with the buffer size so it doesn't + * have to blindly assume that the buffer is big enough. + * + * Revision 1.124 2008/04/16 16:38:21 fabiankeil + * Don't pass the whole csp structure to flush_socket() + * when it only needs a file descriptor and a buffer. + * + * Revision 1.123 2008/03/29 12:13:46 fabiankeil + * Remove send-wafer and send-vanilla-wafer actions. + * + * Revision 1.122 2008/03/28 15:13:39 fabiankeil + * Remove inspect-jpegs action. + * + * Revision 1.121 2008/01/05 21:37:03 fabiankeil + * Let client_range() also handle Request-Range headers + * which apparently are still supported by many servers. + * + * Revision 1.120 2008/01/04 17:43:45 fabiankeil + * Improve the warning messages that get logged if the action files + * "enable" filters but no filters of that type have been loaded. + * + * Revision 1.119 2007/12/28 18:32:51 fabiankeil + * In server_content_type(): + * - Don't require leading white space when detecting image content types. + * - Change '... not replaced ...' message to sound less crazy if the text + * type actually is 'text/plain'. + * - Mark the 'text/plain == binary data' assumption for removal. + * - Remove a bunch of trailing white space. + * + * Revision 1.118 2007/12/28 16:56:35 fabiankeil + * Minor server_content_disposition() changes: + * - Don't regenerate the header name all lower-case. + * - Some white space fixes. + * - Remove useless log message in case of ENOMEM. + * + * Revision 1.117 2007/12/06 18:11:50 fabiankeil + * Garbage-collect the code to add a X-Forwarded-For + * header as it seems to be mostly used by accident. + * + * Revision 1.116 2007/12/01 13:04:22 fabiankeil + * Fix a crash on mingw32 with some Last Modified times in the future. + * + * Revision 1.115 2007/11/02 16:52:50 fabiankeil + * Remove a "can't happen" error block which, over + * time, mutated into a "guaranteed to happen" block. + * + * Revision 1.114 2007/10/19 16:56:26 fabiankeil + * - Downgrade "Buffer limit reached" message to LOG_LEVEL_INFO. + * - Use shiny new content_filters_enabled() in client_range(). + * + * Revision 1.113 2007/10/10 17:29:57 fabiankeil + * I forgot about Poland. + * + * Revision 1.112 2007/10/09 16:38:40 fabiankeil + * Remove Range and If-Range headers if content filtering is enabled. + * + * Revision 1.111 2007/10/04 18:07:00 fabiankeil + * Move ACTION_VANILLA_WAFER handling from jcc's chat() into + * client_cookie_adder() to make sure send-vanilla-wafer can be + * controlled through tags (and thus regression-tested). + * + * Revision 1.110 2007/09/29 10:42:37 fabiankeil + * - Remove "scanning headers for" log message again. + * - Some more whitespace fixes. + * + * Revision 1.109 2007/09/08 14:25:48 fabiankeil + * Refactor client_referrer() and add conditional-forge parameter. + * + * Revision 1.108 2007/08/28 18:21:03 fabiankeil + * A bunch of whitespace fixes, pointy hat to me. + * + * Revision 1.107 2007/08/28 18:16:32 fabiankeil + * Fix possible memory corruption in server_http, make sure it's not + * executed for ordinary server headers and mark some problems for later. + * + * Revision 1.106 2007/08/18 14:30:32 fabiankeil + * Let content-type-overwrite{} honour force-text-mode again. + * + * Revision 1.105 2007/08/11 14:49:49 fabiankeil + * - Add prototpyes for the header parsers and make them static. + * - Comment out client_accept_encoding_adder() which isn't used right now. + * + * Revision 1.104 2007/07/14 07:38:19 fabiankeil + * Move the ACTION_FORCE_TEXT_MODE check out of + * server_content_type(). Signal other functions + * whether or not a content type has been declared. + * Part of the fix for BR#1750917. + * + * Revision 1.103 2007/06/01 16:31:54 fabiankeil + * Change sed() to return a jb_err in preparation for forward-override{}. + * + * Revision 1.102 2007/05/27 12:39:32 fabiankeil + * Adjust "X-Filter: No" to disable dedicated header filters. + * + * Revision 1.101 2007/05/14 10:16:41 fabiankeil + * Streamline client_cookie_adder(). + * * Revision 1.100 2007/04/30 15:53:11 fabiankeil * Make sure filters with dynamic jobs actually use them. * @@ -706,7 +908,6 @@ const char parsers_rcs[] = "$Id: parsers.c,v 1.100 2007/04/30 15:53:11 fabiankei #endif /* def FEATURE_PTHREAD */ #include "list.h" #include "parsers.h" -#include "encode.h" #include "ssplit.h" #include "errlog.h" #include "jbsockets.h" @@ -734,10 +935,74 @@ const char parsers_h_rcs[] = PARSERS_H_VERSION; #define ijb_isupper(__X) isupper((int)(unsigned char)(__X)) #define ijb_tolower(__X) tolower((int)(unsigned char)(__X)) -jb_err header_tagger(struct client_state *csp, char *header); -jb_err scan_headers(struct client_state *csp); +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 parse_header_time(const char *header_time, time_t *result); + +static jb_err crumble (struct client_state *csp, char **header); +static jb_err filter_header (struct client_state *csp, char **header); +static jb_err client_connection (struct client_state *csp, char **header); +static jb_err client_referrer (struct client_state *csp, char **header); +static jb_err client_uagent (struct client_state *csp, char **header); +static jb_err client_ua (struct client_state *csp, char **header); +static jb_err client_from (struct client_state *csp, char **header); +static jb_err client_send_cookie (struct client_state *csp, char **header); +static jb_err client_x_forwarded (struct client_state *csp, char **header); +static jb_err client_accept_encoding (struct client_state *csp, char **header); +static jb_err client_te (struct client_state *csp, char **header); +static jb_err client_max_forwards (struct client_state *csp, char **header); +static jb_err client_host (struct client_state *csp, char **header); +static jb_err client_if_modified_since (struct client_state *csp, char **header); +static jb_err client_accept_language (struct client_state *csp, char **header); +static jb_err client_if_none_match (struct client_state *csp, char **header); +static jb_err crunch_client_header (struct client_state *csp, char **header); +static jb_err client_x_filter (struct client_state *csp, char **header); +static jb_err client_range (struct client_state *csp, char **header); +static jb_err server_set_cookie (struct client_state *csp, char **header); +static jb_err server_connection (struct client_state *csp, char **header); +static jb_err server_content_type (struct client_state *csp, char **header); +static jb_err server_adjust_content_length(struct client_state *csp, char **header); +static jb_err server_content_md5 (struct client_state *csp, char **header); +static jb_err server_content_encoding (struct client_state *csp, char **header); +static jb_err server_transfer_coding (struct client_state *csp, char **header); +static jb_err server_http (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_CONNECTION_KEEP_ALIVE +static jb_err server_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 client_xtra_adder (struct client_state *csp); +static jb_err client_x_forwarded_for_adder(struct client_state *csp); +static jb_err client_connection_header_adder(struct client_state *csp); +static jb_err server_connection_close_adder(struct client_state *csp); + +static jb_err create_forged_referrer(char **header, const char *hostport); +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); + +/* + * List of functions to run on a list of headers. + */ +struct parsers +{ + /** 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; +}; -const struct parsers client_patterns[] = { +static const struct parsers client_patterns[] = { { "referer:", 8, client_referrer }, { "user-agent:", 11, client_uagent }, { "ua-", 3, client_ua }, @@ -749,55 +1014,50 @@ const struct parsers client_patterns[] = { { "Host:", 5, client_host }, { "if-modified-since:", 18, client_if_modified_since }, { "Keep-Alive:", 11, crumble }, - { "connection:", 11, connection }, + { "connection:", 11, client_connection }, { "proxy-connection:", 17, crumble }, { "max-forwards:", 13, client_max_forwards }, { "Accept-Language:", 16, client_accept_language }, { "if-none-match:", 14, client_if_none_match }, + { "Range:", 6, client_range }, + { "Request-Range:", 14, client_range }, + { "If-Range:", 9, client_range }, { "X-Filter:", 9, client_x_filter }, { "*", 0, crunch_client_header }, { "*", 0, filter_header }, { NULL, 0, NULL } }; -const struct parsers server_patterns[] = { - { "HTTP", 4, server_http }, +static const struct parsers server_patterns[] = { + { "HTTP/", 5, server_http }, { "set-cookie:", 11, server_set_cookie }, - { "connection:", 11, connection }, + { "connection:", 11, server_connection }, { "Content-Type:", 13, server_content_type }, { "Content-MD5:", 12, server_content_md5 }, { "Content-Encoding:", 17, server_content_encoding }, +#ifdef FEATURE_CONNECTION_KEEP_ALIVE + { "Content-Length:", 15, server_save_content_length }, +#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */ { "Transfer-Encoding:", 18, server_transfer_coding }, { "Keep-Alive:", 11, crumble }, { "content-disposition:", 20, server_content_disposition }, { "Last-Modified:", 14, server_last_modified }, { "*", 0, crunch_server_header }, { "*", 0, filter_header }, - { NULL, 0, NULL } -}; - -const struct parsers server_patterns_light[] = { - { "Content-Length:", 15, server_content_length }, - { "Transfer-Encoding:", 18, server_transfer_coding }, -#ifdef FEATURE_ZLIB - { "Content-Encoding:", 17, server_content_encoding }, -#endif /* def FEATURE_ZLIB */ - { NULL, 0, NULL } + { NULL, 0, NULL } }; -const add_header_func_ptr add_client_headers[] = { +static const add_header_func_ptr add_client_headers[] = { client_host_adder, - client_cookie_adder, - client_x_forwarded_adder, + client_x_forwarded_for_adder, client_xtra_adder, /* Temporarily disabled: client_accept_encoding_adder, */ - connection_close_adder, + client_connection_header_adder, NULL }; - -const add_header_func_ptr add_server_headers[] = { - connection_close_adder, +static const add_header_func_ptr add_server_headers[] = { + server_connection_close_adder, NULL }; @@ -809,7 +1069,7 @@ const add_header_func_ptr add_server_headers[] = { * * Parameters : * 1 : fd = file descriptor of the socket to read - * 2 : csp = Current client state (buffers, headers, etc...) + * 2 : iob = The I/O buffer to flush, usually csp->iob. * * Returns : On success, the number of bytes written are returned (zero * indicates nothing was written). On error, -1 is returned, @@ -819,9 +1079,8 @@ const add_header_func_ptr add_server_headers[] = { * file, the results are not portable. * *********************************************************************/ -int flush_socket(jb_socket fd, struct client_state *csp) +int flush_socket(jb_socket fd, struct iob *iob) { - struct iob *iob = csp->iob; int len = iob->eod - iob->cur; if (len <= 0) @@ -873,7 +1132,9 @@ jb_err add_to_iob(struct client_state *csp, char *buf, int n) */ if (need > csp->config->buffer_limit) { - log_error(LOG_LEVEL_ERROR, "Buffer limit reached while extending the buffer (iob)"); + log_error(LOG_LEVEL_INFO, + "Buffer limit reached while extending the buffer (iob). Needed: %d. Limit: %d", + need, csp->config->buffer_limit); return JB_ERR_MEMORY; } @@ -954,13 +1215,13 @@ jb_err decompress_iob(struct client_state *csp) cur = csp->iob->cur; - if (bufsize < 10) + if (bufsize < (size_t)10) { /* * This is to protect the parsing of gzipped data, * but it should(?) be valid for deflated data also. */ - log_error (LOG_LEVEL_ERROR, "Buffer too small decompressing iob"); + log_error(LOG_LEVEL_ERROR, "Buffer too small decompressing iob"); return JB_ERR_COMPRESS; } @@ -982,7 +1243,7 @@ jb_err decompress_iob(struct client_state *csp) || (*cur++ != (char)0x8b) || (*cur++ != Z_DEFLATED)) { - log_error (LOG_LEVEL_ERROR, "Invalid gzip header when decompressing"); + log_error(LOG_LEVEL_ERROR, "Invalid gzip header when decompressing"); return JB_ERR_COMPRESS; } else @@ -995,7 +1256,7 @@ jb_err decompress_iob(struct client_state *csp) if (flags & 0xe0) { /* The gzip header has reserved bits set; bail out. */ - log_error (LOG_LEVEL_ERROR, "Invalid gzip header flags when decompressing"); + log_error(LOG_LEVEL_ERROR, "Invalid gzip header flags when decompressing"); return JB_ERR_COMPRESS; } cur += 6; @@ -1034,14 +1295,14 @@ jb_err decompress_iob(struct client_state *csp) * The number of bytes to skip should be positive * and we'd like to stay in the buffer. */ - if((skip_bytes < 0) || (skip_bytes >= (csp->iob->eod - cur))) + if ((skip_bytes < 0) || (skip_bytes >= (csp->iob->eod - cur))) { - log_error (LOG_LEVEL_ERROR, + log_error(LOG_LEVEL_ERROR, "Unreasonable amount of bytes to skip (%d). Stopping decompression", skip_bytes); return JB_ERR_COMPRESS; } - log_error (LOG_LEVEL_INFO, + log_error(LOG_LEVEL_INFO, "Skipping %d bytes for gzip compression. Does this sound right?", skip_bytes); cur += skip_bytes; @@ -1075,7 +1336,7 @@ jb_err decompress_iob(struct client_state *csp) * the buffer end, we were obviously tricked to skip * too much. */ - log_error (LOG_LEVEL_ERROR, + log_error(LOG_LEVEL_ERROR, "Malformed gzip header detected. Aborting decompression."); return JB_ERR_COMPRESS; } @@ -1087,7 +1348,7 @@ jb_err decompress_iob(struct client_state *csp) * XXX: The debug level should be lowered * before the next stable release. */ - log_error (LOG_LEVEL_INFO, "Decompressing deflated iob: %d", *cur); + log_error(LOG_LEVEL_INFO, "Decompressing deflated iob: %d", *cur); /* * In theory (that is, according to RFC 1950), deflate-compressed * data should begin with a two-byte zlib header and have an @@ -1107,7 +1368,7 @@ jb_err decompress_iob(struct client_state *csp) } else { - log_error (LOG_LEVEL_ERROR, + log_error(LOG_LEVEL_ERROR, "Unable to determine compression format for decompression"); return JB_ERR_COMPRESS; } @@ -1125,7 +1386,7 @@ jb_err decompress_iob(struct client_state *csp) */ if (inflateInit2 (&zstr, -MAX_WBITS) != Z_OK) { - log_error (LOG_LEVEL_ERROR, "Error initializing decompression"); + log_error(LOG_LEVEL_ERROR, "Error initializing decompression"); return JB_ERR_COMPRESS; } @@ -1134,10 +1395,10 @@ jb_err decompress_iob(struct client_state *csp) * We don't modify the existing iob yet, so in case there * is error in decompression we can recover gracefully. */ - buf = zalloc (bufsize); + buf = zalloc(bufsize); if (NULL == buf) { - log_error (LOG_LEVEL_ERROR, "Out of memory decompressing iob"); + log_error(LOG_LEVEL_ERROR, "Out of memory decompressing iob"); return JB_ERR_MEMORY; } @@ -1209,7 +1470,7 @@ jb_err decompress_iob(struct client_state *csp) */ assert(zstr.avail_out == tmpbuf + bufsize - (char *)zstr.next_out); assert((char *)zstr.next_out == tmpbuf + ((char *)oldnext_out - buf)); - assert(zstr.avail_out > 0); + assert(zstr.avail_out > 0U); buf = tmpbuf; } @@ -1261,7 +1522,7 @@ jb_err decompress_iob(struct client_state *csp) && (csp->iob->eod <= csp->iob->buf + csp->iob->size)) { const size_t new_size = (size_t)(csp->iob->eod - csp->iob->cur); - if (new_size > 0) + if (new_size > (size_t)0) { log_error(LOG_LEVEL_RE_FILTER, "Decompression successful. Old size: %d, new size: %d.", @@ -1289,14 +1550,184 @@ jb_err decompress_iob(struct client_state *csp) #endif /* defined(FEATURE_ZLIB) */ +/********************************************************************* + * + * Function : string_move + * + * Description : memmove wrapper to move the last part of a string + * towards the beginning, overwriting the part in + * the middle. strlcpy() can't be used here as the + * strings overlap. + * + * Parameters : + * 1 : dst = Destination to overwrite + * 2 : src = Source to move. + * + * Returns : N/A + * + *********************************************************************/ +static void string_move(char *dst, char *src) +{ + assert(dst < src); + + /* +1 to copy the terminating nul as well. */ + memmove(dst, src, strlen(src)+1); +} + + +/********************************************************************* + * + * Function : normalize_lws + * + * Description : Reduces unquoted linear white space in headers + * to a single space in accordance with RFC 2616 2.2. + * This simplifies parsing and filtering later on. + * + * XXX: Remove log messages before + * the next stable release? + * + * Parameters : + * 1 : header = A header with linear white space to reduce. + * + * Returns : N/A + * + *********************************************************************/ +static void normalize_lws(char *header) +{ + char *p = header; + + while (*p != '\0') + { + if (ijb_isspace(*p) && ijb_isspace(*(p+1))) + { + char *q = p+1; + + while (ijb_isspace(*q)) + { + q++; + } + log_error(LOG_LEVEL_HEADER, "Reducing white space in '%s'", header); + string_move(p+1, q); + } + + if (*p == '\t') + { + log_error(LOG_LEVEL_HEADER, + "Converting tab to space in '%s'", header); + *p = ' '; + } + else if (*p == '"') + { + char *end_of_token = strstr(p+1, "\""); + + if (NULL != end_of_token) + { + /* Don't mess with quoted text. */ + p = end_of_token; + } + else + { + log_error(LOG_LEVEL_HEADER, + "Ignoring single quote in '%s'", header); + } + } + p++; + } + + p = strchr(header, ':'); + if ((p != NULL) && (p != header) && ijb_isspace(*(p-1))) + { + /* + * There's still space before the colon. + * We don't want it. + */ + string_move(p-1, p); + } +} + + /********************************************************************* * * Function : get_header * * Description : This (odd) routine will parse the csp->iob + * to get the next complete header. * * Parameters : - * 1 : csp = Current client state (buffers, headers, etc...) + * 1 : iob = The I/O buffer to parse, usually csp->iob. + * + * Returns : Any one of the following: + * + * 1) a pointer to a dynamically allocated string that contains a header line + * 2) NULL indicating that the end of the header was reached + * 3) "" indicating that the end of the iob was reached before finding + * a complete header line. + * + *********************************************************************/ +char *get_header(struct iob *iob) +{ + char *header; + + header = get_header_line(iob); + + if ((header == NULL) || (*header == '\0')) + { + /* + * No complete header read yet, tell the client. + */ + return header; + } + + while ((iob->cur[0] == ' ') || (iob->cur[0] == '\t')) + { + /* + * Header spans multiple lines, append the next one. + */ + char *continued_header; + + continued_header = get_header_line(iob); + if ((continued_header == NULL) || (*continued_header == '\0')) + { + /* + * No complete header read yet, return what we got. + * XXX: Should "unread" header instead. + */ + log_error(LOG_LEVEL_INFO, + "Failed to read a multi-line header properly: '%s'", + header); + break; + } + + if (JB_ERR_OK != string_join(&header, continued_header)) + { + log_error(LOG_LEVEL_FATAL, + "Out of memory while appending multiple headers."); + } + else + { + /* XXX: remove before next stable release. */ + log_error(LOG_LEVEL_HEADER, + "Merged multiple header lines to: '%s'", + header); + } + } + + normalize_lws(header); + + return header; + +} + + +/********************************************************************* + * + * Function : get_header_line + * + * Description : This (odd) routine will parse the csp->iob + * to get the next header line. + * + * Parameters : + * 1 : iob = The I/O buffer to parse, usually csp->iob. * * Returns : Any one of the following: * @@ -1306,11 +1737,9 @@ jb_err decompress_iob(struct client_state *csp) * a complete header line. * *********************************************************************/ -char *get_header(struct client_state *csp) +static char *get_header_line(struct iob *iob) { - struct iob *iob; char *p, *q, *ret; - iob = csp->iob; if ((iob->cur == NULL) || ((p = strchr(iob->cur, '\n')) == NULL)) @@ -1324,8 +1753,9 @@ char *get_header(struct client_state *csp) if (ret == NULL) { /* FIXME No way to handle error properly */ - log_error(LOG_LEVEL_FATAL, "Out of memory in get_header()"); + log_error(LOG_LEVEL_FATAL, "Out of memory in get_header_line()"); } + assert(ret != NULL); iob->cur = p+1; @@ -1335,10 +1765,10 @@ char *get_header(struct client_state *csp) if (*ret == '\0') { freez(ret); - return(NULL); + return NULL; } - return(ret); + return ret; } @@ -1379,9 +1809,9 @@ char *get_header_value(const struct list *header_list, const char *header_name) /* * Found: return pointer to start of value */ - ret = (char *) (cur_entry->str + length); + ret = cur_entry->str + length; while (*ret && ijb_isspace(*ret)) ret++; - return(ret); + return ret; } } } @@ -1406,13 +1836,11 @@ char *get_header_value(const struct list *header_list, const char *header_name) * Returns : JB_ERR_OK * *********************************************************************/ -jb_err scan_headers(struct client_state *csp) +static jb_err scan_headers(struct client_state *csp) { struct list_entry *h; /* Header */ jb_err err = JB_ERR_OK; - log_error(LOG_LEVEL_HEADER, "scanning headers for: %s", csp->http->url); - for (h = csp->headers->first; (err == JB_ERR_OK) && (h != NULL) ; h = h->next) { /* Header crunch()ed in previous run? -> ignore */ @@ -1438,91 +1866,114 @@ jb_err scan_headers(struct client_state *csp) * header lines. * * Parameters : - * 1 : pats = list of patterns to match against headers - * 2 : more_headers = list of functions to add more - * headers (client or server) - * 3 : csp = Current client state (buffers, headers, etc...) + * 1 : csp = Current client state (buffers, headers, etc...) + * 2 : filter_server_headers = Boolean to switch between + * server and header filtering. * - * Returns : Single pointer to a fully formed header, or NULL - * on out-of-memory error. + * Returns : JB_ERR_OK in case off success, or + * JB_ERR_MEMORY on out-of-memory error. * *********************************************************************/ -char *sed(const struct parsers pats[], - const add_header_func_ptr more_headers[], - struct client_state *csp) +jb_err sed(struct client_state *csp, int filter_server_headers) { + /* XXX: use more descriptive names. */ struct list_entry *p; const struct parsers *v; const add_header_func_ptr *f; jb_err err = JB_ERR_OK; - int first_run; - /* - * If filtering is enabled, sed is run twice, - * but most of the work needs to be done only once. - */ - first_run = (more_headers != NULL ) ? 1 : 0; - - if (first_run) /* Parse and print */ + if (filter_server_headers) + { + v = server_patterns; + f = add_server_headers; + } + else { - scan_headers(csp); + v = client_patterns; + f = add_client_headers; + } + + scan_headers(csp); - for (v = pats; (err == JB_ERR_OK) && (v->str != NULL) ; v++) + while ((err == JB_ERR_OK) && (v->str != NULL)) + { + for (p = csp->headers->first; (err == JB_ERR_OK) && (p != NULL); p = p->next) { - for (p = csp->headers->first; (err == JB_ERR_OK) && (p != NULL) ; p = p->next) - { - /* Header crunch()ed in previous run? -> ignore */ - if (p->str == NULL) continue; + /* Header crunch()ed in previous run? -> ignore */ + if (p->str == NULL) continue; - /* Does the current parser handle this header? */ - if ((strncmpic(p->str, v->str, v->len) == 0) || (v->len == CHECK_EVERY_HEADER_REMAINING)) - { - err = v->parser(csp, (char **)&(p->str)); - } + /* Does the current parser handle this header? */ + if ((strncmpic(p->str, v->str, v->len) == 0) || + (v->len == CHECK_EVERY_HEADER_REMAINING)) + { + err = v->parser(csp, &(p->str)); } } - /* place any additional headers on the csp->headers list */ - for (f = more_headers; (err == JB_ERR_OK) && (*f) ; f++) - { - err = (*f)(csp); - } + v++; } - else /* Parse only */ + + /* place additional headers on the csp->headers list */ + while ((err == JB_ERR_OK) && (*f)) { - /* - * The second run is only needed if the body was modified - * and the content-lenght has changed. - */ - if (strncmpic(csp->http->cmd, "HEAD", 4)) + err = (*f)(csp); + f++; + } + + return err; +} + + +/********************************************************************* + * + * Function : update_server_headers + * + * Description : Updates server headers after the body has been modified. + * + * Parameters : + * 1 : csp = Current client state (buffers, headers, etc...) + * + * Returns : JB_ERR_OK in case off success, or + * JB_ERR_MEMORY on out-of-memory error. + * + *********************************************************************/ +jb_err update_server_headers(struct client_state *csp) +{ + jb_err err = JB_ERR_OK; + + static const struct parsers server_patterns_light[] = { + { "Content-Length:", 15, server_adjust_content_length }, + { "Transfer-Encoding:", 18, server_transfer_coding }, +#ifdef FEATURE_ZLIB + { "Content-Encoding:", 17, server_content_encoding }, +#endif /* def FEATURE_ZLIB */ + { NULL, 0, NULL } + }; + + if (strncmpic(csp->http->cmd, "HEAD", 4)) + { + const struct parsers *v; + struct list_entry *p; + + for (v = server_patterns_light; (err == JB_ERR_OK) && (v->str != NULL); v++) { - /*XXX: Code duplication */ - for (v = pats; (err == JB_ERR_OK) && (v->str != NULL) ; v++) + for (p = csp->headers->first; (err == JB_ERR_OK) && (p != NULL); p = p->next) { - for (p = csp->headers->first; (err == JB_ERR_OK) && (p != NULL) ; p = p->next) - { - /* Header crunch()ed in previous run? -> ignore */ - if (p->str == NULL) continue; + /* Header crunch()ed in previous run? -> ignore */ + if (p->str == NULL) continue; - /* Does the current parser handle this header? */ - if (strncmpic(p->str, v->str, v->len) == 0) - { - err = v->parser(csp, (char **)&(p->str)); - } + /* Does the current parser handle this header? */ + if (strncmpic(p->str, v->str, v->len) == 0) + { + err = v->parser(csp, (char **)&(p->str)); } } } } - if (err != JB_ERR_OK) - { - return NULL; - } - - return list_to_text(csp->headers); + return err; } - /********************************************************************* * * Function : header_tagger @@ -1540,7 +1991,7 @@ char *sed(const struct parsers pats[], * Returns : JB_ERR_OK on success and always succeeds * *********************************************************************/ -jb_err header_tagger(struct client_state *csp, char *header) +static jb_err header_tagger(struct client_state *csp, char *header) { int wanted_filter_type; int multi_action_index; @@ -1581,8 +2032,9 @@ jb_err header_tagger(struct client_state *csp, char *header) if (0 == found_filters) { - log_error(LOG_LEVEL_ERROR, "Unable to get current state of regex tagging."); - return(JB_ERR_OK); + log_error(LOG_LEVEL_ERROR, "Inconsistent configuration: " + "tagging enabled, but no taggers available."); + return JB_ERR_OK; } for (i = 0; i < MAX_AF_FILES; i++) @@ -1651,6 +2103,7 @@ jb_err header_tagger(struct client_state *csp, char *header) if (0 > hits) { /* Regex failure, log it but continue anyway. */ + assert(NULL != header); log_error(LOG_LEVEL_ERROR, "Problems with tagger \'%s\' and header \'%s\': %s", b->name, *header, pcrs_strerror(hits)); @@ -1747,7 +2200,7 @@ jb_err header_tagger(struct client_state *csp, char *header) * Returns : JB_ERR_OK on success and always succeeds * *********************************************************************/ -jb_err filter_header(struct client_state *csp, char **header) +static jb_err filter_header(struct client_state *csp, char **header) { int hits=0; int matches; @@ -1764,6 +2217,11 @@ jb_err filter_header(struct client_state *csp, char **header) int wanted_filter_type; int multi_action_index; + if (csp->flags & CSP_FLAG_NO_FILTERING) + { + return JB_ERR_OK; + } + if (csp->flags & CSP_FLAG_CLIENT_HEADER_PARSING_DONE) { wanted_filter_type = FT_SERVER_HEADER_FILTER; @@ -1793,8 +2251,9 @@ jb_err filter_header(struct client_state *csp, char **header) if (0 == found_filters) { - log_error(LOG_LEVEL_ERROR, "Unable to get current state of regexp filtering."); - return(JB_ERR_OK); + log_error(LOG_LEVEL_ERROR, "Inconsistent configuration: " + "header filtering enabled, but no matching filters available."); + return JB_ERR_OK; } for (i = 0; i < MAX_AF_FILES; i++) @@ -1866,7 +2325,7 @@ jb_err filter_header(struct client_state *csp, char **header) /* RegEx failure */ log_error(LOG_LEVEL_ERROR, "Filtering \'%s\' with \'%s\' didn't work out: %s", *header, b->name, pcrs_strerror(matches)); - if( newheader != NULL) + if (newheader != NULL) { log_error(LOG_LEVEL_ERROR, "Freeing what's left: %s", newheader); freez(newheader); @@ -1894,16 +2353,16 @@ jb_err filter_header(struct client_state *csp, char **header) freez(*header); } - return(JB_ERR_OK); + return JB_ERR_OK; } /********************************************************************* * - * Function : connection + * Function : server_connection * * Description : Makes sure that the value of the Connection: header - * is "close" and signals connection_close_adder + * is "close" and signals server_connection_close_adder * to do nothing. * * Parameters : @@ -1917,14 +2376,23 @@ jb_err filter_header(struct client_state *csp, char **header) * JB_ERR_MEMORY on out-of-memory error. * *********************************************************************/ -jb_err connection(struct client_state *csp, char **header) +static jb_err server_connection(struct client_state *csp, char **header) { char *old_header = *header; /* Do we have a 'Connection: close' header? */ if (strcmpic(*header, "Connection: close")) { - /* No, create one */ +#ifdef FEATURE_CONNECTION_KEEP_ALIVE + if ((csp->config->feature_flags & + RUNTIME_FEATURE_CONNECTION_KEEP_ALIVE) + && !strcmpic(*header, "Connection: keep-alive")) + { + /* Remember to keep the connection alive. */ + csp->flags |= CSP_FLAG_SERVER_CONNECTION_KEEP_ALIVE; + } +#endif /* FEATURE_CONNECTION_KEEP_ALIVE */ + *header = strdup("Connection: close"); if (header == NULL) { @@ -1934,25 +2402,19 @@ jb_err connection(struct client_state *csp, char **header) freez(old_header); } - /* Signal connection_close_adder() to return early. */ - if (csp->flags & CSP_FLAG_CLIENT_HEADER_PARSING_DONE) - { - csp->flags |= CSP_FLAG_SERVER_CONNECTION_CLOSE_SET; - } - else - { - csp->flags |= CSP_FLAG_CLIENT_CONNECTION_CLOSE_SET; - } + /* Signal server_connection_close_adder() to return early. */ + csp->flags |= CSP_FLAG_SERVER_CONNECTION_CLOSE_SET; return JB_ERR_OK; } - /********************************************************************* * - * Function : crumble + * Function : client_connection * - * Description : This is called if a header matches a pattern to "crunch" + * Description : Makes sure a proper "Connection:" header is + * set and signals connection_header_adder + * to do nothing. * * Parameters : * 1 : csp = Current client state (buffers, headers, etc...) @@ -1965,20 +2427,63 @@ jb_err connection(struct client_state *csp, char **header) * JB_ERR_MEMORY on out-of-memory error. * *********************************************************************/ -jb_err crumble(struct client_state *csp, char **header) +static jb_err client_connection(struct client_state *csp, char **header) { - log_error(LOG_LEVEL_HEADER, "crumble crunched: %s!", *header); - freez(*header); - return JB_ERR_OK; -} + char *old_header = *header; + const char *wanted_header = get_appropiate_connection_header(csp); -/********************************************************************* - * - * Function : crunch_server_header - * - * Description : Crunch server header if it matches a string supplied by the - * user. Called from `sed'. - * + if (strcmpic(*header, wanted_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); + } + + /* Signal client_connection_close_adder() to return early. */ + csp->flags |= CSP_FLAG_CLIENT_CONNECTION_HEADER_SET; + + return JB_ERR_OK; +} + + +/********************************************************************* + * + * Function : crumble + * + * Description : This is called if a header matches a pattern to "crunch" + * + * 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 crumble(struct client_state *csp, char **header) +{ + (void)csp; + log_error(LOG_LEVEL_HEADER, "crumble crunched: %s!", *header); + freez(*header); + return JB_ERR_OK; +} + + +/********************************************************************* + * + * Function : crunch_server_header + * + * Description : Crunch server header if it matches a string supplied by the + * user. Called from `sed'. + * * Parameters : * 1 : csp = Current client state (buffers, headers, etc...) * 2 : header = On input, pointer to header to modify. @@ -1989,7 +2494,7 @@ jb_err crumble(struct client_state *csp, char **header) * Returns : JB_ERR_OK on success and always succeeds * *********************************************************************/ -jb_err crunch_server_header(struct client_state *csp, char **header) +static jb_err crunch_server_header(struct client_state *csp, char **header) { const char *crunch_pattern; @@ -2032,10 +2537,10 @@ jb_err crunch_server_header(struct client_state *csp, char **header) * JB_ERR_MEMORY on out-of-memory error. * *********************************************************************/ -jb_err server_content_type(struct client_state *csp, char **header) +static jb_err server_content_type(struct client_state *csp, char **header) { /* Remove header if it isn't the first Content-Type header */ - if(csp->content_type && (csp->content_type != CT_TABOO)) + if ((csp->content_type & CT_DECLARED)) { /* * Another, slightly slower, way to see if @@ -2051,62 +2556,47 @@ jb_err server_content_type(struct client_state *csp, char **header) return JB_ERR_OK; } + /* + * Signal that the Content-Type has been set. + */ + csp->content_type |= CT_DECLARED; + if (!(csp->content_type & CT_TABOO)) { - if ((strstr(*header, " text/") && !strstr(*header, "plain")) + /* + * XXX: The assumption that text/plain is a sign of + * binary data seems to be somewhat unreasonable nowadays + * and should be dropped after 3.0.8 is out. + */ + if ((strstr(*header, "text/") && !strstr(*header, "plain")) || strstr(*header, "xml") || strstr(*header, "application/x-javascript")) { csp->content_type |= CT_TEXT; } - else if (strstr(*header, " image/gif")) + else if (strstr(*header, "image/gif")) { csp->content_type |= CT_GIF; } - else if (strstr(*header, " image/jpeg")) - { - csp->content_type |= CT_JPEG; - } - else - { - csp->content_type = 0; - } - } - /* - * Are we enabling text mode by force? - */ - if (csp->action->flags & ACTION_FORCE_TEXT_MODE) - { - /* - * Do we really have to? - */ - if (csp->content_type & CT_TEXT) - { - log_error(LOG_LEVEL_HEADER, "Text mode is already enabled."); - } - else - { - csp->content_type |= CT_TEXT; - log_error(LOG_LEVEL_HEADER, "Text mode enabled by force. Take cover!"); - } } + /* * Are we messing with the content type? - */ + */ if (csp->action->flags & ACTION_CONTENT_TYPE_OVERWRITE) - { + { /* * Make sure the user doesn't accidently * change the content type of binary documents. - */ - if (csp->content_type & CT_TEXT) - { + */ + if ((csp->content_type & CT_TEXT) || (csp->action->flags & ACTION_FORCE_TEXT_MODE)) + { freez(*header); *header = strdup("Content-Type: "); string_append(header, csp->action->string[ACTION_STRING_CONTENT_TYPE]); if (header == NULL) - { + { log_error(LOG_LEVEL_HEADER, "Insufficient memory to replace Content-Type!"); return JB_ERR_MEMORY; } @@ -2114,10 +2604,12 @@ jb_err server_content_type(struct client_state *csp, char **header) } else { - log_error(LOG_LEVEL_HEADER, "%s not replaced. It doesn't look like text. " - "Enable force-text-mode if you know what you're doing.", *header); + log_error(LOG_LEVEL_HEADER, "%s not replaced. " + "It doesn't look like a content type that should be filtered. " + "Enable force-text-mode if you know what you're doing.", *header); } - } + } + return JB_ERR_OK; } @@ -2142,7 +2634,7 @@ jb_err server_content_type(struct client_state *csp, char **header) * JB_ERR_MEMORY on out-of-memory error. * *********************************************************************/ -jb_err server_transfer_coding(struct client_state *csp, char **header) +static jb_err server_transfer_coding(struct client_state *csp, char **header) { /* * Turn off pcrs and gif filtering if body compressed @@ -2210,7 +2702,7 @@ jb_err server_transfer_coding(struct client_state *csp, char **header) * JB_ERR_MEMORY on out-of-memory error. * *********************************************************************/ -jb_err server_content_encoding(struct client_state *csp, char **header) +static jb_err server_content_encoding(struct client_state *csp, char **header) { #ifdef FEATURE_ZLIB if ((csp->flags & CSP_FLAG_MODIFIED) @@ -2274,7 +2766,7 @@ jb_err server_content_encoding(struct client_state *csp, char **header) /********************************************************************* * - * Function : server_content_length + * Function : server_adjust_content_length * * Description : Adjust Content-Length header if we modified * the body. @@ -2290,7 +2782,7 @@ jb_err server_content_encoding(struct client_state *csp, char **header) * JB_ERR_MEMORY on out-of-memory error. * *********************************************************************/ -jb_err server_content_length(struct client_state *csp, char **header) +static jb_err server_adjust_content_length(struct client_state *csp, char **header) { const size_t max_header_length = 80; @@ -2314,6 +2806,46 @@ jb_err server_content_length(struct client_state *csp, char **header) } +#ifdef FEATURE_CONNECTION_KEEP_ALIVE +/********************************************************************* + * + * Function : server_save_content_length + * + * Description : Save the Content-Length sent by the server. + * + * 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_save_content_length(struct client_state *csp, char **header) +{ + unsigned int content_length = 0; + + assert(*(*header+14) == ':'); + + if (1 != sscanf(*header+14, ": %u", &content_length)) + { + log_error(LOG_LEVEL_ERROR, "Crunching invalid header: %s", *header); + freez(*header); + } + else + { + csp->expected_content_length = content_length; + csp->flags |= CSP_FLAG_CONTENT_LENGTH_SET; + } + + return JB_ERR_OK; +} +#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */ + + /********************************************************************* * * Function : server_content_md5 @@ -2332,7 +2864,7 @@ jb_err server_content_length(struct client_state *csp, char **header) * JB_ERR_MEMORY on out-of-memory error. * *********************************************************************/ -jb_err server_content_md5(struct client_state *csp, char **header) +static jb_err server_content_md5(struct client_state *csp, char **header) { if (csp->flags & CSP_FLAG_MODIFIED) { @@ -2343,11 +2875,12 @@ jb_err server_content_md5(struct client_state *csp, char **header) return JB_ERR_OK; } + /********************************************************************* * * Function : server_content_disposition * - * Description : If enabled, blocks or modifies the "content-disposition" header. + * Description : If enabled, blocks or modifies the "Content-Disposition" header. * Called from `sed'. * * Parameters : @@ -2361,22 +2894,22 @@ jb_err server_content_md5(struct client_state *csp, char **header) * JB_ERR_MEMORY on out-of-memory error. * *********************************************************************/ -jb_err server_content_disposition(struct client_state *csp, char **header) +static jb_err server_content_disposition(struct client_state *csp, char **header) { const char *newval; /* - * Are we messing with the content-disposition header? + * Are we messing with the Content-Disposition header? */ if ((csp->action->flags & ACTION_HIDE_CONTENT_DISPOSITION) == 0) { - /*Me tinks not*/ + /* Me tinks not */ return JB_ERR_OK; } newval = csp->action->string[ACTION_STRING_CONTENT_DISPOSITION]; - if ((newval == NULL) || (0 == strcmpic(newval, "block")) ) + if ((newval == NULL) || (0 == strcmpic(newval, "block"))) { /* * Blocking content-disposition header @@ -2388,24 +2921,22 @@ jb_err server_content_disposition(struct client_state *csp, char **header) else { /* - * Replacing content-disposition header + * Replacing Content-Disposition header */ freez(*header); - *header = strdup("content-disposition: "); - string_append(header, newval); + *header = strdup("Content-Disposition: "); + string_append(header, newval); - if (*header == NULL) + if (*header != NULL) { - log_error(LOG_LEVEL_HEADER, "Insufficent memory. content-disposition header not fully replaced."); - } - else - { - log_error(LOG_LEVEL_HEADER, "content-disposition header crunched and replaced with: %s", *header); + log_error(LOG_LEVEL_HEADER, + "Content-Disposition header crunched and replaced with: %s", *header); } } return (*header == NULL) ? JB_ERR_MEMORY : JB_ERR_OK; } + /********************************************************************* * * Function : server_last_modified @@ -2425,7 +2956,7 @@ jb_err server_content_disposition(struct client_state *csp, char **header) * JB_ERR_MEMORY on out-of-memory error. * *********************************************************************/ -jb_err server_last_modified(struct client_state *csp, char **header) +static jb_err server_last_modified(struct client_state *csp, char **header) { const char *newval; char buf[BUFFER_SIZE]; @@ -2464,14 +2995,14 @@ jb_err server_last_modified(struct client_state *csp, char **header) /* * Setting Last-Modified Header to now. */ - get_http_time(0, buf); + get_http_time(0, buf, sizeof(buf)); freez(*header); *header = strdup("Last-Modified: "); string_append(header, buf); if (*header == NULL) { - log_error(LOG_LEVEL_HEADER, "Insufficent memory. Last-Modified header got lost, boohoo."); + log_error(LOG_LEVEL_HEADER, "Insufficient memory. Last-Modified header got lost, boohoo."); } else { @@ -2487,9 +3018,9 @@ jb_err server_last_modified(struct client_state *csp, char **header) #ifdef HAVE_GMTIME_R timeptr = gmtime_r(&now, &gmt); #elif FEATURE_PTHREAD - pthread_mutex_lock(&gmtime_mutex); + privoxy_mutex_lock(&gmtime_mutex); timeptr = gmtime(&now); - pthread_mutex_unlock(&gmtime_mutex); + privoxy_mutex_unlock(&gmtime_mutex); #else timeptr = gmtime(&now); #endif @@ -2503,14 +3034,23 @@ jb_err server_last_modified(struct client_state *csp, char **header) rtime = (long int)difftime(now, last_modified); if (rtime) { + int negative = 0; + + if (rtime < 0) + { + rtime *= -1; + negative = 1; + log_error(LOG_LEVEL_HEADER, "Server time in the future."); + } rtime = pick_from_range(rtime); + if (negative) rtime *= -1; last_modified += rtime; #ifdef HAVE_GMTIME_R timeptr = gmtime_r(&last_modified, &gmt); #elif FEATURE_PTHREAD - pthread_mutex_lock(&gmtime_mutex); + privoxy_mutex_lock(&gmtime_mutex); timeptr = gmtime(&last_modified); - pthread_mutex_unlock(&gmtime_mutex); + privoxy_mutex_unlock(&gmtime_mutex); #else timeptr = gmtime(&last_modified); #endif @@ -2521,21 +3061,19 @@ jb_err server_last_modified(struct client_state *csp, char **header) if (*header == NULL) { - log_error(LOG_LEVEL_ERROR, "Insufficent memory, header crunched without replacement."); + log_error(LOG_LEVEL_ERROR, "Insufficient memory, header crunched without replacement."); return JB_ERR_MEMORY; } - if(LOG_LEVEL_HEADER & debug) /* Save cycles if the user isn't interested. */ - { - days = rtime / (3600 * 24); - hours = rtime / 3600 % 24; - minutes = rtime / 60 % 60; - seconds = rtime % 60; - - log_error(LOG_LEVEL_HEADER, "Randomized: %s (added %d da%s %d hou%s %d minut%s %d second%s", - *header, days, (days == 1) ? "y" : "ys", hours, (hours == 1) ? "r" : "rs", - minutes, (minutes == 1) ? "e" : "es", seconds, (seconds == 1) ? ")" : "s)"); - } + days = rtime / (3600 * 24); + hours = rtime / 3600 % 24; + minutes = rtime / 60 % 60; + seconds = rtime % 60; + + log_error(LOG_LEVEL_HEADER, + "Randomized: %s (added %d da%s %d hou%s %d minut%s %d second%s", + *header, days, (days == 1) ? "y" : "ys", hours, (hours == 1) ? "r" : "rs", + minutes, (minutes == 1) ? "e" : "es", seconds, (seconds == 1) ? ")" : "s)"); } else { @@ -2567,7 +3105,7 @@ jb_err server_last_modified(struct client_state *csp, char **header) * JB_ERR_MEMORY on out-of-memory error. * *********************************************************************/ -jb_err client_accept_encoding(struct client_state *csp, char **header) +static jb_err client_accept_encoding(struct client_state *csp, char **header) { if ((csp->action->flags & ACTION_NO_COMPRESSION) != 0) { @@ -2612,7 +3150,7 @@ jb_err client_accept_encoding(struct client_state *csp, char **header) * JB_ERR_MEMORY on out-of-memory error. * *********************************************************************/ -jb_err client_te(struct client_state *csp, char **header) +static jb_err client_te(struct client_state *csp, char **header) { if ((csp->action->flags & ACTION_NO_COMPRESSION) != 0) { @@ -2623,6 +3161,7 @@ jb_err client_te(struct client_state *csp, char **header) return JB_ERR_OK; } + /********************************************************************* * * Function : client_referrer @@ -2641,115 +3180,67 @@ jb_err client_te(struct client_state *csp, char **header) * JB_ERR_MEMORY on out-of-memory error. * *********************************************************************/ -jb_err client_referrer(struct client_state *csp, char **header) +static jb_err client_referrer(struct client_state *csp, char **header) { - const char *newval; - const char *host; - char *referer; - size_t hostlenght; + const char *parameter; + /* 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 + /* + * Since the referrer can include the prefix even * if the request itself is non-forced, we must - * clean it unconditionally + * clean it unconditionally. + * + * XXX: strclean is too broad */ strclean(*header, FORCE_PREFIX); #endif /* def FEATURE_FORCE_LOAD */ - /* - * Are we sending referer? - */ if ((csp->action->flags & ACTION_HIDE_REFERER) == 0) { + /* Nothing left to do */ return JB_ERR_OK; } - newval = csp->action->string[ACTION_STRING_REFERER]; + parameter = csp->action->string[ACTION_STRING_REFERER]; + assert(parameter != NULL); + parameter_conditional_block = (0 == strcmpic(parameter, "conditional-block")); + parameter_conditional_forge = (0 == strcmpic(parameter, "conditional-forge")); - if ((0 != strcmpic(newval, "conditional-block"))) - { - freez(*header); - } - if ((newval == NULL) || (0 == strcmpic(newval, "block")) ) + if (!parameter_conditional_block && !parameter_conditional_forge) { /* - * Blocking referer + * As conditional-block and conditional-forge are the only + * parameters that rely on the original referrer, we can + * remove it now for all the others. */ + freez(*header); + } + + if (0 == strcmpic(parameter, "block")) + { log_error(LOG_LEVEL_HEADER, "Referer crunched!"); return JB_ERR_OK; } - else if (0 == strcmpic(newval, "conditional-block")) + else if (parameter_conditional_block || parameter_conditional_forge) { - /* - * Block referer if host has changed. - */ - - if (NULL == (host = strdup(csp->http->hostport))) - { - freez(*header); - log_error(LOG_LEVEL_HEADER, "Referer crunched! Couldn't allocate memory for temporary host copy."); - return JB_ERR_MEMORY; - } - if (NULL == (referer = strdup(*header))) - { - freez(*header); - freez(host); - log_error(LOG_LEVEL_HEADER, "Referer crunched! Couldn't allocate memory for temporary referer copy."); - return JB_ERR_MEMORY; - } - hostlenght = strlen(host); - if ( hostlenght < (strlen(referer)-17) ) /*referer begins with 'Referer: http[s]://'*/ - { - /*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'; - } - if ( 0 == strstr(referer, host)) /*Host has changed*/ - { - log_error(LOG_LEVEL_HEADER, "New host is: %s. Crunching %s!", host, *header); - freez(*header); - } - else - { - log_error(LOG_LEVEL_HEADER, "%s (not modified, still on %s)", *header, host); - } - freez(referer); - freez(host); - return JB_ERR_OK; + return handle_conditional_hide_referrer_parameter(header, + csp->http->hostport, parameter_conditional_block); } - else if (0 != strcmpic(newval, "forge")) + else if (0 == strcmpic(parameter, "forge")) { - /* - * We have a specific (fixed) referer we want to send. - */ - if ((0 != strncmpic(newval, "http://", 7)) && (0 != strncmpic(newval, "https://", 8))) - { - log_error(LOG_LEVEL_HEADER, "Parameter: +referrer{%s} is a bad idea, but I don't care.", newval); - } - *header = strdup("Referer: "); - string_append(header, newval); - log_error(LOG_LEVEL_HEADER, "Referer overwritten with: %s", *header); - - return (*header == NULL) ? JB_ERR_MEMORY : JB_ERR_OK; + return create_forged_referrer(header, csp->http->hostport); } else { - /* - * Forge a referer as http://[hostname:port of REQUEST]/ - * to fool stupid checks for in-site links - */ - - *header = strdup("Referer: http://"); - string_append(header, csp->http->hostport); - string_append(header, "/"); - log_error(LOG_LEVEL_HEADER, "Referer forged to: %s", *header); - - return (*header == NULL) ? JB_ERR_MEMORY : JB_ERR_OK; + /* interpret parameter as user-supplied referer to fake */ + return create_fake_referrer(header, parameter); } } + /********************************************************************* * * Function : client_accept_language @@ -2768,7 +3259,7 @@ jb_err client_referrer(struct client_state *csp, char **header) * JB_ERR_MEMORY on out-of-memory error. * *********************************************************************/ -jb_err client_accept_language(struct client_state *csp, char **header) +static jb_err client_accept_language(struct client_state *csp, char **header) { const char *newval; @@ -2804,7 +3295,7 @@ jb_err client_accept_language(struct client_state *csp, char **header) if (*header == NULL) { log_error(LOG_LEVEL_ERROR, - "Insufficent memory. Accept-Language header crunched without replacement."); + "Insufficient memory. Accept-Language header crunched without replacement."); } else { @@ -2815,6 +3306,7 @@ jb_err client_accept_language(struct client_state *csp, char **header) return (*header == NULL) ? JB_ERR_MEMORY : JB_ERR_OK; } + /********************************************************************* * * Function : crunch_client_header @@ -2832,7 +3324,7 @@ jb_err client_accept_language(struct client_state *csp, char **header) * Returns : JB_ERR_OK on success and always succeeds * *********************************************************************/ -jb_err crunch_client_header(struct client_state *csp, char **header) +static jb_err crunch_client_header(struct client_state *csp, char **header) { const char *crunch_pattern; @@ -2871,7 +3363,7 @@ jb_err crunch_client_header(struct client_state *csp, char **header) * JB_ERR_MEMORY on out-of-memory error. * *********************************************************************/ -jb_err client_uagent(struct client_state *csp, char **header) +static jb_err client_uagent(struct client_state *csp, char **header) { const char *newval; @@ -2895,6 +3387,7 @@ jb_err client_uagent(struct client_state *csp, char **header) return (*header == NULL) ? JB_ERR_MEMORY : JB_ERR_OK; } + /********************************************************************* * * Function : client_ua @@ -2912,7 +3405,7 @@ jb_err client_uagent(struct client_state *csp, char **header) * JB_ERR_MEMORY on out-of-memory error. * *********************************************************************/ -jb_err client_ua(struct client_state *csp, char **header) +static jb_err client_ua(struct client_state *csp, char **header) { if ((csp->action->flags & ACTION_HIDE_USER_AGENT) != 0) { @@ -2942,7 +3435,7 @@ jb_err client_ua(struct client_state *csp, char **header) * JB_ERR_MEMORY on out-of-memory error. * *********************************************************************/ -jb_err client_from(struct client_state *csp, char **header) +static jb_err client_from(struct client_state *csp, char **header) { const char *newval; @@ -2993,7 +3486,7 @@ jb_err client_from(struct client_state *csp, char **header) * JB_ERR_MEMORY on out-of-memory error. * *********************************************************************/ -jb_err client_send_cookie(struct client_state *csp, char **header) +static jb_err client_send_cookie(struct client_state *csp, char **header) { if (csp->action->flags & ACTION_NO_COOKIE_READ) { @@ -3025,22 +3518,33 @@ jb_err client_send_cookie(struct client_state *csp, char **header) *********************************************************************/ jb_err client_x_forwarded(struct client_state *csp, char **header) { - if ((csp->action->flags & ACTION_HIDE_FORWARDED) == 0) + if (0 != (csp->action->flags & ACTION_CHANGE_X_FORWARDED_FOR)) { - /* Save it so we can re-add it later */ - freez(csp->x_forwarded); - csp->x_forwarded = *header; + const char *parameter = csp->action->string[ACTION_STRING_CHANGE_X_FORWARDED_FOR]; - /* - * Always set *header = NULL, since this information - * will be sent at the end of the header. - */ - *header = NULL; - } - else - { - freez(*header); - log_error(LOG_LEVEL_HEADER, "crunched x-forwarded-for!"); + if (0 == strcmpic(parameter, "block")) + { + freez(*header); + log_error(LOG_LEVEL_HEADER, "crunched x-forwarded-for!"); + } + else if (0 == strcmpic(parameter, "add")) + { + string_append(header, ", "); + string_append(header, csp->ip_addr_str); + + if (*header == NULL) + { + return JB_ERR_MEMORY; + } + log_error(LOG_LEVEL_HEADER, + "Appended client IP address to %s", *header); + csp->flags |= CSP_FLAG_X_FORWARDED_FOR_APPENDED; + } + else + { + log_error(LOG_LEVEL_FATAL, + "Invalid change-x-forwarded-for parameter: '%s'", parameter); + } } return JB_ERR_OK; @@ -3065,7 +3569,7 @@ jb_err client_x_forwarded(struct client_state *csp, char **header) * JB_ERR_MEMORY on out-of-memory error. * *********************************************************************/ -jb_err client_max_forwards(struct client_state *csp, char **header) +static jb_err client_max_forwards(struct client_state *csp, char **header) { int max_forwards; @@ -3073,12 +3577,13 @@ jb_err client_max_forwards(struct client_state *csp, char **header) (0 == strcmpic(csp->http->gpc, "options"))) { assert(*(*header+12) == ':'); - if (1 == sscanf(*header+12, ": %u", &max_forwards)) + if (1 == sscanf(*header+12, ": %d", &max_forwards)) { if (max_forwards > 0) { - snprintf(*header, strlen(*header)+1, "Max-Forwards: %u", --max_forwards); - log_error(LOG_LEVEL_HEADER, "Max-Forwards value for %s request reduced to %u.", + snprintf(*header, strlen(*header)+1, "Max-Forwards: %d", --max_forwards); + log_error(LOG_LEVEL_HEADER, + "Max-Forwards value for %s request reduced to %d.", csp->http->gpc, max_forwards); } else if (max_forwards < 0) @@ -3086,17 +3591,6 @@ jb_err client_max_forwards(struct client_state *csp, char **header) log_error(LOG_LEVEL_ERROR, "Crunching invalid header: %s", *header); freez(*header); } - else - { - /* - * Not supposed to be reached. direct_response() which - * was already called earlier in chat() should have - * intercepted the request. - */ - log_error(LOG_LEVEL_ERROR, - "Non-intercepted %s request with Max-Forwards zero!", csp->http->gpc); - assert(max_forwards != 0); - } } else { @@ -3131,7 +3625,7 @@ jb_err client_max_forwards(struct client_state *csp, char **header) * JB_ERR_MEMORY on out-of-memory error. * *********************************************************************/ -jb_err client_host(struct client_state *csp, char **header) +static jb_err client_host(struct client_state *csp, char **header) { char *p, *q; @@ -3188,6 +3682,7 @@ jb_err client_host(struct client_state *csp, char **header) return JB_ERR_OK; } + /********************************************************************* * * Function : client_if_modified_since @@ -3205,7 +3700,7 @@ jb_err client_host(struct client_state *csp, char **header) * JB_ERR_MEMORY on out-of-memory error. * *********************************************************************/ -jb_err client_if_modified_since(struct client_state *csp, char **header) +static jb_err client_if_modified_since(struct client_state *csp, char **header) { char newheader[50]; #ifdef HAVE_GMTIME_R @@ -3252,11 +3747,11 @@ jb_err client_if_modified_since(struct client_state *csp, char **header) else { rtime = strtol(newval, &endptr, 0); - if(rtime) + if (rtime) { log_error(LOG_LEVEL_HEADER, "Randomizing: %s (random range: %d minut%s)", *header, rtime, (rtime == 1 || rtime == -1) ? "e": "es"); - if(rtime < 0) + if (rtime < 0) { rtime *= -1; negative = 1; @@ -3273,9 +3768,9 @@ jb_err client_if_modified_since(struct client_state *csp, char **header) #ifdef HAVE_GMTIME_R timeptr = gmtime_r(&tm, &gmt); #elif FEATURE_PTHREAD - pthread_mutex_lock(&gmtime_mutex); + privoxy_mutex_lock(&gmtime_mutex); timeptr = gmtime(&tm); - pthread_mutex_unlock(&gmtime_mutex); + privoxy_mutex_unlock(&gmtime_mutex); #else timeptr = gmtime(&tm); #endif @@ -3287,20 +3782,19 @@ jb_err client_if_modified_since(struct client_state *csp, char **header) if (*header == NULL) { - log_error(LOG_LEVEL_HEADER, "Insufficent memory, header crunched without replacement."); + log_error(LOG_LEVEL_HEADER, "Insufficient memory, header crunched without replacement."); return JB_ERR_MEMORY; } - if(LOG_LEVEL_HEADER & debug) /* Save cycles if the user isn't interested. */ - { - hours = rtime / 3600; - minutes = rtime / 60 % 60; - seconds = rtime % 60; + hours = rtime / 3600; + minutes = rtime / 60 % 60; + seconds = rtime % 60; - log_error(LOG_LEVEL_HEADER, "Randomized: %s (%s %d hou%s %d minut%s %d second%s", - *header, (negative) ? "subtracted" : "added", hours, (hours == 1) ? "r" : "rs", - minutes, (minutes == 1) ? "e" : "es", seconds, (seconds == 1) ? ")" : "s)"); - } + log_error(LOG_LEVEL_HEADER, + "Randomized: %s (%s %d hou%s %d minut%s %d second%s", + *header, (negative) ? "subtracted" : "added", hours, + (hours == 1) ? "r" : "rs", minutes, (minutes == 1) ? "e" : "es", + seconds, (seconds == 1) ? ")" : "s)"); } } } @@ -3308,6 +3802,7 @@ jb_err client_if_modified_since(struct client_state *csp, char **header) return JB_ERR_OK; } + /********************************************************************* * * Function : client_if_none_match @@ -3325,7 +3820,7 @@ jb_err client_if_modified_since(struct client_state *csp, char **header) * JB_ERR_MEMORY on out-of-memory error. * *********************************************************************/ -jb_err client_if_none_match(struct client_state *csp, char **header) +static jb_err client_if_none_match(struct client_state *csp, char **header) { if (csp->action->flags & ACTION_CRUNCH_IF_NONE_MATCH) { @@ -3336,6 +3831,7 @@ jb_err client_if_none_match(struct client_state *csp, char **header) return JB_ERR_OK; } + /********************************************************************* * * Function : client_x_filter @@ -3370,9 +3866,8 @@ jb_err client_x_filter(struct client_state *csp, char **header) } else { - csp->content_type = CT_TABOO; - csp->action->flags &= ~ACTION_FILTER_SERVER_HEADERS; - csp->action->flags &= ~ACTION_FILTER_CLIENT_HEADERS; + 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."); } log_error(LOG_LEVEL_HEADER, "Crunching %s", *header); @@ -3382,6 +3877,40 @@ jb_err client_x_filter(struct client_state *csp, char **header) 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. + * + * 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 client_range(struct client_state *csp, char **header) +{ + if (content_filters_enabled(csp->action)) + { + log_error(LOG_LEVEL_HEADER, "Content filtering is enabled." + " Crunching: \'%s\' to prevent range-mismatch problems.", *header); + freez(*header); + } + + return JB_ERR_OK; +} + /* the following functions add headers directly to the header list */ /********************************************************************* @@ -3398,7 +3927,7 @@ jb_err client_x_filter(struct client_state *csp, char **header) * JB_ERR_MEMORY on out-of-memory error. * *********************************************************************/ -jb_err client_host_adder(struct client_state *csp) +static jb_err client_host_adder(struct client_state *csp) { char *p; jb_err err; @@ -3436,57 +3965,7 @@ jb_err client_host_adder(struct client_state *csp) } -/********************************************************************* - * - * Function : client_cookie_adder - * - * Description : Used in the add_client_headers list to add "wafers". - * Called from `sed'. - * - * Parameters : - * 1 : csp = Current client state (buffers, headers, etc...) - * - * Returns : JB_ERR_OK on success, or - * JB_ERR_MEMORY on out-of-memory error. - * - *********************************************************************/ -jb_err client_cookie_adder(struct client_state *csp) -{ - char *tmp; - struct list_entry *wafer; - struct list_entry *wafer_list = csp->action->multi[ACTION_MULTI_WAFER]->first; - jb_err err; - - if (NULL == wafer_list) - { - /* Nothing to do */ - return JB_ERR_OK; - } - - tmp = strdup("Cookie: "); - - for (wafer = wafer_list; (NULL != tmp) && (NULL != wafer); wafer = wafer->next) - { - if (wafer != wafer_list) - { - /* As this isn't the first wafer, we need a delimiter. */ - string_append(&tmp, "; "); - } - string_join(&tmp, cookie_encode(wafer->str)); - } - - if (tmp == NULL) - { - return JB_ERR_MEMORY; - } - - log_error(LOG_LEVEL_HEADER, "addh: %s", tmp); - err = enlist(csp->headers, tmp); - free(tmp); - return err; -} - - +#if 0 /********************************************************************* * * Function : client_accept_encoding_adder @@ -3503,10 +3982,8 @@ jb_err client_cookie_adder(struct client_state *csp) * JB_ERR_MEMORY on out-of-memory error. * *********************************************************************/ -jb_err client_accept_encoding_adder(struct client_state *csp) +static jb_err client_accept_encoding_adder(struct client_state *csp) { - assert(0); /* Not in use */ - if ( ((csp->action->flags & ACTION_NO_COMPRESSION) != 0) && (!strcmpic(csp->http->ver, "HTTP/1.1")) ) { @@ -3515,6 +3992,7 @@ jb_err client_accept_encoding_adder(struct client_state *csp) return JB_ERR_OK; } +#endif /********************************************************************* @@ -3530,7 +4008,7 @@ jb_err client_accept_encoding_adder(struct client_state *csp) * JB_ERR_MEMORY on out-of-memory error. * *********************************************************************/ -jb_err client_xtra_adder(struct client_state *csp) +static jb_err client_xtra_adder(struct client_state *csp) { struct list_entry *lst; jb_err err; @@ -3553,7 +4031,7 @@ jb_err client_xtra_adder(struct client_state *csp) /********************************************************************* * - * Function : client_x_forwarded_adder + * Function : client_x_forwarded_for_adder * * Description : Used in the add_client_headers list. Called from `sed'. * @@ -3564,35 +4042,34 @@ jb_err client_xtra_adder(struct client_state *csp) * JB_ERR_MEMORY on out-of-memory error. * *********************************************************************/ -jb_err client_x_forwarded_adder(struct client_state *csp) +static jb_err client_x_forwarded_for_adder(struct client_state *csp) { - char *p = NULL; + char *header = NULL; jb_err err; - if ((csp->action->flags & ACTION_HIDE_FORWARDED) != 0) + if (!((csp->action->flags & ACTION_CHANGE_X_FORWARDED_FOR) + && (0 == strcmpic(csp->action->string[ACTION_STRING_CHANGE_X_FORWARDED_FOR], "add"))) + || (csp->flags & CSP_FLAG_X_FORWARDED_FOR_APPENDED)) { + /* + * If we aren't adding X-Forwarded-For headers, + * or we already appended an existing X-Forwarded-For + * header, there's nothing left to do here. + */ return JB_ERR_OK; } - if (csp->x_forwarded) - { - p = strdup(csp->x_forwarded); - string_append(&p, ", "); - } - else - { - p = strdup("X-Forwarded-For: "); - } - string_append(&p, csp->ip_addr_str); + header = strdup("X-Forwarded-For: "); + string_append(&header, csp->ip_addr_str); - if (p == NULL) + if (header == NULL) { return JB_ERR_MEMORY; } - log_error(LOG_LEVEL_HEADER, "addh: %s", p); - err = enlist(csp->headers, p); - free(p); + log_error(LOG_LEVEL_HEADER, "addh: %s", header); + err = enlist(csp->headers, header); + freez(header); return err; } @@ -3600,7 +4077,7 @@ jb_err client_x_forwarded_adder(struct client_state *csp) /********************************************************************* * - * Function : connection_close_adder + * Function : server_connection_close_adder * * Description : "Temporary" fix for the needed but missing HTTP/1.1 * support. Adds a "Connection: close" header to csp->headers @@ -3615,25 +4092,28 @@ jb_err client_x_forwarded_adder(struct client_state *csp) * JB_ERR_MEMORY on out-of-memory error. * *********************************************************************/ -jb_err connection_close_adder(struct client_state *csp) +static jb_err server_connection_close_adder(struct client_state *csp) { const unsigned int flags = csp->flags; + const char *response_status_line = csp->headers->first->str; + + if ((flags & CSP_FLAG_CLIENT_HEADER_PARSING_DONE) + && (flags & CSP_FLAG_SERVER_CONNECTION_CLOSE_SET)) + { + return JB_ERR_OK; + } /* - * Return right away if - * - * - we're parsing server headers and the server header - * "Connection: close" is already set, or if - * - * - we're parsing client headers and the client header - * "Connection: close" is already set. + * XXX: if we downgraded the response, this check will fail. */ - if ((flags & CSP_FLAG_CLIENT_HEADER_PARSING_DONE - && flags & CSP_FLAG_SERVER_CONNECTION_CLOSE_SET) - ||(!(flags & CSP_FLAG_CLIENT_HEADER_PARSING_DONE) - && flags & CSP_FLAG_CLIENT_CONNECTION_CLOSE_SET)) + if ((csp->config->feature_flags & + RUNTIME_FEATURE_CONNECTION_KEEP_ALIVE) + && (NULL != response_status_line) + && !strncmpic(response_status_line, "HTTP/1.1", 8)) { - return JB_ERR_OK; + log_error(LOG_LEVEL_HEADER, "A HTTP/1.1 response " + "without Connection header implies keep-alive."); + csp->flags |= CSP_FLAG_SERVER_CONNECTION_KEEP_ALIVE; } log_error(LOG_LEVEL_HEADER, "Adding: Connection: close"); @@ -3642,6 +4122,37 @@ jb_err connection_close_adder(struct client_state *csp) } +/********************************************************************* + * + * Function : client_connection_header_adder + * + * Description : Adds a proper "Connection:" header to csp->headers + * unless the header was already present. Called from `sed'. + * + * 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_connection_header_adder(struct client_state *csp) +{ + const unsigned int flags = csp->flags; + const char *wanted_header = get_appropiate_connection_header(csp); + + if (!(flags & CSP_FLAG_CLIENT_HEADER_PARSING_DONE) + && (flags & CSP_FLAG_CLIENT_CONNECTION_HEADER_SET)) + { + return JB_ERR_OK; + } + + log_error(LOG_LEVEL_HEADER, "Adding: %s", wanted_header); + + return enlist(csp->headers, wanted_header); +} + + /********************************************************************* * * Function : server_http @@ -3663,7 +4174,7 @@ jb_err connection_close_adder(struct client_state *csp) * JB_ERR_MEMORY on out-of-memory error. * *********************************************************************/ -jb_err server_http(struct client_state *csp, char **header) +static jb_err server_http(struct client_state *csp, char **header) { sscanf(*header, "HTTP/%*d.%*d %d", &(csp->http->status)); if (csp->http->status == 206) @@ -3673,8 +4184,21 @@ jb_err server_http(struct client_state *csp, char **header) if ((csp->action->flags & ACTION_DOWNGRADE) != 0) { - (*header)[7] = '0'; - log_error(LOG_LEVEL_HEADER, "Downgraded answer to HTTP/1.0"); + /* XXX: Should we do a real validity check here? */ + if (strlen(*header) > 8) + { + (*header)[7] = '0'; + log_error(LOG_LEVEL_HEADER, "Downgraded answer to HTTP/1.0"); + } + else + { + /* + * XXX: Should we block the request or + * enlist a valid status code line here? + */ + log_error(LOG_LEVEL_INFO, "Malformed server response detected. " + "Downgrading to HTTP/1.0 impossible."); + } } return JB_ERR_OK; @@ -3705,39 +4229,12 @@ jb_err server_http(struct client_state *csp, char **header) * JB_ERR_MEMORY on out-of-memory error. * *********************************************************************/ -jb_err server_set_cookie(struct client_state *csp, char **header) +static jb_err server_set_cookie(struct client_state *csp, char **header) { time_t now; time_t cookie_time; - struct tm tm_now; - time(&now); -#ifdef FEATURE_COOKIE_JAR - if (csp->config->jar) - { - /* - * Write timestamp into outbuf. - * - * Complex because not all OSs have tm_gmtoff or - * the %z field in strftime() - */ - char tempbuf[ BUFFER_SIZE ]; - -#ifdef HAVE_LOCALTIME_R - tm_now = *localtime_r(&now, &tm_now); -#elif FEATURE_PTHREAD - pthread_mutex_lock(&localtime_mutex); - tm_now = *localtime (&now); - pthread_mutex_unlock(&localtime_mutex); -#else - tm_now = *localtime (&now); -#endif - strftime(tempbuf, BUFFER_SIZE-6, "%b %d %H:%M:%S ", &tm_now); - - /* strlen("set-cookie: ") = 12 */ - fprintf(csp->config->jar, "%s %s\t%s\n", tempbuf, csp->http->host, *header + 12); - } -#endif /* def FEATURE_COOKIE_JAR */ + time(&now); if ((csp->action->flags & ACTION_NO_COOKIE_SET) != 0) { @@ -3802,7 +4299,7 @@ jb_err server_set_cookie(struct client_state *csp, char **header) */ log_error(LOG_LEVEL_ERROR, "Can't parse \'%s\', send by %s. Unsupported time format?", cur_tag, csp->http->url); - memmove(cur_tag, next_tag, strlen(next_tag) + 1); + string_move(cur_tag, next_tag); changed = 1; } else @@ -3853,12 +4350,8 @@ jb_err server_set_cookie(struct client_state *csp, char **header) /* * Still valid, delete expiration date by copying * the rest of the string over it. - * - * (Note that we cannot just use "strcpy(cur_tag, next_tag)", - * since the behaviour of strcpy is undefined for overlapping - * strings.) */ - memmove(cur_tag, next_tag, strlen(next_tag) + 1); + string_move(cur_tag, next_tag); /* That changed the header, need to issue a log message */ changed = 1; @@ -3905,7 +4398,7 @@ jb_err server_set_cookie(struct client_state *csp, char **header) * Returns : Number of eliminations * *********************************************************************/ -int strclean(const char *string, const char *substring) +int strclean(char *string, const char *substring) { int hits = 0; size_t len; @@ -3929,6 +4422,7 @@ int strclean(const char *string, const char *substring) } #endif /* def FEATURE_FORCE_LOAD */ + /********************************************************************* * * Function : parse_header_time @@ -3944,7 +4438,7 @@ int strclean(const char *string, const char *substring) * JB_ERR_PARSE otherwise. * *********************************************************************/ -jb_err parse_header_time(const char *header_time, time_t *result) +static jb_err parse_header_time(const char *header_time, time_t *result) { struct tm gmt; @@ -3978,6 +4472,7 @@ jb_err parse_header_time(const char *header_time, time_t *result) } + /********************************************************************* * * Function : get_destination_from_headers @@ -4060,6 +4555,171 @@ jb_err get_destination_from_headers(const struct list *headers, struct http_requ } +/********************************************************************* + * + * 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 + * + * Parameters : + * 1 : header = Pointer to header pointer + * 2 : hostport = Host and optionally port as string + * + * Returns : JB_ERR_OK in case of success, or + * JB_ERR_MEMORY in case of memory problems. + * + *********************************************************************/ +static jb_err create_forged_referrer(char **header, const char *hostport) +{ + assert(NULL == *header); + + *header = strdup("Referer: http://"); + string_append(header, hostport); + string_append(header, "/"); + + if (NULL == *header) + { + return JB_ERR_MEMORY; + } + + log_error(LOG_LEVEL_HEADER, "Referer forged to: %s", *header); + + return JB_ERR_OK; + +} + + +/********************************************************************* + * + * Function : create_fake_referrer + * + * Description : Helper for client_referrer to create a fake referrer + * based on a string supplied by the user. + * + * Parameters : + * 1 : header = Pointer to header pointer + * 2 : hosthost = Referrer to fake + * + * Returns : JB_ERR_OK in case of success, or + * JB_ERR_MEMORY in case of memory problems. + * + *********************************************************************/ +static jb_err create_fake_referrer(char **header, const char *fake_referrer) +{ + assert(NULL == *header); + + if ((0 != strncmpic(fake_referrer, "http://", 7)) && (0 != strncmpic(fake_referrer, "https://", 8))) + { + log_error(LOG_LEVEL_HEADER, + "Parameter: +hide-referrer{%s} is a bad idea, but I don't care.", fake_referrer); + } + *header = strdup("Referer: "); + string_append(header, fake_referrer); + + if (NULL == *header) + { + return JB_ERR_MEMORY; + } + + log_error(LOG_LEVEL_HEADER, "Referer replaced with: %s", *header); + + return JB_ERR_OK; + +} + + +/********************************************************************* + * + * Function : handle_conditional_hide_referrer_parameter + * + * Description : Helper for client_referrer to crunch or forge + * the referrer header if the host has changed. + * + * Parameters : + * 1 : header = Pointer to header pointer + * 2 : host = The target host (may include the port) + * 3 : parameter_conditional_block = Boolean to signal + * if we're in conditional-block mode. If not set, + * we're in conditional-forge mode. + * + * Returns : JB_ERR_OK in case of success, or + * JB_ERR_MEMORY in case of memory problems. + * + *********************************************************************/ +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); + 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)) + { + /* + * 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_url = strstr(referer, "http://"); + if ((NULL == referer_url) || (NULL == strstr(referer_url, host))) + { + /* Host has changed, Referer is invalid or a https URL. */ + if (parameter_conditional_block) + { + log_error(LOG_LEVEL_HEADER, "New host is: %s. Crunching %s!", host, *header); + freez(*header); + } + else + { + freez(*header); + freez(referer); + return create_forged_referrer(header, host); + } + } + freez(referer); + + return JB_ERR_OK; + +} + + +/********************************************************************* + * + * Function : get_appropiate_connection_header + * + * Description : Returns an appropiate Connection header + * depending on whether or not we try to keep + * the connection to the server alive. + * + * Parameters : + * 1 : csp = Current client state (buffers, headers, etc...) + * + * Returns : Pointer to statically allocated header buffer. + * + *********************************************************************/ +static const char *get_appropiate_connection_header(const struct client_state *csp) +{ + 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) + && (csp->http->ssl == 0)) + { + return connection_keep_alive; + } + return connection_close; +} /* Local Variables: tab-width: 3