X-Git-Url: http://www.privoxy.org/gitweb/?p=privoxy.git;a=blobdiff_plain;f=jcc.c;h=028970f4ceadb0b9c30a7b1445b509db6100cee9;hp=e76358ba447e03080ea2a928b12b0dff00c2bc8d;hb=92f1c5a1258893f24b4236a31983a5cf1a5b262a;hpb=8ef1cce0e3dfe6b68730d19d68cbb628219ebf39 diff --git a/jcc.c b/jcc.c index e76358ba..028970f4 100644 --- a/jcc.c +++ b/jcc.c @@ -1,4 +1,4 @@ -const char jcc_rcs[] = "$Id: jcc.c,v 1.184 2008/08/22 15:34:45 fabiankeil Exp $"; +const char jcc_rcs[] = "$Id: jcc.c,v 1.195 2008/10/13 16:04:37 fabiankeil Exp $"; /********************************************************************* * * File : $Source: /cvsroot/ijbswa/current/jcc.c,v $ @@ -33,6 +33,46 @@ const char jcc_rcs[] = "$Id: jcc.c,v 1.184 2008/08/22 15:34:45 fabiankeil Exp $" * * Revisions : * $Log: jcc.c,v $ + * 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. + * + * Revision 1.188 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.187 2008/09/07 12:35:05 fabiankeil + * Add mutex lock support for _WIN32. + * + * Revision 1.186 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.185 2008/08/30 12:03:07 fabiankeil + * Remove FEATURE_COOKIE_JAR. + * * Revision 1.184 2008/08/22 15:34:45 fabiankeil * - Silence LLVM/Clang complaint. * - Make received_hup_signal static. @@ -1167,27 +1207,31 @@ static int32 server_thread(void *data); #define sleep(N) DosSleep(((N) * 100)) #endif -#ifdef FEATURE_PTHREAD -pthread_mutex_t log_mutex; -pthread_mutex_t log_init_mutex; +#ifdef MUTEX_LOCKS_AVAILABLE +/* + * XXX: Does the locking stuff really belong in this file? + */ +privoxy_mutex_t log_mutex; +privoxy_mutex_t log_init_mutex; +privoxy_mutex_t connection_reuse_mutex; #if !defined(HAVE_GETHOSTBYADDR_R) || !defined(HAVE_GETHOSTBYNAME_R) -pthread_mutex_t resolver_mutex; +privoxy_mutex_t resolver_mutex; #endif /* !defined(HAVE_GETHOSTBYADDR_R) || !defined(HAVE_GETHOSTBYNAME_R) */ #ifndef HAVE_GMTIME_R -pthread_mutex_t gmtime_mutex; +privoxy_mutex_t gmtime_mutex; #endif /* ndef HAVE_GMTIME_R */ #ifndef HAVE_LOCALTIME_R -pthread_mutex_t localtime_mutex; +privoxy_mutex_t localtime_mutex; #endif /* ndef HAVE_GMTIME_R */ #ifndef HAVE_RANDOM -pthread_mutex_t rand_mutex; +privoxy_mutex_t rand_mutex; #endif /* ndef HAVE_RANDOM */ -#endif /* FEATURE_PTHREAD */ +#endif /* def MUTEX_LOCKS_AVAILABLE */ #if defined(unix) const char *basedir = NULL; @@ -1960,6 +2004,53 @@ static jb_err change_request_destination(struct client_state *csp) } +#ifdef FEATURE_CONNECTION_KEEP_ALIVE +/********************************************************************* + * + * Function : server_response_is_complete + * + * Description : Determines whether we should stop reading + * from the server socket. + * + * Parameters : + * 1 : csp = Current client state (buffers, headers, etc...) + * 2 : content_length = Length of content received so far. + * + * Returns : TRUE if the response is complete, + * FALSE otherwise. + * + *********************************************************************/ +static int server_response_is_complete(struct client_state *csp, size_t content_length) +{ + int content_length_known = (csp->flags & CSP_FLAG_CONTENT_LENGTH_SET); + + if (!strcmpic(csp->http->gpc, "HEAD")) + { + /* + * "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; + } + + if (csp->http->status == 304) + { + /* + * 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; + } + + return (content_length_known && ((0 == csp->expected_content_length) + || (csp->expected_content_length <= content_length))); +} +#endif /* FEATURE_CONNECTION_KEEP_ALIVE */ + + /********************************************************************* * * Function : chat @@ -2374,7 +2465,6 @@ static void chat(struct client_state *csp) http->hostport); } - /* Write the answer to the client */ if (rsp != NULL) { @@ -2387,19 +2477,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); } @@ -2428,7 +2517,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. @@ -2450,18 +2539,34 @@ static void chat(struct client_state *csp) FD_SET(csp->cfd, &rfds); FD_SET(csp->sfd, &rfds); +#ifdef FEATURE_CONNECTION_KEEP_ALIVE + if (server_body && server_response_is_complete(csp, byte_count)) + { + log_error(LOG_LEVEL_CONNECT, + "Done reading from server. Expected content length: %d. " + "Actual content length: %d. Most recently received: %d.", + csp->expected_content_length, byte_count, len); + len = 0; + /* + * XXX: should not jump around, + * chat() is complicated enough already. + */ + goto reading_done; + } +#endif /* FEATURE_CONNECTION_KEEP_ALIVE */ + n = select((int)maxfd+1, &rfds, NULL, NULL, NULL); if (n < 0) { log_error(LOG_LEVEL_ERROR, "select() failed!: %E"); - return; + break; } - /* 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); @@ -2474,21 +2579,19 @@ static void chat(struct client_state *csp) if (write_socket(csp->sfd, buf, (size_t)len)) { log_error(LOG_LEVEL_ERROR, "write to: %s failed: %E", http->host); - return; + break; } 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) @@ -2517,11 +2620,10 @@ 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."); - return; + break; } rsp = error_response(csp, "connect-failed", errno); - if (rsp) { send_crunch_response(csp, rsp); @@ -2530,12 +2632,30 @@ static void chat(struct client_state *csp) return; } - /* Add a trailing zero. This lets filter_popups - * use string operations. +#ifdef FEATURE_CONNECTION_KEEP_ALIVE + if (csp->flags & CSP_FLAG_CHUNKED) + { + 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. " + "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 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 @@ -2595,7 +2715,7 @@ static void chat(struct client_state *csp) log_error(LOG_LEVEL_ERROR, "write modified content to client failed: %E"); freez(hdr); freez(p); - return; + break; } freez(hdr); @@ -2625,7 +2745,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) @@ -2640,7 +2759,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) @@ -2652,8 +2772,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); - - return; + break; } hdrlen = strlen(hdr); @@ -2661,10 +2780,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); - return; + break; } /* @@ -2683,7 +2802,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"); - return; + break; } } byte_count += (size_t)len; @@ -2691,34 +2810,30 @@ 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); - - return; + break; } + 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, @@ -2727,10 +2842,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; } @@ -2743,7 +2857,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); - return; + break; } assert(csp->headers->first->str); @@ -2767,7 +2881,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); - return; + break; } /* @@ -2794,7 +2908,7 @@ static void chat(struct client_state *csp) * and are done here after cleaning up. */ freez(hdr); - return; + break; } /* Buffer and pcrs filter this if appropriate. */ @@ -2807,7 +2921,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) */ @@ -2817,26 +2932,36 @@ 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); - return; + break; } 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) { @@ -2847,16 +2972,24 @@ static void chat(struct client_state *csp) } continue; } - - return; /* huh? we should never get here */ + /* + * If we reach this point, the server socket is tainted + * (most likely because we didn't read everything the + * server sent us) and reusing it would lead to garbage. + */ + 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; + } + return; } 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; } @@ -2890,7 +3023,19 @@ 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)) + { + remember_connection(csp->sfd, csp->http, forward_url(csp, csp->http)); + } + else + { + forget_connection(csp->sfd); + close_socket(csp->sfd); + } +#else close_socket(csp->sfd); +#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */ } csp->flags &= ~CSP_FLAG_ACTIVE; @@ -2952,6 +3097,97 @@ static void usage(const char *myname) #endif /* #if !defined(_WIN32) || defined(_WIN_CONSOLE) */ +#ifdef MUTEX_LOCKS_AVAILABLE +/********************************************************************* + * + * Function : privoxy_mutex_lock + * + * Description : Locks a mutex. + * + * Parameters : + * 1 : mutex = The mutex to lock. + * + * Returns : Void. May exit in case of errors. + * + *********************************************************************/ +void privoxy_mutex_lock(privoxy_mutex_t *mutex) +{ +#ifdef FEATURE_PTHREAD + int err = pthread_mutex_lock(mutex); + if (err) + { + if (mutex != &log_mutex) + { + log_error(LOG_LEVEL_FATAL, + "Mutex locking failed: %s.\n", strerror(err)); + } + exit(1); + } +#else + EnterCriticalSection(mutex); +#endif /* def FEATURE_PTHREAD */ +} + + +/********************************************************************* + * + * Function : privoxy_mutex_unlock + * + * Description : Unlocks a mutex. + * + * Parameters : + * 1 : mutex = The mutex to unlock. + * + * Returns : Void. May exit in case of errors. + * + *********************************************************************/ +void privoxy_mutex_unlock(privoxy_mutex_t *mutex) +{ +#ifdef FEATURE_PTHREAD + int err = pthread_mutex_unlock(mutex); + if (err) + { + if (mutex != &log_mutex) + { + log_error(LOG_LEVEL_FATAL, + "Mutex unlocking failed: %s.\n", strerror(err)); + } + exit(1); + } +#else + LeaveCriticalSection(mutex); +#endif /* def FEATURE_PTHREAD */ +} + + +/********************************************************************* + * + * Function : privoxy_mutex_init + * + * Description : Prepares a mutex. + * + * Parameters : + * 1 : mutex = The mutex to initialize. + * + * Returns : Void. May exit in case of errors. + * + *********************************************************************/ +static void privoxy_mutex_init(privoxy_mutex_t *mutex) +{ +#ifdef FEATURE_PTHREAD + int err = pthread_mutex_init(mutex, 0); + if (err) + { + printf("Fatal error. Mutex initialization failed: %s.\n", + strerror(err)); + exit(1); + } +#else + InitializeCriticalSection(mutex); +#endif /* def FEATURE_PTHREAD */ +} +#endif /* def MUTEX_LOCKS_AVAILABLE */ + /********************************************************************* * * Function : initialize_mutexes @@ -2965,15 +3201,13 @@ static void usage(const char *myname) *********************************************************************/ static void initialize_mutexes(void) { - int err = 0; - -#ifdef FEATURE_PTHREAD +#ifdef MUTEX_LOCKS_AVAILABLE /* * Prepare global mutex semaphores */ - err = pthread_mutex_init(&log_mutex, 0); - - if (!err) err = pthread_mutex_init(&log_init_mutex, 0); + privoxy_mutex_init(&log_mutex); + privoxy_mutex_init(&log_init_mutex); + privoxy_mutex_init(&connection_reuse_mutex); /* * XXX: The assumptions below are a bit naive @@ -2984,37 +3218,24 @@ static void initialize_mutexes(void) * thread safe. */ #if !defined(HAVE_GETHOSTBYADDR_R) || !defined(HAVE_GETHOSTBYNAME_R) - if (!err) err = pthread_mutex_init(&resolver_mutex, 0); + privoxy_mutex_init(&resolver_mutex); #endif /* !defined(HAVE_GETHOSTBYADDR_R) || !defined(HAVE_GETHOSTBYNAME_R) */ /* * XXX: should we use a single mutex for * localtime() and gmtime() as well? */ #ifndef HAVE_GMTIME_R - if (!err) err = pthread_mutex_init(&gmtime_mutex, 0); + privoxy_mutex_init(&gmtime_mutex); #endif /* ndef HAVE_GMTIME_R */ #ifndef HAVE_LOCALTIME_R - if (!err) err = pthread_mutex_init(&localtime_mutex, 0); + privoxy_mutex_init(&localtime_mutex); #endif /* ndef HAVE_GMTIME_R */ #ifndef HAVE_RANDOM - if (!err) err = pthread_mutex_init(&rand_mutex, 0); + privoxy_mutex_init(&rand_mutex); #endif /* ndef HAVE_RANDOM */ -#endif /* FEATURE_PTHREAD */ - - /* - * TODO: mutex support for mingw32 would be swell. - */ - - if (err) - { - printf("Fatal error. Mutex initialization failed: %s.\n", - strerror(err)); - exit(1); - } - - return; +#endif /* def MUTEX_LOCKS_AVAILABLE */ } @@ -3230,15 +3451,6 @@ int main(int argc, const char *argv[]) random_seed = (unsigned int)time(NULL); #ifdef HAVE_RANDOM srandom(random_seed); -#elif defined (_WIN32) - /* - * See pick_from_range() in miscutil.c for details. - */ - log_error(LOG_LEVEL_INFO, - "No thread-safe PRNG implemented for your platform. " - "Using weak \'randomization\' factor which will " - "limit the already questionable usefulness of " - "header-time-randomizing actions (disabled by default)."); #else srand(random_seed); #endif /* ifdef HAVE_RANDOM */ @@ -3552,6 +3764,14 @@ static void listen_loop(void) config = load_config(); +#ifdef FEATURE_CONNECTION_KEEP_ALIVE + /* + * XXX: Should be relocated once it no + * longer needs to emit log messages. + */ + initialize_reusable_connections(); +#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */ + bfd = bind_port_helper(config); #ifdef FEATURE_GRACEFUL_TERMINATION