X-Git-Url: http://www.privoxy.org/gitweb/?p=privoxy.git;a=blobdiff_plain;f=jcc.c;h=56e07d8c39f1622fdbdd3488538ead17307e3806;hp=59c8266b3b1cce8015279597a0570a705112b80a;hb=2f946641e6706380d376f6946f30ebe239cc94bc;hpb=731127142a9203aade9b5a9a2b54bf6a19da7ed8 diff --git a/jcc.c b/jcc.c index 59c8266b..56e07d8c 100644 --- a/jcc.c +++ b/jcc.c @@ -1,4 +1,4 @@ -const char jcc_rcs[] = "$Id: jcc.c,v 1.320 2010/06/13 12:27:03 fabiankeil Exp $"; +const char jcc_rcs[] = "$Id: jcc.c,v 1.352 2011/05/27 11:34:39 fabiankeil Exp $"; /********************************************************************* * * File : $Source: /cvsroot/ijbswa/current/jcc.c,v $ @@ -120,7 +120,7 @@ const char jcc_h_rcs[] = JCC_H_VERSION; const char project_h_rcs[] = PROJECT_H_VERSION; int daemon_mode = 1; -struct client_state clients[1]; +struct client_states clients[1]; struct file_list files[1]; #ifdef FEATURE_STATISTICS @@ -244,16 +244,6 @@ static const char INVALID_SERVER_HEADERS_RESPONSE[] = "Connection: close\r\n\r\n" "Bad response. The server or forwarder response doesn't look like HTTP.\r\n"; -#if 0 -/* XXX: should be a template */ -static const char NULL_BYTE_RESPONSE[] = - "HTTP/1.0 400 Bad request received from client\r\n" - "Proxy-Agent: Privoxy " VERSION "\r\n" - "Content-Type: text/plain\r\n" - "Connection: close\r\n\r\n" - "Bad request. Null byte(s) before end of request.\r\n"; -#endif - /* XXX: should be a template */ static const char MESSED_UP_REQUEST_RESPONSE[] = "HTTP/1.0 400 Malformed request after rewriting\r\n" @@ -736,68 +726,6 @@ static void send_crunch_response(const struct client_state *csp, struct http_res } -#if 0 -/********************************************************************* - * - * Function : request_contains_null_bytes - * - * Description : Checks for NULL bytes in the request and sends - * an error message to the client if any were found. - * - * XXX: currently not used, see comment in chat(). - * - * Parameters : - * 1 : csp = Current client state (buffers, headers, etc...) - * 2 : buf = Data from the client's request to check. - * 3 : len = The data length. - * - * Returns : TRUE if the request contained one or more NULL bytes, or - * FALSE otherwise. - * - *********************************************************************/ -static int request_contains_null_bytes(const struct client_state *csp, char *buf, int len) -{ - size_t c_len; /* Request lenght when treated as C string */ - - c_len = strlen(buf); - - if (c_len < len) - { - /* - * Null byte(s) found. Log the request, - * return an error response and hang up. - */ - size_t tmp_len = c_len; - - do - { - /* - * Replace NULL byte(s) with '°' characters - * so the request can be logged as string. - * XXX: Is there a better replacement character? - */ - buf[tmp_len]='°'; - tmp_len += strlen(buf+tmp_len); - } while (tmp_len < len); - - log_error(LOG_LEVEL_ERROR, "%s\'s request contains at least one NULL byte " - "(length=%d, strlen=%u).", csp->ip_addr_str, len, c_len); - log_error(LOG_LEVEL_HEADER, - "Offending request data with NULL bytes turned into \'°\' characters: %s", buf); - - write_socket(csp->cfd, NULL_BYTE_RESPONSE, strlen(NULL_BYTE_RESPONSE)); - - /* XXX: Log correct size */ - log_error(LOG_LEVEL_CLF, "%s - - [%T] \"Invalid request\" 400 0", csp->ip_addr_str); - - return TRUE; - } - - return FALSE; -} -#endif - - /********************************************************************* * * Function : crunch_response_triggered @@ -1223,14 +1151,20 @@ static void verify_request_length(struct client_state *csp) *********************************************************************/ static void mark_server_socket_tainted(struct client_state *csp) { + /* + * For consistency we always mark the server socket + * tainted, however, to reduce the log noise we only + * emit a log message if the server socket could have + * actually been reused. + */ if ((csp->flags & CSP_FLAG_SERVER_CONNECTION_KEEP_ALIVE) && !(csp->flags |= CSP_FLAG_SERVER_SOCKET_TAINTED)) { log_error(LOG_LEVEL_CONNECT, "Marking the server socket %d tainted.", csp->server_connection.sfd); - csp->flags |= CSP_FLAG_SERVER_SOCKET_TAINTED; } + csp->flags |= CSP_FLAG_SERVER_SOCKET_TAINTED; } /********************************************************************* @@ -1418,7 +1352,7 @@ static jb_err receive_client_request(struct client_state *csp) { /* * We were able to read a complete - * header and can finaly enlist it. + * header and can finally enlist it. */ enlist(headers, p); freez(p); @@ -1561,7 +1495,7 @@ static jb_err parse_client_request(struct client_state *csp) * this function is called (via serve()) to handle the * main business of the communication. This function * returns after dealing with a single request. It can - * be called multiple times witht the same client socket + * be called multiple times with the same client socket * if the client is keeping the connection alive. * * The decision whether or not a client connection will @@ -1588,14 +1522,10 @@ static void chat(struct client_state *csp) int server_body; int ms_iis5_hack = 0; unsigned long long 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; long len = 0; /* for buffer sizes (and negative error codes) */ - - /* Function that does the content filtering for the current request */ - filter_function_ptr content_filter = NULL; + int buffer_and_filter_content = 0; /* Skeleton for HTTP response, if we should intercept the request */ struct http_response *rsp; @@ -1669,8 +1599,8 @@ static void chat(struct client_state *csp) csp->action->string[ACTION_STRING_LIMIT_CONNECT]; assert(NULL != acceptable_connect_ports); log_error(LOG_LEVEL_INFO, "Request from %s marked for blocking. " - "limit-connect{%s} doesn't allow CONNECT requests to port %d.", - csp->ip_addr_str, acceptable_connect_ports, csp->http->port); + "limit-connect{%s} doesn't allow CONNECT requests to %s", + csp->ip_addr_str, acceptable_connect_ports, csp->http->hostport); csp->action->flags |= ACTION_BLOCK; http->ssl = 0; } @@ -1687,12 +1617,8 @@ static void chat(struct client_state *csp) if (crunch_response_triggered(csp, crunchers_all)) { /* - * Yes. The client got the crunch response - * and we are done here after cleaning up. + * Yes. The client got the crunch response and we're done here. */ - /* XXX: why list_remove_all()? */ - list_remove_all(csp->headers); - return; } @@ -1731,14 +1657,7 @@ static void chat(struct client_state *csp) } #endif /* def FEATURE_CONNECTION_KEEP_ALIVE */ - while ((csp->server_connection.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); - } + csp->server_connection.sfd = forwarded_connect(fwd, http, csp); if (csp->server_connection.sfd == JB_INVALID_SOCKET) { @@ -1754,8 +1673,6 @@ static void chat(struct client_state *csp) else { rsp = error_response(csp, "connect-failed"); - log_error(LOG_LEVEL_CONNECT, "connect to: %s failed: %E", - http->hostport); } /* Write the answer to the client */ @@ -1865,9 +1782,14 @@ static void chat(struct client_state *csp) && ((csp->iob->eod - csp->iob->cur) >= 5) && !memcmp(csp->iob->eod-5, "0\r\n\r\n", 5)) { + /* + * XXX: This check should be obsolete now, + * but let's wait a while to be sure. + */ log_error(LOG_LEVEL_CONNECT, - "Looks like we read the last chunk together with " - "the server headers. We better stop reading."); + "Looks like we got the last chunk together with " + "the server headers but didn't detect it earlier. " + "We better stop reading."); byte_count = (unsigned long long)(csp->iob->eod - csp->iob->cur); csp->expected_content_length = byte_count; csp->flags |= CSP_FLAG_CONTENT_LENGTH_SET; @@ -2016,7 +1938,14 @@ static void chat(struct client_state *csp) if (FD_ISSET(csp->server_connection.sfd, &rfds)) { #ifdef FEATURE_CONNECTION_KEEP_ALIVE - if (!socket_is_still_alive(csp->cfd)) + /* + * If we are buffering content, we don't want to eat up to + * buffer-limit bytes if the client no longer cares about them. + * If we aren't buffering, however, a dead client socket will be + * noticed pretty much right away anyway, so we can reduce the + * overhead by skipping the check. + */ + if (buffer_and_filter_content && !socket_is_still_alive(csp->cfd)) { #ifdef _WIN32 log_error(LOG_LEVEL_CONNECT, @@ -2120,11 +2049,11 @@ static void chat(struct client_state *csp) * now is the time to apply content modification * and send the result to the client. */ - if (content_filter) + if (buffer_and_filter_content) { - p = execute_content_filter(csp, content_filter); + p = execute_content_filters(csp); /* - * If the content filter fails, use the original + * If content filtering fails, use the original * buffer and length. * (see p != NULL ? p : csp->iob->cur below) */ @@ -2132,6 +2061,19 @@ static void chat(struct client_state *csp) { csp->content_length = (size_t)(csp->iob->eod - csp->iob->cur); } +#ifdef FEATURE_COMPRESSION + else if ((csp->flags & CSP_FLAG_CLIENT_SUPPORTS_DEFLATE) + && (csp->content_length > LOWER_LENGTH_LIMIT_FOR_COMRPESSION)) + { + char *compressed_content = compress_buffer(p, (size_t *)&csp->content_length); + if (compressed_content != NULL) + { + freez(p); + p = compressed_content; + csp->flags |= CSP_FLAG_BUFFERED_CONTENT_DEFLATED; + } + } +#endif if (JB_ERR_OK != update_server_headers(csp)) { @@ -2186,7 +2128,7 @@ static void chat(struct client_state *csp) */ if (server_body || http->ssl) { - if (content_filter) + if (buffer_and_filter_content) { /* * If there is no memory left for buffering the content, or the buffer limit @@ -2234,7 +2176,7 @@ static void chat(struct client_state *csp) */ byte_count = (unsigned long long)flushed; freez(hdr); - content_filter = NULL; + buffer_and_filter_content = 0; server_body = 1; } } @@ -2370,6 +2312,19 @@ static void chat(struct client_state *csp) log_error(LOG_LEVEL_FATAL, "Out of memory parsing server header"); } + if ((csp->flags & CSP_FLAG_CHUNKED) + && !(csp->flags & CSP_FLAG_CONTENT_LENGTH_SET) + && ((csp->iob->eod - csp->iob->cur) >= 5) + && !memcmp(csp->iob->eod-5, "0\r\n\r\n", 5)) + { + log_error(LOG_LEVEL_CONNECT, + "Looks like we got the last chunk together with " + "the server headers. We better stop reading."); + byte_count = (unsigned long long)(csp->iob->eod - csp->iob->cur); + csp->expected_content_length = byte_count; + csp->flags |= CSP_FLAG_CONTENT_LENGTH_SET; + } + csp->server_connection.response_received = time(NULL); if (crunch_response_triggered(csp, crunchers_light)) @@ -2388,12 +2343,12 @@ static void chat(struct client_state *csp) if (!http->ssl) /* We talk plaintext */ { - content_filter = get_filter_function(csp); + buffer_and_filter_content = content_requires_filtering(csp); } /* * Only write if we're not buffering for content modification */ - if (!content_filter) + if (!buffer_and_filter_content) { /* * Write the server's (modified) header to @@ -2448,7 +2403,7 @@ static void chat(struct client_state *csp) if (csp->content_length == 0) { /* - * If Privoxy didn't recalculate the Content-Lenght, + * If Privoxy didn't recalculate the Content-Length, * byte_count is still correct. */ csp->content_length = byte_count; @@ -2541,6 +2496,7 @@ static void serve(struct client_state *csp) do { unsigned int latency; + int config_file_change_detected = 0; /* Only used for debugging */ chat(csp); @@ -2556,7 +2512,8 @@ static void serve(struct client_state *csp) && (((csp->flags & CSP_FLAG_SERVER_CONNECTION_KEEP_ALIVE) && !(csp->flags & CSP_FLAG_SERVER_SOCKET_TAINTED)) || (csp->flags & CSP_FLAG_CRUNCHED)) - && (csp->cfd != JB_INVALID_SOCKET); + && (csp->cfd != JB_INVALID_SOCKET) + && (csp->flags & CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE); if (continue_chatting && !(csp->flags & CSP_FLAG_CRUNCHED)) { @@ -2575,6 +2532,12 @@ static void serve(struct client_state *csp) } } + if (continue_chatting && any_loaded_file_changed(csp->config->config_file_list)) + { + continue_chatting = 0; + config_file_change_detected = 1; + } + if (continue_chatting) { unsigned int client_timeout; @@ -2598,9 +2561,8 @@ static void serve(struct client_state *csp) && data_is_available(csp->cfd, (int)client_timeout) && socket_is_still_alive(csp->cfd)) { - log_error(LOG_LEVEL_CONNECT, "Client request arrived in " - "time or the client closed the connection on socket %d.", - csp->cfd); + log_error(LOG_LEVEL_CONNECT, + "Client request arrived in time on socket %d.", csp->cfd); prepare_csp_for_next_request(csp); } else @@ -2614,7 +2576,7 @@ static void serve(struct client_state *csp) { time_t time_open = time(NULL) - csp->server_connection.timestamp; - if (csp->server_connection.keep_alive_timeout < time_open + latency) + if (csp->server_connection.keep_alive_timeout < time_open - (time_t)latency) { break; } @@ -2641,8 +2603,17 @@ static void serve(struct client_state *csp) else if (csp->server_connection.sfd != JB_INVALID_SOCKET) { log_error(LOG_LEVEL_CONNECT, - "The connection on server socket %d to %s isn't reusable. " - "Closing.", csp->server_connection.sfd, csp->server_connection.host); + "The connection on server socket %d to %s isn't reusable. Closing. " + "Server connection: keep-alive %u, tainted: %u, socket alive %u. " + "Client connection: socket alive: %u. Server timeout: %u. " + "Configuration file change detected: %u", + csp->server_connection.sfd, csp->server_connection.host, + 0 != (csp->flags & CSP_FLAG_SERVER_CONNECTION_KEEP_ALIVE), + 0 != (csp->flags & CSP_FLAG_SERVER_SOCKET_TAINTED), + socket_is_still_alive(csp->server_connection.sfd), + socket_is_still_alive(csp->cfd), + csp->server_connection.keep_alive_timeout, + config_file_change_detected); } } while (continue_chatting); @@ -2905,7 +2876,6 @@ int main(int argc, char **argv) #ifdef unix struct passwd *pw = NULL; struct group *grp = NULL; - char *p; int do_chroot = 0; char *pre_chroot_nslookup_to_load_resolver = NULL; #endif @@ -2944,7 +2914,7 @@ int main(int argc, char **argv) pName++; exit( (install_service(pName)) ? 0 : 1 ); } - else if (strncmp(argv[argc_pos], "--uninstall", + 11) == 0) + else if (strncmp(argv[argc_pos], "--uninstall", 11) == 0) { const char *pName = argv[argc_pos] + 11; if (*pName == ':') @@ -2990,23 +2960,39 @@ int main(int argc, char **argv) else if (strcmp(argv[argc_pos], "--user" ) == 0) { + char *user_arg; + char *group_name; + if (++argc_pos == argc) usage(argv[argc_pos]); - if ((NULL != (p = strchr(argv[argc_pos], '.'))) && *(p + 1) != '0') + user_arg = strdup(argv[argc_pos]); + if (NULL == user_arg) + { + log_error(LOG_LEVEL_FATAL, + "Out of memory splitting --user argument '%s'.", argv[argc_pos]); + } + group_name = strchr(user_arg, '.'); + if (NULL != group_name) { - *p++ = '\0'; - if (NULL == (grp = getgrnam(p))) + /* Nul-terminate the user name */ + *group_name = '\0'; + + /* Skip the former delimiter to actually reach the group name */ + group_name++; + + grp = getgrnam(group_name); + if (NULL == grp) { - log_error(LOG_LEVEL_FATAL, "Group %s not found.", p); + log_error(LOG_LEVEL_FATAL, "Group '%s' not found.", group_name); } } - - if (NULL == (pw = getpwnam(argv[argc_pos]))) + pw = getpwnam(user_arg); + if (NULL == pw) { - log_error(LOG_LEVEL_FATAL, "User %s not found.", argv[argc_pos]); + log_error(LOG_LEVEL_FATAL, "User '%s' not found.", user_arg); } - if (p != NULL) *--p = '\0'; + freez(user_arg); } else if (strcmp(argv[argc_pos], "--pre-chroot-nslookup" ) == 0) @@ -3417,6 +3403,7 @@ void w32_service_listen_loop(void *p) *********************************************************************/ static void listen_loop(void) { + struct client_states *csp_list = NULL; struct client_state *csp = NULL; jb_socket bfd; struct configuration_spec *config; @@ -3466,11 +3453,36 @@ static void listen_loop(void) } #endif - if ( NULL == (csp = (struct client_state *) zalloc(sizeof(*csp))) ) + csp_list = (struct client_states *)zalloc(sizeof(*csp_list)); + if (NULL == csp_list) { - log_error(LOG_LEVEL_FATAL, "malloc(%d) for csp failed: %E", sizeof(*csp)); + log_error(LOG_LEVEL_FATAL, + "malloc(%d) for csp_list failed: %E", sizeof(*csp_list)); continue; } + csp = &csp_list->csp; + + log_error(LOG_LEVEL_CONNECT, "Listening for new connections ... "); + + if (!accept_connection(csp, bfd)) + { + log_error(LOG_LEVEL_CONNECT, "accept failed: %E"); + +#ifdef AMIGA + if(!childs) + { + exit(1); + } +#endif + freez(csp_list); + continue; + } + else + { + log_error(LOG_LEVEL_CONNECT, + "accepted connection from %s on socket %d", + csp->ip_addr_str, csp->cfd); + } csp->flags |= CSP_FLAG_ACTIVE; csp->server_connection.sfd = JB_INVALID_SOCKET; @@ -3497,26 +3509,6 @@ static void listen_loop(void) bfd = bind_port_helper(config); } - log_error(LOG_LEVEL_CONNECT, "Listening for new connections ... "); - - if (!accept_connection(csp, bfd)) - { - log_error(LOG_LEVEL_CONNECT, "accept failed: %E"); - -#ifdef AMIGA - if(!childs) - { - exit(1); - } -#endif - freez(csp); - continue; - } - else - { - log_error(LOG_LEVEL_CONNECT, "accepted connection from %s", csp->ip_addr_str); - } - #ifdef FEATURE_TOGGLE if (global_toggle_state) #endif /* def FEATURE_TOGGLE */ @@ -3536,7 +3528,7 @@ static void listen_loop(void) log_error(LOG_LEVEL_CONNECT, "Connection from %s dropped due to ACL", csp->ip_addr_str); close_socket(csp->cfd); freez(csp->ip_addr_str); - freez(csp); + freez(csp_list); continue; } #endif /* def FEATURE_ACL */ @@ -3551,19 +3543,19 @@ static void listen_loop(void) strlen(TOO_MANY_CONNECTIONS_RESPONSE)); close_socket(csp->cfd); freez(csp->ip_addr_str); - freez(csp); + freez(csp_list); continue; } /* add it to the list of clients */ - csp->next = clients->next; - clients->next = csp; + csp_list->next = clients->next; + clients->next = csp_list; if (config->multi_threaded) { int child_id; -/* this is a switch () statment in the C preprocessor - ugh */ +/* this is a switch () statement in the C preprocessor - ugh */ #undef SELECTED_ONE_OPTION /* Use Pthreads in preference to native code */ @@ -3776,7 +3768,6 @@ static void listen_loop(void) #if defined(unix) freez(basedir); #endif - freez(configfile); #if defined(_WIN32) && !defined(_WIN_CONSOLE) /* Cleanup - remove taskbar icon etc. */