-const char jcc_rcs[] = "$Id: jcc.c,v 1.118 2007/01/07 07:43:43 joergs 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 $
*
* 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.
*
#include <signal.h>
#include <fcntl.h>
#include <errno.h>
+#include <assert.h>
#ifdef _WIN32
# ifndef FEATURE_PTHREAD
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"
"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)
/*********************************************************************
*
#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...)
*
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,
- * unless accept-intercepted-requests is disabled.
+ * If we still don't know the request destination,
+ * the request is invalid or the client uses
+ * Privoxy without it's knowledge.
*/
- 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, http->cmd);
- log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 400 0", csp->ip_addr_str, http->cmd);
-
- strcpy(buf, CHEADER);
- write_socket(csp->cfd, buf, strlen(buf));
- free_http_request(http);
- destroy_list(headers);
- return;
- }
- else if (JB_ERR_OK == get_destination_from_headers(headers, http))
+ if (JB_ERR_OK != get_request_destination_elsewhere(csp, headers))
{
- /* Split the domain we just got for pattern matching */
- init_domain_components(http);
- }
- else
- {
- /* 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;
}
{
/* Socks error. */
rsp = error_response(csp, "forwarding-failed", errno);
-
- log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 503 0",
- csp->ip_addr_str, http->ocmd);
}
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_CONNECT, "connect to: %s failed: %E",
http->hostport);
-
- log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 503 0",
- csp->ip_addr_str, http->ocmd);
}
/* 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, "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);
{
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;
}
*/
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;
}
return;
}
- byte_count += hdrlen + (size_t)(flushed + len);
+ byte_count += hdrlen + (size_t)flushed + (size_t)len;
freez(hdr);
content_filter = NULL;
server_body = 1;
{
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)
{
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
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 */
-
-#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 */
-
-#ifndef HAVE_RANDOM
- pthread_mutex_init(&rand_mutex,0);
-#endif /* ndef HAVE_RANDOM */
-
-#endif /* FEATURE_PTHREAD */
+ /* Prepare mutexes if supported and necessary. */
+ initialize_mutexes();
random_seed = (unsigned int)time(NULL);
#ifdef HAVE_RANDOM
#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;
projects / privoxy.git / blobdiff