-const char jcc_rcs[] = "$Id: jcc.c,v 1.168 2008/03/02 12:25:25 fabiankeil Exp $";
+const char jcc_rcs[] = "$Id: jcc.c,v 1.186 2008/09/04 08:13:58 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-2007 the SourceForge
+ * Copyright : Written by and Copyright (C) 2001-2008 the SourceForge
* Privoxy team. http://www.privoxy.org/
*
* Based on the Internet Junkbuster originally written
*
* Revisions :
* $Log: jcc.c,v $
+ * Revision 1.186 2008/09/04 08:13:58 fabiankeil
+ * Prepare for critical sections on Windows by adding a
+ * layer of indirection before the pthread mutex functions.
+ *
+ * Revision 1.185 2008/08/30 12:03:07 fabiankeil
+ * Remove FEATURE_COOKIE_JAR.
+ *
+ * Revision 1.184 2008/08/22 15:34:45 fabiankeil
+ * - Silence LLVM/Clang complaint.
+ * - Make received_hup_signal static.
+ * - Hide definitions for basedir, pidfile and received_hup_signal
+ * from __EMX__ as they only seem to be used in case of #ifdef unix.
+ *
+ * Revision 1.183 2008/08/21 07:09:35 fabiankeil
+ * Accept Shoutcast responses again. Problem reported
+ * and fix suggested by Stefan in #2062860.
+ *
+ * Revision 1.182 2008/06/27 11:13:56 fabiankeil
+ * Fix possible NULL-pointer dereference reported
+ * by din_a4 in #2003937. Pointy hat to me.
+ *
+ * Revision 1.181 2008/05/21 15:47:15 fabiankeil
+ * Streamline sed()'s prototype and declare
+ * the header parse and add structures static.
+ *
+ * Revision 1.180 2008/05/21 15:26:32 fabiankeil
+ * - Mark csp as immutable for send_crunch_response().
+ * - Fix comment spelling.
+ *
+ * Revision 1.179 2008/05/20 20:13:32 fabiankeil
+ * Factor update_server_headers() out of sed(), ditch the
+ * first_run hack and make server_patterns_light static.
+ *
+ * Revision 1.178 2008/05/10 13:23:38 fabiankeil
+ * Don't provide get_header() with the whole client state
+ * structure when it only needs access to csp->iob.
+ *
+ * Revision 1.177 2008/05/10 11:51:12 fabiankeil
+ * Make the "read the rest of the headers" loop a bit more readable.
+ *
+ * Revision 1.176 2008/05/10 11:37:57 fabiankeil
+ * - Instead of logging when the IIS5 hack is enabled, log when it fails.
+ * - Remove useless comment.
+ *
+ * Revision 1.175 2008/05/09 18:53:59 fabiankeil
+ * Fix comment grammar.
+ *
+ * Revision 1.174 2008/05/07 18:05:53 fabiankeil
+ * Remove the pointless buffer in client_protocol_is_unsupported().
+ *
+ * Revision 1.173 2008/05/06 15:09:00 fabiankeil
+ * Least-effort fix for bug #1821930 (reported by Lee):
+ * If the response doesn't look like HTTP,
+ * tell the client and log the problem.
+ *
+ * Revision 1.172 2008/04/16 16:38:21 fabiankeil
+ * Don't pass the whole csp structure to flush_socket()
+ * when it only needs a file descriptor and a buffer.
+ *
+ * Revision 1.171 2008/03/27 18:27:25 fabiankeil
+ * Remove kill-popups action.
+ *
+ * Revision 1.170 2008/03/06 16:33:46 fabiankeil
+ * If limit-connect isn't used, don't limit CONNECT requests to port 443.
+ *
+ * Revision 1.169 2008/03/04 18:30:39 fabiankeil
+ * Remove the treat-forbidden-connects-like-blocks action. We now
+ * use the "blocked" page for forbidden CONNECT requests by default.
+ *
* Revision 1.168 2008/03/02 12:25:25 fabiankeil
* Also use shiny new connect_port_is_forbidden() in jcc.c.
*
#include "filters.h"
#include "loaders.h"
#include "parsers.h"
-#include "killpopup.h"
#include "miscutil.h"
#include "errlog.h"
#include "jbsockets.h"
static jb_err get_request_destination_elsewhere(struct client_state *csp, struct list *headers);
static jb_err get_server_headers(struct client_state *csp);
static const char *crunch_reason(const struct http_response *rsp);
-static void send_crunch_response(struct client_state *csp, struct http_response *rsp);
+static void send_crunch_response(const struct client_state *csp, struct http_response *rsp);
/*
* static int request_contains_null_bytes(const struct client_state *csp, char *buf, int len);
*/
#define sleep(N) DosSleep(((N) * 100))
#endif
-#ifdef FEATURE_PTHREAD
-pthread_mutex_t log_mutex;
-pthread_mutex_t log_init_mutex;
+#ifdef MUTEX_LOCKS_AVAILABLE
+/*
+ * XXX: Does the locking stuff really belong in this file?
+ */
+privoxy_mutex_t log_mutex;
+privoxy_mutex_t log_init_mutex;
#if !defined(HAVE_GETHOSTBYADDR_R) || !defined(HAVE_GETHOSTBYNAME_R)
-pthread_mutex_t resolver_mutex;
+privoxy_mutex_t resolver_mutex;
#endif /* !defined(HAVE_GETHOSTBYADDR_R) || !defined(HAVE_GETHOSTBYNAME_R) */
#ifndef HAVE_GMTIME_R
-pthread_mutex_t gmtime_mutex;
+privoxy_mutex_t gmtime_mutex;
#endif /* ndef HAVE_GMTIME_R */
#ifndef HAVE_LOCALTIME_R
-pthread_mutex_t localtime_mutex;
+privoxy_mutex_t localtime_mutex;
#endif /* ndef HAVE_GMTIME_R */
#ifndef HAVE_RANDOM
-pthread_mutex_t rand_mutex;
+privoxy_mutex_t rand_mutex;
#endif /* ndef HAVE_RANDOM */
-#endif /* FEATURE_PTHREAD */
+#endif /* def MUTEX_LOCKS_AVAILABLE */
-#if defined(unix) || defined(__EMX__)
+#if defined(unix)
const char *basedir = NULL;
const char *pidfile = NULL;
-int received_hup_signal = 0;
+static int received_hup_signal = 0;
#endif /* defined unix */
/* HTTP snipplets. */
"Empty server or forwarder response.\r\n"
"The connection has been closed but Privoxy didn't receive any data.\r\n";
+/* XXX: should be a template */
+static const char INVALID_SERVER_HEADERS_RESPONSE[] =
+ "HTTP/1.0 502 Server or forwarder response invalid\r\n"
+ "Proxy-Agent: Privoxy " VERSION "\r\n"
+ "Content-Type: text/plain\r\n"
+ "Connection: close\r\n\r\n"
+ "Bad response. The server or forwarder response doesn't look like HTTP.\r\n";
+
#if 0
/* XXX: should be a template */
static const char NULL_BYTE_RESPONSE[] =
};
+/*
+ * XXX: Don't we really mean
+ *
+ * #if defined(unix)
+ *
+ * here?
+ */
#if !defined(_WIN32) && !defined(__OS2__) && !defined(AMIGA)
/*********************************************************************
*
break;
case SIGHUP:
+#if defined(unix)
received_hup_signal = 1;
+#endif
break;
default:
*********************************************************************/
static 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.
*
*/
if (!strncmpic(req, "GET ftp://", 10) || !strncmpic(req, "GET gopher://", 13))
{
+ const char *response = NULL;
+ const char *protocol = NULL;
+
if (!strncmpic(req, "GET ftp://", 10))
{
- 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);
+ response = FTP_RESPONSE;
+ protocol = "FTP";
}
else
{
- 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);
+ response = GOPHER_RESPONSE;
+ protocol = "GOPHER";
}
- log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 400 0", csp->ip_addr_str, req);
+ log_error(LOG_LEVEL_ERROR,
+ "%s tried to use Privoxy as %s proxy: %s",
+ csp->ip_addr_str, protocol, 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));
+ write_socket(csp->cfd, response, strlen(response));
return TRUE;
}
int continue_hack_in_da_house = 0;
char * header;
- while (((header = get_header(csp)) != NULL) || continue_hack_in_da_house)
+ while (((header = get_header(csp->iob)) != NULL) || continue_hack_in_da_house)
{
if (header == NULL)
{
{
/*
* It's a bodyless continue response, don't
- * stop header parsing after reaching it's end.
+ * stop header parsing after reaching its end.
*
* As a result Privoxy will concatenate the
* next response's head and parse and deliver
return JB_ERR_PARSE;
}
- /* Enlist header */
if (JB_ERR_MEMORY == enlist(csp->headers, header))
{
/*
* Returns : Nothing.
*
*********************************************************************/
-static void send_crunch_response(struct client_state *csp, struct http_response *rsp)
+static void send_crunch_response(const struct client_state *csp, struct http_response *rsp)
{
const struct http_request *http = csp->http;
char status_code[4];
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)
+ else
{
- log_error(LOG_LEVEL_FATAL, "Out of memory copying rewritten HTTP request line");
+ /* XXX: ocmd is a misleading name */
+ http->ocmd = strdup(http->cmd);
+ if (http->ocmd == NULL)
+ {
+ log_error(LOG_LEVEL_FATAL,
+ "Out of memory copying rewritten HTTP request line");
+ }
}
return err;
struct http_request *http;
int len; /* for buffer sizes (and negative error codes) */
jb_err err;
-#ifdef FEATURE_KILL_POPUPS
- int block_popups_now = 0; /* bool, 1==currently blocking popups */
-#endif /* def FEATURE_KILL_POPUPS */
/* Function that does the content filtering for the current request */
filter_function_ptr content_filter = NULL;
return;
}
- req = get_header(csp);
+ req = get_header(csp->iob);
} while ((NULL != req) && ('\0' == *req));
init_list(headers);
for (;;)
{
- if ( ( ( p = get_header(csp) ) != NULL) && ( *p == '\0' ) )
+ p = get_header(csp->iob);
+
+ if (p == NULL)
{
+ /* There are no additional headers to read. */
+ break;
+ }
+
+ if (*p == '\0')
+ {
+ /*
+ * We didn't receive a complete header
+ * line yet, get the rest of it.
+ */
len = read_socket(csp->cfd, buf, sizeof(buf) - 1);
if (len <= 0)
{
return;
}
- /*
- * If there is no memory left for buffering the
- * request, there is nothing we can do but hang up
- */
if (add_to_iob(csp, buf, len))
{
+ /*
+ * If there is no memory left for buffering the
+ * request, there is nothing we can do but hang up
+ */
destroy_list(headers);
return;
}
- continue;
}
-
- if (p == NULL) break;
-
- enlist(headers, p);
- freez(p);
-
+ else
+ {
+ /*
+ * We were able to read a complete
+ * header and can finaly enlist it.
+ */
+ enlist(headers, p);
+ freez(p);
+ }
}
if (http->host == NULL)
list_append_list_unique(csp->headers, headers);
destroy_list(headers);
- err = sed(client_patterns, add_client_headers, csp);
+ err = sed(csp, FILTER_CLIENT_HEADERS);
if (JB_ERR_OK != err)
{
assert(err == JB_ERR_PARSE);
if (http->ssl && connect_port_is_forbidden(csp))
{
const char *acceptable_connect_ports =
- csp->action->string[ACTION_STRING_LIMIT_CONNECT] ?
- csp->action->string[ACTION_STRING_LIMIT_CONNECT] :
- "443 (implied default)";
+ csp->action->string[ACTION_STRING_LIMIT_CONNECT];
+ assert(NULL != acceptable_connect_ports);
log_error(LOG_LEVEL_INFO, "Request from %s marked for blocking. "
"limit-connect{%s} doesn't allow CONNECT requests to port %d.",
csp->ip_addr_str, acceptable_connect_ports, csp->http->port);
*/
if (write_socket(csp->sfd, hdr, strlen(hdr))
- || (flush_socket(csp->sfd, csp) < 0))
+ || (flush_socket(csp->sfd, csp->iob) < 0))
{
log_error(LOG_LEVEL_CONNECT, "write header to: %s failed: %E",
http->hostport);
*/
buf[len] = '\0';
-#ifdef FEATURE_KILL_POPUPS
- /* Filter the popups on this read. */
- if (block_popups_now)
- {
- filter_popups(buf, csp);
- }
-#endif /* def FEATURE_KILL_POPUPS */
-
/* Normally, this would indicate that we've read
* as much as the server has sent us and we can
* close the client connection. However, Microsoft
csp->content_length = (size_t)(csp->iob->eod - csp->iob->cur);
}
- if (JB_ERR_OK != sed(server_patterns_light, NULL, csp))
+ if (JB_ERR_OK != update_server_headers(csp))
{
- log_error(LOG_LEVEL_FATAL, "Failed to parse server headers.");
+ log_error(LOG_LEVEL_FATAL,
+ "Failed to update server headers. after filtering.");
}
hdr = list_to_text(csp->headers);
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))
{
* This is NOT the body, so
* Let's pretend the server just sent us a blank line.
*/
- log_error(LOG_LEVEL_INFO,
- "Malformerd HTTP headers detected and MS IIS5 hack enabled. "
- "Expect an invalid response or even no response at all.");
snprintf(buf, sizeof(buf), "\r\n");
len = (int)strlen(buf);
hdrlen = strlen(hdr);
if (write_socket(csp->cfd, hdr, hdrlen)
- || ((flushed = flush_socket(csp->cfd, csp)) < 0)
+ || ((flushed = flush_socket(csp->cfd, csp->iob)) < 0)
|| (write_socket(csp->cfd, buf, (size_t)len)))
{
log_error(LOG_LEVEL_CONNECT, "Flush header and buffers to client failed: %E");
* and there isn't anything
* we can do about it.
*/
+ log_error(LOG_LEVEL_INFO,
+ "MS IIS5 hack didn't produce valid headers.");
break;
}
else
return;
}
- /* we have now received the entire header.
+ assert(csp->headers->first->str);
+ assert(!http->ssl);
+ if (strncmpic(csp->headers->first->str, "HTTP", 4) &&
+ strncmpic(csp->headers->first->str, "ICY", 3))
+ {
+ /*
+ * It doesn't look like a HTTP (or Shoutcast) response:
+ * tell the client and log the problem.
+ */
+ if (strlen(csp->headers->first->str) > 30)
+ {
+ csp->headers->first->str[30] = '\0';
+ }
+ log_error(LOG_LEVEL_ERROR,
+ "Invalid server or forwarder response. Starts with: %s",
+ csp->headers->first->str);
+ log_error(LOG_LEVEL_CLF,
+ "%s - - [%T] \"%s\" 502 0", csp->ip_addr_str, http->cmd);
+ write_socket(csp->cfd, INVALID_SERVER_HEADERS_RESPONSE,
+ strlen(INVALID_SERVER_HEADERS_RESPONSE));
+ free_http_request(http);
+ return;
+ }
+
+ /*
+ * We have now received the entire server header,
* filter it and send the result to the client
*/
- if (JB_ERR_OK != sed(server_patterns, add_server_headers, csp))
+ if (JB_ERR_OK != sed(csp, FILTER_SERVER_HEADERS))
{
log_error(LOG_LEVEL_FATAL, "Failed to parse server headers.");
}
if (!http->ssl) /* We talk plaintext */
{
-
-#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);
}
/*
*/
if (write_socket(csp->cfd, hdr, strlen(hdr))
- || ((len = flush_socket(csp->cfd, csp)) < 0))
+ || ((len = flush_socket(csp->cfd, csp->iob)) < 0))
{
log_error(LOG_LEVEL_CONNECT, "write header to client failed: %E");
*/
if (ms_iis5_hack)
{
+ log_error(LOG_LEVEL_INFO,
+ "Closed server connection detected with MS IIS5 hack enabled.");
break;
}
}
#endif /* #if !defined(_WIN32) || defined(_WIN_CONSOLE) */
+#ifdef MUTEX_LOCKS_AVAILABLE
+/*********************************************************************
+ *
+ * Function : privoxy_mutex_lock
+ *
+ * Description : Locks a mutex.
+ *
+ * Parameters :
+ * 1 : mutex = The mutex to lock.
+ *
+ * Returns : Void. May exit in case of errors.
+ *
+ *********************************************************************/
+void privoxy_mutex_lock(privoxy_mutex_t *mutex)
+{
+#ifdef FEATURE_PTHREAD
+ int err = pthread_mutex_lock(mutex);
+ if (err)
+ {
+ if (mutex != &log_mutex)
+ {
+ log_error(LOG_LEVEL_FATAL,
+ "Mutex locking failed: %s.\n", strerror(err));
+ }
+ exit(1);
+ }
+#else
+ EnterCriticalSection(mutex);
+#endif /* def FEATURE_PTHREAD */
+}
+
+
+/*********************************************************************
+ *
+ * Function : privoxy_mutex_unlock
+ *
+ * Description : Unlocks a mutex.
+ *
+ * Parameters :
+ * 1 : mutex = The mutex to unlock.
+ *
+ * Returns : Void. May exit in case of errors.
+ *
+ *********************************************************************/
+void privoxy_mutex_unlock(privoxy_mutex_t *mutex)
+{
+#ifdef FEATURE_PTHREAD
+ int err = pthread_mutex_unlock(mutex);
+ if (err)
+ {
+ if (mutex != &log_mutex)
+ {
+ log_error(LOG_LEVEL_FATAL,
+ "Mutex unlocking failed: %s.\n", strerror(err));
+ }
+ exit(1);
+ }
+#else
+ LeaveCriticalSection(mutex);
+#endif /* def FEATURE_PTHREAD */
+}
+
+
+/*********************************************************************
+ *
+ * Function : privoxy_mutex_init
+ *
+ * Description : Prepares a mutex.
+ *
+ * Parameters :
+ * 1 : mutex = The mutex to initialize.
+ *
+ * Returns : Void. May exit in case of errors.
+ *
+ *********************************************************************/
+static void privoxy_mutex_init(privoxy_mutex_t *mutex)
+{
+#ifdef FEATURE_PTHREAD
+ int err = pthread_mutex_init(mutex, 0);
+ if (err)
+ {
+ printf("Fatal error. Mutex initialization failed: %s.\n",
+ strerror(err));
+ exit(1);
+ }
+#else
+ InitializeCriticalSection(mutex);
+#endif /* def FEATURE_PTHREAD */
+}
+#endif /* def MUTEX_LOCKS_AVAILABLE */
+
/*********************************************************************
*
* Function : initialize_mutexes
*********************************************************************/
static void initialize_mutexes(void)
{
- int err = 0;
-
-#ifdef FEATURE_PTHREAD
+#ifdef MUTEX_LOCKS_AVAILABLE
/*
* Prepare global mutex semaphores
*/
- err = pthread_mutex_init(&log_mutex, 0);
+ privoxy_mutex_init(&log_mutex);
- if (!err) err = pthread_mutex_init(&log_init_mutex, 0);
+ privoxy_mutex_init(&log_init_mutex);
/*
* XXX: The assumptions below are a bit naive
* thread safe.
*/
#if !defined(HAVE_GETHOSTBYADDR_R) || !defined(HAVE_GETHOSTBYNAME_R)
- if (!err) err = pthread_mutex_init(&resolver_mutex, 0);
+ privoxy_mutex_init(&resolver_mutex);
#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);
+ privoxy_mutex_init(&gmtime_mutex);
#endif /* ndef HAVE_GMTIME_R */
#ifndef HAVE_LOCALTIME_R
- if (!err) err = pthread_mutex_init(&localtime_mutex, 0);
+ privoxy_mutex_init(&localtime_mutex);
#endif /* ndef HAVE_GMTIME_R */
#ifndef HAVE_RANDOM
- if (!err) err = pthread_mutex_init(&rand_mutex, 0);
+ privoxy_mutex_init(&rand_mutex);
#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;
+#endif /* def MUTEX_LOCKS_AVAILABLE */
}
* Parse the command line arguments
*
* XXX: simply printing usage information in case of
- * invalid arguments isn't particular user friendly.
+ * invalid arguments isn't particularly user friendly.
*/
while (++argc_pos < argc)
{
random_seed = (unsigned int)time(NULL);
#ifdef HAVE_RANDOM
srandom(random_seed);
-#elif defined (_WIN32)
- /*
- * See pick_from_range() in miscutil.c for details.
- */
- log_error(LOG_LEVEL_INFO,
- "No thread-safe PRNG implemented for your platform. "
- "Using weak \'randomization\' factor which will "
- "limit the already questionable usefulness of "
- "header-time-randomizing actions (disabled by default).");
#else
srand(random_seed);
#endif /* ifdef HAVE_RANDOM */
}
#endif
-#ifdef __OS2__
-#ifdef FEATURE_COOKIE_JAR
- /*
- * Need a workaround here: we have to fclose() the jarfile, or we die because it's
- * already open. I think unload_configfile() is not being run, which should do
- * this work. Until that can get resolved, we'll use this workaround.
- */
- if (csp)
- if(csp->config)
- if (csp->config->jar)
- {
- fclose(csp->config->jar);
- csp->config->jar = NULL;
- }
-#endif /* FEATURE_COOKIE_JAR */
-#endif /* __OS2__ */
-
if ( NULL == (csp = (struct client_state *) zalloc(sizeof(*csp))) )
{
log_error(LOG_LEVEL_FATAL, "malloc(%d) for csp failed: %E", sizeof(*csp));
#endif
freez(configfile);
-#ifdef FEATURE_COOKIE_JAR
- if (NULL != config->jar)
- {
- fclose(config->jar);
- }
-#endif
-
#if defined(_WIN32) && !defined(_WIN_CONSOLE)
/* Cleanup - remove taskbar icon etc. */
TermLogWindow();
projects / privoxy.git / blobdiff