-const char jcc_rcs[] = "$Id: jcc.c,v 1.124 2007/02/23 14:59:54 fabiankeil Exp $";
+const char jcc_rcs[] = "$Id: jcc.c,v 1.139 2007/07/14 07:46:41 fabiankeil Exp $";
/*********************************************************************
*
* File : $Source: /cvsroot/ijbswa/current/jcc.c,v $
*
* Revisions :
* $Log: jcc.c,v $
+ * Revision 1.139 2007/07/14 07:46:41 fabiankeil
+ * - Allow to rewrite the request destination behind the client's back.
+ * - Turn the weird-looking unconditional for loop that
+ * reads the client request into a conditional while loop.
+ * Move the stuff that only runs once out of the loop.
+ * - Move parts of chat(), server_content_type() and the
+ * necessary stuff to fix BR#1750917 into get_filter_function().
+ *
+ * Revision 1.138 2007/06/03 18:45:18 fabiankeil
+ * Temporary workaround for BR#1730105.
+ *
+ * Revision 1.137 2007/06/01 18:16:36 fabiankeil
+ * Use the same mutex for gethostbyname() and gethostbyaddr() to prevent
+ * deadlocks and crashes on OpenBSD and possibly other OS with neither
+ * gethostbyname_r() nor gethostaddr_r(). Closes BR#1729174.
+ * Thanks to Ralf Horstmann for report and solution.
+ *
+ * Revision 1.136 2007/06/01 16:41:11 fabiankeil
+ * Add forward-override{} to change the forwarding settings through
+ * action sections. This is mainly interesting to forward different
+ * clients differently (for example based on User-Agent or request
+ * origin).
+ *
+ * Revision 1.135 2007/05/24 17:03:50 fabiankeil
+ * - Let usage() mention the --chroot parameter.
+ * - Use read_socket() consistently and always leave
+ * the last buffer byte alone, even in cases where
+ * null termination (currently) doesn't matter.
+ *
+ * Revision 1.134 2007/05/16 14:59:46 fabiankeil
+ * - Fix config file loading on Unix if no config file is specified.
+ * Since r1.97 Privoxy would always interpret the last argument as
+ * config file, even if it's a valid command line option.
+ * - Abort in case of unrecognized command line options. Closes #1719696.
+ * - Remove a bunch of unnecessary strcpy() calls (yay for c&p without thinking).
+ * - Replace the remaining strcpy() and strcat() calls with strlcpy() and strcat().
+ *
+ * Revision 1.133 2007/05/04 11:23:19 fabiankeil
+ * - Don't rerun crunchers that only depend on the request URL.
+ * - Don't count redirects and CGI requests as "blocked requests".
+ *
+ * Revision 1.132 2007/04/25 15:15:17 fabiankeil
+ * Support crunching based on tags created by server-header taggers.
+ *
+ * Revision 1.131 2007/04/22 13:24:50 fabiankeil
+ * Make HTTP snippets static (again). Add a Content-Type for those
+ * with content so the browser doesn't guess it based on the URL.
+ *
+ * Revision 1.130 2007/04/19 13:47:34 fabiankeil
+ * Move crunching and request line rebuilding out of chat().
+ *
+ * Revision 1.129 2007/04/15 16:39:20 fabiankeil
+ * Introduce tags as alternative way to specify which
+ * actions apply to a request. At the moment tags can be
+ * created based on client and server headers.
+ *
+ * Revision 1.128 2007/03/25 16:55:54 fabiankeil
+ * Don't CLF-log CONNECT requests twice.
+ *
+ * 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.
pthread_mutex_t log_mutex;
pthread_mutex_t log_init_mutex;
+#if !defined(HAVE_GETHOSTBYADDR_R) || !defined(HAVE_GETHOSTBYNAME_R)
+pthread_mutex_t resolver_mutex;
+#endif /* !defined(HAVE_GETHOSTBYADDR_R) || !defined(HAVE_GETHOSTBYNAME_R) */
+
#ifndef HAVE_GMTIME_R
pthread_mutex_t gmtime_mutex;
#endif /* ndef HAVE_GMTIME_R */
pthread_mutex_t localtime_mutex;
#endif /* ndef HAVE_GMTIME_R */
-#ifndef HAVE_GETHOSTBYADDR_R
-pthread_mutex_t gethostbyaddr_mutex;
-#endif /* ndef HAVE_GETHOSTBYADDR_R */
-
-#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 */
"(copyright_or_otherwise)_applying_to_any_cookie._";
/* HTTP snipplets. */
-const char CSUCCEED[] =
+const static char CSUCCEED[] =
"HTTP/1.0 200 Connection established\n"
"Proxy-Agent: Privoxy/" VERSION "\r\n\r\n";
-const char CHEADER[] =
+const static char CHEADER[] =
"HTTP/1.0 400 Invalid header received from browser\r\n"
+ "Proxy-Agent: Privoxy " VERSION "\r\n"
+ "Content-Type: text/plain\r\n"
"Connection: close\r\n\r\n"
"Invalid header received from browser.\r\n";
-const char CFORBIDDEN[] =
+const static 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";
-const char FTP_RESPONSE[] =
+const static char FTP_RESPONSE[] =
"HTTP/1.0 400 Invalid request received from browser\r\n"
+ "Content-Type: text/plain\r\n"
"Connection: close\r\n\r\n"
"Invalid request. Privoxy doesn't support FTP.\r\n";
-const char GOPHER_RESPONSE[] =
+const static char GOPHER_RESPONSE[] =
"HTTP/1.0 400 Invalid request received from browser\r\n"
+ "Content-Type: text/plain\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[] =
+const static char MISSING_DESTINATION_RESPONSE[] =
"HTTP/1.0 400 Bad request received from browser\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 */
-const char NO_SERVER_DATA_RESPONSE[] =
+const static char NO_SERVER_DATA_RESPONSE[] =
"HTTP/1.0 502 Server or forwarder response empty\r\n"
"Proxy-Agent: Privoxy " VERSION "\r\n"
+ "Content-Type: text/plain\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[] =
+const static char NULL_BYTE_RESPONSE[] =
"HTTP/1.0 400 Bad request received from browser\r\n"
"Proxy-Agent: Privoxy " VERSION "\r\n"
+ "Content-Type: text/plain\r\n"
"Connection: close\r\n\r\n"
"Bad request. Null byte(s) before end of request.\r\n";
+/* XXX: should be a template */
+const static char MESSED_UP_REQUEST_RESPONSE[] =
+ "HTTP/1.0 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";
+
+/* A function to crunch a response */
+typedef struct http_response *(*crunch_func_ptr)(struct client_state *);
+
+typedef char *(*filter_function_ptr)();
+
+/* Crunch function flags */
+#define CF_NO_FLAGS 0
+/* Cruncher applies to forced requests as well */
+#define CF_IGNORE_FORCE 1
+/* Crunched requests are counted for the block statistics */
+#define CF_COUNT_AS_REJECT 2
+
+/* A crunch function and its flags */
+struct cruncher
+{
+ const crunch_func_ptr cruncher;
+ const int flags;
+};
+
+/* Complete list of cruncher functions */
+const static struct cruncher crunchers_all[] = {
+ { direct_response, CF_COUNT_AS_REJECT|CF_IGNORE_FORCE},
+ { block_url, CF_COUNT_AS_REJECT },
+#ifdef FEATURE_TRUST
+ { trust_url, CF_COUNT_AS_REJECT },
+#endif /* def FEATURE_TRUST */
+ { redirect_url, CF_NO_FLAGS },
+ { dispatch_cgi, CF_IGNORE_FORCE},
+ { NULL, 0 }
+};
+
+/* Light version, used after tags are applied */
+const static struct cruncher crunchers_light[] = {
+ { block_url, CF_COUNT_AS_REJECT },
+ { redirect_url, CF_NO_FLAGS },
+ { NULL, 0 }
+};
+
+
#if !defined(_WIN32) && !defined(__OS2__) && !defined(AMIGA)
/*********************************************************************
*
{
if (!strncmpic(req, "GET ftp://", 10))
{
- strcpy(buf, FTP_RESPONSE);
+ strlcpy(buf, FTP_RESPONSE, sizeof(buf));
log_error(LOG_LEVEL_ERROR, "%s tried to use Privoxy as FTP proxy: %s",
csp->ip_addr_str, req);
}
else
{
- strcpy(buf, GOPHER_RESPONSE);
+ strlcpy(buf, GOPHER_RESPONSE, sizeof(buf));
log_error(LOG_LEVEL_ERROR, "%s tried to use Privoxy as gopher proxy: %s",
csp->ip_addr_str, req);
}
*********************************************************************/
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_CLF, "%s - - [%T] \"%s\" 400 0",
csp->ip_addr_str, csp->http->cmd);
- strcpy(buf, CHEADER);
- write_socket(csp->cfd, buf, strlen(buf));
+ write_socket(csp->cfd, CHEADER, strlen(CHEADER));
destroy_list(headers);
return JB_ERR_PARSE;
csp->ip_addr_str, csp->http->cmd, req);
freez(req);
- strcpy(buf, MISSING_DESTINATION_RESPONSE);
- write_socket(csp->cfd, buf, strlen(buf));
+ write_socket(csp->cfd, MISSING_DESTINATION_RESPONSE, strlen(MISSING_DESTINATION_RESPONSE));
destroy_list(headers);
return JB_ERR_PARSE;
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));
+ write_socket(csp->cfd, NULL_BYTE_RESPONSE, strlen(NULL_BYTE_RESPONSE));
/* XXX: Log correct size */
log_error(LOG_LEVEL_CLF, "%s - - [%T] \"Invalid request\" 400 0", csp->ip_addr_str);
}
+/*********************************************************************
+ *
+ * Function : crunch_response_triggered
+ *
+ * Description : Checks if the request has to be crunched,
+ * and delivers the crunch response if necessary.
+ *
+ * Parameters :
+ * 1 : csp = Current client state (buffers, headers, etc...)
+ * 2 : crunchers = list of cruncher functions to run
+ *
+ * Returns : TRUE if the request was answered with a crunch response
+ * FALSE otherwise.
+ *
+ *********************************************************************/
+int crunch_response_triggered(struct client_state *csp, const struct cruncher crunchers[])
+{
+ struct http_response *rsp = NULL;
+ const struct cruncher *c;
+
+ /*
+ * If CGI request crunching is disabled,
+ * check the CGI dispatcher out of order to
+ * prevent unintentional blocks or redirects.
+ */
+ if (!(csp->config->feature_flags & RUNTIME_FEATURE_CGI_CRUNCHING)
+ && (NULL != (rsp = dispatch_cgi(csp))))
+ {
+ /* Deliver, log and free the interception response. */
+ send_crunch_response(csp, rsp);
+ return TRUE;
+ }
+
+ for (c = crunchers; c->cruncher != NULL; c++)
+ {
+ /*
+ * Check the cruncher if either Privoxy is toggled
+ * on and the request isn't forced, or if the cruncher
+ * applies to forced requests as well.
+ */
+ if (((csp->flags & CSP_FLAG_TOGGLED_ON) &&
+ !(csp->flags & CSP_FLAG_FORCED)) ||
+ (c->flags & CF_IGNORE_FORCE))
+ {
+ rsp = c->cruncher(csp);
+ if (NULL != rsp)
+ {
+ /* Deliver, log and free the interception response. */
+ send_crunch_response(csp, rsp);
+#ifdef FEATURE_STATISTICS
+ if (c->flags & CF_COUNT_AS_REJECT)
+ {
+ csp->flags |= CSP_FLAG_REJECTED;
+ }
+#endif /* def FEATURE_STATISTICS */
+
+ return TRUE;
+ }
+ }
+ }
+
+ return FALSE;
+}
+
+
+/*********************************************************************
+ *
+ * Function : build_request_line
+ *
+ * Description : Builds the HTTP request line.
+ *
+ * If a HTTP forwarder is used it expects the whole URL,
+ * web servers only get the path.
+ *
+ * Parameters :
+ * 1 : csp = Current client state (buffers, headers, etc...)
+ * 2 : fwd = The forwarding spec used for the request
+ * XXX: Should use http->fwd instead.
+ * 3 : request_line = The old request line which will be replaced.
+ *
+ * Returns : Nothing. Terminates in case of memory problems.
+ *
+ *********************************************************************/
+void build_request_line(struct client_state *csp, const struct forward_spec *fwd, char **request_line)
+{
+ struct http_request *http = csp->http;
+
+ assert(http->ssl == 0);
+
+ /*
+ * Downgrade http version from 1.1 to 1.0
+ * if +downgrade action applies.
+ */
+ if ( (csp->action->flags & ACTION_DOWNGRADE)
+ && (!strcmpic(http->ver, "HTTP/1.1")))
+ {
+ freez(http->ver);
+ http->ver = strdup("HTTP/1.0");
+
+ if (http->ver == NULL)
+ {
+ log_error(LOG_LEVEL_FATAL, "Out of memory downgrading HTTP version");
+ }
+ }
+
+ /*
+ * Rebuild the request line.
+ */
+ freez(*request_line);
+ *request_line = strdup(http->gpc);
+ string_append(request_line, " ");
+
+ if (fwd->forward_host)
+ {
+ string_append(request_line, http->url);
+ }
+ else
+ {
+ string_append(request_line, http->path);
+ }
+ string_append(request_line, " ");
+ string_append(request_line, http->ver);
+
+ if (*request_line == NULL)
+ {
+ log_error(LOG_LEVEL_FATAL, "Out of memory writing HTTP command");
+ }
+ log_error(LOG_LEVEL_HEADER, "New HTTP Request-Line: %s", *request_line);
+}
+
+
+/*********************************************************************
+ *
+ * Function : change_request_destination
+ *
+ * Description : Parse a (rewritten) request line and regenerate
+ * the http request data.
+ *
+ * Parameters :
+ * 1 : csp = Current client state (buffers, headers, etc...)
+ *
+ * Returns : Forwards the parse_http_request() return code.
+ * Terminates in case of memory problems.
+ *
+ *********************************************************************/
+jb_err change_request_destination(struct client_state *csp)
+{
+ struct http_request *http = csp->http;
+ jb_err err;
+
+ log_error(LOG_LEVEL_INFO, "Rewrite detected: %s", csp->headers->first->str);
+ free_http_request(http);
+ err = parse_http_request(csp->headers->first->str, http, csp);
+ if (JB_ERR_OK != err)
+ {
+ log_error(LOG_LEVEL_ERROR, "Couldn't parse rewritten request: %s.",
+ jb_err_to_string(err));
+ }
+ http->ocmd = strdup(http->cmd); /* XXX: ocmd is a misleading name */
+ if (http->ocmd == NULL)
+ {
+ log_error(LOG_LEVEL_FATAL, "Out of memory copying rewritten HTTP request line");
+ }
+
+ return err;
+}
+
+
+/*********************************************************************
+ *
+ * Function : get_filter_function
+ *
+ * Description : Decides which content filter function has
+ * to be applied (if any).
+ *
+ * XXX: Doesn't handle filter_popups()
+ * because of the different prototype. Probably
+ * we should ditch filter_popups() anyway, it's
+ * even less reliable than popup blocking based
+ * on pcrs filters.
+ *
+ * Parameters :
+ * 1 : csp = Current client state (buffers, headers, etc...)
+ *
+ * Returns : The content filter function to run, or
+ * NULL if no content filter is active
+ *
+ *********************************************************************/
+filter_function_ptr get_filter_function(struct client_state *csp)
+{
+ filter_function_ptr filter_function = NULL;
+
+ /*
+ * Are we enabling text mode by force?
+ */
+ if (csp->action->flags & ACTION_FORCE_TEXT_MODE)
+ {
+ /*
+ * Do we really have to?
+ */
+ if (csp->content_type & CT_TEXT)
+ {
+ log_error(LOG_LEVEL_HEADER, "Text mode is already enabled.");
+ }
+ else
+ {
+ csp->content_type |= CT_TEXT;
+ log_error(LOG_LEVEL_HEADER, "Text mode enabled by force. Take cover!");
+ }
+ }
+
+ if (!(csp->content_type & CT_DECLARED))
+ {
+ /*
+ * The server didn't bother to declare a MIME-Type.
+ * Assume it's text that can be filtered.
+ *
+ * This also regulary happens with 304 responses,
+ * therefore logging anything here would cause
+ * too much noise.
+ */
+ csp->content_type |= CT_TEXT;
+ }
+
+
+ /*
+ * Choose the applying filter function based on
+ * the content type and action settings.
+ */
+ if ((csp->content_type & CT_TEXT) &&
+ (csp->rlist != NULL) &&
+ (!list_is_empty(csp->action->multi[ACTION_MULTI_FILTER])))
+ {
+ filter_function = pcrs_filter_response;
+ }
+ else if ((csp->content_type & CT_GIF) &&
+ (csp->action->flags & ACTION_DEANIMATE))
+ {
+ filter_function = gif_deanimate_response;
+ }
+ else if ((csp->content_type & CT_JPEG) &&
+ (csp->action->flags & ACTION_JPEG_INSPECT))
+ {
+ filter_function = jpeg_inspect_response;
+ }
+
+ return filter_function;
+}
+
/*********************************************************************
*
* Function : chat
* Parameters :
* 1 : csp = Current client state (buffers, headers, etc...)
*
- * Returns : On success, the number of bytes written are returned (zero
- * indicates nothing was written). On error, -1 is returned,
- * and errno is set appropriately. If count is zero and the
- * file descriptor refers to a regular file, 0 will be
- * returned without causing any other effect. For a special
- * file, the results are not portable.
+ * Returns : Nothing.
*
*********************************************************************/
static void chat(struct client_state *csp)
{
-/*
- * This next lines are a little ugly, but they simplifies the if statements
- * below. Basically if TOGGLE, then we want the if to test if the
- * CSP_FLAG_TOGGLED_ON flag ist set, else we don't. And if FEATURE_FORCE_LOAD,
- * then we want the if to test for CSP_FLAG_FORCED , else we don't
- */
-#ifdef FEATURE_TOGGLE
-# define IS_TOGGLED_ON_AND (csp->flags & CSP_FLAG_TOGGLED_ON) &&
-#else /* ifndef FEATURE_TOGGLE */
-# define IS_TOGGLED_ON_AND
-#endif /* ndef FEATURE_TOGGLE */
-#ifdef FEATURE_FORCE_LOAD
-# define IS_NOT_FORCED_AND !(csp->flags & CSP_FLAG_FORCED) &&
-#else /* ifndef FEATURE_FORCE_LOAD */
-# define IS_NOT_FORCED_AND
-#endif /* def FEATURE_FORCE_LOAD */
-
-#define IS_ENABLED_AND IS_TOGGLED_ON_AND IS_NOT_FORCED_AND
-
char buf[BUFFER_SIZE];
char *hdr;
char *p;
const struct forward_spec * fwd;
struct http_request *http;
int len; /* for buffer sizes (and negative error codes) */
+ jb_err err;
#ifdef FEATURE_KILL_POPUPS
- int block_popups; /* bool, 1==will block popups */
int block_popups_now = 0; /* bool, 1==currently blocking popups */
#endif /* def FEATURE_KILL_POPUPS */
- int pcrs_filter; /* bool, 1==will filter through pcrs */
- int gif_deanimate; /* bool, 1==will deanimate gifs */
- int jpeg_inspect; /* bool, 1==will inspect jpegs */
-
/* Function that does the content filtering for the current request */
- char *(*content_filter)() = NULL;
+ filter_function_ptr content_filter = NULL;
/* Skeleton for HTTP response, if we should intercept the request */
struct http_response *rsp;
* could get blocked here if a client connected, then didn't say anything!
*/
- for (;;)
+ do
{
- len = read_socket(csp->cfd, buf, sizeof(buf)-1);
+ 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
req = get_header(csp);
- if (req == NULL)
- {
- break; /* no HTTP request! */
- }
+ } while ((NULL != req) && ('\0' == *req));
- if (*req == '\0')
+ if (NULL != req)
+ {
+ /* Request received. Validate and parse it. */
+
+#if 0
+ /*
+ * XXX: Temporary disabled to prevent problems
+ * with POST requests whose bodies are allowed to
+ * contain NULL bytes. BR#1730105.
+ *
+ * The main purpose of this check is to properly
+ * log stuff like BitTorrent traffic and other junk
+ * that hits public proxies. It's not required for
+ * Privoxy to functions as those requests are discarded
+ * later on anyway.
+ *
+ * It probably should be rewritten to only check
+ * the head of the request. Another option would
+ * be to let all POST requests pass, although that
+ * may not be good enough.
+ */
+ if (request_contains_null_bytes(csp, buf, len))
{
- continue; /* more to come! */
+ /* NULL bytes found and dealt with, just hang up. */
+ return;
}
+#endif
/* Does the request line look invalid? */
if (client_protocol_is_unsupported(csp, req))
}
#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 */
-
- switch( parse_http_request(req, http, csp) )
+ err = parse_http_request(req, http, csp);
+ if (JB_ERR_OK != err)
{
- case JB_ERR_MEMORY:
- log_error(LOG_LEVEL_ERROR, "Out of memory while parsing request.");
- break;
- case JB_ERR_PARSE:
- log_error(LOG_LEVEL_ERROR, "Couldn't parse request: %s.", req);
- break;
+ log_error(LOG_LEVEL_ERROR, "Couldn't parse request: %s.", jb_err_to_string(err));
}
freez(req);
- break;
}
if (http->cmd == NULL)
{
- strcpy(buf, CHEADER);
- write_socket(csp->cfd, buf, strlen(buf));
+ write_socket(csp->cfd, CHEADER, strlen(CHEADER));
/* XXX: Use correct size */
log_error(LOG_LEVEL_CLF, "%s - - [%T] \"Invalid request\" 400 0", csp->ip_addr_str);
log_error(LOG_LEVEL_ERROR, "Invalid header received from %s.", csp->ip_addr_str);
{
if ( ( ( p = get_header(csp) ) != NULL) && ( *p == '\0' ) )
{
- len = read_socket(csp->cfd, buf, sizeof(buf));
+ len = read_socket(csp->cfd, buf, sizeof(buf) - 1);
if (len <= 0)
{
log_error(LOG_LEVEL_ERROR, "read from client failed: %E");
/*
* If we still don't know the request destination,
* the request is invalid or the client uses
- * Privoxy without it's knowledge.
+ * Privoxy without its knowledge.
*/
if (JB_ERR_OK != get_request_destination_elsewhere(csp, headers))
{
}
}
- /* decide how to route the HTTP request */
+ /*
+ * Determine the actions for this URL
+ */
+#ifdef FEATURE_TOGGLE
+ if (!(csp->flags & CSP_FLAG_TOGGLED_ON))
+ {
+ /* Most compatible set of actions (i.e. none) */
+ init_current_action(csp->action);
+ }
+ else
+#endif /* ndef FEATURE_TOGGLE */
+ {
+ url_actions(http, csp);
+ }
+
+ /*
+ * Save a copy of the original request for logging
+ */
+ http->ocmd = strdup(http->cmd);
+
+ if (http->ocmd == NULL)
+ {
+ log_error(LOG_LEVEL_FATAL, "Out of memory copying HTTP request line");
+ }
+
+ enlist(csp->headers, http->cmd);
+
+ /* Append the previously read headers */
+ list_append_list_unique(csp->headers, headers);
+ destroy_list(headers);
- if ((fwd = forward_url(http, csp)) == NULL)
+ /*
+ * If the user has not supplied any wafers, and the user has not
+ * told us to suppress the vanilla wafer, then send the vanilla wafer.
+ */
+ if (list_is_empty(csp->action->multi[ACTION_MULTI_WAFER])
+ && ((csp->action->flags & ACTION_VANILLA_WAFER) != 0))
+ {
+ enlist(csp->action->multi[ACTION_MULTI_WAFER], VANILLA_WAFER);
+ }
+
+ err = sed(client_patterns, add_client_headers, csp);
+ if (JB_ERR_OK != err)
+ {
+ assert(err == JB_ERR_PARSE);
+ log_error(LOG_LEVEL_FATAL, "Failed to parse client headers");
+ }
+ csp->flags |= CSP_FLAG_CLIENT_HEADER_PARSING_DONE;
+
+ if (strcmp(http->cmd, csp->headers->first->str))
+ {
+ /*
+ * A header filter rewrote the request line,
+ * modify the http request accordingly.
+ */
+ if (JB_ERR_OK != change_request_destination(csp))
+ {
+ write_socket(csp->cfd, MESSED_UP_REQUEST_RESPONSE, strlen(MESSED_UP_REQUEST_RESPONSE));
+ /* XXX: Use correct size */
+ log_error(LOG_LEVEL_CLF, "%s - - [%T] \"Invalid request generated\" 500 0", csp->ip_addr_str);
+ log_error(LOG_LEVEL_ERROR, "Invalid request line after applying header filters.");
+
+ free_http_request(http);
+ return;
+ }
+ }
+
+ /* decide how to route the HTTP request */
+ if (NULL == (fwd = forward_url(http, csp)))
{
log_error(LOG_LEVEL_FATAL, "gateway spec is NULL!?!? This can't happen!");
/* Never get here - LOG_LEVEL_FATAL causes program exit */
*
*/
- /*
- * Determine the actions for this URL
- */
-#ifdef FEATURE_TOGGLE
- if (!(csp->flags & CSP_FLAG_TOGGLED_ON))
- {
- /* Most compatible set of actions (i.e. none) */
- init_current_action(csp->action);
- }
- else
-#endif /* ndef FEATURE_TOGGLE */
- {
- url_actions(http, csp);
- }
-
-
/*
* Check if a CONNECT request is allowable:
* In the absence of a +limit-connect action, allow only port 443.
}
else
{
- strcpy(buf, CFORBIDDEN);
- write_socket(csp->cfd, buf, strlen(buf));
+ write_socket(csp->cfd, CFORBIDDEN, strlen(CFORBIDDEN));
log_error(LOG_LEVEL_CONNECT, "Denying suspicious CONNECT request from %s", csp->ip_addr_str);
log_error(LOG_LEVEL_CLF, "%s - - [%T] \" \" 403 0", csp->ip_addr_str);
- return;
- }
- }
- }
+ list_remove_all(csp->headers);
- /*
- * Downgrade http version from 1.1 to 1.0 if +downgrade
- * action applies
- */
- if ( (http->ssl == 0)
- && (!strcmpic(http->ver, "HTTP/1.1"))
- && (csp->action->flags & ACTION_DOWNGRADE))
- {
- freez(http->ver);
- http->ver = strdup("HTTP/1.0");
-
- if (http->ver == NULL)
- {
- log_error(LOG_LEVEL_FATAL, "Out of memory downgrading HTTP version");
+ return;
+ }
}
}
- /*
- * Save a copy of the original request for logging
- */
- http->ocmd = strdup(http->cmd);
-
- if (http->ocmd == NULL)
- {
- log_error(LOG_LEVEL_FATAL, "Out of memory copying HTTP request line");
- }
-
- /*
- * (Re)build the HTTP request for non-SSL requests.
- * If forwarding, use the whole URL, else, use only the path.
- */
if (http->ssl == 0)
{
- freez(http->cmd);
-
- http->cmd = strdup(http->gpc);
- string_append(&http->cmd, " ");
-
- if (fwd->forward_host)
- {
- string_append(&http->cmd, http->url);
- }
- else
- {
- string_append(&http->cmd, http->path);
- }
- string_append(&http->cmd, " ");
- string_append(&http->cmd, http->ver);
-
- if (http->cmd == NULL)
- {
- log_error(LOG_LEVEL_FATAL, "Out of memory writing HTTP command");
- }
- log_error(LOG_LEVEL_HEADER, "New HTTP Request-Line: %s", http->cmd);
+ freez(csp->headers->first->str);
+ build_request_line(csp, fwd, &csp->headers->first->str);
}
- enlist(csp->headers, http->cmd);
- /* Append the previously read headers */
- list_append_list_unique(csp->headers, headers);
- destroy_list(headers);
-
- /*
- * If the user has not supplied any wafers, and the user has not
- * told us to suppress the vanilla wafer, then send the vanilla wafer.
- */
- if (list_is_empty(csp->action->multi[ACTION_MULTI_WAFER])
- && ((csp->action->flags & ACTION_VANILLA_WAFER) != 0))
+ hdr = list_to_text(csp->headers);
+ if (hdr == NULL)
{
- enlist(csp->action->multi[ACTION_MULTI_WAFER], VANILLA_WAFER);
+ /* FIXME Should handle error properly */
+ log_error(LOG_LEVEL_FATAL, "Out of memory parsing client header");
}
-
-#ifdef FEATURE_KILL_POPUPS
- block_popups = ((csp->action->flags & ACTION_NO_POPUPS) != 0);
-#endif /* def FEATURE_KILL_POPUPS */
-
- pcrs_filter = (csp->rlist != NULL) && /* There are expressions to be used */
- (!list_is_empty(csp->action->multi[ACTION_MULTI_FILTER]));
-
- gif_deanimate = ((csp->action->flags & ACTION_DEANIMATE) != 0);
-
- jpeg_inspect = ((csp->action->flags & ACTION_JPEG_INSPECT) != 0);
-
/*
- * We have a request. Now, check to see if we need to
- * intercept it, i.e. If ..
+ * We have a request. Check if one of the crunchers wants it.
*/
-
- if (
- /* We may not forward the request by rfc2616 sect 14.31 */
- (NULL != (rsp = direct_response(csp)))
-
- /* or we are enabled and... */
- || (IS_ENABLED_AND (
-
- /* ..the request was blocked */
- ( NULL != (rsp = block_url(csp)))
-
- /* ..or untrusted */
-#ifdef FEATURE_TRUST
- || ( NULL != (rsp = trust_url(csp)))
-#endif /* def FEATURE_TRUST */
-
- /* ..or a redirect kicked in */
- || ( NULL != (rsp = redirect_url(csp)))
- ))
-
- /*
- * .. or a CGI call was detected and answered.
- *
- * This check comes last to give the user the power
- * to deny acces to some (or all) of the cgi pages.
- */
- || (NULL != (rsp = dispatch_cgi(csp)))
-
- )
+ if (crunch_response_triggered(csp, crunchers_all))
{
/*
- * Deliver, log and free the interception
- * response. Afterwards we're done here.
+ * Yes. The client got the crunch response
+ * and we are done here after cleaning up.
*/
- send_crunch_response(csp, rsp);
-#ifdef FEATURE_STATISTICS
- /* Count as a rejected request */
- csp->flags |= CSP_FLAG_REJECTED;
-#endif /* def FEATURE_STATISTICS */
+ freez(hdr);
+ list_remove_all(csp->headers);
return;
}
- hdr = sed(client_patterns, add_client_headers, csp);
- if (hdr == NULL)
- {
- /* FIXME Should handle error properly */
- log_error(LOG_LEVEL_FATAL, "Out of memory parsing client header");
- }
-
+ /*
+ * The headers can't be removed earlier because
+ * they were still needed for the referrer check
+ * in case of CGI crunches.
+ *
+ * XXX: Would it be worth to move the referrer check
+ * into client_referrer() and set a flag if it's trusted?
+ */
list_remove_all(csp->headers);
log_error(LOG_LEVEL_GPC, "%s%s", http->hostport, http->path);
/* Write the answer to the client */
- if(rsp != NULL)
+ if (rsp != NULL)
{
send_crunch_response(csp, rsp);
}
* 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 0",
- csp->ip_addr_str, http->ocmd);
-
- if (write_socket(csp->cfd, CSUCCEED, sizeof(CSUCCEED)-1))
+ if (write_socket(csp->cfd, CSUCCEED, strlen(CSUCCEED)))
{
freez(hdr);
return;
if (FD_ISSET(csp->cfd, &rfds))
{
- len = read_socket(csp->cfd, buf, sizeof(buf));
+ len = read_socket(csp->cfd, buf, sizeof(buf) - 1);
if (len <= 0)
{
csp->content_length = (size_t)(csp->iob->eod - csp->iob->cur);
}
- hdr = sed(server_patterns_light, NULL, csp);
+ if (JB_ERR_OK != sed(server_patterns_light, NULL, csp))
+ {
+ log_error(LOG_LEVEL_FATAL, "Failed to parse server headers.");
+ }
+ hdr = list_to_text(csp->headers);
if (hdr == NULL)
{
/* FIXME Should handle error properly */
log_error(LOG_LEVEL_FATAL, "Out of memory parsing server header");
}
+ /*
+ * Shouldn't happen because this was the second sed run
+ * and tags are only created for the first one.
+ */
+ assert(!crunch_response_triggered(csp, crunchers_all));
+
if (write_socket(csp->cfd, hdr, strlen(hdr))
|| write_socket(csp->cfd, p != NULL ? p : csp->iob->cur, csp->content_length))
{
int flushed;
log_error(LOG_LEVEL_ERROR, "Flushing header and buffers. Stepping back from filtering.");
-
- hdr = sed(server_patterns, add_server_headers, csp);
+ if (JB_ERR_OK != sed(server_patterns, add_server_headers, csp))
+ {
+ log_error(LOG_LEVEL_FATAL, "Failed to parse server headers.");
+ }
+ hdr = list_to_text(csp->headers);
if (hdr == NULL)
{
/*
return;
}
+ 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);
+ return;
+ }
+
hdrlen = strlen(hdr);
if (write_socket(csp->cfd, hdr, hdrlen)
{
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));
+ write_socket(csp->cfd, NO_SERVER_DATA_RESPONSE, strlen(NO_SERVER_DATA_RESPONSE));
free_http_request(http);
return;
}
/* we have now received the entire header.
* filter it and send the result to the client
*/
-
- hdr = sed(server_patterns, add_server_headers, csp);
+ if (JB_ERR_OK != sed(server_patterns, add_server_headers, csp))
+ {
+ log_error(LOG_LEVEL_FATAL, "Failed to parse server headers.");
+ }
+ hdr = list_to_text(csp->headers);
if (hdr == NULL)
{
/* FIXME Should handle error properly */
log_error(LOG_LEVEL_FATAL, "Out of memory parsing server header");
}
-#ifdef FEATURE_KILL_POPUPS
- /* Start blocking popups if appropriate. */
-
- if ((csp->content_type & CT_TEXT) && /* It's a text / * MIME-Type */
- !http->ssl && /* We talk plaintext */
- block_popups) /* Policy allows */
+ if (crunch_response_triggered(csp, crunchers_light))
{
- block_popups_now = 1;
/*
- * Filter the part of the body that came in the same read
- * as the last headers:
+ * 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.
*/
- filter_popups(csp->iob->cur, csp);
+ freez(hdr);
+ return;
}
-
-#endif /* def FEATURE_KILL_POPUPS */
-
/* Buffer and pcrs filter this if appropriate. */
- if ((csp->content_type & CT_TEXT) && /* It's a text / * MIME-Type */
- !http->ssl && /* We talk plaintext */
- pcrs_filter) /* Policy allows */
+ if (!http->ssl) /* We talk plaintext */
{
- content_filter = pcrs_filter_response;
- }
-
- /* Buffer and gif_deanimate this if appropriate. */
-
- if ((csp->content_type & CT_GIF) && /* It's an image/gif MIME-Type */
- !http->ssl && /* We talk plaintext */
- gif_deanimate) /* Policy allows */
- {
- content_filter = gif_deanimate_response;
- }
- /* Buffer and jpg_inspect this if appropriate. */
-
- if ((csp->content_type & CT_JPEG) && /* It's an image/jpeg MIME-Type */
- !http->ssl && /* We talk plaintext */
- jpeg_inspect) /* Policy allows */
- {
- content_filter = jpeg_inspect_response;
+#ifdef FEATURE_KILL_POPUPS
+ /* Start blocking popups if appropriate. */
+ if ((csp->content_type & CT_TEXT) && /* It's a text / * MIME-Type */
+ (csp->action->flags & ACTION_NO_POPUPS) != 0) /* Policy allows */
+ {
+ block_popups_now = 1;
+ /*
+ * Filter the part of the body that came in the same read
+ * as the last headers:
+ */
+ filter_popups(csp->iob->cur, csp);
+ }
+#endif /* def FEATURE_KILL_POPUPS */
+ content_filter = get_filter_function(csp);
}
-
/*
* Only write if we're not buffering for content modification
*/
void usage(const char *myname)
{
printf("Privoxy version " VERSION " (" HOME_PAGE_URL ")\n"
-#if !defined(unix)
- "Usage: %s [--help] [--version] [configfile]\n"
-#else
- "Usage: %s [--help] [--version] [--no-daemon] [--pidfile pidfile] [--user user[.group]] [configfile]\n"
-#endif
- "Aborting.\n", myname);
-
+ "Usage: %s "
+#if defined(unix)
+ "[--chroot] "
+#endif /* defined(unix) */
+ "[--help] "
+#if defined(unix)
+ "[--no-daemon] [--pidfile pidfile] [--user user[.group]] "
+#endif /* defined(unix) */
+ "[--version] [configfile]\n"
+ "Aborting\n", myname);
+
exit(2);
}
*
* For example older FreeBSD versions (< 6.x?)
* have no gethostbyname_r, but gethostbyname is
- * thead safe.
+ * thread safe.
+ */
+#if !defined(HAVE_GETHOSTBYADDR_R) || !defined(HAVE_GETHOSTBYNAME_R)
+ if (!err) err = pthread_mutex_init(&resolver_mutex, 0);
+#endif /* !defined(HAVE_GETHOSTBYADDR_R) || !defined(HAVE_GETHOSTBYNAME_R) */
+ /*
+ * XXX: should we use a single mutex for
+ * localtime() and gmtime() as well?
*/
#ifndef HAVE_GMTIME_R
if (!err) err = pthread_mutex_init(&gmtime_mutex, 0);
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 */
/*
* Parse the command line arguments
+ *
+ * XXX: simply printing usage information in case of
+ * invalid arguments isn't particular user friendly.
*/
while (++argc_pos < argc)
{
{
do_chroot = 1;
}
-
#endif /* defined(unix) */
+
+ else if (argc_pos + 1 != argc)
+ {
+ /*
+ * This is neither the last command line
+ * option, nor was it recognized before,
+ * therefore it must be invalid.
+ */
+ usage(argv[0]);
+ }
+ else
+
#endif /* defined(_WIN32) && !defined(_WIN_CONSOLE) */
{
configfile = argv[argc_pos];
#if defined(unix)
if ( *configfile != '/' )
{
- char *abs_file, cwd[1024];
+ char cwd[BUFFER_SIZE];
+ char *abs_file;
+ size_t abs_file_size;
/* make config-filename absolute here */
- if ( !(getcwd(cwd, sizeof(cwd))))
+ if (NULL == getcwd(cwd, sizeof(cwd)))
{
- perror("get working dir failed");
+ perror("failed to get current working directory");
exit( 1 );
}
- if (!(basedir = strdup(cwd))
- || (!(abs_file = malloc( strlen( basedir ) + strlen( configfile ) + 5 ))))
+ /* XXX: why + 5? */
+ abs_file_size = strlen(cwd) + strlen(configfile) + 5;
+ basedir = strdup(cwd);
+
+ if (NULL == basedir ||
+ NULL == (abs_file = malloc(abs_file_size)))
{
perror("malloc failed");
exit( 1 );
}
- strcpy( abs_file, basedir );
- strcat( abs_file, "/" );
- strcat( abs_file, configfile );
+ strlcpy(abs_file, basedir, abs_file_size);
+ strlcat(abs_file, "/", abs_file_size );
+ strlcat(abs_file, configfile, abs_file_size);
configfile = abs_file;
}
#endif /* defined unix */
{
char putenv_dummy[64];
- strcpy(putenv_dummy, "HOME=/");
+ strlcpy(putenv_dummy, "HOME=/", sizeof(putenv_dummy));
if (putenv(putenv_dummy) != 0)
{
log_error(LOG_LEVEL_FATAL, "Cannot putenv(): HOME");
}
- snprintf(putenv_dummy, 64, "USER=%s", pw->pw_name);
+ snprintf(putenv_dummy, sizeof(putenv_dummy), "USER=%s", pw->pw_name);
if (putenv(putenv_dummy) != 0)
{
log_error(LOG_LEVEL_FATAL, "Cannot putenv(): USER");
#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;