-const char jcc_rcs[] = "$Id: jcc.c,v 1.414 2012/11/09 10:53:39 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-2012 the
+ * Copyright : Written by and Copyright (C) 2001-2018 the
* Privoxy team. http://www.privoxy.org/
*
* Based on the Internet Junkbuster originally written
# ifndef STRICT
# define STRICT
# endif
+# include <winsock2.h>
# include <windows.h>
# include <process.h>
# endif /* ndef FEATURE_PTHREAD */
# ifdef __OS2__
#define INCL_DOS
# include <os2.h>
-#define bzero(B,N) memset(B,0x00,n)
# endif
+#ifdef HAVE_POLL
+#ifdef __GLIBC__
+#include <sys/poll.h>
+#else
+#include <poll.h>
+#endif /* def __GLIBC__ */
+#else
# ifndef FD_ZERO
# include <select.h>
# endif
+#warning poll() appears to be unavailable. Your platform will become unsupported in the future.
+#endif /* HAVE_POLL */
#endif
#include "cgi.h"
#include "loadcfg.h"
#include "urlmatch.h"
-
-const char jcc_h_rcs[] = JCC_H_VERSION;
-const char project_h_rcs[] = PROJECT_H_VERSION;
+#ifdef FEATURE_CLIENT_TAGS
+#include "client-tags.h"
+#endif
int daemon_mode = 1;
struct client_states clients[1];
int g_terminate = 0;
#endif
-#if !defined(_WIN32) && !defined(__OS2__) && !defined(AMIGA)
+#if !defined(_WIN32) && !defined(__OS2__)
static void sig_handler(int the_signal);
#endif
static int client_protocol_is_unsupported(const struct client_state *csp, char *req);
static void usage(const char *myname);
#endif
static void initialize_mutexes(void);
-static jb_socket bind_port_helper(const char *haddr, int hport);
+static jb_socket bind_port_helper(const char *haddr, int hport, int backlog);
static void bind_ports_helper(struct configuration_spec *config, jb_socket sockets[]);
static void close_ports_helper(jb_socket sockets[]);
static void listen_loop(void);
-
-#ifdef AMIGA
-void serve(struct client_state *csp);
-#else /* ifndef AMIGA */
static void serve(struct client_state *csp);
-#endif /* def AMIGA */
#ifdef __BEOS__
static int32 server_thread(void *data);
#define sleep(N) DosSleep(((N) * 100))
#endif
+#ifdef FUZZ
+int process_fuzzed_input(char *fuzz_input_type, char *fuzz_input_file);
+void show_fuzz_usage(const char *name);
+#endif
+
#ifdef MUTEX_LOCKS_AVAILABLE
/*
* XXX: Does the locking stuff really belong in this file?
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) */
privoxy_mutex_t localtime_mutex;
#endif /* ndef HAVE_GMTIME_R */
-#ifndef HAVE_RANDOM
+#if !defined(HAVE_ARC4RANDOM) && !defined(HAVE_RANDOM)
privoxy_mutex_t rand_mutex;
-#endif /* ndef HAVE_RANDOM */
+#endif /* !defined(HAVE_ARC4RANDOM) && !defined(HAVE_RANDOM) */
#endif /* def MUTEX_LOCKS_AVAILABLE */
/* 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 *);
*
* here?
*/
-#if !defined(_WIN32) && !defined(__OS2__) && !defined(AMIGA)
+#if !defined(_WIN32) && !defined(__OS2__)
/*********************************************************************
*
* Function : sig_handler
#endif
+/*********************************************************************
+ *
+ * Function : get_write_delay
+ *
+ * Description : Parse the delay-response parameter.
+ *
+ * Parameters :
+ * 1 : csp = Current client state (buffers, headers, etc...)
+ *
+ * Returns : Number of milliseconds to delay writes.
+ *
+ *********************************************************************/
+static unsigned int get_write_delay(const struct client_state *csp)
+{
+ unsigned int delay;
+ char *endptr;
+ char *newval;
+
+ if ((csp->action->flags & ACTION_DELAY_RESPONSE) == 0)
+ {
+ return 0;
+ }
+ newval = csp->action->string[ACTION_STRING_DELAY_RESPONSE];
+
+ delay = (unsigned)strtol(newval, &endptr, 0);
+ if (*endptr != '\0')
+ {
+ log_error(LOG_LEVEL_FATAL,
+ "Invalid delay-response{} parameter: '%s'", newval);
+ }
+
+ return delay;
+
+}
+
+
/*********************************************************************
*
* Function : client_protocol_is_unsupported
log_error(LOG_LEVEL_CLF,
"%s - - [%T] \"%s\" 400 0", csp->ip_addr_str, req);
freez(req);
- write_socket(csp->cfd, response, strlen(response));
+ write_socket_delayed(csp->cfd, response, strlen(response),
+ get_write_delay(csp));
+
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+
+/*********************************************************************
+ *
+ * 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_delayed(csp->cfd,
+ UNSUPPORTED_CLIENT_EXPECTATION_ERROR_RESPONSE,
+ strlen(UNSUPPORTED_CLIENT_EXPECTATION_ERROR_RESPONSE),
+ get_write_delay(csp));
return TRUE;
}
return FALSE;
+
}
log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 400 0",
csp->ip_addr_str, csp->http->cmd);
- write_socket(csp->cfd, CHEADER, strlen(CHEADER));
+ write_socket_delayed(csp->cfd, CHEADER, strlen(CHEADER),
+ get_write_delay(csp));
destroy_list(headers);
return JB_ERR_PARSE;
csp->ip_addr_str, csp->http->cmd, req);
freez(req);
- write_socket(csp->cfd, MISSING_DESTINATION_RESPONSE, strlen(MISSING_DESTINATION_RESPONSE));
+ write_socket_delayed(csp->cfd, MISSING_DESTINATION_RESPONSE,
+ strlen(MISSING_DESTINATION_RESPONSE), get_write_delay(csp));
destroy_list(headers);
return JB_ERR_PARSE;
*
* Parameters :
* 1 : csp = Current client state (buffers, headers, etc...)
- * 1 : rsp = Fully prepared response. Will be freed on exit.
+ * 2 : rsp = Fully prepared response. Will be freed on exit.
*
* Returns : Nothing.
*
csp->ip_addr_str, http->ocmd, status_code, rsp->content_length);
/* Write the answer to the client */
- if (write_socket(csp->cfd, rsp->head, rsp->head_length)
- || write_socket(csp->cfd, rsp->body, rsp->content_length))
+ if (write_socket_delayed(csp->cfd, rsp->head, rsp->head_length, get_write_delay(csp))
+ || write_socket_delayed(csp->cfd, rsp->body, rsp->content_length, get_write_delay(csp)))
{
/* There is nothing we can do about it. */
- log_error(LOG_LEVEL_ERROR,
- "Couldn't deliver the error message through client socket %d: %E",
- csp->cfd);
+ log_error(LOG_LEVEL_CONNECT,
+ "Couldn't deliver the error message for %s through client socket %d: %E",
+ http->url, csp->cfd);
}
/* Clean up and return */
*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;
}
* 1 : sfd = Open socket to remember.
* 2 : http = The destination for the connection.
* 3 : fwd = The forwarder settings used.
- * 3 : server_connection = storage.
+ * 4 : server_connection = storage.
*
* Returns : void
*
{
/* XXX: this is an incomplete hack */
csp->flags &= ~CSP_FLAG_CLIENT_REQUEST_COMPLETELY_READ;
- csp->flags |= CSP_FLAG_SERVER_SOCKET_TAINTED;
- 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
{
* 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.",
do
{
- if (!data_is_available(csp->cfd, csp->config->socket_timeout))
+ if (
+#ifdef FUZZ
+ 0 == (csp->flags & CSP_FLAG_FUZZED_INPUT) &&
+#endif
+ !data_is_available(csp->cfd, csp->config->socket_timeout)
+ )
{
if (socket_is_still_alive(csp->cfd))
{
log_error(LOG_LEVEL_CONNECT,
"No request line on socket %d received in time. Timeout: %d.",
csp->cfd, csp->config->socket_timeout);
- write_socket(csp->cfd, CLIENT_CONNECTION_TIMEOUT_RESPONSE,
- strlen(CLIENT_CONNECTION_TIMEOUT_RESPONSE));
+ write_socket_delayed(csp->cfd, CLIENT_CONNECTION_TIMEOUT_RESPONSE,
+ strlen(CLIENT_CONNECTION_TIMEOUT_RESPONSE),
+ get_write_delay(csp));
}
else
{
}
+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_delayed(csp->cfd, CLIENT_BODY_PARSE_ERROR_RESPONSE,
+ strlen(CLIENT_BODY_PARSE_ERROR_RESPONSE), get_write_delay(csp));
+ 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 FUZZ
+/*********************************************************************
+ *
+ * Function : fuzz_chunked_transfer_encoding
+ *
+ * Description : Treat the fuzzed input as chunked transfer encoding
+ * to check and dechunk.
+ *
+ * Parameters :
+ * 1 : csp = Used to store the data.
+ * 2 : fuzz_input_file = File to read the input from.
+ *
+ * Returns : Result of dechunking
+ *
+ *********************************************************************/
+extern int fuzz_chunked_transfer_encoding(struct client_state *csp, char *fuzz_input_file)
+{
+ size_t length;
+ size_t size = (size_t)(csp->iob->eod - csp->iob->cur);
+ enum chunk_status status;
+
+ status = chunked_body_is_complete(csp->iob, &length);
+ if (CHUNK_STATUS_BODY_COMPLETE != status)
+ {
+ log_error(LOG_LEVEL_INFO, "Chunked body is incomplete or invalid");
+ }
+
+ return (JB_ERR_OK == remove_chunked_transfer_coding(csp->iob->cur, &size));
+
+}
+
+
+/*********************************************************************
+ *
+ * Function : fuzz_client_request
+ *
+ * Description : Try to get a client request from the fuzzed input.
+ *
+ * Parameters :
+ * 1 : csp = Current client state (buffers, headers, etc...)
+ * 2 : fuzz_input_file = File to read the input from.
+ *
+ * Returns : Result of fuzzing.
+ *
+ *********************************************************************/
+extern int fuzz_client_request(struct client_state *csp, char *fuzz_input_file)
+{
+ jb_err err;
+
+ csp->cfd = 0;
+ csp->ip_addr_str = "fuzzer";
+
+ if (strcmp(fuzz_input_file, "-") != 0)
+ {
+ log_error(LOG_LEVEL_FATAL,
+ "Fuzzed client requests can currenty only be read from stdin (-).");
+ }
+ err = receive_client_request(csp);
+ if (err != JB_ERR_OK)
+ {
+ return 1;
+ }
+ err = parse_client_request(csp);
+ if (err != JB_ERR_OK)
+ {
+ return 1;
+ }
+
+ return 0;
+
+}
+#endif /* def FUZZ */
+
+
+#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 */
+
/*********************************************************************
*
}
#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 */
freez(req);
if (JB_ERR_OK != err)
{
- write_socket(csp->cfd, CHEADER, strlen(CHEADER));
+ write_socket_delayed(csp->cfd, CHEADER, strlen(CHEADER),
+ get_write_delay(csp));
/* XXX: Use correct size */
log_error(LOG_LEVEL_CLF, "%s - - [%T] \"Invalid request\" 400 0", csp->ip_addr_str);
log_error(LOG_LEVEL_ERROR,
}
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;
}
if (csp->http->ssl == 0)
{
- csp->expected_client_content_length = get_expected_content_length(csp->headers);
+ /*
+ * 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);
}
+ else
+ {
+ csp->flags |= CSP_FLAG_SERVER_SOCKET_TAINTED;
+ }
#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_delayed(csp->cfd, CHEADER, strlen(CHEADER), get_write_delay(csp));
+ return JB_ERR_PARSE;
}
csp->flags |= CSP_FLAG_CLIENT_HEADER_PARSING_DONE;
/*
* A header filter broke the request line - bail out.
*/
- write_socket(csp->cfd, MESSED_UP_REQUEST_RESPONSE, strlen(MESSED_UP_REQUEST_RESPONSE));
+ write_socket_delayed(csp->cfd, MESSED_UP_REQUEST_RESPONSE,
+ strlen(MESSED_UP_REQUEST_RESPONSE), get_write_delay(csp));
/* XXX: Use correct size */
log_error(LOG_LEVEL_CLF,
"%s - - [%T] \"Invalid request generated\" 500 0", csp->ip_addr_str);
return JB_ERR_PARSE;
}
+ if (client_has_unsupported_expectations(csp))
+ {
+ return JB_ERR_PARSE;
+ }
+
return JB_ERR_OK;
}
/*********************************************************************
*
- * Function : chat
+ * Function : send_http_request
*
- * Description : Once a connection from the client has been accepted,
- * 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 with the same client socket
- * if the client is keeping the connection alive.
+ * Description : Sends the HTTP headers from the client request
+ * and all the body data that has already been received.
*
- * The decision whether or not a client connection will
- * be kept alive is up to the caller which also must
- * close the client socket when done.
+ * Parameters :
+ * 1 : csp = Current client state (buffers, headers, etc...)
*
- * FIXME: chat is nearly thousand lines long.
- * Ridiculous.
+ * Returns : 0 on success, anything else is an error.
+ *
+ *********************************************************************/
+static int send_http_request(struct client_state *csp)
+{
+ char *hdr;
+ int write_failure;
+
+ 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);
+
+ /*
+ * Write the client's (modified) header to the server
+ * (along with anything else that may be in the buffer)
+ */
+ 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",
+ csp->http->hostport);
+ }
+ else if (((csp->flags & CSP_FLAG_PIPELINED_REQUEST_WAITING) == 0)
+ && (flush_iob(csp->server_connection.sfd, csp->client_iob, 0) < 0))
+ {
+ write_failure = 1;
+ log_error(LOG_LEVEL_CONNECT, "Failed sending request body to: %s: %E",
+ csp->http->hostport);
+ }
+
+ return write_failure;
+
+}
+
+
+/*********************************************************************
+ *
+ * Function : handle_established_connection
+ *
+ * Description : Shuffle data between client and server once the
+ * connection has been established.
*
* Parameters :
* 1 : csp = Current client state (buffers, headers, etc...)
* Returns : Nothing.
*
*********************************************************************/
-static void chat(struct client_state *csp)
+static void handle_established_connection(struct client_state *csp)
{
- char buf[BUFFER_SIZE];
char *hdr;
char *p;
- fd_set rfds;
int n;
+#ifdef HAVE_POLL
+ struct pollfd poll_fds[2];
+#else
+ fd_set rfds;
jb_socket maxfd;
+ struct timeval timeout;
+#endif
int server_body;
int ms_iis5_hack = 0;
unsigned long long byte_count = 0;
- const struct forward_spec *fwd;
struct http_request *http;
long len = 0; /* for buffer sizes (and negative error codes) */
int buffer_and_filter_content = 0;
+ unsigned int write_delay;
/* Skeleton for HTTP response, if we should intercept the request */
struct http_response *rsp;
- struct timeval timeout;
#ifdef FEATURE_CONNECTION_KEEP_ALIVE
int watch_client_socket;
#endif
- memset(buf, 0, sizeof(buf));
-
- http = csp->http;
-
- if (receive_client_request(csp) != JB_ERR_OK)
+ csp->receive_buffer_size = csp->config->receive_buffer_size;
+ csp->receive_buffer = zalloc(csp->receive_buffer_size + 1);
+ if (csp->receive_buffer == NULL)
{
+ log_error(LOG_LEVEL_ERROR,
+ "Out of memory. Failed to allocate the receive buffer.");
+ rsp = cgi_error_memory();
+ send_crunch_response(csp, rsp);
return;
}
- if (parse_client_request(csp) != JB_ERR_OK)
- {
- return;
- }
-
- /* decide how to route the HTTP request */
- fwd = forward_url(csp, http);
- if (NULL == fwd)
- {
- log_error(LOG_LEVEL_FATAL, "gateway spec is NULL!?!? This can't happen!");
- /* Never get here - LOG_LEVEL_FATAL causes program exit */
- return;
- }
-
- /*
- * build the http request to send to the server
- * we have to do one of the following:
- *
- * create = use the original HTTP request to create a new
- * HTTP request that has either the path component
- * without the http://domainspec (w/path) or the
- * full orininal URL (w/url)
- * Note that the path and/or the HTTP version may
- * have been altered by now.
- *
- * connect = Open a socket to the host:port of the server
- * and short-circuit server and client socket.
- *
- * pass = Pass the request unchanged if forwarding a CONNECT
- * request to a parent proxy. Note that we'll be sending
- * the CFAIL message ourselves if connecting to the parent
- * fails, but we won't send a CSUCCEED message if it works,
- * since that would result in a double message (ours and the
- * parent's). After sending the request to the parent, we simply
- * tunnel.
- *
- * here's the matrix:
- * SSL
- * 0 1
- * +--------+--------+
- * | | |
- * 0 | create | connect|
- * | w/path | |
- * Forwarding +--------+--------+
- * | | |
- * 1 | create | pass |
- * | w/url | |
- * +--------+--------+
- *
- */
-
- if (http->ssl && connect_port_is_forbidden(csp))
- {
- const char *acceptable_connect_ports =
- 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 %s",
- csp->ip_addr_str, acceptable_connect_ports, csp->http->hostport);
- csp->action->flags |= ACTION_BLOCK;
- http->ssl = 0;
- }
-
- if (http->ssl == 0)
- {
- freez(csp->headers->first->str);
- build_request_line(csp, fwd, &csp->headers->first->str);
- }
-
- /*
- * We have a request. Check if one of the crunchers wants it.
- */
- if (crunch_response_triggered(csp, crunchers_all))
- {
- /*
- * Yes. The client got the crunch response and we're done here.
- */
- return;
- }
-
- log_applied_actions(csp->action);
- 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);
- }
- else
- {
- log_error(LOG_LEVEL_CONNECT, "to %s", http->hostport);
- }
-
- /* here we connect to the server, gateway, or the forwarder */
-
-#ifdef FEATURE_CONNECTION_KEEP_ALIVE
- if ((csp->server_connection.sfd != JB_INVALID_SOCKET)
- && socket_is_still_alive(csp->server_connection.sfd)
- && connection_destination_matches(&csp->server_connection, http, fwd))
- {
- log_error(LOG_LEVEL_CONNECT,
- "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)
- {
-#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 */
-
- csp->server_connection.sfd = forwarded_connect(fwd, http, csp);
-
- if (csp->server_connection.sfd == JB_INVALID_SOCKET)
- {
- if (fwd->type != SOCKS_NONE)
- {
- /* Socks error. */
- rsp = error_response(csp, "forwarding-failed");
- }
- else if (errno == EINVAL)
- {
- rsp = error_response(csp, "no-such-domain");
- }
- else
- {
- rsp = error_response(csp, "connect-failed");
- }
-
- /* Write the answer to the client */
- if (rsp != NULL)
- {
- send_crunch_response(csp, rsp);
- }
-
- return;
- }
-#ifdef FEATURE_CONNECTION_KEEP_ALIVE
- save_connection_destination(csp->server_connection.sfd,
- http, fwd, &csp->server_connection);
- csp->server_connection.keep_alive_timeout =
- (unsigned)csp->config->keep_alive_timeout;
- }
-#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
-
- csp->server_connection.requests_sent_total++;
- if (fwd->forward_host || (http->ssl == 0))
- {
- int write_failure;
- 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);
-
- /*
- * Write the client's (modified) header to the server
- * (along with anything else that may be in the buffer)
- */
- 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,
- "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);
- }
- return;
- }
- }
- else
- {
- /*
- * We're running an SSL tunnel and we're not forwarding,
- * so just ditch the client headers, send the "connect succeeded"
- * message to the client, flush the rest, and get out of the way.
- */
- list_remove_all(csp->headers);
- if (write_socket(csp->cfd, CSUCCEED, strlen(CSUCCEED)))
- {
- return;
- }
- clear_iob(csp->client_iob);
- }
-
- log_error(LOG_LEVEL_CONNECT, "to %s successful", http->hostport);
-
- csp->server_connection.request_sent = time(NULL);
+ http = csp->http;
+#ifndef HAVE_POLL
maxfd = (csp->cfd > csp->server_connection.sfd) ?
csp->cfd : csp->server_connection.sfd;
+#endif
/* pass data between the client and server
* until one or the other shuts down the connection.
#ifdef FEATURE_CONNECTION_KEEP_ALIVE
watch_client_socket = 0 == (csp->flags & CSP_FLAG_PIPELINED_REQUEST_WAITING);
#endif
+ write_delay = get_write_delay(csp);
for (;;)
{
+#ifndef HAVE_POLL
#ifdef __OS2__
/*
* FD_ZERO here seems to point to an errant macro which crashes.
}
FD_SET(csp->server_connection.sfd, &rfds);
+#endif /* ndef HAVE_POLL */
#ifdef FEATURE_CONNECTION_KEEP_ALIVE
if ((csp->flags & CSP_FLAG_CHUNKED)
* XXX: should not jump around,
* chat() is complicated enough already.
*/
- goto reading_done;
+ goto reading_done;
+ }
+#endif /* FEATURE_CONNECTION_KEEP_ALIVE */
+
+#ifdef HAVE_POLL
+ poll_fds[0].fd = csp->cfd;
+#ifdef FEATURE_CONNECTION_KEEP_ALIVE
+ if (!watch_client_socket)
+ {
+ /*
+ * Ignore incoming data, but still watch out
+ * for disconnects etc. These flags are always
+ * implied anyway but explicitly setting them
+ * doesn't hurt.
+ */
+ poll_fds[0].events = POLLERR|POLLHUP;
}
-#endif /* FEATURE_CONNECTION_KEEP_ALIVE */
-
+ else
+#endif
+ {
+ poll_fds[0].events = POLLIN;
+ }
+ poll_fds[1].fd = csp->server_connection.sfd;
+ poll_fds[1].events = POLLIN;
+ n = poll(poll_fds, 2, csp->config->socket_timeout * 1000);
+#else
timeout.tv_sec = csp->config->socket_timeout;
timeout.tv_usec = 0;
n = select((int)maxfd+1, &rfds, NULL, NULL, &timeout);
+#endif /* def HAVE_POLL */
if (n == 0)
{
- log_error(LOG_LEVEL_ERROR,
- "Didn't receive data in time: %s", http->url);
+ log_error(LOG_LEVEL_CONNECT, "Socket timeout %d reached: %s",
+ csp->config->socket_timeout, http->url);
if ((byte_count == 0) && (http->ssl == 0))
{
send_crunch_response(csp, error_response(csp, "connection-timeout"));
}
else if (n < 0)
{
+#ifdef HAVE_POLL
+ log_error(LOG_LEVEL_ERROR, "poll() failed!: %E");
+#else
log_error(LOG_LEVEL_ERROR, "select() failed!: %E");
+#endif
mark_server_socket_tainted(csp);
return;
}
* XXX: Make sure the client doesn't use pipelining
* behind Privoxy's back.
*/
+#ifdef HAVE_POLL
+ if ((poll_fds[0].revents & (POLLERR|POLLHUP|POLLNVAL)) != 0)
+ {
+ log_error(LOG_LEVEL_CONNECT,
+ "The client socket %d has become unusable while "
+ "the server socket %d is still open.",
+ csp->cfd, csp->server_connection.sfd);
+ mark_server_socket_tainted(csp);
+ break;
+ }
+
+ if (poll_fds[0].revents != 0)
+#else
if (FD_ISSET(csp->cfd, &rfds))
+#endif /* def HAVE_POLL*/
{
- int max_bytes_to_read = sizeof(buf) - 1;
+ int max_bytes_to_read = (int)csp->receive_buffer_size;
#ifdef FEATURE_CONNECTION_KEEP_ALIVE
if ((csp->flags & CSP_FLAG_CLIENT_REQUEST_COMPLETELY_READ))
*/
watch_client_socket = 0;
log_error(LOG_LEVEL_CONNECT,
- "Stopping to watch the client socket %d. "
+ "Stop watching client socket %d. "
"There's already another request waiting.",
csp->cfd);
continue;
}
if (csp->expected_client_content_length != 0)
{
- if (csp->expected_client_content_length < (sizeof(buf) - 1))
+ if (csp->expected_client_content_length < csp->receive_buffer_size)
{
max_bytes_to_read = (int)csp->expected_client_content_length;
}
"Waiting for up to %d bytes from the client.",
max_bytes_to_read);
}
- assert(max_bytes_to_read < sizeof(buf));
+ assert(max_bytes_to_read <= csp->receive_buffer_size);
#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
- len = read_socket(csp->cfd, buf, max_bytes_to_read);
+ len = read_socket(csp->cfd, csp->receive_buffer, max_bytes_to_read);
if (len <= 0)
{
}
#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
- if (write_socket(csp->server_connection.sfd, buf, (size_t)len))
+ if (write_socket(csp->server_connection.sfd, csp->receive_buffer, (size_t)len))
{
log_error(LOG_LEVEL_ERROR, "write to: %s failed: %E", http->host);
mark_server_socket_tainted(csp);
* If `hdr' is null, then it's the header otherwise it's the body.
* FIXME: Does `hdr' really mean `host'? No.
*/
+#ifdef HAVE_POLL
+ if (poll_fds[1].revents != 0)
+#else
if (FD_ISSET(csp->server_connection.sfd, &rfds))
+#endif /* HAVE_POLL */
{
#ifdef FEATURE_CONNECTION_KEEP_ALIVE
/*
}
#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
- len = read_socket(csp->server_connection.sfd, buf, sizeof(buf) - 1);
+ len = read_socket(csp->server_connection.sfd, csp->receive_buffer, (int)csp->receive_buffer_size);
if (len < 0)
{
log_error(LOG_LEVEL_ERROR, "read from: %s failed: %E", http->host);
- if (http->ssl && (fwd->forward_host == NULL))
+ if (http->ssl && (csp->fwd == NULL))
{
/*
* Just hang up. We already confirmed the client's CONNECT
#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(csp->receive_buffer+len-5, "0\r\n\r\n", 5))
{
/* XXX: this is a temporary hack */
log_error(LOG_LEVEL_CONNECT,
reading_done:
#endif /* FEATURE_CONNECTION_KEEP_ALIVE */
+ /*
+ * This is guaranteed by allocating with zalloc_or_die()
+ * and never (intentionally) writing to the last byte.
+ *
+ * csp->receive_buffer_size is the size of the part of the
+ * buffer we intentionally write to, but we actually
+ * allocated csp->receive_buffer_size+1 bytes so the assertion
+ * stays within the allocated range.
+ */
+ assert(csp->receive_buffer[csp->receive_buffer_size] == '\0');
+
/*
* Add a trailing zero to let be able to use string operations.
* XXX: do we still need this with filter_popups gone?
*/
- buf[len] = '\0';
+ assert(len <= csp->receive_buffer_size);
+ csp->receive_buffer[len] = '\0';
/*
* Normally, this would indicate that we've read
log_error(LOG_LEVEL_FATAL, "Out of memory parsing server header");
}
- if (write_socket(csp->cfd, hdr, strlen(hdr))
- || write_socket(csp->cfd,
- ((p != NULL) ? p : csp->iob->cur), (size_t)csp->content_length))
+ if (write_socket_delayed(csp->cfd, hdr, strlen(hdr), write_delay)
+ || write_socket_delayed(csp->cfd,
+ ((p != NULL) ? p : csp->iob->cur),
+ (size_t)csp->content_length, write_delay))
{
log_error(LOG_LEVEL_ERROR, "write modified content to client failed: %E");
freez(hdr);
* This is NOT the body, so
* Let's pretend the server just sent us a blank line.
*/
- snprintf(buf, sizeof(buf), "\r\n");
- len = (int)strlen(buf);
+ snprintf(csp->receive_buffer, csp->receive_buffer_size, "\r\n");
+ len = (int)strlen(csp->receive_buffer);
/*
* Now, let the normal header parsing algorithm below do its
* 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->iob, csp->config->buffer_limit, buf, len))
+ if (add_to_iob(csp->iob, csp->config->buffer_limit, csp->receive_buffer, len))
{
size_t hdrlen;
long flushed;
}
hdrlen = strlen(hdr);
- if (write_socket(csp->cfd, hdr, hdrlen)
- || ((flushed = flush_socket(csp->cfd, csp->iob)) < 0)
- || (write_socket(csp->cfd, buf, (size_t)len)))
+ if (write_socket_delayed(csp->cfd, hdr, hdrlen, write_delay)
+ || ((flushed = flush_iob(csp->cfd, csp->iob, write_delay) < 0)
+ || (write_socket_delayed(csp->cfd, csp->receive_buffer,
+ (size_t)len, write_delay))))
{
log_error(LOG_LEVEL_CONNECT,
"Flush header and buffers to client failed: %E");
}
else
{
- if (write_socket(csp->cfd, buf, (size_t)len))
+ if (write_socket_delayed(csp->cfd, csp->receive_buffer,
+ (size_t)len, write_delay))
{
log_error(LOG_LEVEL_ERROR, "write to client failed: %E");
mark_server_socket_tainted(csp);
* 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->iob, csp->config->buffer_limit, buf, len))
+ if (add_to_iob(csp->iob, csp->config->buffer_limit, csp->receive_buffer, len))
{
log_error(LOG_LEVEL_ERROR, "Out of memory while looking for end of server headers.");
rsp = cgi_error_memory();
"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));
+ write_socket_delayed(csp->cfd,
+ INVALID_SERVER_HEADERS_RESPONSE,
+ strlen(INVALID_SERVER_HEADERS_RESPONSE), write_delay);
mark_server_socket_tainted(csp);
return;
}
csp->headers->first->str);
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));
+ write_socket_delayed(csp->cfd, INVALID_SERVER_HEADERS_RESPONSE,
+ strlen(INVALID_SERVER_HEADERS_RESPONSE), write_delay);
free_http_request(http);
mark_server_socket_tainted(csp);
return;
*/
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_delayed(csp->cfd, INVALID_SERVER_HEADERS_RESPONSE,
+ strlen(INVALID_SERVER_HEADERS_RESPONSE), write_delay);
+ free_http_request(http);
+ mark_server_socket_tainted(csp);
+ return;
}
hdr = list_to_text(csp->headers);
if (hdr == NULL)
csp->flags |= CSP_FLAG_CONTENT_LENGTH_SET;
}
- csp->server_connection.response_received = time(NULL);
+ csp->server_connection.response_received = time(NULL);
+
+ if (crunch_response_triggered(csp, crunchers_light))
+ {
+ /*
+ * One of the tags created by a server-header
+ * tagger triggered a crunch. We already
+ * delivered the crunch response to the client
+ * and are done here after cleaning up.
+ */
+ freez(hdr);
+ mark_server_socket_tainted(csp);
+ return;
+ }
+ /* Buffer and pcrs filter this if appropriate. */
+
+ if (!http->ssl) /* We talk plaintext */
+ {
+ buffer_and_filter_content = content_requires_filtering(csp);
+ }
+ /*
+ * Only write if we're not buffering for content modification
+ */
+ if (!buffer_and_filter_content)
+ {
+ /*
+ * Write the server's (modified) header to
+ * the client (along with anything else that
+ * may be in the buffer)
+ */
+
+ if (write_socket_delayed(csp->cfd, hdr, strlen(hdr), write_delay)
+ || ((len = flush_iob(csp->cfd, csp->iob, write_delay)) < 0))
+ {
+ log_error(LOG_LEVEL_CONNECT, "write header to client failed: %E");
+
+ /*
+ * The write failed, so don't bother mentioning it
+ * to the client... it probably can't hear us anyway.
+ */
+ freez(hdr);
+ mark_server_socket_tainted(csp);
+ return;
+ }
+ }
+
+ /* we're finished with the server's header */
+
+ freez(hdr);
+ server_body = 1;
+
+ /*
+ * If this was a MS IIS/5 hack then it means the server
+ * has already closed the connection. Nothing more to read.
+ * Time to bail.
+ */
+ if (ms_iis5_hack)
+ {
+ 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_delayed(csp->cfd, INVALID_SERVER_HEADERS_RESPONSE,
+ strlen(INVALID_SERVER_HEADERS_RESPONSE), write_delay);
+ mark_server_socket_tainted(csp);
+ return;
+ }
+ }
+ continue;
+ }
+ mark_server_socket_tainted(csp);
+ return; /* huh? we should never get here */
+ }
+
+ if (csp->content_length == 0)
+ {
+ /*
+ * If Privoxy didn't recalculate the Content-Length,
+ * byte_count is still correct.
+ */
+ csp->content_length = byte_count;
+ }
+
+#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);
+
+ csp->server_connection.timestamp = time(NULL);
+}
+
+
+/*********************************************************************
+ *
+ * Function : chat
+ *
+ * Description : Once a connection from the client has been accepted,
+ * 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 with the same client socket
+ * if the client is keeping the connection alive.
+ *
+ * The decision whether or not a client connection will
+ * be kept alive is up to the caller which also must
+ * close the client socket when done.
+ *
+ * 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)
+{
+ const struct forward_spec *fwd;
+ struct http_request *http;
+ /* Skeleton for HTTP response, if we should intercept the request */
+ struct http_response *rsp;
+
+ http = csp->http;
+
+ if (receive_client_request(csp) != JB_ERR_OK)
+ {
+ return;
+ }
+ if (parse_client_request(csp) != JB_ERR_OK)
+ {
+ return;
+ }
+
+ /* decide how to route the HTTP request */
+ fwd = forward_url(csp, http);
+ if (NULL == fwd)
+ {
+ log_error(LOG_LEVEL_FATAL, "gateway spec is NULL!?!? This can't happen!");
+ /* Never get here - LOG_LEVEL_FATAL causes program exit */
+ return;
+ }
+
+ /*
+ * build the http request to send to the server
+ * we have to do one of the following:
+ *
+ * create = use the original HTTP request to create a new
+ * HTTP request that has either the path component
+ * without the http://domainspec (w/path) or the
+ * full orininal URL (w/url)
+ * Note that the path and/or the HTTP version may
+ * have been altered by now.
+ *
+ * connect = Open a socket to the host:port of the server
+ * and short-circuit server and client socket.
+ *
+ * pass = Pass the request unchanged if forwarding a CONNECT
+ * request to a parent proxy. Note that we'll be sending
+ * the CFAIL message ourselves if connecting to the parent
+ * fails, but we won't send a CSUCCEED message if it works,
+ * since that would result in a double message (ours and the
+ * parent's). After sending the request to the parent, we simply
+ * tunnel.
+ *
+ * here's the matrix:
+ * SSL
+ * 0 1
+ * +--------+--------+
+ * | | |
+ * 0 | create | connect|
+ * | w/path | |
+ * Forwarding +--------+--------+
+ * | | |
+ * 1 | create | pass |
+ * | w/url | |
+ * +--------+--------+
+ *
+ */
+
+ if (http->ssl && connect_port_is_forbidden(csp))
+ {
+ const char *acceptable_connect_ports =
+ 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 %s",
+ csp->ip_addr_str, acceptable_connect_ports, csp->http->hostport);
+ csp->action->flags |= ACTION_BLOCK;
+ http->ssl = 0;
+ }
+
+ if (http->ssl == 0)
+ {
+ freez(csp->headers->first->str);
+ build_request_line(csp, fwd, &csp->headers->first->str);
+ }
+
+ /*
+ * We have a request. Check if one of the crunchers wants it.
+ */
+ if (crunch_response_triggered(csp, crunchers_all))
+ {
+ /*
+ * Yes. The client got the crunch response and we're done here.
+ */
+ return;
+ }
+
+ log_applied_actions(csp->action);
+ 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);
+ }
+ else
+ {
+ log_error(LOG_LEVEL_CONNECT, "to %s", http->hostport);
+ }
+
+ /* here we connect to the server, gateway, or the forwarder */
- if (crunch_response_triggered(csp, crunchers_light))
- {
- /*
- * One of the tags created by a server-header
- * tagger triggered a crunch. We already
- * delivered the crunch response to the client
- * and are done here after cleaning up.
- */
- freez(hdr);
- mark_server_socket_tainted(csp);
- return;
- }
- /* Buffer and pcrs filter this if appropriate. */
+#ifdef FEATURE_CONNECTION_KEEP_ALIVE
+ if ((csp->server_connection.sfd != JB_INVALID_SOCKET)
+ && socket_is_still_alive(csp->server_connection.sfd)
+ && connection_destination_matches(&csp->server_connection, http, fwd))
+ {
+ log_error(LOG_LEVEL_CONNECT,
+ "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)
+ {
+#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 (!http->ssl) /* We talk plaintext */
- {
- buffer_and_filter_content = content_requires_filtering(csp);
- }
- /*
- * Only write if we're not buffering for content modification
- */
- if (!buffer_and_filter_content)
- {
- /*
- * Write the server's (modified) header to
- * the client (along with anything else that
- * may be in the buffer)
- */
+ csp->server_connection.sfd = forwarded_connect(fwd, http, csp);
- if (write_socket(csp->cfd, hdr, strlen(hdr))
- || ((len = flush_socket(csp->cfd, csp->iob)) < 0))
- {
- log_error(LOG_LEVEL_CONNECT, "write header to client failed: %E");
+ if (csp->server_connection.sfd == JB_INVALID_SOCKET)
+ {
+ if (fwd->type != SOCKS_NONE)
+ {
+ /* Socks error. */
+ rsp = error_response(csp, "forwarding-failed");
+ }
+ else if (errno == EINVAL)
+ {
+ rsp = error_response(csp, "no-such-domain");
+ }
+ else
+ {
+ rsp = error_response(csp, "connect-failed");
+ }
- /*
- * The write failed, so don't bother mentioning it
- * to the client... it probably can't hear us anyway.
- */
- freez(hdr);
- mark_server_socket_tainted(csp);
- return;
- }
- }
+ /* Write the answer to the client */
+ if (rsp != NULL)
+ {
+ send_crunch_response(csp, rsp);
+ }
- /* we're finished with the server's header */
+ /*
+ * 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;
- freez(hdr);
- server_body = 1;
+ return;
+ }
+#ifdef FEATURE_CONNECTION_KEEP_ALIVE
+ save_connection_destination(csp->server_connection.sfd,
+ http, fwd, &csp->server_connection);
+ csp->server_connection.keep_alive_timeout =
+ (unsigned)csp->config->keep_alive_timeout;
+ }
+#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
- /*
- * If this was a MS IIS/5 hack then it means the server
- * has already closed the connection. Nothing more to read.
- * Time to bail.
- */
- if (ms_iis5_hack)
- {
- 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;
- }
+ 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))
+ {
+ if (send_http_request(csp))
+ {
+ rsp = error_response(csp, "connect-failed");
+ if (rsp)
+ {
+ send_crunch_response(csp, rsp);
}
- continue;
+ return;
}
- mark_server_socket_tainted(csp);
- return; /* huh? we should never get here */
}
-
- if (csp->content_length == 0)
+ else
{
/*
- * If Privoxy didn't recalculate the Content-Length,
- * byte_count is still correct.
+ * We're running an SSL tunnel and we're not forwarding,
+ * so just ditch the client headers, send the "connect succeeded"
+ * message to the client, flush the rest, and get out of the way.
*/
- csp->content_length = byte_count;
+ list_remove_all(csp->headers);
+ if (write_socket_delayed(csp->cfd, CSUCCEED,
+ strlen(CSUCCEED), get_write_delay(csp)))
+ {
+ return;
+ }
+ clear_iob(csp->client_iob);
}
-#ifdef FEATURE_CONNECTION_KEEP_ALIVE
- if ((csp->flags & CSP_FLAG_CONTENT_LENGTH_SET)
- && (csp->expected_content_length != byte_count))
+ 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);
+
+ handle_established_connection(csp);
+ freez(csp->receive_buffer);
+}
+
+
+#ifdef FUZZ
+/*********************************************************************
+ *
+ * Function : fuzz_server_response
+ *
+ * Description : Treat the input as a whole server response.
+ *
+ * Parameters :
+ * 1 : csp = Current client state (buffers, headers, etc...)
+ * 2 : fuzz_input_file = File to read the input from.
+ *
+ * Returns : 0
+ *
+ *********************************************************************/
+extern int fuzz_server_response(struct client_state *csp, char *fuzz_input_file)
+{
+ static struct forward_spec fwd; /* Zero'd due to being static */
+ csp->cfd = 0;
+
+ if (strcmp(fuzz_input_file, "-") == 0)
{
- log_error(LOG_LEVEL_CONNECT,
- "Received %llu bytes while expecting %llu.",
- byte_count, csp->expected_content_length);
- mark_server_socket_tainted(csp);
+ /* XXX: Doesn'T work yet. */
+ csp->server_connection.sfd = 0;
}
-#endif
+ else
+ {
+ csp->server_connection.sfd = open(fuzz_input_file, O_RDONLY);
+ if (csp->server_connection.sfd == -1)
+ {
+ log_error(LOG_LEVEL_FATAL, "Failed to open %s: %E",
+ fuzz_input_file);
+ }
+ }
+ csp->fwd = &fwd;
+ csp->content_type |= CT_GIF;
+ csp->action->flags |= ACTION_DEANIMATE;
+ csp->action->string[ACTION_STRING_DEANIMATE] = "last";
- log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 200 %llu",
- csp->ip_addr_str, http->ocmd, csp->content_length);
+ csp->http->path = strdup_or_die("/");
+ csp->http->host = strdup_or_die("fuzz.example.org");
+ csp->http->hostport = strdup_or_die("fuzz.example.org:80");
+ /* Prevent client socket monitoring */
+ csp->flags |= CSP_FLAG_PIPELINED_REQUEST_WAITING;
+ csp->flags |= CSP_FLAG_CHUNKED;
- csp->server_connection.timestamp = time(NULL);
+ csp->config->feature_flags |= RUNTIME_FEATURE_CONNECTION_KEEP_ALIVE;
+ csp->flags |= CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE;
+
+ csp->content_type |= CT_DECLARED|CT_GIF;
+
+ csp->config->socket_timeout = 0;
+
+ cgi_init_error_messages();
+
+ handle_established_connection(csp);
+ freez(csp->receive_buffer);
+
+ return 0;
}
+#endif
#ifdef FEATURE_CONNECTION_KEEP_ALIVE
*********************************************************************/
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;
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;
}
* Returns : N/A
*
*********************************************************************/
-#ifdef AMIGA
-void serve(struct client_state *csp)
-#else /* ifndef AMIGA */
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
}
}
- 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;
drain_and_close_socket(csp->cfd);
}
+ free_csp_resources(csp);
+
csp->flags &= ~CSP_FLAG_ACTIVE;
}
* Returns : No. ,-)
*
*********************************************************************/
-static void usage(const char *myname)
+static void usage(const char *name)
{
printf("Privoxy version " VERSION " (" HOME_PAGE_URL ")\n"
"Usage: %s [--config-test] "
#if defined(unix)
"[--no-daemon] [--pidfile pidfile] [--pre-chroot-nslookup hostname] [--user user[.group]] "
#endif /* defined(unix) */
- "[--version] [configfile]\n"
- "Aborting\n", myname);
+ "[--version] [configfile]\n",
+ name);
+
+#ifdef FUZZ
+ show_fuzz_usage(name);
+#endif
+
+ printf("Aborting\n");
exit(2);
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
privoxy_mutex_init(&localtime_mutex);
#endif /* ndef HAVE_GMTIME_R */
-#ifndef HAVE_RANDOM
+#if !defined(HAVE_ARC4RANDOM) && !defined(HAVE_RANDOM)
privoxy_mutex_init(&rand_mutex);
-#endif /* ndef HAVE_RANDOM */
+#endif /* !defined(HAVE_ARC4RANDOM) && !defined(HAVE_RANDOM) */
#endif /* def MUTEX_LOCKS_AVAILABLE */
}
-
/*********************************************************************
*
* Function : main
{
int argc_pos = 0;
int do_config_test = 0;
+#ifndef HAVE_ARC4RANDOM
unsigned int random_seed;
+#endif
#ifdef unix
struct passwd *pw = NULL;
struct group *grp = NULL;
int do_chroot = 0;
char *pre_chroot_nslookup_to_load_resolver = NULL;
#endif
+#ifdef FUZZ
+ char *fuzz_input_type = NULL;
+ char *fuzz_input_file = NULL;
+#endif
Argc = argc;
Argv = argv;
{
do_config_test = 1;
}
-
+#ifdef FUZZ
+ else if (strcmp(argv[argc_pos], "--fuzz") == 0)
+ {
+ argc_pos++;
+ if (argc < argc_pos + 2) usage(argv[0]);
+ fuzz_input_type = argv[argc_pos];
+ argc_pos++;
+ fuzz_input_file = argv[argc_pos];
+ }
+ else if (strcmp(argv[argc_pos], "--stfu") == 0)
+ {
+ set_debug_level(LOG_LEVEL_STFU);
+ }
+#endif
else if (argc_pos + 1 != argc)
{
/*
clients->next = NULL;
/* XXX: factor out initialising after the next stable release. */
-#ifdef AMIGA
- InitAmiga();
-#elif defined(_WIN32)
+#ifdef _WIN32
InitWin32();
#endif
+#ifndef HAVE_ARC4RANDOM
random_seed = (unsigned int)time(NULL);
#ifdef HAVE_RANDOM
srandom(random_seed);
#else
srand(random_seed);
#endif /* ifdef HAVE_RANDOM */
+#endif /* ifndef HAVE_ARC4RANDOM */
/*
* Unix signal handling
*
* Catch the abort, interrupt and terminate signals for a graceful exit
* Catch the hangup signal so the errlog can be reopened.
- * Ignore the broken pipe signals (FIXME: Why?)
+ *
+ * Ignore the broken pipe signal as connection failures
+ * are handled when and where they occur without relying
+ * on a signal.
*/
-#if !defined(_WIN32) && !defined(__OS2__) && !defined(AMIGA)
+#if !defined(_WIN32) && !defined(__OS2__)
{
int idx;
const int catched_signals[] = { SIGTERM, SIGINT, SIGHUP };
# endif /* def _WIN_CONSOLE */
#endif /* def _WIN32 */
+#ifdef FUZZ
+ if (fuzz_input_type != NULL)
+ {
+ exit(process_fuzzed_input(fuzz_input_type, fuzz_input_file));
+ }
+ log_error(LOG_LEVEL_FATAL,
+ "When compiled with fuzzing support, Privoxy should only be used for fuzzing. "
+ "Various data structures are static which is unsafe when using threads.");
+#endif
+
if (do_config_test)
{
exit(NULL == load_config());
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) */
* As soon as we have written the PID file, we can switch
* to the user and group ID indicated by the --user option
*/
- write_pid_file();
-
+ if (pidfile != NULL)
+ {
+ write_pid_file(pidfile);
+ }
if (NULL != pw)
{
if (setgid((NULL != grp) ? grp->gr_gid : 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.
+ * 3 : backlog = Listen backlog.
*
* Returns : Port that was opened.
*
*********************************************************************/
-static jb_socket bind_port_helper(const char *haddr, int hport)
+static jb_socket bind_port_helper(const char *haddr, int hport, int backlog)
{
int result;
jb_socket bfd;
- result = bind_port(haddr, hport, &bfd);
+ result = bind_port(haddr, hport, backlog, &bfd);
if (result < 0)
{
return JB_INVALID_SOCKET;
}
+#ifndef HAVE_POLL
+#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
+#endif
+
if (haddr == NULL)
{
log_error(LOG_LEVEL_INFO, "Listening on port %d on all IP addresses",
{
if (config->hport[i])
{
- sockets[i] = bind_port_helper(config->haddr[i], config->hport[i]);
+ sockets[i] = bind_port_helper(config->haddr[i],
+ config->hport[i], config->listen_backlog);
+#if defined(FEATURE_ACCEPT_FILTER) && defined(SO_ACCEPTFILTER)
+ if (config->enable_accept_filter && sockets[i] != JB_INVALID_SOCKET)
+ {
+ struct accept_filter_arg af_options;
+ bzero(&af_options, sizeof(af_options));
+ strlcpy(af_options.af_name, "httpready", sizeof(af_options.af_name));
+ if (setsockopt(sockets[i], SOL_SOCKET, SO_ACCEPTFILTER, &af_options,
+ sizeof(af_options)))
+ {
+ log_error(LOG_LEVEL_ERROR,
+ "Enabling accept filter for socket %d failed: %E", sockets[i]);
+ }
+ }
+#endif
}
else
{
jb_socket bfds[MAX_LISTENING_SOCKETS];
struct configuration_spec *config;
unsigned int active_threads = 0;
+#if defined(FEATURE_PTHREAD)
+ pthread_attr_t attrs;
+
+ pthread_attr_init(&attrs);
+ pthread_attr_setdetachstate(&attrs, PTHREAD_CREATE_DETACHED);
+#endif
config = load_config();
for (;;)
#endif
{
-#if !defined(FEATURE_PTHREAD) && !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA) && !defined(__OS2__)
+#if !defined(FEATURE_PTHREAD) && !defined(_WIN32) && !defined(__BEOS__) && !defined(__OS2__)
while (waitpid(-1, NULL, WNOHANG) > 0)
{
/* zombie children */
}
-#endif /* !defined(FEATURE_PTHREAD) && !defined(_WIN32) && !defined(__BEOS__) && !defined(AMIGA) */
+#endif /* !defined(FEATURE_PTHREAD) && !defined(_WIN32) && !defined(__BEOS__) */
/*
* Free data that was used by died threads
}
#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))
{
log_error(LOG_LEVEL_CONNECT, "accept failed: %E");
-
-#ifdef AMIGA
- if (!childs)
- {
- exit(1);
- }
-#endif
freez(csp_list);
continue;
}
* new one.
*
* Which-ever is correct, we will serve 1 more page via the
- * old settings. This should probably be a "show-proxy-args"
+ * old settings. This should probably be a "show-status"
* request. This should not be a so common of an operation
* that this will hurt people's feelings.
*/
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;
}
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));
+ write_socket_delayed(csp->cfd, TOO_MANY_CONNECTIONS_RESPONSE,
+ strlen(TOO_MANY_CONNECTIONS_RESPONSE), get_write_delay(csp));
close_socket(csp->cfd);
freez(csp->ip_addr_str);
+ freez(csp->listen_addr_str);
freez(csp_list);
continue;
}
#define SELECTED_ONE_OPTION
{
pthread_t the_thread;
- pthread_attr_t attrs;
- pthread_attr_init(&attrs);
- pthread_attr_setdetachstate(&attrs, PTHREAD_CREATE_DETACHED);
errno = pthread_create(&the_thread, &attrs,
(void * (*)(void *))serve, csp);
child_id = errno ? -1 : 0;
- pthread_attr_destroy(&attrs);
}
#endif
}
#endif
-#if defined(AMIGA) && !defined(SELECTED_ONE_OPTION)
-#define SELECTED_ONE_OPTION
- csp->cfd = ReleaseSocket(csp->cfd, -1);
-
-#ifdef __amigaos4__
- child_id = (int)CreateNewProcTags(NP_Entry, (ULONG)server_thread,
- NP_Output, Output(),
- NP_CloseOutput, FALSE,
- NP_Name, (ULONG)"privoxy child",
- NP_Child, TRUE,
- TAG_DONE);
-#else
- child_id = (int)CreateNewProcTags(NP_Entry, (ULONG)server_thread,
- NP_Output, Output(),
- NP_CloseOutput, FALSE,
- NP_Name, (ULONG)"privoxy child",
- NP_StackSize, 200*1024,
- TAG_DONE);
-#endif
- if (0 != child_id)
- {
- childs++;
- ((struct Task *)child_id)->tc_UserData = csp;
- Signal((struct Task *)child_id, SIGF_SINGLE);
- Wait(SIGF_SINGLE);
- }
-#endif
-
#if !defined(SELECTED_ONE_OPTION)
child_id = fork();
* 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));
+ "Unable to take any additional connections: %E. Active threads: %d",
+ active_threads);
+ write_socket_delayed(csp->cfd, TOO_MANY_CONNECTIONS_RESPONSE,
+ strlen(TOO_MANY_CONNECTIONS_RESPONSE), get_write_delay(csp));
close_socket(csp->cfd);
csp->flags &= ~CSP_FLAG_ACTIVE;
}
}
}
+#if defined(FEATURE_PTHREAD)
+ pthread_attr_destroy(&attrs);
+#endif
+
/* NOTREACHED unless FEATURE_GRACEFUL_TERMINATION is defined */
/* Clean up. Aim: free all memory (no leaks) */