-const char jcc_rcs[] = "$Id: jcc.c,v 1.447 2016/09/27 22:48:28 ler762 Exp $";
+const char jcc_rcs[] = "$Id: jcc.c,v 1.456 2017/05/25 11:16:56 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-2016 the
+ * Copyright : Written by and Copyright (C) 2001-2017 the
* Privoxy team. http://www.privoxy.org/
*
* Based on the Internet Junkbuster originally written
# ifdef __OS2__
#define INCL_DOS
# include <os2.h>
-#define bzero(B,N) memset(B,0x00,n)
# endif
+#ifdef HAVE_POLL
+#ifdef __GLIBC__
+#include <sys/poll.h>
+#else
+#include <poll.h>
+#endif /* def __GLIBC__ */
+#else
# ifndef FD_ZERO
# include <select.h>
# endif
+#endif /* HAVE_POLL */
#endif
#define sleep(N) DosSleep(((N) * 100))
#endif
+#ifdef FUZZ
+int process_fuzzed_input(char *fuzz_input_type, char *fuzz_input_file);
+void show_fuzz_usage(const char *name);
+#endif
+
#ifdef MUTEX_LOCKS_AVAILABLE
/*
* XXX: Does the locking stuff really belong in this file?
privoxy_mutex_t localtime_mutex;
#endif /* ndef HAVE_GMTIME_R */
-#ifndef HAVE_RANDOM
+#if !defined(HAVE_ARC4RANDOM) && !defined(HAVE_RANDOM)
privoxy_mutex_t rand_mutex;
-#endif /* ndef HAVE_RANDOM */
+#endif /* !defined(HAVE_ARC4RANDOM) && !defined(HAVE_RANDOM) */
#endif /* def MUTEX_LOCKS_AVAILABLE */
do
{
- if (!data_is_available(csp->cfd, csp->config->socket_timeout))
+ if (
+#ifdef FUZZ
+ 0 == (csp->flags & CSP_FLAG_FUZZED_INPUT) &&
+#endif
+ !data_is_available(csp->cfd, csp->config->socket_timeout)
+ )
{
if (socket_is_still_alive(csp->cfd))
{
enum chunk_status status;
while (CHUNK_STATUS_MISSING_DATA ==
- (status = chunked_body_is_complete(csp->client_iob,&body_length)))
+ (status = chunked_body_is_complete(csp->client_iob, &body_length)))
{
char buf[BUFFER_SIZE];
int len;
}
+#ifdef FUZZ
+/*********************************************************************
+ *
+ * Function : fuzz_chunked_transfer_encoding
+ *
+ * Description : Treat the fuzzed input as chunked transfer encoding
+ * to check and dechunk.
+ *
+ * Parameters :
+ * 1 : csp = Used to store the data.
+ * 2 : fuzz_input_file = File to read the input from.
+ *
+ * Returns : Result of dechunking
+ *
+ *********************************************************************/
+extern int fuzz_chunked_transfer_encoding(struct client_state *csp, char *fuzz_input_file)
+{
+ size_t length;
+ size_t size = (size_t)(csp->iob->eod - csp->iob->cur);
+ enum chunk_status status;
+
+ status = chunked_body_is_complete(csp->iob, &length);
+ if (CHUNK_STATUS_BODY_COMPLETE != status)
+ {
+ log_error(LOG_LEVEL_INFO, "Chunked body is incomplete or invalid");
+ }
+
+ return (JB_ERR_OK == remove_chunked_transfer_coding(csp->iob->cur, &size));
+
+}
+
+
+/*********************************************************************
+ *
+ * Function : fuzz_client_request
+ *
+ * Description : Try to get a client request from the fuzzed input.
+ *
+ * Parameters :
+ * 1 : csp = Current client state (buffers, headers, etc...)
+ * 2 : fuzz_input_file = File to read the input from.
+ *
+ * Returns : Result of fuzzing.
+ *
+ *********************************************************************/
+extern int fuzz_client_request(struct client_state *csp, char *fuzz_input_file)
+{
+ jb_err err;
+
+ csp->cfd = 0;
+ csp->ip_addr_str = "fuzzer";
+
+ if (strcmp(fuzz_input_file, "-") != 0)
+ {
+ log_error(LOG_LEVEL_FATAL,
+ "Fuzzed client requests can currenty only be read from stdin (-).");
+ }
+ err = receive_client_request(csp);
+ if (err != JB_ERR_OK)
+ {
+ return 1;
+ }
+ err = parse_client_request(csp);
+ if (err != JB_ERR_OK)
+ {
+ return 1;
+ }
+
+ return 0;
+
+}
+#endif /* def FUZZ */
+
+
#ifdef FEATURE_FORCE_LOAD
/*********************************************************************
*
}
+/*********************************************************************
+ *
+ * Function : send_http_request
+ *
+ * Description : Sends the HTTP headers from the client request
+ * and all the body data that has already been received.
+ *
+ * Parameters :
+ * 1 : csp = Current client state (buffers, headers, etc...)
+ *
+ * Returns : 0 on success, anything else is na error.
+ *
+ *********************************************************************/
+static int send_http_request(struct client_state *csp)
+{
+ char *hdr;
+ int write_failure;
+
+ hdr = list_to_text(csp->headers);
+ if (hdr == NULL)
+ {
+ /* FIXME Should handle error properly */
+ log_error(LOG_LEVEL_FATAL, "Out of memory parsing client header");
+ }
+ list_remove_all(csp->headers);
+
+ /*
+ * Write the client's (modified) header to the server
+ * (along with anything else that may be in the buffer)
+ */
+ write_failure = 0 != write_socket(csp->server_connection.sfd, hdr, strlen(hdr));
+ freez(hdr);
+
+ if (write_failure)
+ {
+ log_error(LOG_LEVEL_CONNECT, "Failed sending request headers to: %s: %E",
+ csp->http->hostport);
+ }
+ else if (((csp->flags & CSP_FLAG_PIPELINED_REQUEST_WAITING) == 0)
+ && (flush_socket(csp->server_connection.sfd, csp->client_iob) < 0))
+ {
+ write_failure = 1;
+ log_error(LOG_LEVEL_CONNECT, "Failed sending request body to: %s: %E",
+ csp->http->hostport);
+ }
+
+ return write_failure;
+
+}
+
+
/*********************************************************************
*
* Function : handle_established_connection
char buf[BUFFER_SIZE];
char *hdr;
char *p;
- fd_set rfds;
int n;
+#ifdef HAVE_POLL
+ struct pollfd poll_fds[2];
+#else
+ fd_set rfds;
jb_socket maxfd;
+ struct timeval timeout;
+#endif
int server_body;
int ms_iis5_hack = 0;
unsigned long long byte_count = 0;
/* Skeleton for HTTP response, if we should intercept the request */
struct http_response *rsp;
- struct timeval timeout;
#ifdef FEATURE_CONNECTION_KEEP_ALIVE
int watch_client_socket;
#endif
http = csp->http;
+#ifndef HAVE_POLL
maxfd = (csp->cfd > csp->server_connection.sfd) ?
csp->cfd : csp->server_connection.sfd;
+#endif
/* pass data between the client and server
* until one or the other shuts down the connection.
for (;;)
{
+#ifndef HAVE_POLL
#ifdef __OS2__
/*
* FD_ZERO here seems to point to an errant macro which crashes.
}
FD_SET(csp->server_connection.sfd, &rfds);
+#endif /* ndef HAVE_POLL */
#ifdef FEATURE_CONNECTION_KEEP_ALIVE
if ((csp->flags & CSP_FLAG_CHUNKED)
}
#endif /* FEATURE_CONNECTION_KEEP_ALIVE */
+#ifdef HAVE_POLL
+ poll_fds[0].fd = csp->cfd;
+#ifdef FEATURE_CONNECTION_KEEP_ALIVE
+ if (!watch_client_socket)
+ {
+ /*
+ * Ignore incoming data, but still watch out
+ * for disconnects etc. These flags are always
+ * implied anyway but explicitly setting them
+ * doesn't hurt.
+ */
+ poll_fds[0].events = POLLERR|POLLHUP;
+ }
+ else
+#endif
+ {
+ poll_fds[0].events = POLLIN;
+ }
+ poll_fds[1].fd = csp->server_connection.sfd;
+ poll_fds[1].events = POLLIN;
+ n = poll(poll_fds, 2, csp->config->socket_timeout * 1000);
+#else
timeout.tv_sec = csp->config->socket_timeout;
timeout.tv_usec = 0;
n = select((int)maxfd+1, &rfds, NULL, NULL, &timeout);
+#endif /* def HAVE_POLL */
if (n == 0)
{
}
else if (n < 0)
{
+#ifdef HAVE_POLL
+ log_error(LOG_LEVEL_ERROR, "poll() failed!: %E");
+#else
log_error(LOG_LEVEL_ERROR, "select() failed!: %E");
+#endif
mark_server_socket_tainted(csp);
return;
}
* XXX: Make sure the client doesn't use pipelining
* behind Privoxy's back.
*/
+#ifdef HAVE_POLL
+ if ((poll_fds[0].revents & (POLLERR|POLLHUP|POLLNVAL)) != 0)
+ {
+ log_error(LOG_LEVEL_CONNECT,
+ "The client socket %d has become unusable while "
+ "the server socket %d is still open.",
+ csp->cfd, csp->server_connection.sfd);
+ mark_server_socket_tainted(csp);
+ break;
+ }
+
+ if (poll_fds[0].revents != 0)
+#else
if (FD_ISSET(csp->cfd, &rfds))
+#endif /* def HAVE_POLL*/
{
int max_bytes_to_read = sizeof(buf) - 1;
* If `hdr' is null, then it's the header otherwise it's the body.
* FIXME: Does `hdr' really mean `host'? No.
*/
+#ifdef HAVE_POLL
+ if (poll_fds[1].revents != 0)
+#else
if (FD_ISSET(csp->server_connection.sfd, &rfds))
+#endif /* HAVE_POLL */
{
#ifdef FEATURE_CONNECTION_KEEP_ALIVE
/*
csp->server_connection.timestamp = time(NULL);
}
+
/*********************************************************************
*
* Function : chat
*********************************************************************/
static void chat(struct client_state *csp)
{
- char buf[BUFFER_SIZE];
- char *hdr;
const struct forward_spec *fwd;
struct http_request *http;
/* Skeleton for HTTP response, if we should intercept the request */
struct http_response *rsp;
- memset(buf, 0, sizeof(buf));
-
http = csp->http;
if (receive_client_request(csp) != JB_ERR_OK)
}
else if (fwd->forward_host || (http->ssl == 0))
{
- int write_failure;
- hdr = list_to_text(csp->headers);
- if (hdr == NULL)
- {
- /* FIXME Should handle error properly */
- log_error(LOG_LEVEL_FATAL, "Out of memory parsing client header");
- }
- list_remove_all(csp->headers);
-
- /*
- * Write the client's (modified) header to the server
- * (along with anything else that may be in the buffer)
- */
- write_failure = 0 != write_socket(csp->server_connection.sfd, hdr, strlen(hdr));
- freez(hdr);
-
- if (write_failure)
- {
- log_error(LOG_LEVEL_CONNECT,
- "Failed sending request headers to: %s: %E", http->hostport);
- }
- else if (((csp->flags & CSP_FLAG_PIPELINED_REQUEST_WAITING) == 0)
- && (flush_socket(csp->server_connection.sfd, csp->client_iob) < 0))
- {
- write_failure = 1;
- log_error(LOG_LEVEL_CONNECT,
- "Failed sending request body to: %s: %E", http->hostport);
- }
-
- if (write_failure)
+ if (send_http_request(csp))
{
rsp = error_response(csp, "connect-failed");
if (rsp)
}
+#ifdef FUZZ
+/*********************************************************************
+ *
+ * Function : fuzz_server_response
+ *
+ * Description : Treat the input as a whole server response.
+ *
+ * Parameters :
+ * 1 : csp = Current client state (buffers, headers, etc...)
+ * 2 : fuzz_input_file = File to read the input from.
+ *
+ * Returns : 0
+ *
+ *********************************************************************/
+extern int fuzz_server_response(struct client_state *csp, char *fuzz_input_file)
+{
+ static struct forward_spec fwd; /* Zero'd due to being static */
+ csp->cfd = 0;
+
+ if (strcmp(fuzz_input_file, "-") == 0)
+ {
+ /* XXX: Doesn'T work yet. */
+ csp->server_connection.sfd = 0;
+ }
+ else
+ {
+ csp->server_connection.sfd = open(fuzz_input_file, O_RDONLY);
+ if (csp->server_connection.sfd == -1)
+ {
+ log_error(LOG_LEVEL_FATAL, "Failed to open %s: %E",
+ fuzz_input_file);
+ }
+ }
+ csp->content_type |= CT_GIF;
+ csp->action->flags |= ACTION_DEANIMATE;
+ csp->action->string[ACTION_STRING_DEANIMATE] = "last";
+
+ csp->http->path = strdup_or_die("/");
+ csp->http->host = strdup_or_die("fuzz.example.org");
+ csp->http->hostport = strdup_or_die("fuzz.example.org:80");
+ /* Prevent client socket monitoring */
+ csp->flags |= CSP_FLAG_PIPELINED_REQUEST_WAITING;
+ csp->flags |= CSP_FLAG_CHUNKED;
+
+ csp->config->feature_flags |= RUNTIME_FEATURE_CONNECTION_KEEP_ALIVE;
+ csp->flags |= CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE;
+
+ csp->content_type |= CT_DECLARED|CT_GIF;
+
+ csp->config->socket_timeout = 0;
+
+ cgi_init_error_messages();
+
+ handle_established_connection(csp, &fwd);
+
+ return 0;
+}
+#endif
+
+
#ifdef FEATURE_CONNECTION_KEEP_ALIVE
/*********************************************************************
*
* Returns : No. ,-)
*
*********************************************************************/
-static void usage(const char *myname)
+static void usage(const char *name)
{
printf("Privoxy version " VERSION " (" HOME_PAGE_URL ")\n"
"Usage: %s [--config-test] "
#if defined(unix)
"[--no-daemon] [--pidfile pidfile] [--pre-chroot-nslookup hostname] [--user user[.group]] "
#endif /* defined(unix) */
- "[--version] [configfile]\n"
- "Aborting\n", myname);
+ "[--version] [configfile]\n",
+ name);
+
+#ifdef FUZZ
+ show_fuzz_usage(name);
+#endif
+
+ printf("Aborting\n");
exit(2);
privoxy_mutex_init(&localtime_mutex);
#endif /* ndef HAVE_GMTIME_R */
-#ifndef HAVE_RANDOM
+#if !defined(HAVE_ARC4RANDOM) && !defined(HAVE_RANDOM)
privoxy_mutex_init(&rand_mutex);
-#endif /* ndef HAVE_RANDOM */
+#endif /* !defined(HAVE_ARC4RANDOM) && !defined(HAVE_RANDOM) */
#endif /* def MUTEX_LOCKS_AVAILABLE */
}
-
/*********************************************************************
*
* Function : main
{
int argc_pos = 0;
int do_config_test = 0;
+#ifndef HAVE_ARC4RANDOM
unsigned int random_seed;
+#endif
#ifdef unix
struct passwd *pw = NULL;
struct group *grp = NULL;
int do_chroot = 0;
char *pre_chroot_nslookup_to_load_resolver = NULL;
#endif
+#ifdef FUZZ
+ char *fuzz_input_type = NULL;
+ char *fuzz_input_file = NULL;
+#endif
Argc = argc;
Argv = argv;
{
do_config_test = 1;
}
-
+#ifdef FUZZ
+ else if (strcmp(argv[argc_pos], "--fuzz") == 0)
+ {
+ argc_pos++;
+ if (argc < argc_pos + 2) usage(argv[0]);
+ fuzz_input_type = argv[argc_pos];
+ argc_pos++;
+ fuzz_input_file = argv[argc_pos];
+ }
+ else if (strcmp(argv[argc_pos], "--stfu") == 0)
+ {
+ set_debug_level(LOG_LEVEL_STFU);
+ }
+#endif
else if (argc_pos + 1 != argc)
{
/*
InitWin32();
#endif
+#ifndef HAVE_ARC4RANDOM
random_seed = (unsigned int)time(NULL);
#ifdef HAVE_RANDOM
srandom(random_seed);
#else
srand(random_seed);
#endif /* ifdef HAVE_RANDOM */
+#endif /* ifndef HAVE_ARC4RANDOM */
/*
* Unix signal handling
*
* Catch the abort, interrupt and terminate signals for a graceful exit
* Catch the hangup signal so the errlog can be reopened.
- * Ignore the broken pipe signals (FIXME: Why?)
+ *
+ * Ignore the broken pipe signal as connection failures
+ * are handled when and where they occur without relying
+ * on a signal.
*/
#if !defined(_WIN32) && !defined(__OS2__) && !defined(AMIGA)
{
# endif /* def _WIN_CONSOLE */
#endif /* def _WIN32 */
+#ifdef FUZZ
+ if (fuzz_input_type != NULL)
+ {
+ exit(process_fuzzed_input(fuzz_input_type, fuzz_input_file));
+ }
+#endif
+
if (do_config_test)
{
exit(NULL == load_config());
return JB_INVALID_SOCKET;
}
+#ifndef HAVE_POLL
#ifndef _WIN32
if (bfd >= FD_SETSIZE)
{
"Bind socket number too high to use select(): %d >= %d",
bfd, FD_SETSIZE);
}
+#endif
#endif
if (haddr == NULL)
projects / privoxy.git / blobdiff