-const char jcc_rcs[] = "$Id: jcc.c,v 1.380 2012/07/23 12:39:42 fabiankeil Exp $";
+const char jcc_rcs[] = "$Id: jcc.c,v 1.445 2016/05/25 10:51:10 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-2010 the
+ * Copyright : Written by and Copyright (C) 2001-2016 the
* Privoxy team. http://www.privoxy.org/
*
* Based on the Internet Junkbuster originally written
#include "cgi.h"
#include "loadcfg.h"
#include "urlmatch.h"
+#ifdef FEATURE_CLIENT_TAGS
+#include "client-tags.h"
+#endif
const char jcc_h_rcs[] = JCC_H_VERSION;
const char project_h_rcs[] = PROJECT_H_VERSION;
privoxy_mutex_t log_init_mutex;
privoxy_mutex_t connection_reuse_mutex;
+#ifdef FEATURE_EXTERNAL_FILTERS
+privoxy_mutex_t external_filter_mutex;
+#endif
+#ifdef FEATURE_CLIENT_TAGS
+privoxy_mutex_t client_tags_mutex;
+#endif
+
#if !defined(HAVE_GETHOSTBYADDR_R) || !defined(HAVE_GETHOSTBYNAME_R)
privoxy_mutex_t resolver_mutex;
#endif /* !defined(HAVE_GETHOSTBYADDR_R) || !defined(HAVE_GETHOSTBYNAME_R) */
/* HTTP snipplets. */
static const char CSUCCEED[] =
- "HTTP/1.1 200 Connection established\r\n"
- "Proxy-Agent: Privoxy/" VERSION "\r\n\r\n";
+ "HTTP/1.1 200 Connection established\r\n\r\n";
static const char CHEADER[] =
"HTTP/1.1 400 Invalid header received from client\r\n"
- "Proxy-Agent: Privoxy " VERSION "\r\n"
"Content-Type: text/plain\r\n"
"Connection: close\r\n\r\n"
"Invalid header received from client.\r\n";
/* XXX: should be a template */
static const char MISSING_DESTINATION_RESPONSE[] =
"HTTP/1.1 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. Privoxy was unable to extract the destination.\r\n";
/* XXX: should be a template */
static const char INVALID_SERVER_HEADERS_RESPONSE[] =
"HTTP/1.1 502 Server or forwarder response invalid\r\n"
- "Proxy-Agent: Privoxy " VERSION "\r\n"
"Content-Type: text/plain\r\n"
"Connection: close\r\n\r\n"
"Bad response. The server or forwarder response doesn't look like HTTP.\r\n";
/* XXX: should be a template */
static const char MESSED_UP_REQUEST_RESPONSE[] =
"HTTP/1.1 400 Malformed request after rewriting\r\n"
- "Proxy-Agent: Privoxy " VERSION "\r\n"
"Content-Type: text/plain\r\n"
"Connection: close\r\n\r\n"
"Bad request. Messed up with header filters.\r\n";
static const char TOO_MANY_CONNECTIONS_RESPONSE[] =
"HTTP/1.1 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";
static const char CLIENT_CONNECTION_TIMEOUT_RESPONSE[] =
"HTTP/1.1 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 because the client request didn't arrive in time.\r\n";
+static const char CLIENT_BODY_PARSE_ERROR_RESPONSE[] =
+ "HTTP/1.1 400 Failed reading client body\r\n"
+ "Content-Type: text/plain\r\n"
+ "Connection: close\r\n\r\n"
+ "Failed parsing or buffering the chunk-encoded client body.\r\n";
+
+static const char UNSUPPORTED_CLIENT_EXPECTATION_ERROR_RESPONSE[] =
+ "HTTP/1.1 417 Expecting too much\r\n"
+ "Content-Type: text/plain\r\n"
+ "Connection: close\r\n\r\n"
+ "Privoxy detected an unsupported Expect header value.\r\n";
+
/* A function to crunch a response */
typedef struct http_response *(*crunch_func_ptr)(struct client_state *);
}
+/*********************************************************************
+ *
+ * Function : client_has_unsupported_expectations
+ *
+ * Description : Checks if the client used an unsupported expectation
+ * in which case an error message is delivered.
+ *
+ * Parameters :
+ * 1 : csp = Current client state (buffers, headers, etc...)
+ *
+ * Returns : TRUE if an error response has been generated, or
+ * FALSE if the request doesn't look invalid.
+ *
+ *********************************************************************/
+static int client_has_unsupported_expectations(const struct client_state *csp)
+{
+ if ((csp->flags & CSP_FLAG_UNSUPPORTED_CLIENT_EXPECTATION))
+ {
+ log_error(LOG_LEVEL_ERROR,
+ "Rejecting request from client %s with unsupported Expect header value",
+ csp->ip_addr_str);
+ log_error(LOG_LEVEL_CLF,
+ "%s - - [%T] \"%s\" 417 0", csp->ip_addr_str, csp->http->cmd);
+ write_socket(csp->cfd, UNSUPPORTED_CLIENT_EXPECTATION_ERROR_RESPONSE,
+ strlen(UNSUPPORTED_CLIENT_EXPECTATION_ERROR_RESPONSE));
+
+ return TRUE;
+ }
+
+ return FALSE;
+
+}
+
+
/*********************************************************************
*
* Function : get_request_destination_elsewhere
}
+/*********************************************************************
+ *
+ * Function : log_applied_actions
+ *
+ * Description : Logs the applied actions if LOG_LEVEL_ACTIONS is
+ * enabled.
+ *
+ * Parameters :
+ * 1 : actions = Current action spec to log
+ *
+ * Returns : Nothing.
+ *
+ *********************************************************************/
+static void log_applied_actions(const struct current_action_spec *actions)
+{
+ /*
+ * The conversion to text requires lots of memory allocations so
+ * we only do the conversion if the user is actually interested.
+ */
+ if (debug_level_is_enabled(LOG_LEVEL_ACTIONS))
+ {
+ char *actions_as_text = actions_to_line_of_text(actions);
+ log_error(LOG_LEVEL_ACTIONS, "%s", actions_as_text);
+ freez(actions_as_text);
+ }
+}
+
+
/*********************************************************************
*
* Function : send_crunch_response
status_code[3] = '\0';
/* Log that the request was crunched and why. */
+ log_applied_actions(csp->action);
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);
*request_line = strdup(http->gpc);
string_append(request_line, " ");
- if (fwd->forward_host)
+ if (fwd->forward_host && fwd->type != FORWARD_WEBSERVER)
{
string_append(request_line, http->url);
}
struct http_request *http = csp->http;
jb_err err;
- log_error(LOG_LEVEL_INFO, "Rewrite detected: %s", csp->headers->first->str);
+ log_error(LOG_LEVEL_REDIRECTS, "Rewrite detected: %s",
+ csp->headers->first->str);
free_http_request(http);
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.",
jb_err_to_string(err));
}
- else
- {
- /* XXX: ocmd is a misleading name */
- http->ocmd = strdup_or_die(http->cmd);
- }
return err;
}
*/
csp->expected_content_length = 0;
content_length_known = TRUE;
+ csp->flags |= CSP_FLAG_SERVER_CONTENT_LENGTH_SET;
}
if (csp->http->status == 204 || csp->http->status == 304)
*/
csp->expected_content_length = 0;
content_length_known = TRUE;
+ csp->flags |= CSP_FLAG_SERVER_CONTENT_LENGTH_SET;
}
return (content_length_known && ((0 == csp->expected_content_length)
* we do.
*
* Data that doesn't belong to the current request is
- * thrown away to let the client retry on a clean socket.
- *
- * XXX: This is a hack until we can deal with multiple
- * pipelined requests at the same time.
- *
+ * either thrown away to let the client retry on a clean
+ * socket, or stashed to be dealt with after the current
+ * request is served.
*
* Parameters :
* 1 : csp = Current client state (buffers, headers, etc...)
static void verify_request_length(struct client_state *csp)
{
unsigned long long buffered_request_bytes =
- (unsigned long long)(csp->iob->eod - csp->iob->cur);
+ (unsigned long long)(csp->client_iob->eod - csp->client_iob->cur);
if ((csp->expected_client_content_length != 0)
&& (buffered_request_bytes != 0))
}
else
{
- assert(csp->iob->eod > csp->iob->cur + csp->expected_client_content_length);
- csp->iob->eod = csp->iob->cur + csp->expected_client_content_length;
+ assert(csp->client_iob->eod > csp->client_iob->cur + csp->expected_client_content_length);
+ csp->client_iob->eod = csp->client_iob->cur + csp->expected_client_content_length;
log_error(LOG_LEVEL_CONNECT, "Reducing expected bytes to 0. "
"Marking the server socket tainted after throwing %llu bytes away.",
buffered_request_bytes - csp->expected_client_content_length);
}
if (!(csp->flags & CSP_FLAG_CLIENT_REQUEST_COMPLETELY_READ)
- && ((csp->iob->cur[0] != '\0') || (csp->expected_client_content_length != 0)))
+ && ((csp->client_iob->cur < csp->client_iob->eod)
+ || (csp->expected_client_content_length != 0)))
{
- csp->flags |= CSP_FLAG_SERVER_SOCKET_TAINTED;
if (strcmpic(csp->http->gpc, "GET")
&& strcmpic(csp->http->gpc, "HEAD")
&& strcmpic(csp->http->gpc, "TRACE")
{
/* XXX: this is an incomplete hack */
csp->flags &= ~CSP_FLAG_CLIENT_REQUEST_COMPLETELY_READ;
- log_error(LOG_LEVEL_CONNECT,
- "There might be a request body. The connection will not be kept alive.");
+ log_error(LOG_LEVEL_CONNECT, "There better be a request body.");
}
else
{
- /* XXX: and so is this */
csp->flags |= CSP_FLAG_CLIENT_REQUEST_COMPLETELY_READ;
- log_error(LOG_LEVEL_CONNECT,
- "Possible pipeline attempt detected. The connection will not "
- "be kept alive and we will only serve the first request.");
- /* Nuke the pipelined requests from orbit, just to be sure. */
- csp->iob->buf[0] = '\0';
- csp->iob->eod = csp->iob->cur = csp->iob->buf;
+
+ if ((csp->config->feature_flags & RUNTIME_FEATURE_TOLERATE_PIPELINING) == 0)
+ {
+ csp->flags |= CSP_FLAG_SERVER_SOCKET_TAINTED;
+ log_error(LOG_LEVEL_CONNECT,
+ "Possible pipeline attempt detected. The connection will not "
+ "be kept alive and we will only serve the first request.");
+ /* Nuke the pipelined requests from orbit, just to be sure. */
+ clear_iob(csp->client_iob);
+ }
+ else
+ {
+ /*
+ * Keep the pipelined data around for now, we'll deal with
+ * it once we're done serving the current request.
+ */
+ csp->flags |= CSP_FLAG_PIPELINED_REQUEST_WAITING;
+ assert(csp->client_iob->eod >= csp->client_iob->cur);
+ log_error(LOG_LEVEL_CONNECT, "Complete client request followed by "
+ "%d bytes of pipelined data received.",
+ (int)(csp->client_iob->eod - csp->client_iob->cur));
+ }
}
}
else
* actually been reused.
*/
if ((csp->flags & CSP_FLAG_SERVER_CONNECTION_KEEP_ALIVE)
- && !(csp->flags |= CSP_FLAG_SERVER_SOCKET_TAINTED))
+ && !(csp->flags & CSP_FLAG_SERVER_SOCKET_TAINTED))
{
log_error(LOG_LEVEL_CONNECT,
"Marking the server socket %d tainted.",
memset(buf, 0, sizeof(buf));
+ if ((csp->flags & CSP_FLAG_PIPELINED_REQUEST_WAITING) != 0)
+ {
+ /*
+ * If there are multiple pipelined requests waiting,
+ * the flag will be set again once the next request
+ * has been parsed.
+ */
+ csp->flags &= ~CSP_FLAG_PIPELINED_REQUEST_WAITING;
+
+ request_line = get_header(csp->client_iob);
+ if ((NULL != request_line) && ('\0' != *request_line))
+ {
+ return request_line;
+ }
+ else
+ {
+ log_error(LOG_LEVEL_CONNECT, "No complete request line "
+ "received yet. Continuing reading from %d.", csp->cfd);
+ }
+ }
+
do
{
if (!data_is_available(csp->cfd, csp->config->socket_timeout))
* If there is no memory left for buffering the
* request, there is nothing we can do but hang up
*/
- if (add_to_iob(csp, buf, len))
+ if (add_to_iob(csp->client_iob, csp->config->buffer_limit, buf, len))
{
return NULL;
}
- request_line = get_header(csp->iob);
+ request_line = get_header(csp->client_iob);
} while ((NULL != request_line) && ('\0' == *request_line));
}
+enum chunk_status
+{
+ CHUNK_STATUS_MISSING_DATA,
+ CHUNK_STATUS_BODY_COMPLETE,
+ CHUNK_STATUS_PARSE_ERROR
+};
+
+
+/*********************************************************************
+ *
+ * Function : chunked_body_is_complete
+ *
+ * Description : Figures out whether or not a chunked body is complete.
+ *
+ * Currently it always starts at the beginning of the
+ * buffer which is somewhat wasteful and prevents Privoxy
+ * from starting to forward the correctly parsed chunks
+ * as soon as theoretically possible.
+ *
+ * Should be modified to work with a common buffer,
+ * and allow the caller to skip already parsed chunks.
+ *
+ * This would allow the function to be used for unbuffered
+ * response bodies as well.
+ *
+ * Parameters :
+ * 1 : iob = Buffer with the body to check.
+ * 2 : length = Length of complete body
+ *
+ * Returns : Enum with the result of the check.
+ *
+ *********************************************************************/
+static enum chunk_status chunked_body_is_complete(struct iob *iob, size_t *length)
+{
+ unsigned int chunksize;
+ char *p = iob->cur;
+
+ do
+ {
+ /*
+ * We need at least a single digit, followed by "\r\n",
+ * followed by an unknown amount of data, followed by "\r\n".
+ */
+ if (p + 5 > iob->eod)
+ {
+ return CHUNK_STATUS_MISSING_DATA;
+ }
+ if (sscanf(p, "%x", &chunksize) != 1)
+ {
+ return CHUNK_STATUS_PARSE_ERROR;
+ }
+
+ /*
+ * We want at least a single digit, followed by "\r\n",
+ * followed by the specified amount of data, followed by "\r\n".
+ */
+ if (p + chunksize + 5 > iob->eod)
+ {
+ return CHUNK_STATUS_MISSING_DATA;
+ }
+
+ /* Skip chunk-size. */
+ p = strstr(p, "\r\n");
+ if (NULL == p)
+ {
+ return CHUNK_STATUS_PARSE_ERROR;
+ }
+ /* Move beyond the chunkdata. */
+ p += 2 + chunksize;
+
+ /* There should be another "\r\n" to skip */
+ if (memcmp(p, "\r\n", 2))
+ {
+ return CHUNK_STATUS_PARSE_ERROR;
+ }
+ p += 2;
+ } while (chunksize > 0U);
+
+ *length = (size_t)(p - iob->cur);
+ assert(*length <= (size_t)(iob->eod - iob->cur));
+ assert(p <= iob->eod);
+
+ return CHUNK_STATUS_BODY_COMPLETE;
+
+}
+
+
+/*********************************************************************
+ *
+ * Function : receive_chunked_client_request_body
+ *
+ * Description : Read the chunk-encoded client request body.
+ * Failures are dealt with.
+ *
+ * Parameters :
+ * 1 : csp = Current client state (buffers, headers, etc...)
+ *
+ * Returns : JB_ERR_OK or JB_ERR_PARSE
+ *
+ *********************************************************************/
+static jb_err receive_chunked_client_request_body(struct client_state *csp)
+{
+ size_t body_length;
+ enum chunk_status status;
+
+ while (CHUNK_STATUS_MISSING_DATA ==
+ (status = chunked_body_is_complete(csp->client_iob,&body_length)))
+ {
+ char buf[BUFFER_SIZE];
+ int len;
+
+ if (!data_is_available(csp->cfd, csp->config->socket_timeout))
+ {
+ log_error(LOG_LEVEL_ERROR,
+ "Timeout while waiting for the client body.");
+ break;
+ }
+ len = read_socket(csp->cfd, buf, sizeof(buf) - 1);
+ if (len <= 0)
+ {
+ log_error(LOG_LEVEL_ERROR, "Read the client body failed: %E");
+ break;
+ }
+ if (add_to_iob(csp->client_iob, csp->config->buffer_limit, buf, len))
+ {
+ break;
+ }
+ }
+ if (status != CHUNK_STATUS_BODY_COMPLETE)
+ {
+ write_socket(csp->cfd, CLIENT_BODY_PARSE_ERROR_RESPONSE,
+ strlen(CLIENT_BODY_PARSE_ERROR_RESPONSE));
+ log_error(LOG_LEVEL_CLF,
+ "%s - - [%T] \"Failed reading chunked client body\" 400 0", csp->ip_addr_str);
+ return JB_ERR_PARSE;
+ }
+ log_error(LOG_LEVEL_CONNECT,
+ "Chunked client body completely read. Length: %d", body_length);
+ csp->expected_client_content_length = body_length;
+
+ return JB_ERR_OK;
+
+}
+
+
+#ifdef FEATURE_FORCE_LOAD
+/*********************************************************************
+ *
+ * Function : force_required
+ *
+ * Description : Checks a request line to see if it contains
+ * the FORCE_PREFIX. If it does, it is removed
+ * unless enforcing requests has beend disabled.
+ *
+ * Parameters :
+ * 1 : request_line = HTTP request line
+ *
+ * Returns : TRUE if force is required, FALSE otherwise.
+ *
+ *********************************************************************/
+static int force_required(const struct client_state *csp, char *request_line)
+{
+ char *p;
+
+ p = strstr(request_line, "http://");
+ if (p != NULL)
+ {
+ /* Skip protocol */
+ p += strlen("http://");
+ }
+ else
+ {
+ /* Intercepted request usually don't specify the protocol. */
+ p = request_line;
+ }
+
+ /* Go to the beginning of the path */
+ p = strstr(p, "/");
+ if (p == NULL)
+ {
+ /*
+ * If the path is missing the request line is invalid and we
+ * are done here. The client-visible rejection happens later on.
+ */
+ return 0;
+ }
+
+ if (0 == strncmpic(p, FORCE_PREFIX, strlen(FORCE_PREFIX) - 1))
+ {
+ if (!(csp->config->feature_flags & RUNTIME_FEATURE_ENFORCE_BLOCKS))
+ {
+ /* XXX: Should clean more carefully */
+ strclean(request_line, FORCE_PREFIX);
+ log_error(LOG_LEVEL_FORCE,
+ "Enforcing request: \"%s\".", request_line);
+
+ return 1;
+ }
+ log_error(LOG_LEVEL_FORCE,
+ "Ignored force prefix in request: \"%s\".", request_line);
+ }
+
+ return 0;
+
+}
+#endif /* def FEATURE_FORCE_LOAD */
+
/*********************************************************************
*
struct list header_list;
struct list *headers = &header_list;
+ /* We don't care if the arriving data is a valid HTTP request or not. */
+ csp->requests_received_total++;
+
http = csp->http;
memset(buf, 0, sizeof(buf));
}
#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 (force_required(csp, req))
{
- 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;
- }
+ csp->flags |= CSP_FLAG_FORCED;
}
#endif /* def FEATURE_FORCE_LOAD */
init_list(headers);
for (;;)
{
- p = get_header(csp->iob);
+ p = get_header(csp->client_iob);
if (p == NULL)
{
return JB_ERR_PARSE;
}
- if (add_to_iob(csp, buf, len))
+ if (add_to_iob(csp->client_iob, csp->config->buffer_limit, buf, len))
{
/*
* If there is no memory left for buffering the
}
else
{
+ if (!strncmpic(p, "Transfer-Encoding:", 18))
+ {
+ /*
+ * XXX: should be called through sed()
+ * but currently can't.
+ */
+ client_transfer_encoding(csp, &p);
+ }
/*
* We were able to read a complete
* header and can finally enlist it.
}
}
+#ifdef FEATURE_CLIENT_TAGS
+ /* XXX: If the headers were enlisted sooner, passing csp would do. */
+ set_client_address(csp, headers);
+ get_tag_list_for_client(csp->client_tags, csp->client_address);
+#endif
+
/*
* Determine the actions for this URL
*/
get_url_actions(csp, http);
}
- /*
- * Save a copy of the original request for logging
- */
- http->ocmd = strdup_or_die(http->cmd);
enlist(csp->headers, http->cmd);
/* Append the previously read headers */
- list_append_list_unique(csp->headers, headers);
+ err = list_append_list_unique(csp->headers, headers);
destroy_list(headers);
- return JB_ERR_OK;
+ return err;
}
/* Assume persistence until further notice */
csp->flags |= CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE;
}
+
+ if (csp->http->ssl == 0)
+ {
+ /*
+ * This whole block belongs to chat() but currently
+ * has to be executed before sed().
+ */
+ if (csp->flags & CSP_FLAG_CHUNKED_CLIENT_BODY)
+ {
+ if (receive_chunked_client_request_body(csp) != JB_ERR_OK)
+ {
+ return JB_ERR_PARSE;
+ }
+ }
+ else
+ {
+ csp->expected_client_content_length = get_expected_content_length(csp->headers);
+ }
+ verify_request_length(csp);
+ }
#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
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_ERROR, "Failed to parse client request from %s.",
+ csp->ip_addr_str);
+ log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 400 0",
+ csp->ip_addr_str, csp->http->cmd);
+ write_socket(csp->cfd, CHEADER, strlen(CHEADER));
+ return JB_ERR_PARSE;
}
csp->flags |= CSP_FLAG_CLIENT_HEADER_PARSING_DONE;
return JB_ERR_PARSE;
}
-#ifdef FEATURE_CONNECTION_KEEP_ALIVE
- if (csp->http->ssl == 0)
+ if (client_has_unsupported_expectations(csp))
{
- verify_request_length(csp);
+ return JB_ERR_PARSE;
}
-#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
return JB_ERR_OK;
struct http_response *rsp;
struct timeval timeout;
#ifdef FEATURE_CONNECTION_KEEP_ALIVE
- int watch_client_socket = 1;
+ int watch_client_socket;
#endif
memset(buf, 0, sizeof(buf));
return;
}
+ log_applied_actions(csp->action);
log_error(LOG_LEVEL_GPC, "%s%s", http->hostport, http->path);
if (fwd->forward_host)
&& connection_destination_matches(&csp->server_connection, http, fwd))
{
log_error(LOG_LEVEL_CONNECT,
- "Reusing server socket %u. Opened for %s.",
- csp->server_connection.sfd, csp->server_connection.host);
+ "Reusing server socket %d connected to %s. Total requests: %u.",
+ csp->server_connection.sfd, csp->server_connection.host,
+ csp->server_connection.requests_sent_total);
}
else
{
if (csp->server_connection.sfd != JB_INVALID_SOCKET)
{
- log_error(LOG_LEVEL_CONNECT,
- "Closing server socket %u. Opened for %s.",
- csp->server_connection.sfd, csp->server_connection.host);
- close_socket(csp->server_connection.sfd);
+#ifdef FEATURE_CONNECTION_SHARING
+ if (csp->config->feature_flags & RUNTIME_FEATURE_CONNECTION_SHARING)
+ {
+ remember_connection(&csp->server_connection);
+ }
+ else
+#endif /* def FEATURE_CONNECTION_SHARING */
+ {
+ log_error(LOG_LEVEL_CONNECT,
+ "Closing server socket %d connected to %s. Total requests: %u.",
+ csp->server_connection.sfd, csp->server_connection.host,
+ csp->server_connection.requests_sent_total);
+ close_socket(csp->server_connection.sfd);
+ }
mark_connection_closed(&csp->server_connection);
}
#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
if (csp->server_connection.sfd == JB_INVALID_SOCKET)
{
- if (fwd->type != SOCKS_NONE)
+ if ((fwd->type != SOCKS_NONE) && (fwd->type != FORWARD_WEBSERVER))
{
/* Socks error. */
rsp = error_response(csp, "forwarding-failed");
send_crunch_response(csp, rsp);
}
+ /*
+ * Temporary workaround to prevent already-read client
+ * bodies from being parsed as new requests. For now we
+ * err on the safe side and throw all the following
+ * requests under the bus, even if no client body has been
+ * buffered. A compliant client will repeat the dropped
+ * requests on an untainted connection.
+ *
+ * The proper fix is to discard the no longer needed
+ * client body in the buffer (if there is one) and to
+ * continue parsing the bytes that follow.
+ */
+ drain_and_close_socket(csp->cfd);
+ csp->cfd = JB_INVALID_SOCKET;
+
return;
}
#ifdef FEATURE_CONNECTION_KEEP_ALIVE
}
#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
- if (fwd->forward_host || (http->ssl == 0))
+ csp->server_connection.requests_sent_total++;
+
+ if ((fwd->type == SOCKS_5T) && (NULL == csp->headers->first))
+ {
+ /* Client headers have been sent optimistically */
+ assert(csp->headers->last == NULL);
+ }
+ else if (fwd->forward_host || (http->ssl == 0))
{
+ int write_failure;
hdr = list_to_text(csp->headers);
if (hdr == NULL)
{
* Write the client's (modified) header to the server
* (along with anything else that may be in the buffer)
*/
- if (write_socket(csp->server_connection.sfd, hdr, strlen(hdr))
- || (flush_socket(csp->server_connection.sfd, csp->iob) < 0))
+ write_failure = 0 != write_socket(csp->server_connection.sfd, hdr, strlen(hdr));
+ freez(hdr);
+
+ if (write_failure)
+ {
+ log_error(LOG_LEVEL_CONNECT,
+ "Failed sending request headers to: %s: %E", http->hostport);
+ }
+ else if (((csp->flags & CSP_FLAG_PIPELINED_REQUEST_WAITING) == 0)
+ && (flush_socket(csp->server_connection.sfd, csp->client_iob) < 0))
{
+ write_failure = 1;
log_error(LOG_LEVEL_CONNECT,
- "write header to: %s failed: %E", http->hostport);
+ "Failed sending request body to: %s: %E", http->hostport);
+ }
+ if (write_failure)
+ {
rsp = error_response(csp, "connect-failed");
if (rsp)
{
send_crunch_response(csp, rsp);
}
-
- freez(hdr);
return;
}
- freez(hdr);
}
else
{
{
return;
}
- IOB_RESET(csp);
+ clear_iob(csp->client_iob);
}
log_error(LOG_LEVEL_CONNECT, "to %s successful", http->hostport);
+ /* XXX: should the time start earlier for optimistically sent data? */
csp->server_connection.request_sent = time(NULL);
maxfd = (csp->cfd > csp->server_connection.sfd) ?
server_body = 0;
+#ifdef FEATURE_CONNECTION_KEEP_ALIVE
+ watch_client_socket = 0 == (csp->flags & CSP_FLAG_PIPELINED_REQUEST_WAITING);
+#endif
+
for (;;)
{
#ifdef __OS2__
}
#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
- fflush(NULL);
len = read_socket(csp->server_connection.sfd, buf, sizeof(buf) - 1);
if (len < 0)
* has been reached, switch to non-filtering mode, i.e. make & write the
* header, flush the iob and buf, and get out of the way.
*/
- if (add_to_iob(csp, buf, len))
+ if (add_to_iob(csp->iob, csp->config->buffer_limit, buf, len))
{
size_t hdrlen;
long flushed;
* 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))
+ if (add_to_iob(csp->iob, csp->config->buffer_limit, buf, len))
{
log_error(LOG_LEVEL_ERROR, "Out of memory while looking for end of server headers.");
rsp = cgi_error_memory();
* we can parse the headers we just continue here.
*/
log_error(LOG_LEVEL_CONNECT,
- "Continuing buffering headers. Bytes most recently read: %d.",
- len);
+ "Continuing buffering server headers from socket %d. "
+ "Bytes most recently read: %d.", csp->cfd, len);
continue;
}
}
*/
if (JB_ERR_OK != sed(csp, FILTER_SERVER_HEADERS))
{
- log_error(LOG_LEVEL_FATAL, "Failed to parse server headers.");
+ 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));
+ free_http_request(http);
+ mark_server_socket_tainted(csp);
+ return;
}
hdr = list_to_text(csp->headers);
if (hdr == NULL)
*********************************************************************/
static void prepare_csp_for_next_request(struct client_state *csp)
{
- unsigned int toggled_on_flag_set = (0 != (csp->flags & CSP_FLAG_TOGGLED_ON));
-
csp->content_type = 0;
csp->content_length = 0;
csp->expected_content_length = 0;
csp->expected_client_content_length = 0;
list_remove_all(csp->headers);
- freez(csp->iob->buf);
- memset(csp->iob, 0, sizeof(csp->iob));
+ clear_iob(csp->iob);
freez(csp->error_message);
free_http_request(csp->http);
destroy_list(csp->headers);
destroy_list(csp->tags);
+#ifdef FEATURE_CLIENT_TAGS
+ destroy_list(csp->client_tags);
+ freez(csp->client_address);
+#endif
free_current_action(csp->action);
if (NULL != csp->fwd)
{
}
/* XXX: Store per-connection flags someplace else. */
csp->flags = (CSP_FLAG_ACTIVE | CSP_FLAG_REUSED_CLIENT_CONNECTION);
- if (toggled_on_flag_set)
+#ifdef FEATURE_TOGGLE
+ if (global_toggle_state)
+#endif /* def FEATURE_TOGGLE */
{
csp->flags |= CSP_FLAG_TOGGLED_ON;
}
+
+ if (csp->client_iob->eod > csp->client_iob->cur)
+ {
+ long bytes_to_shift = csp->client_iob->cur - csp->client_iob->buf;
+ size_t data_length = (size_t)(csp->client_iob->eod - csp->client_iob->cur);
+
+ assert(bytes_to_shift > 0);
+ assert(data_length > 0);
+
+ log_error(LOG_LEVEL_CONNECT, "Shifting %d pipelined bytes by %d bytes",
+ data_length, bytes_to_shift);
+ memmove(csp->client_iob->buf, csp->client_iob->cur, data_length);
+ csp->client_iob->cur = csp->client_iob->buf;
+ assert(csp->client_iob->eod == csp->client_iob->buf + bytes_to_shift + data_length);
+ csp->client_iob->eod = csp->client_iob->buf + data_length;
+ memset(csp->client_iob->eod, '\0', (size_t)bytes_to_shift);
+
+ csp->flags |= CSP_FLAG_PIPELINED_REQUEST_WAITING;
+ }
+ else
+ {
+ /*
+ * We mainly care about resetting client_iob->cur so we don't
+ * waste buffer space at the beginning and don't mess up the
+ * request restoration done by cgi_show_request().
+ *
+ * Freeing the buffer itself isn't technically necessary,
+ * but makes debugging more convenient.
+ */
+ clear_iob(csp->client_iob);
+ }
}
#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
static void serve(struct client_state *csp)
#endif /* def AMIGA */
{
+ int config_file_change_detected = 0; /* Only used for debugging */
#ifdef FEATURE_CONNECTION_KEEP_ALIVE
#ifdef FEATURE_CONNECTION_SHARING
static int monitor_thread_running = 0;
#endif /* def FEATURE_CONNECTION_SHARING */
int continue_chatting = 0;
+ log_error(LOG_LEVEL_CONNECT, "Accepted connection from %s on socket %d",
+ csp->ip_addr_str, csp->cfd);
+
do
{
unsigned int latency;
- int config_file_change_detected = 0; /* Only used for debugging */
chat(csp);
latency = (unsigned)(csp->server_connection.response_received -
csp->server_connection.request_sent) / 2;
+ if ((csp->flags & CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE)
+ && (csp->flags & CSP_FLAG_CRUNCHED)
+ && (csp->expected_client_content_length != 0))
+ {
+ csp->flags |= CSP_FLAG_SERVER_SOCKET_TAINTED;
+ log_error(LOG_LEVEL_CONNECT,
+ "Tainting client socket %d due to unread data.", csp->cfd);
+ }
+
continue_chatting = (csp->config->feature_flags
& RUNTIME_FEATURE_CONNECTION_KEEP_ALIVE)
&& !(csp->flags & CSP_FLAG_SERVER_SOCKET_TAINTED)
- && ((csp->flags & CSP_FLAG_SERVER_CONNECTION_KEEP_ALIVE)
- || (csp->flags & CSP_FLAG_CRUNCHED))
&& (csp->cfd != JB_INVALID_SOCKET)
- && ((csp->flags & CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE)
- || (csp->config->feature_flags &
- RUNTIME_FEATURE_CONNECTION_SHARING));
+ && (csp->flags & CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE)
+ && ((csp->flags & CSP_FLAG_SERVER_CONTENT_LENGTH_SET)
+ || (csp->flags & CSP_FLAG_CHUNKED));
- if (continue_chatting && !(csp->flags & CSP_FLAG_CRUNCHED))
+ if (!(csp->flags & CSP_FLAG_CRUNCHED)
+ && (csp->server_connection.sfd != JB_INVALID_SOCKET))
{
- continue_chatting = (csp->server_connection.sfd != JB_INVALID_SOCKET)
- && socket_is_still_alive(csp->server_connection.sfd);
- if (continue_chatting)
+ if (!(csp->flags & CSP_FLAG_SERVER_KEEP_ALIVE_TIMEOUT_SET))
+ {
+ csp->server_connection.keep_alive_timeout = csp->config->default_server_timeout;
+ }
+ if (!(csp->flags & CSP_FLAG_SERVER_CONNECTION_KEEP_ALIVE)
+ || (csp->flags & CSP_FLAG_SERVER_SOCKET_TAINTED)
+ || !socket_is_still_alive(csp->server_connection.sfd)
+ || !(latency < csp->server_connection.keep_alive_timeout))
{
- if (!(csp->flags & CSP_FLAG_SERVER_KEEP_ALIVE_TIMEOUT_SET))
+ log_error(LOG_LEVEL_CONNECT,
+ "Closing server socket %d connected to %s. "
+ "Keep-alive %u. Tainted: %u. Socket alive %u. Timeout: %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),
+ csp->server_connection.keep_alive_timeout);
+#ifdef FEATURE_CONNECTION_SHARING
+ if (csp->config->feature_flags & RUNTIME_FEATURE_CONNECTION_SHARING)
{
- csp->server_connection.keep_alive_timeout = csp->config->default_server_timeout;
- log_error(LOG_LEVEL_CONNECT,
- "The server didn't specify how long the connection will stay open. "
- "Assumed timeout is: %u.", csp->server_connection.keep_alive_timeout);
+ forget_connection(csp->server_connection.sfd);
}
- continue_chatting = (latency < csp->server_connection.keep_alive_timeout);
+#endif /* def FEATURE_CONNECTION_SHARING */
+ close_socket(csp->server_connection.sfd);
+ mark_connection_closed(&csp->server_connection);
}
}
- if (continue_chatting && any_loaded_file_changed(csp->config->config_file_list))
+ if (continue_chatting && any_loaded_file_changed(csp))
{
continue_chatting = 0;
config_file_change_detected = 1;
if (continue_chatting)
{
- unsigned int client_timeout = 1; /* XXX: Use something else here? */
+ if (((csp->flags & CSP_FLAG_PIPELINED_REQUEST_WAITING) != 0)
+ && socket_is_still_alive(csp->cfd))
+ {
+ log_error(LOG_LEVEL_CONNECT, "Client request %d has been "
+ "pipelined on socket %d and the socket is still alive.",
+ csp->requests_received_total+1, csp->cfd);
+ prepare_csp_for_next_request(csp);
+ continue;
+ }
if (0 != (csp->flags & CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE))
{
if (csp->server_connection.sfd != JB_INVALID_SOCKET)
{
- client_timeout = (unsigned)csp->server_connection.keep_alive_timeout - latency;
log_error(LOG_LEVEL_CONNECT,
"Waiting for the next client request on socket %d. "
"Keeping the server socket %d to %s open.",
"No server socket to keep open.", csp->cfd);
}
}
+
if ((csp->flags & CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE)
- && data_is_available(csp->cfd, (int)client_timeout)
+ && data_is_available(csp->cfd, (int)csp->config->keep_alive_timeout)
&& socket_is_still_alive(csp->cfd))
{
log_error(LOG_LEVEL_CONNECT,
- "Client request arrived in time on socket %d.", csp->cfd);
+ "Client request %u arrived in time on socket %d.",
+ csp->requests_received_total+1, csp->cfd);
prepare_csp_for_next_request(csp);
}
else
{
- if (0 != (csp->flags & CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE))
- {
- log_error(LOG_LEVEL_CONNECT,
- "No additional client request received in time on socket %d.",
- csp->cfd);
- }
#ifdef FEATURE_CONNECTION_SHARING
if ((csp->config->feature_flags & RUNTIME_FEATURE_CONNECTION_SHARING)
+ && (csp->server_connection.sfd != JB_INVALID_SOCKET)
&& (socket_is_still_alive(csp->server_connection.sfd)))
{
time_t time_open = time(NULL) - csp->server_connection.timestamp;
remember_connection(&csp->server_connection);
csp->server_connection.sfd = JB_INVALID_SOCKET;
- close_socket(csp->cfd);
+ drain_and_close_socket(csp->cfd);
csp->cfd = JB_INVALID_SOCKET;
privoxy_mutex_lock(&connection_reuse_mutex);
if (!monitor_thread_running)
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. "
- "Server connection: keep-alive %u, tainted: %u, socket alive %u. "
- "Client connection: socket alive: %u. Server timeout: %u. "
+ "Closing server socket %d connected to %s. Keep-alive: %u. "
+ "Tainted: %u. Socket alive: %u. 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);
}
if (csp->cfd != JB_INVALID_SOCKET)
{
- close_socket(csp->cfd);
+ log_error(LOG_LEVEL_CONNECT, "Closing client socket %d. "
+ "Keep-alive: %u. Socket alive: %u. Data available: %u. "
+ "Configuration file change detected: %u. Requests received: %u.",
+ csp->cfd, 0 != (csp->flags & CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE),
+ socket_is_still_alive(csp->cfd), data_is_available(csp->cfd, 0),
+ config_file_change_detected, csp->requests_received_total);
+ drain_and_close_socket(csp->cfd);
}
csp->flags &= ~CSP_FLAG_ACTIVE;
static void usage(const char *myname)
{
printf("Privoxy version " VERSION " (" HOME_PAGE_URL ")\n"
- "Usage: %s "
+ "Usage: %s [--config-test] "
#if defined(unix)
"[--chroot] "
#endif /* defined(unix) */
privoxy_mutex_init(&log_mutex);
privoxy_mutex_init(&log_init_mutex);
privoxy_mutex_init(&connection_reuse_mutex);
+#ifdef FEATURE_EXTERNAL_FILTERS
+ privoxy_mutex_init(&external_filter_mutex);
+#endif
+#ifdef FEATURE_CLIENT_TAGS
+ privoxy_mutex_init(&client_tags_mutex);
+#endif
/*
* XXX: The assumptions below are a bit naive
#endif
{
int argc_pos = 0;
+ int do_config_test = 0;
unsigned int random_seed;
#ifdef unix
struct passwd *pw = NULL;
}
#endif /* defined(unix) */
+ else if (strcmp(argv[argc_pos], "--config-test") == 0)
+ {
+ do_config_test = 1;
+ }
+
else if (argc_pos + 1 != argc)
{
/*
basedir = strdup_or_die(cwd);
/* XXX: why + 5? */
abs_file_size = strlen(cwd) + strlen(configfile) + 5;
- abs_file = malloc(abs_file_size);
- if (NULL == abs_file)
- {
- perror("malloc failed");
- exit(1);
- }
+ abs_file = malloc_or_die(abs_file_size);
strlcpy(abs_file, basedir, abs_file_size);
strlcat(abs_file, "/", abs_file_size);
strlcat(abs_file, configfile, abs_file_size);
# endif /* def _WIN_CONSOLE */
#endif /* def _WIN32 */
+ if (do_config_test)
+ {
+ exit(NULL == load_config());
+ }
/* Initialize the CGI subsystem */
cgi_init_error_messages();
/*
- * If runnig on unix and without the --nodaemon
+ * If running on unix and without the --no-daemon
* option, become a daemon. I.e. fork, detach
* from tty and get process group leadership
*/
close(fd);
}
+#ifdef FEATURE_EXTERNAL_FILTERS
+ for (fd = 0; fd < 3; fd++)
+ {
+ mark_socket_for_close_on_execute(fd);
+ }
+#endif
+
chdir("/");
} /* -END- if (daemon_mode) */
{
log_error(LOG_LEVEL_FATAL, "Cannot setgid(): Insufficient permissions.");
}
- if ((NULL != grp) && setgroups(1, &grp->gr_gid))
+ if (NULL != grp)
{
- log_error(LOG_LEVEL_FATAL, "setgroups() failed: %E");
+ if (setgroups(1, &grp->gr_gid))
+ {
+ log_error(LOG_LEVEL_FATAL, "setgroups() failed: %E");
+ }
}
else if (initgroups(pw->pw_name, pw->pw_gid))
{
* on failure.
*
* Parameters :
- * 1 : haddr = Host addres to bind to. Use NULL to bind to
+ * 1 : haddr = Host address to bind to. Use NULL to bind to
* INADDR_ANY.
* 2 : hport = Specifies port to bind to.
*
return JB_INVALID_SOCKET;
}
+#ifndef _WIN32
+ if (bfd >= FD_SETSIZE)
+ {
+ log_error(LOG_LEVEL_FATAL,
+ "Bind socket number too high to use select(): %d >= %d",
+ bfd, FD_SETSIZE);
+ }
+#endif
+
if (haddr == NULL)
{
log_error(LOG_LEVEL_INFO, "Listening on port %d on all IP addresses",
}
#endif
- csp_list = (struct client_states *)zalloc(sizeof(*csp_list));
- if (NULL == csp_list)
- {
- log_error(LOG_LEVEL_FATAL,
- "malloc(%d) for csp_list failed: %E", sizeof(*csp_list));
- continue;
- }
+ csp_list = zalloc_or_die(sizeof(*csp_list));
csp = &csp_list->csp;
- log_error(LOG_LEVEL_CONNECT, "Listening for new connections ... ");
+ log_error(LOG_LEVEL_CONNECT,
+ "Waiting for the next client connection. Currently active threads: %d",
+ active_threads);
+
+ /*
+ * This config may be outdated, but for accept_connection()
+ * it's fresh enough.
+ */
+ csp->config = config;
if (!accept_connection(csp, bfds))
{
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;
if (block_acl(NULL,csp))
{
log_error(LOG_LEVEL_CONNECT,
- "Connection from %s on socket %d dropped due to ACL", csp->ip_addr_str, csp->cfd);
+ "Connection from %s on %s (socket %d) dropped due to ACL",
+ csp->ip_addr_str, csp->listen_addr_str, csp->cfd);
close_socket(csp->cfd);
freez(csp->ip_addr_str);
+ freez(csp->listen_addr_str);
freez(csp_list);
continue;
}
strlen(TOO_MANY_CONNECTIONS_RESPONSE));
close_socket(csp->cfd);
freez(csp->ip_addr_str);
+ freez(csp->listen_addr_str);
freez(csp_list);
continue;
}
* XXX: If you assume ...
*/
log_error(LOG_LEVEL_ERROR,
- "Unable to take any additional connections: %E");
+ "Unable to take any additional connections: %E. Active threads: %d",
+ active_threads);
write_socket(csp->cfd, TOO_MANY_CONNECTIONS_RESPONSE,
strlen(TOO_MANY_CONNECTIONS_RESPONSE));
close_socket(csp->cfd);
projects / privoxy.git / blobdiff