-const char jcc_rcs[] = "$Id: jcc.c,v 1.193 2008/10/12 15:57:35 fabiankeil Exp $";
+const char jcc_rcs[] = "$Id: jcc.c,v 1.248 2009/05/10 10:25:19 fabiankeil Exp $";
/*********************************************************************
*
* File : $Source: /cvsroot/ijbswa/current/jcc.c,v $
* Purpose : Main file. Contains main() method, main loop, and
* the main connection-handling function.
*
- * Copyright : Written by and Copyright (C) 2001-2008 the SourceForge
+ * Copyright : Written by and Copyright (C) 2001-2009 the SourceForge
* Privoxy team. http://www.privoxy.org/
*
* Based on the Internet Junkbuster originally written
*
* Revisions :
* $Log: jcc.c,v $
+ * Revision 1.248 2009/05/10 10:25:19 fabiankeil
+ * Change wait_for_alive_connection() prototype to use (void).
+ *
+ * Revision 1.247 2009/05/10 10:19:23 fabiankeil
+ * Reenable server-side-only keep-alive support, but only share
+ * outgoing connections if the connection-sharing option is set.
+ *
+ * Revision 1.246 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.245 2009/04/24 15:29:43 fabiankeil
+ * Allow to limit the number of of client connections.
+ *
+ * Revision 1.244 2009/04/17 11:34:34 fabiankeil
+ * Style cosmetics for the IPv6 code.
+ *
+ * Revision 1.243 2009/04/17 11:27:49 fabiankeil
+ * Petr Pisar's privoxy-3.0.12-ipv6-3.diff.
+ *
+ * Revision 1.242 2009/04/11 10:44:47 fabiankeil
+ * Update a comment. We're not in Kansas anymore.
+ *
+ * Revision 1.241 2009/04/11 10:37:23 fabiankeil
+ * When dropping connections due to ACL, don't leak csp->ip_addr_str.
+ *
+ * Revision 1.240 2009/04/09 10:12:54 fabiankeil
+ * Fix two cases in which an invalid server response would result
+ * in the client connection being closed without sending an error
+ * message first.
+ *
+ * Revision 1.239 2009/04/07 11:43:50 fabiankeil
+ * If the server rudely resets the connection directly after sending the
+ * headers, pass the mess to the client instead of sending an incorrect
+ * connect-failed message. Fixes #2698674 reported by mybugaccount.
+ *
+ * Revision 1.238 2009/03/27 14:42:30 fabiankeil
+ * Correct the status code for CONNECTION_TIMEOUT_RESPONSE.
+ *
+ * Revision 1.237 2009/03/27 14:32:04 fabiankeil
+ * If spawning a child in listen_loop() fails, send a real
+ * HTTP response to the client and continue listening for
+ * new connections without artificial delay.
+ *
+ * Revision 1.236 2009/03/25 17:30:24 fabiankeil
+ * In serve(), keep the client socket open until we marked the
+ * server socket as unused. This should increase the chances
+ * that we reuse the connection for the client's next request
+ * to the same destination.
+ *
+ * Revision 1.235 2009/03/18 21:01:20 fabiankeil
+ * Comment fix. Spotted by Roland.
+ *
+ * Revision 1.234 2009/03/18 20:48:42 fabiankeil
+ * If the --no-daemon option is used, enable LOG_LEVEL_INFO
+ * before the config file has been parsed (as we always did).
+ *
+ * Revision 1.233 2009/03/13 14:10:07 fabiankeil
+ * Fix some more harmless warnings on amd64.
+ *
+ * Revision 1.232 2009/03/08 19:29:16 fabiankeil
+ * Reinitialize the timeout structure every time before passing
+ * it to select(). Apparently some implementations mess with it.
+ * Probably fixes #2669131 reported by cyberpatrol.
+ *
+ * Revision 1.231 2009/03/08 14:19:23 fabiankeil
+ * Fix justified (but harmless) compiler warnings
+ * on platforms where sizeof(int) < sizeof(long).
+ *
+ * Revision 1.230 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.229 2009/03/07 11:17:01 fabiankeil
+ * Fix compiler warning.
+ *
+ * Revision 1.228 2009/03/06 20:30:13 fabiankeil
+ * Log unsigned values as such.
+ *
+ * Revision 1.227 2009/03/02 19:18:11 fabiankeil
+ * Streamline parse_http_request()'s prototype. As
+ * cparser pointed out it doesn't actually use csp.
+ *
+ * Revision 1.226 2009/03/01 18:28:24 fabiankeil
+ * Help clang understand that we aren't dereferencing
+ * NULL pointers here.
+ *
+ * Revision 1.225 2009/02/19 18:09:32 fabiankeil
+ * Unbreak build without FEATURE_CONNECTION_KEEP_ALIVE.
+ * Noticed by David.
+ *
+ * Revision 1.224 2009/02/14 15:32:04 fabiankeil
+ * Add the request URL to the timeout message in chat().
+ * Suggested by Lee.
+ *
+ * Revision 1.223 2009/02/09 21:21:16 fabiankeil
+ * Now that init_log_module() is called earlier, call show_version()
+ * later on from main() directly so it doesn't get called for --help
+ * or --version.
+ *
+ * Revision 1.222 2009/02/08 12:56:51 fabiankeil
+ * Call initialize_mutexes() before init_log_module() again.
+ * Broken since r220, might be the cause of Lee's #2579448.
+ *
+ * Revision 1.221 2009/02/06 18:02:58 fabiankeil
+ * When dropping privileges, also give up membership in supplementary
+ * groups. Thanks to Matthias Drochner for reporting the problem,
+ * providing the initial patch and testing the final version.
+ *
+ * Revision 1.220 2009/02/04 18:29:07 fabiankeil
+ * Initialize the log module before parsing arguments.
+ * Thanks to Matthias Drochner for the report.
+ *
+ * Revision 1.219 2009/01/31 16:08:21 fabiankeil
+ * Remove redundant error check in receive_client_request().
+ *
+ * Revision 1.218 2009/01/31 12:25:54 fabiankeil
+ * Flatten indentation in receive_client_request().
+ *
+ * Revision 1.217 2009/01/07 19:50:09 fabiankeil
+ * - If the socket-timeout has been reached and the client
+ * hasn't received any data yet, send an explanation before
+ * closing the connection.
+ * - In get_request_line(), signal timeouts the right way.
+ *
+ * Revision 1.216 2008/12/24 22:13:11 ler762
+ * fix GCC 3.4.4 warning
+ *
+ * Revision 1.215 2008/12/24 17:06:19 fabiankeil
+ * Keep a thread around to timeout alive connections
+ * even if no new requests are coming in.
+ *
+ * Revision 1.214 2008/12/20 14:53:55 fabiankeil
+ * Add config option socket-timeout to control the time
+ * Privoxy waits for data to arrive on a socket. Useful
+ * in case of stale ssh tunnels or when fuzz-testing.
+ *
+ * Revision 1.213 2008/12/15 18:45:51 fabiankeil
+ * When logging crunches, log the whole URL, so one can easily
+ * differentiate between vanilla HTTP and CONNECT requests.
+ *
+ * Revision 1.212 2008/12/14 15:46:22 fabiankeil
+ * Give crunched requests their own log level.
+ *
+ * Revision 1.211 2008/12/06 10:05:03 fabiankeil
+ * Downgrade "Received x bytes while expecting y." message to
+ * LOG_LEVEL_CONNECT as it doesn't necessarily indicate an error.
+ *
+ * Revision 1.210 2008/12/02 22:03:18 fabiankeil
+ * Don't miscalculate byte_count if we don't get all the
+ * server headers with one read_socket() call. With keep-alive
+ * support enabled, this caused delays until the server closed
+ * the connection.
+ *
+ * Revision 1.209 2008/11/27 09:44:04 fabiankeil
+ * Cosmetics for the last commit: Don't watch out for
+ * the last chunk if the content isn't chunk-encoded or
+ * if we already determined the content length previously.
+ *
+ * Revision 1.208 2008/11/26 18:24:17 fabiankeil
+ * Recognize that the server response is complete if the
+ * last chunk is read together with the server headers.
+ * Reported by Lee.
+ *
+ * Revision 1.207 2008/11/25 17:25:16 fabiankeil
+ * Don't convert the client-header list to text until we need to.
+ *
+ * Revision 1.206 2008/11/23 17:00:11 fabiankeil
+ * Some more chat() cosmetics.
+ *
+ * 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
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);
"Connection: close\r\n\r\n"
"Bad request. Messed up with header filters.\r\n";
+static const char TOO_MANY_CONNECTIONS_RESPONSE[] =
+ "HTTP/1.0 503 Too many open connections\r\n"
+ "Proxy-Agent: Privoxy " VERSION "\r\n"
+ "Content-Type: text/plain\r\n"
+ "Connection: close\r\n\r\n"
+ "Maximum number of open connections reached.\r\n";
+
+/* XXX: should be a template */
+static const char CONNECTION_TIMEOUT_RESPONSE[] =
+ "HTTP/1.0 504 Connection timeout\r\n"
+ "Proxy-Agent: Privoxy " VERSION "\r\n"
+ "Content-Type: text/plain\r\n"
+ "Connection: close\r\n\r\n"
+ "The connection timed out.\r\n";
+
/* A function to crunch a response */
typedef struct http_response *(*crunch_func_ptr)(struct client_state *);
}
/* Log that the request was crunched and why. */
- log_error(LOG_LEVEL_GPC, "%s%s crunch! (%s)",
- http->hostport, http->path, crunch_reason(rsp));
- log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" %s %d",
+ log_error(LOG_LEVEL_CRUNCH, "%s: %s", crunch_reason(rsp), http->url);
+ log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" %s %u",
csp->ip_addr_str, http->ocmd, status_code, rsp->content_length);
/* Clean up and return */
} while (tmp_len < len);
log_error(LOG_LEVEL_ERROR, "%s\'s request contains at least one NULL byte "
- "(length=%d, strlen=%d).", csp->ip_addr_str, len, c_len);
+ "(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);
log_error(LOG_LEVEL_INFO, "Rewrite detected: %s", csp->headers->first->str);
free_http_request(http);
- err = parse_http_request(csp->headers->first->str, http, csp);
+ err = parse_http_request(csp->headers->first->str, http);
if (JB_ERR_OK != err)
{
log_error(LOG_LEVEL_ERROR, "Couldn't parse rewritten request: %s.",
* FALSE otherwise.
*
*********************************************************************/
-static int server_response_is_complete(struct client_state *csp, size_t content_length)
+static int server_response_is_complete(struct client_state *csp,
+ unsigned long long content_length)
{
- int content_length_known = (csp->flags & CSP_FLAG_CONTENT_LENGTH_SET);
+ 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;
}
/*
* 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
+ * Function : wait_for_alive_connections
*
- * 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 : Waits for alive connections to timeout.
*
- * FIXME: chat is nearly thousand lines long.
- * Ridiculous.
+ * Parameters : N/A
+ *
+ * Returns : N/A
+ *
+ *********************************************************************/
+static void wait_for_alive_connections(void)
+{
+ int connections_alive = close_unusable_connections();
+
+ while (0 < connections_alive)
+ {
+ log_error(LOG_LEVEL_CONNECT,
+ "Waiting for %d connections to timeout.",
+ connections_alive);
+ sleep(60);
+ connections_alive = close_unusable_connections();
+ }
+
+ log_error(LOG_LEVEL_CONNECT, "No connections to wait for left.");
+
+}
+
+
+/*********************************************************************
+ *
+ * Function : save_connection_destination
+ *
+ * Description : Remembers a connection for reuse later on.
*
* Parameters :
- * 1 : csp = Current client state (buffers, headers, etc...)
+ * 1 : sfd = Open socket to remember.
+ * 2 : http = The destination for the connection.
+ * 3 : fwd = The forwarder settings used.
+ * 3 : server_connection = storage.
*
- * Returns : Nothing.
+ * Returns : void
*
*********************************************************************/
-static void chat(struct client_state *csp)
+void save_connection_destination(jb_socket sfd,
+ const struct http_request *http,
+ const struct forward_spec *fwd,
+ struct reusable_connection *server_connection)
{
- 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;
+ assert(sfd != JB_INVALID_SOCKET);
+ assert(NULL != http->host);
+ server_connection->host = strdup(http->host);
+ if (NULL == server_connection->host)
+ {
+ log_error(LOG_LEVEL_FATAL, "Out of memory saving socket.");
+ }
+ server_connection->port = http->port;
- /* Function that does the content filtering for the current request */
- filter_function_ptr content_filter = NULL;
+ assert(NULL != fwd);
+ assert(server_connection->gateway_host == NULL);
+ assert(server_connection->gateway_port == 0);
+ assert(server_connection->forwarder_type == 0);
+ assert(server_connection->forward_host == NULL);
+ assert(server_connection->forward_port == 0);
- /* Skeleton for HTTP response, if we should intercept the request */
- struct http_response *rsp;
+ server_connection->forwarder_type = fwd->type;
+ if (NULL != fwd->gateway_host)
+ {
+ server_connection->gateway_host = strdup(fwd->gateway_host);
+ if (NULL == server_connection->gateway_host)
+ {
+ log_error(LOG_LEVEL_FATAL, "Out of memory saving gateway_host.");
+ }
+ }
+ else
+ {
+ server_connection->gateway_host = NULL;
+ }
+ server_connection->gateway_port = fwd->gateway_port;
- /* Temporary copy of the client's headers before they get enlisted in csp->headers */
- struct list header_list;
- struct list *headers = &header_list;
+ if (NULL != fwd->forward_host)
+ {
+ server_connection->forward_host = strdup(fwd->forward_host);
+ if (NULL == server_connection->forward_host)
+ {
+ log_error(LOG_LEVEL_FATAL, "Out of memory saving forward_host.");
+ }
+ }
+ else
+ {
+ server_connection->forward_host = NULL;
+ }
+ server_connection->forward_port = fwd->forward_port;
+}
+#endif /* FEATURE_CONNECTION_KEEP_ALIVE */
- http = csp->http;
- memset(buf, 0, sizeof(buf));
+/*********************************************************************
+ *
+ * Function : mark_server_socket_tainted
+ *
+ * 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).
+ *
+ * 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;
+ }
+}
- /*
- * 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!
- */
+/*********************************************************************
+ *
+ * Function : get_request_line
+ *
+ * Description : Read the client request line.
+ *
+ * Parameters :
+ * 1 : csp = Current client state (buffers, headers, etc...)
+ *
+ * Returns : Pointer to request line or NULL in case of errors.
+ *
+ *********************************************************************/
+static char *get_request_line(struct client_state *csp)
+{
+ char buf[BUFFER_SIZE];
+ char *request_line = NULL;
+ int len;
+
+ memset(buf, 0, sizeof(buf));
do
{
+ if (!data_is_available(csp->cfd, csp->config->socket_timeout))
+ {
+ log_error(LOG_LEVEL_ERROR,
+ "Stopped waiting for the request line.");
+ write_socket(csp->cfd, CONNECTION_TIMEOUT_RESPONSE,
+ strlen(CONNECTION_TIMEOUT_RESPONSE));
+ return NULL;
+ }
+
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
*/
if (add_to_iob(csp, buf, len))
{
- return;
+ return NULL;
}
- req = get_header(csp->iob);
+ request_line = get_header(csp->iob);
- } while ((NULL != req) && ('\0' == *req));
+ } while ((NULL != request_line) && ('\0' == *request_line));
- if ((NULL != req) && ('\0' != *req))
- {
- /* Request received. Validate and parse it. */
+ return request_line;
-#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))
- {
- /*
- * Yes. The request has already been
- * answered with a error response, the buffers
- * were freed and we're done with chatting.
- */
- return;
- }
+
+/*********************************************************************
+ *
+ * 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 (req == NULL)
+ {
+ return JB_ERR_PARSE;
+ }
+ assert(*req != '\0');
+
+ if (client_protocol_is_unsupported(csp, req))
+ {
+ return JB_ERR_PARSE;
+ }
#ifdef FEATURE_FORCE_LOAD
- /*
- * If this request contains the FORCE_PREFIX and blocks
- * aren't enforced, get rid of it and set the force flag.
- */
- if (strstr(req, FORCE_PREFIX))
+ /*
+ * If this request contains the FORCE_PREFIX and blocks
+ * aren't enforced, get rid of it and set the force flag.
+ */
+ if (strstr(req, FORCE_PREFIX))
+ {
+ if (csp->config->feature_flags & RUNTIME_FEATURE_ENFORCE_BLOCKS)
{
- if (csp->config->feature_flags & RUNTIME_FEATURE_ENFORCE_BLOCKS)
- {
- log_error(LOG_LEVEL_FORCE,
- "Ignored force prefix in request: \"%s\".", req);
- }
- else
- {
- strclean(req, FORCE_PREFIX);
- log_error(LOG_LEVEL_FORCE, "Enforcing request: \"%s\".", req);
- csp->flags |= CSP_FLAG_FORCED;
- }
+ log_error(LOG_LEVEL_FORCE,
+ "Ignored force prefix in request: \"%s\".", req);
}
-
-#endif /* def FEATURE_FORCE_LOAD */
- err = parse_http_request(req, http, csp);
- if (JB_ERR_OK != err)
+ else
{
- log_error(LOG_LEVEL_ERROR, "Couldn't parse request: %s.", jb_err_to_string(err));
+ strclean(req, FORCE_PREFIX);
+ log_error(LOG_LEVEL_FORCE, "Enforcing request: \"%s\".", req);
+ csp->flags |= CSP_FLAG_FORCED;
}
-
- freez(req);
}
+#endif /* def FEATURE_FORCE_LOAD */
- if (http->cmd == NULL)
+ err = parse_http_request(req, http);
+ freez(req);
+ if (JB_ERR_OK != err)
{
write_socket(csp->cfd, CHEADER, strlen(CHEADER));
/* XXX: Use correct size */
log_error(LOG_LEVEL_CLF, "%s - - [%T] \"Invalid request\" 400 0", csp->ip_addr_str);
- log_error(LOG_LEVEL_ERROR, "Invalid header received from %s.", csp->ip_addr_str);
+ log_error(LOG_LEVEL_ERROR,
+ "Couldn't parse request line received from %s: %s",
+ csp->ip_addr_str, jb_err_to_string(err));
free_http_request(http);
- return;
+ return JB_ERR_PARSE;
}
/* grab the rest of the client's headers */
* We didn't receive a complete header
* line yet, get the rest of it.
*/
+ if (!data_is_available(csp->cfd, csp->config->socket_timeout))
+ {
+ log_error(LOG_LEVEL_ERROR,
+ "Stopped grabbing the client headers.");
+ return JB_ERR_PARSE;
+ }
+
len = read_socket(csp->cfd, buf, sizeof(buf) - 1);
if (len <= 0)
{
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))
* request, there is nothing we can do but hang up
*/
destroy_list(headers);
- return;
+ return JB_ERR_MEMORY;
}
}
else
* An error response has already been send
* and we're done here.
*/
- return;
+ return JB_ERR_PARSE;
}
}
* 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;
*/
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;
+ 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;
+
+ /* Skeleton for HTTP response, if we should intercept the request */
+ struct http_response *rsp;
+ struct timeval timeout;
+
+ 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;
}
{
log_error(LOG_LEVEL_FATAL, "gateway spec is NULL!?!? This can't happen!");
/* Never get here - LOG_LEVEL_FATAL causes program exit */
+ return;
}
/*
build_request_line(csp, fwd, &csp->headers->first->str);
}
- hdr = list_to_text(csp->headers);
- if (hdr == NULL)
- {
- /* FIXME Should handle error properly */
- log_error(LOG_LEVEL_FATAL, "Out of memory parsing client header");
- }
-
/*
* We have a request. Check if one of the crunchers wants it.
*/
* Yes. The client got the crunch response
* and we are done here after cleaning up.
*/
- freez(hdr);
+ /* XXX: why list_remove_all()? */
list_remove_all(csp->headers);
return;
}
- /*
- * The headers can't be removed earlier because
- * they were still needed for the referrer check
- * in case of CGI crunches.
- *
- * XXX: Would it be worth to move the referrer check
- * into client_referrer() and set a flag if it's trusted?
- */
- list_remove_all(csp->headers);
-
log_error(LOG_LEVEL_GPC, "%s%s", http->hostport, http->path);
if (fwd->forward_host)
{
- log_error(LOG_LEVEL_CONNECT, "via %s:%d to: %s",
- fwd->forward_host, fwd->forward_port, http->hostport);
+ log_error(LOG_LEVEL_CONNECT, "via [%s]:%d to: %s",
+ fwd->forward_host, fwd->forward_port, http->hostport);
}
else
{
/* 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))
+#ifdef FEATURE_CONNECTION_KEEP_ALIVE
+ if ((csp->sfd != JB_INVALID_SOCKET)
+ && socket_is_still_usable(csp->sfd)
+ && connection_destination_matches(&csp->server_connection, http, fwd))
{
- log_error(LOG_LEVEL_ERROR, "failed request #%u to connect to %s. Trying again.",
- forwarded_connect_retries, http->hostport);
+ log_error(LOG_LEVEL_CONNECT,
+ "Reusing server socket %u. Opened for %s.",
+ csp->sfd, csp->server_connection.host);
}
-
- if (csp->sfd == JB_INVALID_SOCKET)
+ else
{
- if (fwd->type != SOCKS_NONE)
+ if (csp->sfd != JB_INVALID_SOCKET)
{
- /* Socks error. */
- rsp = error_response(csp, "forwarding-failed", errno);
- }
- else if (errno == EINVAL)
- {
- rsp = error_response(csp, "no-such-domain", errno);
+ log_error(LOG_LEVEL_CONNECT,
+ "Closing server socket %u. Opened for %s.",
+ csp->sfd, csp->server_connection.host);
+ close_socket(csp->sfd);
+ mark_connection_closed(&csp->server_connection);
}
- else
+#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
+
+ while ((csp->sfd = forwarded_connect(fwd, http, csp))
+ && (errno == EINVAL)
+ && (forwarded_connect_retries++ < max_forwarded_connect_retries))
{
- rsp = error_response(csp, "connect-failed", errno);
- log_error(LOG_LEVEL_CONNECT, "connect to: %s failed: %E",
- http->hostport);
+ log_error(LOG_LEVEL_ERROR,
+ "failed request #%u to connect to %s. Trying again.",
+ forwarded_connect_retries, http->hostport);
}
- /* Write the answer to the client */
- if (rsp != NULL)
+ if (csp->sfd == JB_INVALID_SOCKET)
{
- send_crunch_response(csp, rsp);
+ if (fwd->type != SOCKS_NONE)
+ {
+ /* Socks error. */
+ rsp = error_response(csp, "forwarding-failed", errno);
+ }
+ else if (errno == EINVAL)
+ {
+ rsp = error_response(csp, "no-such-domain", errno);
+ }
+ else
+ {
+ rsp = error_response(csp, "connect-failed", errno);
+ log_error(LOG_LEVEL_CONNECT, "connect to: %s failed: %E",
+ http->hostport);
+ }
+
+ /* Write the answer to the client */
+ if (rsp != NULL)
+ {
+ send_crunch_response(csp, rsp);
+ }
+
+ return;
}
+#ifdef FEATURE_CONNECTION_KEEP_ALIVE
+ save_connection_destination(csp->sfd, http, fwd, &csp->server_connection);
+ csp->server_connection.keep_alive_timeout = (unsigned)csp->config->keep_alive_timeout;
+ }
+#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
- freez(hdr);
- return;
+ hdr = list_to_text(csp->headers);
+ if (hdr == NULL)
+ {
+ /* FIXME Should handle error properly */
+ log_error(LOG_LEVEL_FATAL, "Out of memory parsing client header");
}
+ list_remove_all(csp->headers);
if (fwd->forward_host || (http->ssl == 0))
{
FD_SET(csp->sfd, &rfds);
#ifdef FEATURE_CONNECTION_KEEP_ALIVE
+ 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 read 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;
+ }
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.",
+ "Done reading from server. Expected content length: %llu. "
+ "Actual content length: %llu. Most recently received: %d.",
csp->expected_content_length, byte_count, len);
len = 0;
/*
}
#endif /* FEATURE_CONNECTION_KEEP_ALIVE */
- n = select((int)maxfd+1, &rfds, NULL, NULL, NULL);
+ timeout.tv_sec = csp->config->socket_timeout;
+ timeout.tv_usec = 0;
+ n = select((int)maxfd+1, &rfds, NULL, NULL, &timeout);
- if (n < 0)
+ if (n == 0)
+ {
+ log_error(LOG_LEVEL_ERROR,
+ "Didn't receive data in time: %s", http->url);
+ if ((byte_count == 0) && (http->ssl == 0))
+ {
+ write_socket(csp->cfd, CONNECTION_TIMEOUT_RESPONSE,
+ strlen(CONNECTION_TIMEOUT_RESPONSE));
+ }
+ mark_server_socket_tainted(csp);
+ return;
+ }
+ else 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 and write it.
+ *
+ * XXX: Make sure the client doesn't use pipelining
+ * behind Privoxy's back.
*/
if (FD_ISSET(csp->cfd, &rfds))
{
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;
*/
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);
- }
-
- return;
+ /*
+ * XXX: Consider handling the cases above the same.
+ */
+ mark_server_socket_tainted(csp);
+ len = 0;
}
#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 + (unsigned long long)len;
csp->flags |= CSP_FLAG_CONTENT_LENGTH_SET;
}
}
}
if (write_socket(csp->cfd, hdr, strlen(hdr))
- || write_socket(csp->cfd, p != NULL ? p : csp->iob->cur, csp->content_length))
+ || write_socket(csp->cfd,
+ ((p != NULL) ? p : csp->iob->cur), (size_t)csp->content_length))
{
log_error(LOG_LEVEL_ERROR, "write modified content to client failed: %E");
freez(hdr);
freez(p);
+ mark_server_socket_tainted(csp);
return;
}
if (add_to_iob(csp, buf, len))
{
size_t hdrlen;
- int flushed;
+ long flushed;
log_error(LOG_LEVEL_INFO,
"Flushing header and buffers. Stepping back from filtering.");
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);
log_error(LOG_LEVEL_CONNECT,
"Flush header and buffers to client failed: %E");
freez(hdr);
+ mark_server_socket_tainted(csp);
return;
}
* we just flushed. len will be added a few lines below,
* hdrlen doesn't matter for LOG_LEVEL_CLF.
*/
- byte_count = (size_t)flushed;
+ byte_count = (unsigned long long)flushed;
freez(hdr);
content_filter = NULL;
server_body = 1;
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;
}
}
- byte_count += (size_t)len;
+ byte_count += (unsigned long long)len;
continue;
}
else
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;
}
* The header is incomplete and there isn't anything
* we can do about it.
*/
- log_error(LOG_LEVEL_INFO,
- "MS IIS5 hack didn't produce valid headers.");
- break;
+ log_error(LOG_LEVEL_ERROR, "Invalid server headers. "
+ "Applying the MS IIS5 hack didn't help.");
+ log_error(LOG_LEVEL_CLF,
+ "%s - - [%T] \"%s\" 502 0", csp->ip_addr_str, http->cmd);
+ write_socket(csp->cfd, INVALID_SERVER_HEADERS_RESPONSE,
+ strlen(INVALID_SERVER_HEADERS_RESPONSE));
+ mark_server_socket_tainted(csp);
+ return;
}
else
{
* Since we have to wait for more from the server before
* we can parse the headers we just continue here.
*/
+ long header_offset = csp->iob->cur - header_start;
+ assert(csp->iob->cur >= header_start);
+ byte_count += (unsigned long long)(len - header_offset);
+ log_error(LOG_LEVEL_CONNECT, "Continuing buffering headers. "
+ "byte_count: %llu. header_offset: %d. len: %d.",
+ byte_count, header_offset, len);
continue;
}
}
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;
}
write_socket(csp->cfd, INVALID_SERVER_HEADERS_RESPONSE,
strlen(INVALID_SERVER_HEADERS_RESPONSE));
free_http_request(http);
+ mark_server_socket_tainted(csp);
return;
}
* and are done here after cleaning up.
*/
freez(hdr);
+ mark_server_socket_tainted(csp);
return;
}
/* Buffer and pcrs filter this if appropriate. */
* to the client... it probably can't hear us anyway.
*/
freez(hdr);
+ mark_server_socket_tainted(csp);
return;
}
- byte_count += (size_t)len;
+ byte_count += (unsigned long long)len;
}
else
{
* XXX: the header lenght should probably
* be calculated by get_server_headers().
*/
- int header_length = csp->iob->cur - header_start;
+ long header_length = csp->iob->cur - header_start;
assert(csp->iob->cur > header_start);
- byte_count += len - header_length;
+ byte_count += (unsigned long long)(len - header_length);
}
/* we're finished with the server's header */
*/
if (ms_iis5_hack)
{
- log_error(LOG_LEVEL_INFO,
- "Closed server connection detected with MS IIS5 hack enabled.");
- break;
+ log_error(LOG_LEVEL_ERROR,
+ "Closed server connection detected. "
+ "Applying the MS IIS5 hack didn't help.");
+ log_error(LOG_LEVEL_CLF,
+ "%s - - [%T] \"%s\" 502 0", csp->ip_addr_str, http->cmd);
+ write_socket(csp->cfd, INVALID_SERVER_HEADERS_RESPONSE,
+ strlen(INVALID_SERVER_HEADERS_RESPONSE));
+ mark_server_socket_tainted(csp);
+ return;
}
}
continue;
}
-
+ mark_server_socket_tainted(csp);
return; /* huh? we should never get here */
}
csp->content_length = byte_count;
}
- log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 200 %d",
+#ifdef FEATURE_CONNECTION_KEEP_ALIVE
+ if ((csp->flags & CSP_FLAG_CONTENT_LENGTH_SET)
+ && (csp->expected_content_length != byte_count))
+ {
+ log_error(LOG_LEVEL_CONNECT,
+ "Received %llu bytes while expecting %llu.",
+ byte_count, csp->expected_content_length);
+ mark_server_socket_tainted(csp);
+ }
+#endif
+
+ log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 200 %llu",
csp->ip_addr_str, http->ocmd, csp->content_length);
}
* Function : serve
*
* Description : This is little more than chat. We only "serve" to
- * to close any socket that chat may have opened.
+ * to close (or remember) any socket that chat may have
+ * opened.
*
* Parameters :
* 1 : csp = Current client state (buffers, headers, etc...)
static void serve(struct client_state *csp)
#endif /* def AMIGA */
{
- chat(csp);
- close_socket(csp->cfd);
-
- if (csp->sfd != JB_INVALID_SOCKET)
- {
#ifdef FEATURE_CONNECTION_KEEP_ALIVE
- if ((csp->flags & CSP_FLAG_SERVER_CONNECTION_KEEP_ALIVE))
+ static int monitor_thread_running = 0;
+ int continue_chatting = 0;
+ do
+ {
+ chat(csp);
+
+ continue_chatting = (csp->config->feature_flags
+ & RUNTIME_FEATURE_CONNECTION_KEEP_ALIVE)
+ && (csp->flags & CSP_FLAG_SERVER_CONNECTION_KEEP_ALIVE)
+ && (csp->cfd != JB_INVALID_SOCKET)
+ && (csp->sfd != JB_INVALID_SOCKET)
+ && socket_is_still_usable(csp->sfd);
+
+ if (continue_chatting)
{
- remember_connection(csp->sfd, csp->http, forward_url(csp, csp->http));
+ log_error(LOG_LEVEL_CONNECT,
+ "Waiting for the next client request. "
+ "Keeping the server socket %d to %s open.",
+ csp->sfd, csp->server_connection.host);
+
+ if ((csp->flags & CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE)
+ && data_is_available(csp->cfd, (int)csp->server_connection.keep_alive_timeout)
+ && socket_is_still_usable(csp->cfd))
+ {
+ log_error(LOG_LEVEL_CONNECT, "Client request arrived in "
+ "time or the client closed the connection.");
+ /*
+ * Get the csp in a mostly vergin state again.
+ * XXX: Should be done elsewhere.
+ */
+ csp->content_type = 0;
+ csp->content_length = 0;
+ csp->expected_content_length = 0;
+ list_remove_all(csp->headers);
+ freez(csp->iob->buf);
+ memset(csp->iob, 0, sizeof(csp->iob));
+ freez(csp->error_message);
+ free_http_request(csp->http);
+ destroy_list(csp->headers);
+ destroy_list(csp->tags);
+ free_current_action(csp->action);
+ if (NULL != csp->fwd)
+ {
+ unload_forward_spec(csp->fwd);
+ csp->fwd = NULL;
+ }
+
+ /* XXX: Store per-connection flags someplace else. */
+ csp->flags = CSP_FLAG_ACTIVE | (csp->flags & CSP_FLAG_TOGGLED_ON);
+ }
+ else
+ {
+ log_error(LOG_LEVEL_CONNECT,
+ "No additional client request received in time.");
+ if ((csp->config->feature_flags & RUNTIME_FEATURE_CONNECTION_SHARING))
+ {
+ remember_connection(csp->sfd, csp->http,
+ forward_url(csp, csp->http),
+ csp->server_connection.keep_alive_timeout);
+ csp->sfd = JB_INVALID_SOCKET;
+ close_socket(csp->cfd);
+ csp->cfd = JB_INVALID_SOCKET;
+ privoxy_mutex_lock(&connection_reuse_mutex);
+ if (!monitor_thread_running)
+ {
+ monitor_thread_running = 1;
+ privoxy_mutex_unlock(&connection_reuse_mutex);
+ wait_for_alive_connections();
+ privoxy_mutex_lock(&connection_reuse_mutex);
+ monitor_thread_running = 0;
+ }
+ privoxy_mutex_unlock(&connection_reuse_mutex);
+ }
+ break;
+ }
}
- else
+ else if (csp->sfd != JB_INVALID_SOCKET)
{
- forget_connection(csp->sfd);
- close_socket(csp->sfd);
+ log_error(LOG_LEVEL_CONNECT,
+ "The connection on server socket %d to %s isn't reusable. "
+ "Closing.", csp->sfd, csp->server_connection.host);
}
+ } while (continue_chatting);
+
+ mark_connection_closed(&csp->server_connection);
#else
- close_socket(csp->sfd);
+ chat(csp);
+#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
+
+ if (csp->sfd != JB_INVALID_SOCKET)
+ {
+#ifdef FEATURE_CONNECTION_KEEP_ALIVE
+ forget_connection(csp->sfd);
#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
+ close_socket(csp->sfd);
+ }
+
+ if (csp->cfd != JB_INVALID_SOCKET)
+ {
+ close_socket(csp->cfd);
}
csp->flags &= ~CSP_FLAG_ACTIVE;
#endif
;
+ /* Prepare mutexes if supported and necessary. */
+ initialize_mutexes();
+
+ /* Enable logging until further notice. */
+ init_log_module();
+
/*
* Parse the command line arguments
*
else if (strcmp(argv[argc_pos], "--no-daemon" ) == 0)
{
+ set_debug_level(LOG_LEVEL_FATAL | LOG_LEVEL_ERROR | LOG_LEVEL_INFO);
no_daemon = 1;
}
} /* -END- while (more arguments) */
+ show_version(Argv[0]);
+
#if defined(unix)
if ( *configfile != '/' )
{
InitWin32();
#endif
- /* Prepare mutexes if supported and necessary. */
- initialize_mutexes();
-
- /* Enable logging until further notice. */
- init_log_module(Argv[0]);
-
random_seed = (unsigned int)time(NULL);
#ifdef HAVE_RANDOM
srandom(random_seed);
}
#endif /* 1 */
/*
- * stderr (fd 2) will be closed later on, when the
- * log file has been parsed.
+ * stderr (fd 2) will be closed later on,
+ * when the config file has been parsed.
*/
close( 0 );
{
log_error(LOG_LEVEL_FATAL, "Cannot setgid(): Insufficient permissions.");
}
+ if (NULL != grp)
+ {
+ if (setgroups(1, &grp->gr_gid))
+ {
+ log_error(LOG_LEVEL_FATAL, "setgroups() failed: %E");
+ }
+ }
+ else if (initgroups(pw->pw_name, pw->pw_gid))
+ {
+ log_error(LOG_LEVEL_FATAL, "initgroups() failed: %E");
+ }
if (do_chroot)
{
if (!pw->pw_dir)
{
struct client_state *csp = NULL;
jb_socket bfd;
- struct configuration_spec * config;
+ struct configuration_spec *config;
+ unsigned int active_threads = 0;
config = load_config();
/*
* Free data that was used by died threads
*/
- sweep();
+ active_threads = sweep();
#if defined(unix)
/*
*/
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
{
/*
* Since we were listening to the "old port", we will not see
- * a "listen" param change until the next IJB request. So, at
+ * a "listen" param change until the next request. So, at
* least 1 more request must be made for us to find the new
* setting. I am simply closing the old socket and binding the
* new one.
{
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);
continue;
}
#endif /* def FEATURE_ACL */
+ if ((0 != config->max_client_connections)
+ && (active_threads >= config->max_client_connections))
+ {
+ log_error(LOG_LEVEL_CONNECT,
+ "Rejecting connection from %s. Maximum number of connections reached.",
+ csp->ip_addr_str);
+ write_socket(csp->cfd, TOO_MANY_CONNECTIONS_RESPONSE,
+ strlen(TOO_MANY_CONNECTIONS_RESPONSE));
+ close_socket(csp->cfd);
+ freez(csp->ip_addr_str);
+ freez(csp);
+ continue;
+ }
+
/* add it to the list of clients */
csp->next = clients->next;
clients->next = csp;
#undef SELECTED_ONE_OPTION
/* end of cpp switch () */
- if (child_id < 0) /* failed */
+ if (child_id < 0)
{
- char buf[BUFFER_SIZE];
-
- log_error(LOG_LEVEL_ERROR, "can't fork: %E");
-
- snprintf(buf , sizeof(buf), "Privoxy: can't fork: errno = %d", errno);
-
- write_socket(csp->cfd, buf, strlen(buf));
+ /*
+ * Spawning the child failed, assume it's because
+ * there are too many children running already.
+ * XXX: If you assume ...
+ */
+ log_error(LOG_LEVEL_ERROR,
+ "Unable to take any additional connections: %E");
+ write_socket(csp->cfd, TOO_MANY_CONNECTIONS_RESPONSE,
+ strlen(TOO_MANY_CONNECTIONS_RESPONSE));
close_socket(csp->cfd);
csp->flags &= ~CSP_FLAG_ACTIVE;
- sleep(5);
- continue;
}
}
else