X-Git-Url: http://www.privoxy.org/gitweb/?p=privoxy.git;a=blobdiff_plain;f=parsers.c;h=a76c05157587cf776f51ed6bf24cae8baa08dd09;hp=a1f1f4f215fde44935e33b3f99ef54aaa969d645;hb=8a5751cc96dd085fcbcc34bef77499306bddc0c0;hpb=ab4ae55aa26d51c2820e3e588937df2aeeba2e91 diff --git a/parsers.c b/parsers.c index a1f1f4f2..a76c0515 100644 --- a/parsers.c +++ b/parsers.c @@ -1,4 +1,4 @@ -const char parsers_rcs[] = "$Id: parsers.c,v 1.133 2008/05/21 15:50:47 fabiankeil Exp $"; +const char parsers_rcs[] = "$Id: parsers.c,v 1.155 2009/05/10 10:12:30 fabiankeil Exp $"; /********************************************************************* * * File : $Source: /cvsroot/ijbswa/current/parsers.c,v $ @@ -17,7 +17,7 @@ const char parsers_rcs[] = "$Id: parsers.c,v 1.133 2008/05/21 15:50:47 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-2008 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,95 @@ const char parsers_rcs[] = "$Id: parsers.c,v 1.133 2008/05/21 15:50:47 fabiankei * * Revisions : * $Log: parsers.c,v $ + * Revision 1.155 2009/05/10 10:12:30 fabiankeil + * Initial keep-alive support for the client socket. + * Temporarily disable the server-side-only keep-alive code. + * + * Revision 1.154 2009/03/13 14:10:07 fabiankeil + * Fix some more harmless warnings on amd64. + * + * 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 **). * @@ -869,8 +958,8 @@ 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); @@ -888,8 +977,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); @@ -898,14 +988,25 @@ 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); +static jb_err server_keep_alive(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 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_adder(struct client_state *csp); +#ifdef FEATURE_CONNECTION_KEEP_ALIVE +static jb_err server_proxy_connection_adder(struct client_state *csp); +#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */ 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. @@ -933,8 +1034,10 @@ static const struct parsers client_patterns[] = { { "TE:", 3, client_te }, { "Host:", 5, client_host }, { "if-modified-since:", 18, client_if_modified_since }, +#ifndef FEATURE_CONNECTION_KEEP_ALIVE { "Keep-Alive:", 11, crumble }, - { "connection:", 11, connection }, +#endif + { "connection:", 11, client_connection }, { "proxy-connection:", 17, crumble }, { "max-forwards:", 13, client_max_forwards }, { "Accept-Language:", 16, client_accept_language }, @@ -951,29 +1054,38 @@ static const struct parsers client_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 }, - { "Transfer-Encoding:", 18, server_transfer_coding }, +#ifdef FEATURE_CONNECTION_KEEP_ALIVE + { "Content-Length:", 15, server_save_content_length }, + { "Keep-Alive:", 11, server_keep_alive }, +#else { "Keep-Alive:", 11, crumble }, +#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */ + { "Transfer-Encoding:", 18, server_transfer_coding }, { "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 } }; static const add_header_func_ptr add_client_headers[] = { client_host_adder, + client_x_forwarded_for_adder, client_xtra_adder, /* Temporarily disabled: client_accept_encoding_adder, */ - connection_close_adder, + client_connection_header_adder, NULL }; static const add_header_func_ptr add_server_headers[] = { - connection_close_adder, + server_connection_adder, +#ifdef FEATURE_CONNECTION_KEEP_ALIVE + server_proxy_connection_adder, +#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */ NULL }; @@ -995,9 +1107,9 @@ static const add_header_func_ptr add_server_headers[] = { * file, the results are not portable. * *********************************************************************/ -int flush_socket(jb_socket fd, struct iob *iob) +long flush_socket(jb_socket fd, struct iob *iob) { - int len = iob->eod - iob->cur; + long len = iob->eod - iob->cur; if (len <= 0) { @@ -1030,7 +1142,7 @@ int flush_socket(jb_socket fd, struct iob *iob) * 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; @@ -1048,7 +1160,9 @@ jb_err add_to_iob(struct client_state *csp, char *buf, int n) */ if (need > csp->config->buffer_limit) { - log_error(LOG_LEVEL_INFO, "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; } @@ -1129,7 +1243,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, @@ -1384,7 +1498,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; } @@ -1436,7 +1550,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.", @@ -1669,6 +1783,7 @@ static char *get_header_line(struct iob *iob) /* FIXME No way to handle error properly */ log_error(LOG_LEVEL_FATAL, "Out of memory in get_header_line()"); } + assert(ret != NULL); iob->cur = p+1; @@ -1678,10 +1793,10 @@ static char *get_header_line(struct iob *iob) if (*ret == '\0') { freez(ret); - return(NULL); + return NULL; } - return(ret); + return ret; } @@ -1722,9 +1837,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; } } } @@ -1854,12 +1969,12 @@ 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_content_length }, + { "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 } + { NULL, 0, NULL } }; if (strncmpic(csp->http->cmd, "HEAD", 4)) @@ -1947,7 +2062,7 @@ static jb_err header_tagger(struct client_state *csp, char *header) { log_error(LOG_LEVEL_ERROR, "Inconsistent configuration: " "tagging enabled, but no taggers available."); - return(JB_ERR_OK); + return JB_ERR_OK; } for (i = 0; i < MAX_AF_FILES; i++) @@ -2016,6 +2131,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)); @@ -2165,7 +2281,7 @@ static jb_err filter_header(struct client_state *csp, char **header) { log_error(LOG_LEVEL_ERROR, "Inconsistent configuration: " "header filtering enabled, but no matching filters available."); - return(JB_ERR_OK); + return JB_ERR_OK; } for (i = 0; i < MAX_AF_FILES; i++) @@ -2265,17 +2381,17 @@ 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 - * to do nothing. + * 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...) @@ -2288,14 +2404,24 @@ 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; + } + log_error(LOG_LEVEL_HEADER, + "Keeping the server header '%s' around.", *header); +#else + char *old_header = *header; + *header = strdup("Connection: close"); if (header == NULL) { @@ -2303,20 +2429,126 @@ static jb_err connection(struct client_state *csp, char **header) } log_error(LOG_LEVEL_HEADER, "Replaced: \'%s\' with \'%s\'", old_header, *header); freez(old_header); +#endif /* FEATURE_CONNECTION_KEEP_ALIVE */ } - /* Signal connection_close_adder() to return early. */ - if (csp->flags & CSP_FLAG_CLIENT_HEADER_PARSING_DONE) + /* Signal server_connection_adder() to return early. */ + csp->flags |= CSP_FLAG_SERVER_CONNECTION_HEADER_SET; + + return JB_ERR_OK; +} + + +#ifdef FEATURE_CONNECTION_KEEP_ALIVE +/********************************************************************* + * + * Function : server_keep_alive + * + * Description : Stores the servers keep alive timeout. + * + * Parameters : + * 1 : csp = Current client state (buffers, headers, etc...) + * 2 : header = On input, pointer to header to modify. + * On output, pointer to the modified header, or NULL + * to remove the header. This function frees the + * original string if necessary. + * + * Returns : JB_ERR_OK. + * + *********************************************************************/ +static jb_err server_keep_alive(struct client_state *csp, char **header) +{ + unsigned int keep_alive_timeout; + const char *timeout_position = strstr(*header, "timeout="); + + if ((NULL != timeout_position) + && (1 != sscanf(timeout_position, "timeout=%u", &keep_alive_timeout))) { - csp->flags |= CSP_FLAG_SERVER_CONNECTION_CLOSE_SET; + log_error(LOG_LEVEL_ERROR, "Couldn't parse: %s", *header); } else { - csp->flags |= CSP_FLAG_CLIENT_CONNECTION_CLOSE_SET; + if (keep_alive_timeout < csp->server_connection.keep_alive_timeout) + { + log_error(LOG_LEVEL_HEADER, + "Reducing keep-alive timeout from %u to %u.", + csp->server_connection.keep_alive_timeout, keep_alive_timeout); + csp->server_connection.keep_alive_timeout = keep_alive_timeout; + } + else + { + /* XXX: Is this log worthy? */ + log_error(LOG_LEVEL_HEADER, + "Server keep-alive timeout is %u. Sticking with %u.", + keep_alive_timeout, csp->server_connection.keep_alive_timeout); + } } return JB_ERR_OK; } +#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */ + + + +/********************************************************************* + * + * Function : client_connection + * + * Description : Makes sure a proper "Connection:" header is + * set and signals connection_header_adder + * 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) +{ + const char *wanted_header = get_appropiate_connection_header(csp); + + if (strcmpic(*header, wanted_header)) + { +#ifdef FEATURE_CONNECTION_KEEP_ALIVE + log_error(LOG_LEVEL_HEADER, + "Keeping the client header '%s' around. " + "The connection will not be kept alive.", + *header); +#else + char *old_header = *header; + + *header = strdup(wanted_header); + if (header == NULL) + { + return JB_ERR_MEMORY; + } + log_error(LOG_LEVEL_HEADER, + "Replaced: \'%s\' with \'%s\'", old_header, *header); + freez(old_header); +#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */ + } +#ifdef FEATURE_CONNECTION_KEEP_ALIVE + else + { + log_error(LOG_LEVEL_HEADER, + "Keeping the client header '%s' around. " + "The server connection will be kept alive if possible.", + *header); + csp->flags |= CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE; + } +#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */ + + /* Signal client_connection_adder() to return early. */ + csp->flags |= CSP_FLAG_CLIENT_CONNECTION_HEADER_SET; + + return JB_ERR_OK; +} /********************************************************************* @@ -2338,6 +2570,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; @@ -2633,7 +2866,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. @@ -2649,7 +2882,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; @@ -2673,6 +2906,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 @@ -2829,7 +3102,7 @@ static jb_err server_last_modified(struct client_state *csp, char **header) 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 { @@ -2845,9 +3118,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 @@ -2875,9 +3148,9 @@ static jb_err server_last_modified(struct client_state *csp, char **header) #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 @@ -2888,21 +3161,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 { @@ -3124,7 +3395,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 { @@ -3347,10 +3618,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)) { - freez(*header); - log_error(LOG_LEVEL_HEADER, "crunched x-forwarded-for!"); + const char *parameter = csp->action->string[ACTION_STRING_CHANGE_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; @@ -3383,12 +3677,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) @@ -3573,9 +3868,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 @@ -3587,20 +3882,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)"); } } } @@ -3837,13 +4131,56 @@ static jb_err client_xtra_adder(struct client_state *csp) /********************************************************************* * - * Function : connection_close_adder + * Function : client_x_forwarded_for_adder * - * Description : "Temporary" fix for the needed but missing HTTP/1.1 - * support. Adds a "Connection: close" header to csp->headers - * unless the header was already present. Called from `sed'. + * Description : Used in the add_client_headers list. Called from `sed'. + * + * Parameters : + * 1 : csp = Current client state (buffers, headers, etc...) * - * FIXME: This whole function shouldn't be neccessary! + * Returns : JB_ERR_OK on success, or + * JB_ERR_MEMORY on out-of-memory error. + * + *********************************************************************/ +static jb_err client_x_forwarded_for_adder(struct client_state *csp) +{ + char *header = NULL; + jb_err err; + + 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; + } + + header = strdup("X-Forwarded-For: "); + string_append(&header, csp->ip_addr_str); + + if (header == NULL) + { + return JB_ERR_MEMORY; + } + + log_error(LOG_LEVEL_HEADER, "addh: %s", header); + err = enlist(csp->headers, header); + freez(header); + + return err; +} + + +/********************************************************************* + * + * Function : server_connection_adder + * + * Description : Adds an appropiate "Connection:" header to csp->headers + * unless the header was already present. Called from `sed'. * * Parameters : * 1 : csp = Current client state (buffers, headers, etc...) @@ -3852,30 +4189,89 @@ static jb_err client_xtra_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_adder(struct client_state *csp) { const unsigned int flags = csp->flags; + const char *response_status_line = csp->headers->first->str; + const char *wanted_header = get_appropiate_connection_header(csp); + + if ((flags & CSP_FLAG_CLIENT_HEADER_PARSING_DONE) + && (flags & CSP_FLAG_SERVER_CONNECTION_HEADER_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)) + { + 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: %s", wanted_header); + + return enlist(csp->headers, wanted_header); +} + + +#ifdef FEATURE_CONNECTION_KEEP_ALIVE +/********************************************************************* + * + * Function : server_proxy_connection_adder + * + * Description : Adds a "Proxy-Connection: keep-alive" header to + * csp->headers. XXX: We should reuse existant ones. + * + * 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 server_proxy_connection_adder(struct client_state *csp) +{ + static const char proxy_connection_header[] = "Proxy-Connection: keep-alive"; + log_error(LOG_LEVEL_HEADER, "Adding: %s", proxy_connection_header); + return enlist(csp->headers, proxy_connection_header); +} +#endif /* FEATURE_CONNECTION_KEEP_ALIVE */ + + +/********************************************************************* + * + * 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: Connection: close"); + log_error(LOG_LEVEL_HEADER, "Adding: %s", wanted_header); - return enlist(csp->headers, "Connection: close"); + return enlist(csp->headers, wanted_header); } @@ -3959,35 +4355,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) { @@ -4151,7 +4520,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; @@ -4406,6 +4775,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) { @@ -4414,7 +4784,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 @@ -4423,9 +4793,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); @@ -4444,6 +4815,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