X-Git-Url: http://www.privoxy.org/gitweb/?p=privoxy.git;a=blobdiff_plain;f=parsers.c;h=cfe9307fd30a43e653c88b51102d925e2618e394;hp=026f367e877ea8c983d655e1cc1dadf728de2eea;hb=1bd4869ad6285c7d6d1825e0b395c32a132f5499;hpb=b4be68402b1179b8c27c84221c20a265b53d2548 diff --git a/parsers.c b/parsers.c index 026f367e..cfe9307f 100644 --- a/parsers.c +++ b/parsers.c @@ -1,4 +1,4 @@ -const char parsers_rcs[] = "$Id: parsers.c,v 1.111 2007/10/04 18:07:00 fabiankeil Exp $"; +const char parsers_rcs[] = "$Id: parsers.c,v 1.153 2009/03/07 13:09:17 fabiankeil Exp $"; /********************************************************************* * * File : $Source: /cvsroot/ijbswa/current/parsers.c,v $ @@ -17,7 +17,7 @@ const char parsers_rcs[] = "$Id: parsers.c,v 1.111 2007/10/04 18:07:00 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,177 @@ const char parsers_rcs[] = "$Id: parsers.c,v 1.111 2007/10/04 18:07:00 fabiankei * * Revisions : * $Log: parsers.c,v $ + * Revision 1.153 2009/03/07 13:09:17 fabiankeil + * Change csp->expected_content and_csp->expected_content_length from + * size_t to unsigned long long to reduce the likelihood of integer + * overflows that would let us close the connection prematurely. + * Bug found while investigating #2669131, reported by cyberpatrol. + * + * Revision 1.152 2009/03/01 18:43:48 fabiankeil + * Help clang understand that we aren't dereferencing + * NULL pointers here. + * + * 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 @@ -747,7 +918,6 @@ const char parsers_rcs[] = "$Id: parsers.c,v 1.111 2007/10/04 18:07:00 fabiankei #endif /* def FEATURE_PTHREAD */ #include "list.h" #include "parsers.h" -#include "encode.h" #include "ssplit.h" #include "errlog.h" #include "jbsockets.h" @@ -775,13 +945,14 @@ 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)) +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 connection (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); @@ -799,8 +970,9 @@ 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_content_length (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); @@ -809,18 +981,38 @@ 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_cookie_adder (struct client_state *csp); static jb_err client_xtra_adder (struct client_state *csp); -static jb_err client_x_forwarded_adder(struct client_state *csp); -static jb_err connection_close_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 }, @@ -832,12 +1024,13 @@ 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 }, @@ -845,56 +1038,39 @@ const struct parsers client_patterns[] = { { NULL, 0, NULL } }; -const struct parsers server_patterns[] = { +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 } + { 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 } -}; - -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 }; -/* The vanilla wafer. */ -static const char VANILLA_WAFER[] = - "NOTICE=TO_WHOM_IT_MAY_CONCERN_" - "Do_not_send_me_any_copyrighted_information_other_than_the_" - "document_that_I_am_requesting_or_any_of_its_necessary_components._" - "In_particular_do_not_send_me_any_cookies_that_" - "are_subject_to_a_claim_of_copyright_by_anybody._" - "Take_notice_that_I_refuse_to_be_bound_by_any_license_condition_" - "(copyright_or_otherwise)_applying_to_any_cookie._"; - /********************************************************************* * * Function : flush_socket @@ -903,7 +1079,7 @@ static const char VANILLA_WAFER[] = * * 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, @@ -913,10 +1089,9 @@ static const char VANILLA_WAFER[] = * file, the results are not portable. * *********************************************************************/ -int flush_socket(jb_socket fd, struct client_state *csp) +long flush_socket(jb_socket fd, struct iob *iob) { - struct iob *iob = csp->iob; - int len = iob->eod - iob->cur; + long len = iob->eod - iob->cur; if (len <= 0) { @@ -949,7 +1124,7 @@ int flush_socket(jb_socket fd, struct client_state *csp) * or buffer limit reached. * *********************************************************************/ -jb_err add_to_iob(struct client_state *csp, char *buf, int n) +jb_err add_to_iob(struct client_state *csp, char *buf, long n) { struct iob *iob = csp->iob; size_t used, offset, need, want; @@ -967,7 +1142,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; } @@ -1048,7 +1225,7 @@ 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, @@ -1303,7 +1480,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; } @@ -1355,7 +1532,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.", @@ -1383,14 +1560,111 @@ 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: * @@ -1400,11 +1674,82 @@ jb_err decompress_iob(struct client_state *csp) * a complete header line. * *********************************************************************/ -char *get_header(struct client_state *csp) +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: + * + * 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. + * + *********************************************************************/ +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)) @@ -1418,8 +1763,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; @@ -1429,10 +1775,10 @@ char *get_header(struct client_state *csp) if (*ret == '\0') { freez(ret); - return(NULL); + return NULL; } - return(ret); + return ret; } @@ -1473,9 +1819,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; } } } @@ -1529,79 +1875,106 @@ static jb_err scan_headers(struct client_state *csp) * As a side effect it frees the space used by the original * header lines. * - * XXX: should be split to remove the first_run hack. - * * 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 : JB_ERR_OK in case off success, or * JB_ERR_MEMORY on out-of-memory error. * *********************************************************************/ -jb_err 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)); } } } @@ -1611,7 +1984,6 @@ jb_err sed(const struct parsers pats[], } - /********************************************************************* * * Function : header_tagger @@ -1670,8 +2042,9 @@ static 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++) @@ -1740,6 +2113,7 @@ static 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)); @@ -1887,8 +2261,9 @@ static 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++) @@ -1988,16 +2363,16 @@ static 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 : @@ -2011,14 +2386,23 @@ static jb_err filter_header(struct client_state *csp, char **header) * JB_ERR_MEMORY on out-of-memory error. * *********************************************************************/ -static 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) { @@ -2028,16 +2412,51 @@ static 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 + /* Signal server_connection_close_adder() to return early. */ + csp->flags |= CSP_FLAG_SERVER_CONNECTION_CLOSE_SET; + + return JB_ERR_OK; +} + +/********************************************************************* + * + * Function : client_connection + * + * 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...) + * 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_connection(struct client_state *csp, char **header) +{ + char *old_header = *header; + const char *wanted_header = get_appropiate_connection_header(csp); + + if (strcmpic(*header, wanted_header)) { - csp->flags |= CSP_FLAG_CLIENT_CONNECTION_CLOSE_SET; + *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; } @@ -2061,6 +2480,7 @@ static jb_err connection(struct client_state *csp, char **header) *********************************************************************/ 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; @@ -2153,39 +2573,40 @@ static jb_err server_content_type(struct client_state *csp, char **header) 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; - } } /* * 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) || (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; } @@ -2193,10 +2614,11 @@ static 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; } @@ -2354,7 +2776,7 @@ static 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. @@ -2370,7 +2792,7 @@ static jb_err server_content_encoding(struct client_state *csp, char **header) * JB_ERR_MEMORY on out-of-memory error. * *********************************************************************/ -static 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; @@ -2394,6 +2816,46 @@ static 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 long long content_length = 0; + + assert(*(*header+14) == ':'); + + if (1 != sscanf(*header+14, ": %llu", &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 @@ -2428,7 +2890,7 @@ static jb_err server_content_md5(struct client_state *csp, char **header) * * 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 : @@ -2447,17 +2909,17 @@ 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 @@ -2469,19 +2931,16 @@ static 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; @@ -2546,14 +3005,14 @@ static 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 { @@ -2569,9 +3028,9 @@ static 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 @@ -2585,14 +3044,23 @@ static 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 @@ -2603,21 +3071,19 @@ static 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 { @@ -2839,7 +3305,7 @@ static 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 { @@ -3062,22 +3528,33 @@ static 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; @@ -3110,12 +3587,13 @@ static 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) @@ -3123,17 +3601,6 @@ static 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 { @@ -3311,9 +3778,9 @@ static 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 @@ -3325,20 +3792,19 @@ static 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)"); } } } @@ -3426,9 +3892,9 @@ jb_err client_x_filter(struct client_state *csp, char **header) * * Function : client_range * - * Description : Removes 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 + * 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. @@ -3445,9 +3911,7 @@ jb_err client_x_filter(struct client_state *csp, char **header) *********************************************************************/ static jb_err client_range(struct client_state *csp, char **header) { - if (((csp->rlist != NULL) && - (!list_is_empty(csp->action->multi[ACTION_MULTI_FILTER]))) || - (csp->action->flags & (ACTION_DEANIMATE|ACTION_JPEG_INSPECT))) + if (content_filters_enabled(csp->action)) { log_error(LOG_LEVEL_HEADER, "Content filtering is enabled." " Crunching: \'%s\' to prevent range-mismatch problems.", *header); @@ -3511,69 +3975,6 @@ static 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; - jb_err err; - - /* - * If the user has not supplied any wafers, and the user has not - * told us to suppress the vanilla wafer, then send the vanilla wafer. - */ - if ((0 != (csp->action->flags & ACTION_VANILLA_WAFER)) - && list_is_empty(csp->action->multi[ACTION_MULTI_WAFER])) - { - enlist(csp->action->multi[ACTION_MULTI_WAFER], VANILLA_WAFER); - } - - wafer_list = csp->action->multi[ACTION_MULTI_WAFER]->first; - - 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 /********************************************************************* * @@ -3640,7 +4041,7 @@ static 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'. * @@ -3651,35 +4052,34 @@ static jb_err client_xtra_adder(struct client_state *csp) * JB_ERR_MEMORY on out-of-memory error. * *********************************************************************/ -static 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; } @@ -3687,7 +4087,7 @@ static 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 @@ -3702,25 +4102,28 @@ static jb_err client_x_forwarded_adder(struct client_state *csp) * JB_ERR_MEMORY on out-of-memory error. * *********************************************************************/ -static 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"); @@ -3729,6 +4132,37 @@ static 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 @@ -3809,35 +4243,8 @@ 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) { @@ -3902,7 +4309,7 @@ static 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 @@ -3953,12 +4360,8 @@ static 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; @@ -4005,7 +4408,7 @@ static 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; @@ -4260,6 +4663,7 @@ static jb_err handle_conditional_hide_referrer_parameter(char **header, { char *referer = strdup(*header); const size_t hostlenght = strlen(host); + const char *referer_url = NULL; if (NULL == referer) { @@ -4268,7 +4672,7 @@ static jb_err handle_conditional_hide_referrer_parameter(char **header, } /* referer begins with 'Referer: http[s]://' */ - if (hostlenght < (strlen(referer)-17)) + if ((hostlenght+17) < strlen(referer)) { /* * Shorten referer to make sure the referer is blocked @@ -4277,9 +4681,10 @@ static jb_err handle_conditional_hide_referrer_parameter(char **header, */ referer[hostlenght+17] = '\0'; } - if (NULL == strstr(referer, host)) + referer_url = strstr(referer, "http://"); + if ((NULL == referer_url) || (NULL == strstr(referer_url, host))) { - /* Host has changed */ + /* 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); @@ -4298,6 +4703,33 @@ static jb_err handle_conditional_hide_referrer_parameter(char **header, } + +/********************************************************************* + * + * 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