X-Git-Url: http://www.privoxy.org/gitweb/?p=privoxy.git;a=blobdiff_plain;f=jcc.c;h=7eb067ac1c33de1207ce362897a451bba8569cf5;hp=99b72a65d638278bb1907aa805ed778f18c9c4e1;hb=f3a37c457380fc507715cdce112786db4b97c337;hpb=ac7c5278701033c844c2c1a2fc059d822375b250 diff --git a/jcc.c b/jcc.c index 99b72a65..7eb067ac 100644 --- a/jcc.c +++ b/jcc.c @@ -1,4 +1,4 @@ -const char jcc_rcs[] = "$Id: jcc.c,v 1.189 2008/10/11 09:53:00 fabiankeil Exp $"; +const char jcc_rcs[] = "$Id: jcc.c,v 1.205 2008/11/16 12:43:49 fabiankeil Exp $"; /********************************************************************* * * File : $Source: /cvsroot/ijbswa/current/jcc.c,v $ @@ -33,6 +33,68 @@ const char jcc_rcs[] = "$Id: jcc.c,v 1.189 2008/10/11 09:53:00 fabiankeil Exp $" * * Revisions : * $Log: jcc.c,v $ + * Revision 1.205 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.204 2008/11/06 19:42:17 fabiankeil + * Fix last-chunk detection hack to also apply + * if buf[] contains nothing but the last-chunk. + * + * Revision 1.203 2008/11/06 18:34:35 fabiankeil + * Factor receive_client_request() and + * parse_client_request() out of chat(). + * + * Revision 1.202 2008/11/02 18:40:34 fabiankeil + * If we received a different amount of data than we expected, + * log a warning and make sure the server socket isn't reused. + * + * Revision 1.201 2008/11/02 16:48:20 fabiankeil + * Revert revision 1.195 and try again. + * + * Revision 1.200 2008/10/26 16:53:18 fabiankeil + * Fix gcc44 warning. + * + * Revision 1.199 2008/10/26 15:36:10 fabiankeil + * Remove two debug messages with LOG_LEVEL_INFO. + * + * Revision 1.198 2008/10/22 15:19:55 fabiankeil + * Once More, With Feeling: if there is no logfile + * because the user didn't specify one, we shouldn't + * call init_error_log() after receiving SIGHUP either. + * + * Revision 1.197 2008/10/20 17:02:40 fabiankeil + * If SIGHUP is received while we aren't running in daemon + * mode, calling init_error_log() would be a mistake. + * + * Revision 1.196 2008/10/16 09:16:41 fabiankeil + * - Fix two gcc44 conversion warnings. + * - Don't bother logging the last five bytes + * of the 0-chunk. + * + * Revision 1.195 2008/10/13 16:04:37 fabiankeil + * Make sure we don't try to reuse tainted server sockets. + * + * Revision 1.194 2008/10/12 18:35:18 fabiankeil + * The last commit was a bit too ambitious, apparently the content + * length adjustment is only necessary if we aren't buffering. + * + * Revision 1.193 2008/10/12 15:57:35 fabiankeil + * Fix content length calculation if we read headers + * and the start of the body at once. Now that we have + * FEATURE_CONNECTION_KEEP_ALIVE, it actually matters. + * + * Revision 1.192 2008/10/11 18:19:14 fabiankeil + * Even more chat() cosmetics. + * + * Revision 1.191 2008/10/11 18:00:14 fabiankeil + * Reformat some comments in chat(). + * + * Revision 1.190 2008/10/11 14:58:00 fabiankeil + * In case of chunk-encoded content, stop reading if + * the buffer looks like it ends with the last chunk. + * * Revision 1.189 2008/10/11 09:53:00 fabiankeil * Let server_response_is_complete() deal properly with * content that is neither buffered nor read all at once. @@ -1153,9 +1215,9 @@ static jb_err get_request_destination_elsewhere(struct client_state *csp, struct static jb_err get_server_headers(struct client_state *csp); static const char *crunch_reason(const struct http_response *rsp); static void send_crunch_response(const struct client_state *csp, struct http_response *rsp); -/* - * static int request_contains_null_bytes(const struct client_state *csp, char *buf, int len); - */ +static char *get_request_line(struct client_state *csp); +static jb_err receive_client_request(struct client_state *csp); +static jb_err parse_client_request(struct client_state *csp); static void build_request_line(struct client_state *csp, const struct forward_spec *fwd, char **request_line); static jb_err change_request_destination(struct client_state *csp); static void chat(struct client_state *csp); @@ -2008,7 +2070,6 @@ static int server_response_is_complete(struct client_state *csp, size_t content_ * "HEAD" implies no body, we are thus expecting * no content. XXX: incomplete "list" of methods? */ - log_error(LOG_LEVEL_INFO, "Method %s implies no body.", csp->http->gpc); csp->expected_content_length = 0; content_length_known = TRUE; } @@ -2018,7 +2079,6 @@ static int server_response_is_complete(struct client_state *csp, size_t content_ /* * Expect no body. XXX: incomplete "list" of status codes? */ - log_error(LOG_LEVEL_INFO, "Status code %d implies no body.", csp->http->status); csp->expected_content_length = 0; content_length_known = TRUE; } @@ -2028,69 +2088,54 @@ static int server_response_is_complete(struct client_state *csp, size_t content_ } #endif /* FEATURE_CONNECTION_KEEP_ALIVE */ - /********************************************************************* * - * Function : chat + * Function : mark_server_socket_tainted * - * Description : Once a connection to the client has been accepted, - * this function is called (via serve()) to handle the - * main business of the communication. When this - * function returns, the caller must close the client - * socket handle. + * Description : Makes sure we don't reuse a server socket + * (if we didn't read everything the server sent + * us reusing the socket would lead to garbage). * - * FIXME: chat is nearly thousand lines long. - * Ridiculous. + * Parameters : + * 1 : csp = Current client state (buffers, headers, etc...) + * + * Returns : void. + * + *********************************************************************/ +static void mark_server_socket_tainted(struct client_state *csp) +{ + if ((csp->flags & CSP_FLAG_SERVER_CONNECTION_KEEP_ALIVE)) + { + log_error(LOG_LEVEL_CONNECT, "Unsetting keep-alive flag."); + csp->flags &= ~CSP_FLAG_SERVER_CONNECTION_KEEP_ALIVE; + } +} + +/********************************************************************* + * + * Function : get_request_line + * + * Description : Read the client request line. * * Parameters : * 1 : csp = Current client state (buffers, headers, etc...) * - * Returns : Nothing. + * Returns : Pointer to request line or NULL in case of errors. * *********************************************************************/ -static void chat(struct client_state *csp) +static char *get_request_line(struct client_state *csp) { char buf[BUFFER_SIZE]; - char *hdr; - char *p; - char *req = NULL; - fd_set rfds; - int n; - jb_socket maxfd; - int server_body; - int ms_iis5_hack = 0; - size_t byte_count = 0; - int forwarded_connect_retries = 0; - int max_forwarded_connect_retries = csp->config->forwarded_connect_retries; - const struct forward_spec * fwd; - struct http_request *http; - int len; /* for buffer sizes (and negative error codes) */ - jb_err err; - - /* Function that does the content filtering for the current request */ - filter_function_ptr content_filter = NULL; - - /* Skeleton for HTTP response, if we should intercept the request */ - struct http_response *rsp; - - /* Temporary copy of the client's headers before they get enlisted in csp->headers */ - struct list header_list; - struct list *headers = &header_list; - - http = csp->http; + char *request_line = NULL; + int len; memset(buf, 0, sizeof(buf)); - /* - * Read the client's request. Note that since we're not using select() we - * could get blocked here if a client connected, then didn't say anything! - */ - do { len = read_socket(csp->cfd, buf, sizeof(buf) - 1); - if (len <= 0) break; /* error! */ + if (len <= 0) return NULL; /* * If there is no memory left for buffering the @@ -2098,41 +2143,58 @@ static void chat(struct client_state *csp) */ if (add_to_iob(csp, buf, len)) { - return; + return NULL; } - req = get_header(csp->iob); + request_line = get_header(csp->iob); + + } while ((NULL != request_line) && ('\0' == *request_line)); - } while ((NULL != req) && ('\0' == *req)); + return request_line; + +} + + +/********************************************************************* + * + * Function : receive_client_request + * + * Description : Read the client's request (more precisely the + * client headers) and answer it if necessary. + * + * Note that since we're not using select() we could get + * blocked here if a client connected, then didn't say + * anything! + * + * Parameters : + * 1 : csp = Current client state (buffers, headers, etc...) + * + * Returns : JB_ERR_OK, JB_ERR_PARSE or JB_ERR_MEMORY + * + *********************************************************************/ +static jb_err receive_client_request(struct client_state *csp) +{ + char buf[BUFFER_SIZE]; + char *p; + char *req = NULL; + struct http_request *http; + int len; + jb_err err; + + /* Temporary copy of the client's headers before they get enlisted in csp->headers */ + struct list header_list; + struct list *headers = &header_list; + + http = csp->http; + + memset(buf, 0, sizeof(buf)); + + req = get_request_line(csp); if ((NULL != req) && ('\0' != *req)) { /* Request received. Validate and parse it. */ -#if 0 - /* - * XXX: Temporary disabled to prevent problems - * with POST requests whose bodies are allowed to - * contain NULL bytes. BR#1730105. - * - * The main purpose of this check is to properly - * log stuff like BitTorrent traffic and other junk - * that hits public proxies. It's not required for - * Privoxy to functions as those requests are discarded - * later on anyway. - * - * It probably should be rewritten to only check - * the head of the request. Another option would - * be to let all POST requests pass, although that - * may not be good enough. - */ - if (request_contains_null_bytes(csp, buf, len)) - { - /* NULL bytes found and dealt with, just hang up. */ - return; - } -#endif - /* Does the request line look invalid? */ if (client_protocol_is_unsupported(csp, req)) { @@ -2141,7 +2203,7 @@ static void chat(struct client_state *csp) * answered with a error response, the buffers * were freed and we're done with chatting. */ - return; + return JB_ERR_PARSE; } #ifdef FEATURE_FORCE_LOAD @@ -2163,8 +2225,8 @@ static void chat(struct client_state *csp) csp->flags |= CSP_FLAG_FORCED; } } - #endif /* def FEATURE_FORCE_LOAD */ + err = parse_http_request(req, http, csp); if (JB_ERR_OK != err) { @@ -2182,7 +2244,7 @@ static void chat(struct client_state *csp) log_error(LOG_LEVEL_ERROR, "Invalid header received from %s.", csp->ip_addr_str); free_http_request(http); - return; + return JB_ERR_PARSE; } /* grab the rest of the client's headers */ @@ -2208,7 +2270,7 @@ static void chat(struct client_state *csp) { log_error(LOG_LEVEL_ERROR, "read from client failed: %E"); destroy_list(headers); - return; + return JB_ERR_PARSE; } if (add_to_iob(csp, buf, len)) @@ -2218,7 +2280,7 @@ static void chat(struct client_state *csp) * request, there is nothing we can do but hang up */ destroy_list(headers); - return; + return JB_ERR_MEMORY; } } else @@ -2249,7 +2311,7 @@ static void chat(struct client_state *csp) * An error response has already been send * and we're done here. */ - return; + return JB_ERR_PARSE; } } @@ -2272,23 +2334,50 @@ static void chat(struct client_state *csp) * Save a copy of the original request for logging */ http->ocmd = strdup(http->cmd); - if (http->ocmd == NULL) { - log_error(LOG_LEVEL_FATAL, "Out of memory copying HTTP request line"); + log_error(LOG_LEVEL_FATAL, + "Out of memory copying HTTP request line"); } - enlist(csp->headers, http->cmd); /* Append the previously read headers */ list_append_list_unique(csp->headers, headers); destroy_list(headers); + return JB_ERR_OK; + +} + + +/********************************************************************* + * + * Function : parse_client_request + * + * Description : Parses the client's request and decides what to do + * with it. + * + * Note that since we're not using select() we could get + * blocked here if a client connected, then didn't say + * anything! + * + * Parameters : + * 1 : csp = Current client state (buffers, headers, etc...) + * + * Returns : JB_ERR_OK or JB_ERR_PARSE + * + *********************************************************************/ +static jb_err parse_client_request(struct client_state *csp) +{ + struct http_request *http = csp->http; + jb_err err; + err = sed(csp, FILTER_CLIENT_HEADERS); if (JB_ERR_OK != err) { + /* XXX: Should be handled in sed(). */ assert(err == JB_ERR_PARSE); - log_error(LOG_LEVEL_FATAL, "Failed to parse client headers"); + log_error(LOG_LEVEL_FATAL, "Failed to parse client headers."); } csp->flags |= CSP_FLAG_CLIENT_HEADER_PARSING_DONE; @@ -2302,10 +2391,72 @@ static void chat(struct client_state *csp) */ write_socket(csp->cfd, MESSED_UP_REQUEST_RESPONSE, strlen(MESSED_UP_REQUEST_RESPONSE)); /* XXX: Use correct size */ - log_error(LOG_LEVEL_CLF, "%s - - [%T] \"Invalid request generated\" 500 0", csp->ip_addr_str); - log_error(LOG_LEVEL_ERROR, "Invalid request line after applying header filters."); - + log_error(LOG_LEVEL_CLF, + "%s - - [%T] \"Invalid request generated\" 500 0", csp->ip_addr_str); + log_error(LOG_LEVEL_ERROR, + "Invalid request line after applying header filters."); free_http_request(http); + + return JB_ERR_PARSE; + } + + return JB_ERR_OK; + +} + + +/********************************************************************* + * + * Function : chat + * + * Description : Once a connection to the client has been accepted, + * this function is called (via serve()) to handle the + * main business of the communication. When this + * function returns, the caller must close the client + * socket handle. + * + * FIXME: chat is nearly thousand lines long. + * Ridiculous. + * + * Parameters : + * 1 : csp = Current client state (buffers, headers, etc...) + * + * Returns : Nothing. + * + *********************************************************************/ +static void chat(struct client_state *csp) +{ + char buf[BUFFER_SIZE]; + char *hdr; + char *p; + fd_set rfds; + int n; + jb_socket maxfd; + int server_body; + int ms_iis5_hack = 0; + size_t byte_count = 0; + int forwarded_connect_retries = 0; + int max_forwarded_connect_retries = csp->config->forwarded_connect_retries; + const struct forward_spec *fwd; + struct http_request *http; + int len; /* for buffer sizes (and negative error codes) */ + + /* Function that does the content filtering for the current request */ + filter_function_ptr content_filter = NULL; + + /* Skeleton for HTTP response, if we should intercept the request */ + struct http_response *rsp; + + memset(buf, 0, sizeof(buf)); + + http = csp->http; + + if (receive_client_request(csp) != JB_ERR_OK) + { + return; + } + if (parse_client_request(csp) != JB_ERR_OK) + { return; } @@ -2409,7 +2560,7 @@ static void chat(struct client_state *csp) if (fwd->forward_host) { log_error(LOG_LEVEL_CONNECT, "via %s:%d to: %s", - fwd->forward_host, fwd->forward_port, http->hostport); + fwd->forward_host, fwd->forward_port, http->hostport); } else { @@ -2418,11 +2569,13 @@ static void chat(struct client_state *csp) /* here we connect to the server, gateway, or the forwarder */ - while ( (csp->sfd = forwarded_connect(fwd, http, csp)) - && (errno == EINVAL) && (forwarded_connect_retries++ < max_forwarded_connect_retries)) + while ((csp->sfd = forwarded_connect(fwd, http, csp)) + && (errno == EINVAL) + && (forwarded_connect_retries++ < max_forwarded_connect_retries)) { - log_error(LOG_LEVEL_ERROR, "failed request #%u to connect to %s. Trying again.", - forwarded_connect_retries, http->hostport); + log_error(LOG_LEVEL_ERROR, + "failed request #%u to connect to %s. Trying again.", + forwarded_connect_retries, http->hostport); } if (csp->sfd == JB_INVALID_SOCKET) @@ -2440,10 +2593,9 @@ static void chat(struct client_state *csp) { rsp = error_response(csp, "connect-failed", errno); log_error(LOG_LEVEL_CONNECT, "connect to: %s failed: %E", - http->hostport); + http->hostport); } - /* Write the answer to the client */ if (rsp != NULL) { @@ -2456,19 +2608,18 @@ static void chat(struct client_state *csp) if (fwd->forward_host || (http->ssl == 0)) { - /* write the client's (modified) header to the server + /* + * Write the client's (modified) header to the server * (along with anything else that may be in the buffer) */ - if (write_socket(csp->sfd, hdr, strlen(hdr)) || (flush_socket(csp->sfd, csp->iob) < 0)) { - log_error(LOG_LEVEL_CONNECT, "write header to: %s failed: %E", - http->hostport); + log_error(LOG_LEVEL_CONNECT, + "write header to: %s failed: %E", http->hostport); rsp = error_response(csp, "connect-failed", errno); - - if(rsp) + if (rsp) { send_crunch_response(csp, rsp); } @@ -2497,7 +2648,7 @@ static void chat(struct client_state *csp) /* we're finished with the client's header */ freez(hdr); - maxfd = ( csp->cfd > csp->sfd ) ? csp->cfd : csp->sfd; + maxfd = (csp->cfd > csp->sfd) ? csp->cfd : csp->sfd; /* pass data between the client and server * until one or the other shuts down the connection. @@ -2540,40 +2691,42 @@ static void chat(struct client_state *csp) if (n < 0) { log_error(LOG_LEVEL_ERROR, "select() failed!: %E"); + mark_server_socket_tainted(csp); return; } - /* this is the body of the browser's request - * just read it and write it. + /* + * This is the body of the browser's request, + * just read and write it. */ - if (FD_ISSET(csp->cfd, &rfds)) { len = read_socket(csp->cfd, buf, sizeof(buf) - 1); if (len <= 0) { + /* XXX: not sure if this is necessary. */ + mark_server_socket_tainted(csp); break; /* "game over, man" */ } if (write_socket(csp->sfd, buf, (size_t)len)) { log_error(LOG_LEVEL_ERROR, "write to: %s failed: %E", http->host); + mark_server_socket_tainted(csp); return; } continue; } /* - * The server wants to talk. It could be the header or the body. + * The server wants to talk. It could be the header or the body. * If `hdr' is null, then it's the header otherwise it's the body. * FIXME: Does `hdr' really mean `host'? No. */ - - if (FD_ISSET(csp->sfd, &rfds)) { - fflush( 0 ); + fflush(0); len = read_socket(csp->sfd, buf, sizeof(buf) - 1); if (len < 0) @@ -2602,11 +2755,11 @@ static void chat(struct client_state *csp) */ log_error(LOG_LEVEL_ERROR, "Already forwarded the original headers. " "Unable to tell the client about the problem."); + mark_server_socket_tainted(csp); return; } rsp = error_response(csp, "connect-failed", errno); - if (rsp) { send_crunch_response(csp, rsp); @@ -2618,26 +2771,27 @@ static void chat(struct client_state *csp) #ifdef FEATURE_CONNECTION_KEEP_ALIVE if (csp->flags & CSP_FLAG_CHUNKED) { - if ((len > 5) && !memcmp(buf+len-5, "0\r\n\r\n", 5)) + if ((len >= 5) && !memcmp(buf+len-5, "0\r\n\r\n", 5)) { /* XXX: this is a temporary hack */ log_error(LOG_LEVEL_CONNECT, - "Looks like we reached the end of the last chunk: " - "%d %d %d %d %d. We better stop reading.", - buf[len-5], buf[len-4], buf[len-3], buf[len-2], buf[len-1]); - csp->expected_content_length = byte_count + len; + "Looks like we reached the end of the last chunk. " + "We better stop reading."); + csp->expected_content_length = byte_count + (size_t)len; csp->flags |= CSP_FLAG_CONTENT_LENGTH_SET; } } reading_done: #endif /* FEATURE_CONNECTION_KEEP_ALIVE */ - /* Add a trailing zero. This lets filter_popups - * use string operations. + /* + * Add a trailing zero to let be able to use string operations. + * XXX: do we still need this with filter_popups gone? */ buf[len] = '\0'; - /* Normally, this would indicate that we've read + /* + * Normally, this would indicate that we've read * as much as the server has sent us and we can * close the client connection. However, Microsoft * in its wisdom has released IIS/5 with a bug that @@ -2697,6 +2851,7 @@ static void chat(struct client_state *csp) log_error(LOG_LEVEL_ERROR, "write modified content to client failed: %E"); freez(hdr); freez(p); + mark_server_socket_tainted(csp); return; } @@ -2727,7 +2882,6 @@ static void chat(struct client_state *csp) * of the server document, just write it to the client, * unless we need to buffer the body for later content-filtering */ - if (server_body || http->ssl) { if (content_filter) @@ -2742,7 +2896,8 @@ static void chat(struct client_state *csp) size_t hdrlen; int flushed; - log_error(LOG_LEVEL_INFO, "Flushing header and buffers. Stepping back from filtering."); + log_error(LOG_LEVEL_INFO, + "Flushing header and buffers. Stepping back from filtering."); hdr = list_to_text(csp->headers); if (hdr == NULL) @@ -2754,7 +2909,7 @@ static void chat(struct client_state *csp) log_error(LOG_LEVEL_ERROR, "Out of memory while trying to flush."); rsp = cgi_error_memory(); send_crunch_response(csp, rsp); - + mark_server_socket_tainted(csp); return; } hdrlen = strlen(hdr); @@ -2763,9 +2918,10 @@ static void chat(struct client_state *csp) || ((flushed = flush_socket(csp->cfd, csp->iob)) < 0) || (write_socket(csp->cfd, buf, (size_t)len))) { - log_error(LOG_LEVEL_CONNECT, "Flush header and buffers to client failed: %E"); - + log_error(LOG_LEVEL_CONNECT, + "Flush header and buffers to client failed: %E"); freez(hdr); + mark_server_socket_tainted(csp); return; } @@ -2785,6 +2941,7 @@ static void chat(struct client_state *csp) if (write_socket(csp->cfd, buf, (size_t)len)) { log_error(LOG_LEVEL_ERROR, "write to client failed: %E"); + mark_server_socket_tainted(csp); return; } } @@ -2793,34 +2950,31 @@ static void chat(struct client_state *csp) } else { - /* we're still looking for the end of the - * server's header ... (does that make header - * parsing an "out of body experience" ? - */ - - /* - * buffer up the data we just read. If that fails, - * there's little we can do but send our static - * out-of-memory page. + const char *header_start; + /* + * We're still looking for the end of the server's header. + * Buffer up the data we just read. If that fails, there's + * little we can do but send our static out-of-memory page. */ if (add_to_iob(csp, buf, len)) { log_error(LOG_LEVEL_ERROR, "Out of memory while looking for end of server headers."); rsp = cgi_error_memory(); send_crunch_response(csp, rsp); - + mark_server_socket_tainted(csp); return; } + header_start = csp->iob->cur; + /* Convert iob into something sed() can digest */ if (JB_ERR_PARSE == get_server_headers(csp)) { if (ms_iis5_hack) { - /* Well, we tried our MS IIS/5 - * hack and it didn't work. - * The header is incomplete - * and there isn't anything + /* + * Well, we tried our MS IIS/5 hack and it didn't work. + * The header is incomplete and there isn't anything * we can do about it. */ log_error(LOG_LEVEL_INFO, @@ -2829,10 +2983,9 @@ static void chat(struct client_state *csp) } else { - /* Since we have to wait for - * more from the server before - * we can parse the headers - * we just continue here. + /* + * Since we have to wait for more from the server before + * we can parse the headers we just continue here. */ continue; } @@ -2845,6 +2998,7 @@ static void chat(struct client_state *csp) log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 502 0", csp->ip_addr_str, http->cmd); write_socket(csp->cfd, NO_SERVER_DATA_RESPONSE, strlen(NO_SERVER_DATA_RESPONSE)); free_http_request(http); + mark_server_socket_tainted(csp); return; } @@ -2869,6 +3023,7 @@ static void chat(struct client_state *csp) write_socket(csp->cfd, INVALID_SERVER_HEADERS_RESPONSE, strlen(INVALID_SERVER_HEADERS_RESPONSE)); free_http_request(http); + mark_server_socket_tainted(csp); return; } @@ -2896,6 +3051,7 @@ static void chat(struct client_state *csp) * and are done here after cleaning up. */ freez(hdr); + mark_server_socket_tainted(csp); return; } /* Buffer and pcrs filter this if appropriate. */ @@ -2909,7 +3065,8 @@ static void chat(struct client_state *csp) */ if (!content_filter) { - /* write the server's (modified) header to + /* + * Write the server's (modified) header to * the client (along with anything else that * may be in the buffer) */ @@ -2919,26 +3076,37 @@ static void chat(struct client_state *csp) { log_error(LOG_LEVEL_CONNECT, "write header to client failed: %E"); - /* the write failed, so don't bother - * mentioning it to the client... - * it probably can't hear us anyway. + /* + * The write failed, so don't bother mentioning it + * to the client... it probably can't hear us anyway. */ freez(hdr); + mark_server_socket_tainted(csp); return; } byte_count += (size_t)len; } + else + { + /* + * XXX: the header lenght should probably + * be calculated by get_server_headers(). + */ + int header_length = csp->iob->cur - header_start; + assert(csp->iob->cur > header_start); + byte_count += (size_t)(len - header_length); + } /* we're finished with the server's header */ freez(hdr); server_body = 1; - /* If this was a MS IIS/5 hack then it means - * the server has already closed the - * connection. Nothing more to read. Time - * to bail. + /* + * If this was a MS IIS/5 hack then it means the server + * has already closed the connection. Nothing more to read. + * Time to bail. */ if (ms_iis5_hack) { @@ -2949,20 +3117,28 @@ static void chat(struct client_state *csp) } continue; } - + mark_server_socket_tainted(csp); return; /* huh? we should never get here */ } if (csp->content_length == 0) { /* - * If Privoxy didn't recalculate the - * Content-Lenght, byte_count is still - * correct. + * If Privoxy didn't recalculate the Content-Lenght, + * byte_count is still correct. */ csp->content_length = byte_count; } + if ((csp->flags & CSP_FLAG_CONTENT_LENGTH_SET) + && (csp->expected_content_length != byte_count)) + { + log_error(LOG_LEVEL_ERROR, + "Received %d bytes while expecting %d.", + byte_count, csp->expected_content_length); + mark_server_socket_tainted(csp); + } + log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 200 %d", csp->ip_addr_str, http->ocmd, csp->content_length); } @@ -2993,7 +3169,8 @@ static void serve(struct client_state *csp) if (csp->sfd != JB_INVALID_SOCKET) { #ifdef FEATURE_CONNECTION_KEEP_ALIVE - if ((csp->flags & CSP_FLAG_SERVER_CONNECTION_KEEP_ALIVE)) + if ((csp->config->feature_flags & RUNTIME_FEATURE_CONNECTION_KEEP_ALIVE) + && (csp->flags & CSP_FLAG_SERVER_CONNECTION_KEEP_ALIVE)) { remember_connection(csp->sfd, csp->http, forward_url(csp, csp->http)); } @@ -3767,7 +3944,10 @@ static void listen_loop(void) */ if (received_hup_signal) { - init_error_log(Argv[0], config->logfile); + if (NULL != config->logfile) + { + init_error_log(Argv[0], config->logfile); + } received_hup_signal = 0; } #endif