-const char jcc_rcs[] = "$Id: jcc.c,v 1.110 2006/12/13 14:52:53 etresoft Exp $";
+const char jcc_rcs[] = "$Id: jcc.c,v 1.127 2007/03/20 13:53:17 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 the SourceForge
+ * Copyright : Written by and Copyright (C) 2001-2007 the SourceForge
* Privoxy team. http://www.privoxy.org/
*
* Based on the Internet Junkbuster originally written
*
* Revisions :
* $Log: jcc.c,v $
+ * Revision 1.127 2007/03/20 13:53:17 fabiankeil
+ * Log the source address for ACL-related connection drops.
+ *
+ * Revision 1.126 2007/03/17 15:20:05 fabiankeil
+ * New config option: enforce-blocks.
+ *
+ * Revision 1.125 2007/03/09 14:12:00 fabiankeil
+ * - Move null byte check into separate function.
+ * - Don't confuse the client with error pages
+ * if a CONNECT request was already confirmed.
+ *
+ * Revision 1.124 2007/02/23 14:59:54 fabiankeil
+ * Speed up NULL byte escaping and only log the complete
+ * NULL byte requests with header debugging enabled.
+ *
+ * Revision 1.123 2007/02/21 18:42:10 fabiankeil
+ * Answer requests that contain NULL bytes with
+ * a custom response instead of waiting for more
+ * data until the client eventually hangs up.
+ *
+ * Revision 1.122 2007/02/07 11:12:02 fabiankeil
+ * - Move delivery and logging of crunched responses
+ * from chat() into send_crunch_response().
+ * - Display the reason for generating http_responses.
+ * - Log the content length for LOG_LEVEL_CLF correctly
+ * (still incorrect for some fixed responses).
+ * - Reword an incorrect comment about
+ * treat-forbidden-connects-like-blocks violating
+ * the specs.
+ * - Add some log messages.
+ *
+ * Revision 1.121 2007/01/27 10:52:56 fabiankeil
+ * Move mutex initialization into separate
+ * function and exit in case of errors.
+ *
+ * Revision 1.120 2007/01/26 14:18:42 fabiankeil
+ * - Start to reduce chat()'s line count and move
+ * parts of it into separate functions.
+ * - Add "HTTP/1.1 100 Continue" hack for BR 756734.
+ *
+ * Revision 1.119 2007/01/25 14:02:30 fabiankeil
+ * - Add Proxy-Agent header to HTTP snippets that are
+ * supposed to reach HTTP clients only.
+ * - Made a few CONNECT log messages more descriptive.
+ * - Catch completely empty server responses (as seen
+ * with Tor's fake ".noconnect" top level domain).
+ * - Use shiny new "forwarding-failed" template for socks errors.
+ *
+ * Revision 1.118 2007/01/07 07:43:43 joergs
+ * AmigaOS4 support added.
+ *
+ * Revision 1.117 2006/12/31 17:56:37 fabiankeil
+ * Added config option accept-intercepted-requests
+ * and disabled it by default.
+ *
+ * Revision 1.116 2006/12/29 19:08:22 fabiankeil
+ * Reverted parts of my last commit
+ * to keep error handling working.
+ *
+ * Revision 1.115 2006/12/29 17:38:57 fabiankeil
+ * Fixed gcc43 conversion warnings.
+ *
+ * Revision 1.114 2006/12/27 18:52:02 fabiankeil
+ * Fix -pedantic ISO C warning about converting
+ * from function pointer to object pointer.
+ *
+ * Revision 1.113 2006/12/26 17:38:50 fabiankeil
+ * Silence compiler warning I introduced with my last commit.
+ *
+ * Revision 1.112 2006/12/26 17:31:41 fabiankeil
+ * Mutex protect rand() if POSIX threading
+ * is used, warn the user if that's not possible
+ * and stop using it on _WIN32 where it could
+ * cause crashes.
+ *
+ * Revision 1.111 2006/12/23 16:15:06 fabiankeil
+ * Don't prevent core dumps by catching SIGABRT.
+ * It's rude and makes debugging unreasonable painful.
+ *
* Revision 1.110 2006/12/13 14:52:53 etresoft
* Fix build failure on MacOS X. Global symbols can be either static or extern, but not both.
*
#include <signal.h>
#include <fcntl.h>
#include <errno.h>
+#include <assert.h>
#ifdef _WIN32
# ifndef FEATURE_PTHREAD
#ifndef HAVE_GETHOSTBYNAME_R
pthread_mutex_t gethostbyname_mutex;
#endif /* ndef HAVE_GETHOSTBYNAME_R */
+
+#ifndef HAVE_RANDOM
+pthread_mutex_t rand_mutex;
+#endif /* ndef HAVE_RANDOM */
+
#endif /* FEATURE_PTHREAD */
#if defined(unix) || defined(__EMX__)
const char CHEADER[] =
"HTTP/1.0 400 Invalid header received from browser\r\n"
"Connection: close\r\n\r\n"
- "Invalid header received from browser.";
+ "Invalid header received from browser.\r\n";
const char CFORBIDDEN[] =
"HTTP/1.0 403 Connection not allowable\r\n"
+ "Proxy-Agent: Privoxy " VERSION "\r\n"
"X-Hint: If you read this message interactively, then you know why this happens ,-)\r\n"
"Connection: close\r\n\r\n";
"Connection: close\r\n\r\n"
"Invalid request. Privoxy doesn't support gopher.\r\n";
+/* XXX: should be a template */
const char MISSING_DESTINATION_RESPONSE[] =
"HTTP/1.0 400 Bad request received from browser\r\n"
+ "Proxy-Agent: Privoxy " VERSION "\r\n"
"Connection: close\r\n\r\n"
"Bad request. Privoxy was unable to extract the destination.\r\n";
+/* XXX: should be a template */
+const char NO_SERVER_DATA_RESPONSE[] =
+ "HTTP/1.0 502 Server or forwarder response empty\r\n"
+ "Proxy-Agent: Privoxy " VERSION "\r\n"
+ "Connection: close\r\n\r\n"
+ "Empty server or forwarder response.\r\n"
+ "The connection was closed without sending any data.\r\n";
+
+/* XXX: should be a template */
+const char NULL_BYTE_RESPONSE[] =
+ "HTTP/1.0 400 Bad request received from browser\r\n"
+ "Proxy-Agent: Privoxy " VERSION "\r\n"
+ "Connection: close\r\n\r\n"
+ "Bad request. Null byte(s) before end of request.\r\n";
#if !defined(_WIN32) && !defined(__OS2__) && !defined(AMIGA)
/*********************************************************************
* Function : sig_handler
*
* Description : Signal handler for different signals.
- * Exit gracefully on ABRT, TERM and INT
+ * Exit gracefully on TERM and INT
* or set a flag that will cause the errlog
* to be reopened by the main thread on HUP.
*
#endif
+/*********************************************************************
+ *
+ * Function : client_protocol_is_unsupported
+ *
+ * Description : Checks if the client used a known unsupported
+ * protocol and deals with it by sending an error
+ * response.
+ *
+ * Parameters :
+ * 1 : csp = Current client state (buffers, headers, etc...)
+ * 2 : req = the first request line send by the client
+ *
+ * Returns : TRUE if an error response has been generated, or
+ * FALSE if the request doesn't look invalid.
+ *
+ *********************************************************************/
+int client_protocol_is_unsupported(const struct client_state *csp, char *req)
+{
+ char buf[BUFFER_SIZE];
+
+ /*
+ * If it's a FTP or gopher request, we don't support it.
+ *
+ * These checks are better than nothing, but they might
+ * not work in all configurations and some clients might
+ * have problems digesting the answer.
+ *
+ * They should, however, never cause more problems than
+ * Privoxy's old behaviour (returning the misleading HTML
+ * error message:
+ *
+ * "Could not resolve http://(ftp|gopher)://example.org").
+ */
+ if (!strncmpic(req, "GET ftp://", 10) || !strncmpic(req, "GET gopher://", 13))
+ {
+ if (!strncmpic(req, "GET ftp://", 10))
+ {
+ strcpy(buf, FTP_RESPONSE);
+ log_error(LOG_LEVEL_ERROR, "%s tried to use Privoxy as FTP proxy: %s",
+ csp->ip_addr_str, req);
+ }
+ else
+ {
+ strcpy(buf, GOPHER_RESPONSE);
+ log_error(LOG_LEVEL_ERROR, "%s tried to use Privoxy as gopher proxy: %s",
+ csp->ip_addr_str, req);
+ }
+ log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 400 0", csp->ip_addr_str, req);
+ freez(req);
+ write_socket(csp->cfd, buf, strlen(buf));
+
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+
+/*********************************************************************
+ *
+ * Function : get_request_destination_elsewhere
+ *
+ * Description : If the client's request was redirected into
+ * Privoxy without the client's knowledge,
+ * the request line lacks the destination host.
+ *
+ * This function tries to get it elsewhere,
+ * provided accept-intercepted-requests is enabled.
+ *
+ * "Elsewhere" currently only means "Host: header",
+ * but in the future we may ask the redirecting
+ * packet filter to look the destination up.
+ *
+ * If the destination stays unknown, an error
+ * response is send to the client and headers
+ * are freed so that chat() can return directly.
+ *
+ * Parameters :
+ * 1 : csp = Current client state (buffers, headers, etc...)
+ * 2 : headers = a header list
+ *
+ * Returns : JB_ERR_OK if the destination is now known, or
+ * JB_ERR_PARSE if it isn't.
+ *
+ *********************************************************************/
+jb_err get_request_destination_elsewhere(struct client_state *csp, struct list *headers)
+{
+ char buf[BUFFER_SIZE];
+ char *req;
+
+ if (!(csp->config->feature_flags & RUNTIME_FEATURE_ACCEPT_INTERCEPTED_REQUESTS))
+ {
+ log_error(LOG_LEVEL_ERROR, "%s's request: \'%s\' is invalid."
+ " Privoxy isn't configured to accept intercepted requests.",
+ csp->ip_addr_str, csp->http->cmd);
+ /* XXX: Use correct size */
+ log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 400 0",
+ csp->ip_addr_str, csp->http->cmd);
+
+ strcpy(buf, CHEADER);
+ write_socket(csp->cfd, buf, strlen(buf));
+ destroy_list(headers);
+
+ return JB_ERR_PARSE;
+ }
+ else if (JB_ERR_OK == get_destination_from_headers(headers, csp->http))
+ {
+ /* Split the domain we just got for pattern matching */
+ init_domain_components(csp->http);
+
+ return JB_ERR_OK;
+ }
+ else
+ {
+ /* We can't work without destination. Go spread the news.*/
+
+ req = list_to_text(headers);
+ chomp(req);
+ /* XXX: Use correct size */
+ log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 400 0",
+ csp->ip_addr_str, csp->http->cmd);
+ log_error(LOG_LEVEL_ERROR,
+ "Privoxy was unable to get the destination for %s's request:\n%s\n%s",
+ csp->ip_addr_str, csp->http->cmd, req);
+ freez(req);
+
+ strcpy(buf, MISSING_DESTINATION_RESPONSE);
+ write_socket(csp->cfd, buf, strlen(buf));
+ destroy_list(headers);
+
+ return JB_ERR_PARSE;
+ }
+ /*
+ * TODO: If available, use PF's ioctl DIOCNATLOOK as last resort
+ * to get the destination IP address, use it as host directly
+ * or do a reverse DNS lookup first.
+ */
+}
+
+
+/*********************************************************************
+ *
+ * Function : get_server_headers
+ *
+ * Description : Parses server headers in iob and fills them
+ * into csp->headers so that they can later be
+ * handled by sed().
+ *
+ * Parameters :
+ * 1 : csp = Current client state (buffers, headers, etc...)
+ *
+ * Returns : JB_ERR_OK if everything went fine, or
+ * JB_ERR_PARSE if the headers were incomplete.
+ *
+ *********************************************************************/
+jb_err get_server_headers(struct client_state *csp)
+{
+ int continue_hack_in_da_house = 0;
+ char * header;
+
+ while (((header = get_header(csp)) != NULL) || continue_hack_in_da_house)
+ {
+ if (header == NULL)
+ {
+ /*
+ * continue hack in da house. Ignore the ending of
+ * this head and continue enlisting header lines.
+ * The reason is described below.
+ */
+ enlist(csp->headers, "");
+ continue_hack_in_da_house = 0;
+ continue;
+ }
+ else if (0 == strncmpic(header, "HTTP/1.1 100", 12))
+ {
+ /*
+ * It's a bodyless continue response, don't
+ * stop header parsing after reaching it's end.
+ *
+ * As a result Privoxy will concatenate the
+ * next response's head and parse and deliver
+ * the headers as if they belonged to one request.
+ *
+ * The client will separate them because of the
+ * empty line between them.
+ *
+ * XXX: What we're doing here is clearly against
+ * the intended purpose of the continue header,
+ * and under some conditions (HTTP/1.0 client request)
+ * it's a standard violation.
+ *
+ * Anyway, "sort of against the spec" is preferable
+ * to "always getting confused by Continue responses"
+ * (Privoxy's behaviour before this hack was added)
+ */
+ log_error(LOG_LEVEL_HEADER, "Continue hack in da house.");
+ continue_hack_in_da_house = 1;
+ }
+ else if (*header == '\0')
+ {
+ /*
+ * If the header is empty, but the Continue hack
+ * isn't active, we can assume that we reached the
+ * end of the buffer before we hit the end of the
+ * head.
+ *
+ * Inform the caller an let it decide how to handle it.
+ */
+ return JB_ERR_PARSE;
+ }
+
+ /* Enlist header */
+ if (JB_ERR_MEMORY == enlist(csp->headers, header))
+ {
+ /*
+ * XXX: Should we quit the request and return a
+ * out of memory error page instead?
+ */
+ log_error(LOG_LEVEL_ERROR,
+ "Out of memory while enlisting server headers. %s lost.",
+ header);
+ }
+ freez(header);
+ }
+
+ return JB_ERR_OK;
+}
+
+
+/*********************************************************************
+ *
+ * Function : crunch_reason
+ *
+ * Description : Translates the crunch reason code into a string.
+ *
+ * Parameters :
+ * 1 : rsp = a http_response
+ *
+ * Returns : A string with the crunch reason or an error description.
+ *
+ *********************************************************************/
+const char *crunch_reason(const struct http_response *rsp)
+{
+ char * reason = NULL;
+
+ assert(rsp != NULL);
+ if (rsp == NULL)
+ {
+ return "Internal error while searching for crunch reason";
+ }
+
+ switch (rsp->reason)
+ {
+ case RSP_REASON_UNSUPPORTED:
+ reason = "Unsupported HTTP feature";
+ break;
+ case RSP_REASON_BLOCKED:
+ reason = "Blocked";
+ break;
+ case RSP_REASON_UNTRUSTED:
+ reason = "Untrusted";
+ break;
+ case RSP_REASON_REDIRECTED:
+ reason = "Redirected";
+ break;
+ case RSP_REASON_CGI_CALL:
+ reason = "CGI Call";
+ break;
+ case RSP_REASON_NO_SUCH_DOMAIN:
+ reason = "DNS failure";
+ break;
+ case RSP_REASON_FORWARDING_FAILED:
+ reason = "Forwarding failed";
+ break;
+ case RSP_REASON_CONNECT_FAILED:
+ reason = "Connection failure";
+ break;
+ case RSP_REASON_OUT_OF_MEMORY:
+ reason = "Out of memory (may mask other reasons)";
+ break;
+ default:
+ reason = "No reason recorded";
+ break;
+ }
+
+ return reason;
+}
+
+
+/*********************************************************************
+ *
+ * Function : send_crunch_response
+ *
+ * Description : Delivers already prepared response for
+ * intercepted requests, logs the interception
+ * and frees the response.
+ *
+ * Parameters :
+ * 1 : csp = Current client state (buffers, headers, etc...)
+ * 1 : rsp = Fully prepared response. Will be freed on exit.
+ *
+ * Returns : Nothing.
+ *
+ *********************************************************************/
+void send_crunch_response(struct client_state *csp, struct http_response *rsp)
+{
+ const struct http_request *http = csp->http;
+ char status_code[4];
+
+ assert(rsp != NULL);
+ assert(rsp->head != NULL);
+
+ if (rsp == NULL)
+ {
+ /*
+ * Not supposed to happen. If it does
+ * anyway, treat it as an unknown error.
+ */
+ cgi_error_unknown(csp, rsp, RSP_REASON_INTERNAL_ERROR);
+ /* return code doesn't matter */
+ }
+
+ if (rsp == NULL)
+ {
+ /* If rsp is still NULL, we have serious internal problems. */
+ log_error(LOG_LEVEL_FATAL,
+ "NULL response in send_crunch_response and cgi_error_unknown failed as well.");
+ }
+
+ /*
+ * Extract the status code from the actual head
+ * that was send to the client. It is the only
+ * way to get it right for all requests, including
+ * the fixed ones for out-of-memory problems.
+ *
+ * A head starts like this: 'HTTP/1.1 200...'
+ * 0123456789|11
+ * 10
+ */
+ status_code[0] = rsp->head[9];
+ status_code[1] = rsp->head[10];
+ status_code[2] = rsp->head[11];
+ status_code[3] = '\0';
+
+ /* 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))
+ {
+ /* There is nothing we can do about it. */
+ log_error(LOG_LEVEL_ERROR, "write to: %s failed: %E", csp->http->host);
+ }
+
+ /* Log that the request was crunched and why. */
+ log_error(LOG_LEVEL_GPC, "%s%s crunch! (%s)",
+ http->hostport, http->path, crunch_reason(rsp));
+ log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" %s %d",
+ csp->ip_addr_str, http->ocmd, status_code, rsp->content_length);
+
+ /* Clean up and return */
+ if (cgi_error_memory() != rsp)
+ {
+ free_http_response(rsp);
+ }
+ return;
+}
+
+
+/*********************************************************************
+ *
+ * Function : request_contains_null_bytes
+ *
+ * Description : Checks for NULL bytes in the request and sends
+ * an error message to the client if any were found.
+ *
+ * Parameters :
+ * 1 : csp = Current client state (buffers, headers, etc...)
+ * 2 : buf = Data from the client's request to check.
+ * 3 : len = The data length.
+ *
+ * Returns : TRUE if the request contained one or more NULL bytes, or
+ * FALSE otherwise.
+ *
+ *********************************************************************/
+int request_contains_null_bytes(const struct client_state *csp, char *buf, int len)
+{
+ size_t c_len; /* Request lenght when treated as C string */
+
+ c_len = strlen(buf);
+
+ if (c_len < len)
+ {
+ /*
+ * Null byte(s) found. Log the request,
+ * return an error response and hang up.
+ */
+ size_t tmp_len = c_len;
+
+ do
+ {
+ /*
+ * Replace NULL byte(s) with '°' characters
+ * so the request can be logged as string.
+ * XXX: Is there a better replacement character?
+ */
+ buf[tmp_len]='°';
+ tmp_len += strlen(buf+tmp_len);
+ } while (tmp_len < len);
+
+ log_error(LOG_LEVEL_ERROR, "%s\'s request contains at least one NULL byte "
+ "(length=%d, strlen=%d).", csp->ip_addr_str, len, c_len);
+ log_error(LOG_LEVEL_HEADER,
+ "Offending request data with NULL bytes turned into \'°\' characters: %s", buf);
+
+ strcpy(buf, NULL_BYTE_RESPONSE);
+ write_socket(csp->cfd, buf, strlen(buf));
+
+ /* XXX: Log correct size */
+ log_error(LOG_LEVEL_CLF, "%s - - [%T] \"Invalid request\" 400 0", csp->ip_addr_str);
+
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+
/*********************************************************************
*
* Function : chat
* function returns, the caller must close the client
* socket handle.
*
+ * FIXME: chat is nearly thousand lines long.
+ * Ridiculous.
+ *
* Parameters :
* 1 : csp = Current client state (buffers, headers, etc...)
*
jb_socket maxfd;
int server_body;
int ms_iis5_hack = 0;
- int byte_count = 0;
- unsigned int forwarded_connect_retries = 0;
- unsigned int max_forwarded_connect_retries = csp->config->forwarded_connect_retries;
+ size_t byte_count = 0;
+ int forwarded_connect_retries = 0;
+ int max_forwarded_connect_retries = csp->config->forwarded_connect_retries;
const struct forward_spec * fwd;
struct http_request *http;
- int len; /* for buffer sizes */
+ int len; /* for buffer sizes (and negative error codes) */
#ifdef FEATURE_KILL_POPUPS
int block_popups; /* bool, 1==will block popups */
int block_popups_now = 0; /* bool, 1==currently blocking popups */
http = csp->http;
+ memset(buf, 0, sizeof(buf));
+
/*
* Read the client's request. Note that since we're not using select() we
* could get blocked here if a client connected, then didn't say anything!
for (;;)
{
- len = read_socket(csp->cfd, buf, sizeof(buf));
+ len = read_socket(csp->cfd, buf, sizeof(buf)-1);
if (len <= 0) break; /* error! */
-
+
+ if (request_contains_null_bytes(csp, buf, len))
+ {
+ /* NULL bytes found and dealt with, just hang up. */
+ return;
+ }
+
/*
* If there is no memory left for buffering the
* request, there is nothing we can do but hang up
continue; /* more to come! */
}
- /*
- * If it's a FTP or gopher request, we don't support it.
- *
- * These checks are better than nothing, but they might
- * not work in all configurations and some clients might
- * have problems digesting the answer.
- *
- * They should, however, never cause more problems than
- * Privoxy's old behaviour (returning the misleading HTML error message:
- * "Could not resolve http://(ftp|gopher)://example.org").
- */
- if (!strncmpic(req, "GET ftp://", 10) || !strncmpic(req, "GET gopher://", 13))
+ /* Does the request line look invalid? */
+ if (client_protocol_is_unsupported(csp, req))
{
- if (!strncmpic(req, "GET ftp://", 10))
- {
- strcpy(buf, FTP_RESPONSE);
- log_error(LOG_LEVEL_ERROR, "%s tried to use Privoxy as FTP proxy: %s",
- csp->ip_addr_str, req);
- }
- else
- {
- strcpy(buf, GOPHER_RESPONSE);
- log_error(LOG_LEVEL_ERROR, "%s tried to use Privoxy as gopher proxy: %s",
- csp->ip_addr_str, req);
- }
- log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 400 0", csp->ip_addr_str, req);
- freez(req);
- write_socket(csp->cfd, buf, strlen(buf));
- free_http_request(http);
+ /*
+ * Yes. The request has already been
+ * answered with a error response, the buffers
+ * were freed and we're done with chatting.
+ */
return;
}
#ifdef FEATURE_FORCE_LOAD
- /* If this request contains the FORCE_PREFIX,
- * better get rid of it now and set the force flag --oes
+ /*
+ * 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))
{
- strclean(req, FORCE_PREFIX);
- log_error(LOG_LEVEL_FORCE, "Enforcing request \"%s\".\n", req);
- csp->flags |= CSP_FLAG_FORCED;
+ 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;
+ }
}
#endif /* def FEATURE_FORCE_LOAD */
{
strcpy(buf, CHEADER);
write_socket(csp->cfd, buf, strlen(buf));
-
- log_error(LOG_LEVEL_CLF, "%s - - [%T] \" \" 400 0", csp->ip_addr_str);
+ /* XXX: Use correct size */
+ log_error(LOG_LEVEL_CLF, "%s - - [%T] \"Invalid request\" 400 0", csp->ip_addr_str);
+ log_error(LOG_LEVEL_ERROR, "Invalid header received from %s.", csp->ip_addr_str);
free_http_request(http);
return;
if (http->host == NULL)
{
/*
- * Intercepted or invalid request without domain
- * inside the request line. Try to get it another way.
+ * If we still don't know the request destination,
+ * the request is invalid or the client uses
+ * Privoxy without it's knowledge.
*/
- if (JB_ERR_OK == get_destination_from_headers(headers, http))
- {
- /* Split the domain we just got for pattern matching */
- init_domain_components(http);
- }
- else
+ if (JB_ERR_OK != get_request_destination_elsewhere(csp, headers))
{
- /* We can't work without destination. Go spread the news.*/
-
- req = list_to_text(headers);
- chomp(req);
- log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 400 0", csp->ip_addr_str, http->cmd);
- log_error(LOG_LEVEL_ERROR,
- "Privoxy was unable to get the destination for %s's request:\n%s\n%s",
- csp->ip_addr_str, http->cmd, req);
- freez(req);
-
- strcpy(buf, MISSING_DESTINATION_RESPONSE);
- write_socket(csp->cfd, buf, strlen(buf));
- free_http_request(http);
- destroy_list(headers);
- return;
+ /*
+ * Our attempts to get the request destination
+ * elsewhere failed or Privoxy is configured
+ * to only accept proxy requests.
+ *
+ * An error response has already been send
+ * and we're done here.
+ */
+ return;
}
- /*
- * TODO: If available, use PF's ioctl DIOCNATLOOK as last resort
- * to get the destination IP address, use it as host directly
- * or do a reverse DNS lookup first.
- */
}
/* decide how to route the HTTP request */
{
if (csp->action->flags & ACTION_TREAT_FORBIDDEN_CONNECTS_LIKE_BLOCKS)
{
- /* The response will violate the specs, but makes unblocking easier. */
+ /*
+ * The response may confuse some clients,
+ * but makes unblocking easier.
+ */
log_error(LOG_LEVEL_ERROR, "Marking suspicious CONNECT request from %s for blocking.",
csp->ip_addr_str);
csp->action->flags |= ACTION_BLOCK;
)
{
- /* 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))
- {
- log_error(LOG_LEVEL_ERROR, "write to: %s failed: %E", http->host);
- }
-
+ /*
+ * Deliver, log and free the interception
+ * response. Afterwards we're done here.
+ */
+ send_crunch_response(csp, rsp);
#ifdef FEATURE_STATISTICS
/* Count as a rejected request */
csp->flags |= CSP_FLAG_REJECTED;
#endif /* def FEATURE_STATISTICS */
- /* Log (FIXME: All intercept reasons appear as "crunch" with Status 200) */
- log_error(LOG_LEVEL_GPC, "%s%s crunch!", http->hostport, http->path);
- log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 200 3", csp->ip_addr_str, http->ocmd);
-
- /* Clean up and return */
- free_http_response(rsp);
return;
}
if (csp->sfd == JB_INVALID_SOCKET)
{
- log_error(LOG_LEVEL_CONNECT, "connect to: %s failed: %E",
- http->hostport);
-
- if (errno == EINVAL)
+ if (fwd->type != SOCKS_NONE)
+ {
+ /* Socks error. */
+ rsp = error_response(csp, "forwarding-failed", errno);
+ }
+ else if (errno == EINVAL)
{
rsp = error_response(csp, "no-such-domain", errno);
-
- log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 404 0",
- csp->ip_addr_str, http->ocmd);
}
else
{
rsp = error_response(csp, "connect-failed", errno);
-
- log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 503 0",
- csp->ip_addr_str, http->ocmd);
+ log_error(LOG_LEVEL_CONNECT, "connect to: %s failed: %E",
+ http->hostport);
}
/* Write the answer to the client */
- if(rsp)
+ if(rsp != NULL)
{
- if (write_socket(csp->cfd, rsp->head, rsp->head_length)
- || write_socket(csp->cfd, rsp->body, rsp->content_length))
- {
- log_error(LOG_LEVEL_ERROR, "write to: %s failed: %E", http->host);
- }
+ send_crunch_response(csp, rsp);
}
- free_http_response(rsp);
freez(hdr);
return;
}
- log_error(LOG_LEVEL_CONNECT, "OK");
-
if (fwd->forward_host || (http->ssl == 0))
{
/* write the client's (modified) header to the server
log_error(LOG_LEVEL_CONNECT, "write header to: %s failed: %E",
http->hostport);
- log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 503 0",
- csp->ip_addr_str, http->ocmd);
-
rsp = error_response(csp, "connect-failed", errno);
if(rsp)
{
- if (write_socket(csp->cfd, rsp->head, rsp->head_length)
- || write_socket(csp->cfd, rsp->body, rsp->content_length))
- {
- log_error(LOG_LEVEL_ERROR, "write to: %s failed: %E", http->host);
- }
+ send_crunch_response(csp, rsp);
}
- free_http_response(rsp);
freez(hdr);
return;
}
* so just send the "connect succeeded" message to the
* client, flush the rest, and get out of the way.
*/
- log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 200 2\n",
- csp->ip_addr_str, http->ocmd);
-
if (write_socket(csp->cfd, CSUCCEED, sizeof(CSUCCEED)-1))
{
freez(hdr);
IOB_RESET(csp);
}
+ log_error(LOG_LEVEL_CONNECT, "to %s successful", http->hostport);
+
/* we're finished with the client's header */
freez(hdr);
{
log_error(LOG_LEVEL_ERROR, "read from: %s failed: %E", http->host);
- log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 503 0",
- csp->ip_addr_str, http->ocmd);
+ if (http->ssl && (fwd->forward_host == NULL))
+ {
+ /*
+ * Just hang up. We already confirmed the client's CONNECT
+ * request with status code 200 and unencrypted content is
+ * no longer welcome.
+ */
+ log_error(LOG_LEVEL_ERROR,
+ "CONNECT already confirmed. Unable to tell the client about the problem.");
+ return;
+ }
rsp = error_response(csp, "connect-failed", errno);
if(rsp)
{
- if (write_socket(csp->cfd, rsp->head, rsp->head_length)
- || write_socket(csp->cfd, rsp->body, rsp->content_length))
- {
- log_error(LOG_LEVEL_ERROR, "write to: %s failed: %E", http->host);
- }
+ send_crunch_response(csp, rsp);
}
- free_http_response(rsp);
return;
}
*/
if (NULL == (p = (*content_filter)(csp)))
{
- csp->content_length = csp->iob->eod - csp->iob->cur;
+ csp->content_length = (size_t)(csp->iob->eod - csp->iob->cur);
}
hdr = sed(server_patterns_light, NULL, csp);
* This is NOT the body, so
* Let's pretend the server just sent us a blank line.
*/
- len = sprintf(buf, "\r\n");
+ snprintf(buf, sizeof(buf), "\r\n");
+ len = (int)strlen(buf);
/*
* Now, let the normal header parsing algorithm below do its
*/
log_error(LOG_LEVEL_ERROR, "Out of memory while trying to flush.");
rsp = cgi_error_memory();
+ send_crunch_response(csp, rsp);
- if (write_socket(csp->cfd, rsp->head, rsp->head_length)
- || write_socket(csp->cfd, rsp->body, rsp->content_length))
- {
- log_error(LOG_LEVEL_ERROR, "write to: %s failed: %E", http->host);
- }
return;
}
if (write_socket(csp->cfd, hdr, hdrlen)
|| ((flushed = flush_socket(csp->cfd, csp)) < 0)
- || (write_socket(csp->cfd, buf, (size_t) len)))
+ || (write_socket(csp->cfd, buf, (size_t)len)))
{
log_error(LOG_LEVEL_CONNECT, "Flush header and buffers to client failed: %E");
return;
}
- byte_count += hdrlen + flushed + len;
+ byte_count += hdrlen + (size_t)flushed + (size_t)len;
freez(hdr);
content_filter = NULL;
server_body = 1;
return;
}
}
- byte_count += len;
+ byte_count += (size_t)len;
continue;
}
else
{
log_error(LOG_LEVEL_ERROR, "Out of memory while looking for end of server headers.");
rsp = cgi_error_memory();
-
- if (write_socket(csp->cfd, rsp->head, rsp->head_length)
- || write_socket(csp->cfd, rsp->body, rsp->content_length))
- {
- log_error(LOG_LEVEL_ERROR, "write to: %s failed: %E", http->host);
- }
- return;
- }
+ send_crunch_response(csp, rsp);
- /* get header lines from the iob */
-
- while ((p = get_header(csp)) != NULL)
- {
- if (*p == '\0')
- {
- /* see following note */
- break;
- }
- enlist(csp->headers, p);
- freez(p);
+ return;
}
- /* NOTE: there are no "empty" headers so
- * if the pointer `p' is not NULL we must
- * assume that we reached the end of the
- * buffer before we hit the end of the header.
- */
-
- if (p)
+ /* Convert iob into something sed() can digest */
+ if (JB_ERR_PARSE == get_server_headers(csp))
{
if (ms_iis5_hack)
{
}
}
+ /* Did we actually get anything? */
+ if (NULL == csp->headers->first)
+ {
+ log_error(LOG_LEVEL_ERROR, "Empty server or forwarder response.");
+ log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 502 0", csp->ip_addr_str, http->cmd);
+ strcpy(buf, NO_SERVER_DATA_RESPONSE);
+ write_socket(csp->cfd, buf, strlen(buf));
+ free_http_request(http);
+ return;
+ }
+
/* we have now received the entire header.
* filter it and send the result to the client
*/
return;
}
- byte_count += len;
+ byte_count += (size_t)len;
}
/* we're finished with the server's header */
return; /* huh? we should never get here */
}
+ if (csp->content_length == 0)
+ {
+ /*
+ * If Privoxy didn't recalculate the
+ * Content-Lenght, byte_count is still
+ * correct.
+ */
+ csp->content_length = byte_count;
+ }
+
log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 200 %d",
- csp->ip_addr_str, http->ocmd, byte_count);
+ csp->ip_addr_str, http->ocmd, csp->content_length);
}
}
+/*********************************************************************
+ *
+ * Function : initialize_mutexes
+ *
+ * Description : Prepares mutexes if mutex support is available.
+ *
+ * Parameters : None
+ *
+ * Returns : Void, exits in case of errors.
+ *
+ *********************************************************************/
+void initialize_mutexes()
+{
+ int err = 0;
+
+#ifdef FEATURE_PTHREAD
+ /*
+ * Prepare global mutex semaphores
+ */
+ err = pthread_mutex_init(&log_mutex, 0);
+
+ if (!err) err = pthread_mutex_init(&log_init_mutex, 0);
+
+ /*
+ * XXX: The assumptions below are a bit naive
+ * and can cause locks that aren't necessary.
+ *
+ * For example older FreeBSD versions (< 6.x?)
+ * have no gethostbyname_r, but gethostbyname is
+ * thead safe.
+ */
+#ifndef HAVE_GMTIME_R
+ if (!err) err = pthread_mutex_init(&gmtime_mutex, 0);
+#endif /* ndef HAVE_GMTIME_R */
+
+#ifndef HAVE_LOCALTIME_R
+ if (!err) err = pthread_mutex_init(&localtime_mutex, 0);
+#endif /* ndef HAVE_GMTIME_R */
+
+#ifndef HAVE_GETHOSTBYADDR_R
+ if (!err) err = pthread_mutex_init(&gethostbyaddr_mutex, 0);
+#endif /* ndef HAVE_GETHOSTBYADDR_R */
+
+#ifndef HAVE_GETHOSTBYNAME_R
+ if (!err) err = pthread_mutex_init(&gethostbyname_mutex, 0);
+#endif /* ndef HAVE_GETHOSTBYNAME_R */
+
+#ifndef HAVE_RANDOM
+ if (!err) err = pthread_mutex_init(&rand_mutex, 0);
+#endif /* ndef HAVE_RANDOM */
+#endif /* FEATURE_PTHREAD */
+
+ /*
+ * TODO: mutex support for mingw32 would be swell.
+ */
+
+ if (err)
+ {
+ printf("Fatal error. Mutex initialization failed: %s.\n",
+ strerror(err));
+ exit(1);
+ }
+
+ return;
+}
+
+
/*********************************************************************
*
* Function : main
#endif
{
int argc_pos = 0;
-#ifdef HAVE_RANDOM
unsigned int random_seed;
-#endif /* ifdef HAVE_RANDOM */
#ifdef unix
struct passwd *pw = NULL;
struct group *grp = NULL;
InitWin32();
#endif
-#ifdef FEATURE_PTHREAD
- /*
- * Prepare global mutex semaphores
- */
- pthread_mutex_init(&log_mutex,0);
- pthread_mutex_init(&log_init_mutex,0);
-
-#ifndef HAVE_GMTIME_R
- pthread_mutex_init(&gmtime_mutex,0);
-#endif /* ndef HAVE_GMTIME_R */
-
-#ifndef HAVE_LOCALTIME_R
- pthread_mutex_init(&localtime_mutex,0);
-#endif /* ndef HAVE_GMTIME_R */
+ /* Prepare mutexes if supported and necessary. */
+ initialize_mutexes();
-#ifndef HAVE_GETHOSTBYADDR_R
- pthread_mutex_init(&gethostbyaddr_mutex,0);
-#endif /* ndef HAVE_GETHOSTBYADDR_R */
-
-#ifndef HAVE_GETHOSTBYNAME_R
- pthread_mutex_init(&gethostbyname_mutex,0);
-#endif /* ndef HAVE_GETHOSTBYNAME_R */
-#endif /* FEATURE_PTHREAD */
-
-#ifdef HAVE_RANDOM
random_seed = (unsigned int)time(NULL);
+#ifdef HAVE_RANDOM
srandom(random_seed);
+#else
+ srand(random_seed);
#endif /* ifdef HAVE_RANDOM */
/*
* We *are* in a windows console app.
* Print a verbose messages about FAQ's and such
*/
- printf(win32_blurb);
+ printf("%s", win32_blurb);
# endif /* def _WIN_CONSOLE */
#endif /* def _WIN32 */
bfd = bind_port_helper(config);
}
- log_error(LOG_LEVEL_CONNECT, "accept connection ... ");
+ log_error(LOG_LEVEL_CONNECT, "Listening for new connections ... ");
if (!accept_connection(csp, bfd))
{
}
else
{
- log_error(LOG_LEVEL_CONNECT, "OK");
+ log_error(LOG_LEVEL_CONNECT, "accepted connection from %s", csp->ip_addr_str);
}
#ifdef FEATURE_TOGGLE
#ifdef FEATURE_ACL
if (block_acl(NULL,csp))
{
- log_error(LOG_LEVEL_CONNECT, "Connection dropped due to ACL");
+ log_error(LOG_LEVEL_CONNECT, "Connection from %s dropped due to ACL", csp->ip_addr_str);
close_socket(csp->cfd);
freez(csp);
continue;
pthread_attr_init(&attrs);
pthread_attr_setdetachstate(&attrs, PTHREAD_CREATE_DETACHED);
errno = pthread_create(&the_thread, &attrs,
- (void*)serve, csp);
+ (void * (*)(void *))serve, csp);
child_id = errno ? -1 : 0;
pthread_attr_destroy(&attrs);
}
#define SELECTED_ONE_OPTION
csp->cfd = ReleaseSocket(csp->cfd, -1);
- if((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)))
+#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;
log_error(LOG_LEVEL_ERROR, "can't fork: %E");
- sprintf(buf , "Privoxy: can't fork: errno = %d", errno);
+ snprintf(buf , sizeof(buf), "Privoxy: can't fork: errno = %d", errno);
write_socket(csp->cfd, buf, strlen(buf));
close_socket(csp->cfd);
projects / privoxy.git / blobdiff