-const char jcc_rcs[] = "$Id: jcc.c,v 1.455 2017/05/25 11:16:04 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
# ifndef FD_ZERO
# include <select.h>
# endif
+#warning poll() appears to be unavailable. Your platform will become unsupported in the future.
#endif /* HAVE_POLL */
#endif
#include "client-tags.h"
#endif
-const char jcc_h_rcs[] = JCC_H_VERSION;
-const char project_h_rcs[] = PROJECT_H_VERSION;
-
int daemon_mode = 1;
struct client_states clients[1];
struct file_list files[1];
static void usage(const char *myname);
#endif
static void initialize_mutexes(void);
-static jb_socket bind_port_helper(const char *haddr, int hport);
+static jb_socket bind_port_helper(const char *haddr, int hport, int backlog);
static void bind_ports_helper(struct configuration_spec *config, jb_socket sockets[]);
static void close_ports_helper(jb_socket sockets[]);
static void listen_loop(void);
*
* Parameters :
* 1 : csp = Current client state (buffers, headers, etc...)
- * 1 : rsp = Fully prepared response. Will be freed on exit.
+ * 2 : rsp = Fully prepared response. Will be freed on exit.
*
* Returns : Nothing.
*
* 1 : sfd = Open socket to remember.
* 2 : http = The destination for the connection.
* 3 : fwd = The forwarder settings used.
- * 3 : server_connection = storage.
+ * 4 : server_connection = storage.
*
* Returns : void
*
}
verify_request_length(csp);
}
+ else
+ {
+ csp->flags |= CSP_FLAG_SERVER_SOCKET_TAINTED;
+ }
#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
err = sed(csp, FILTER_CLIENT_HEADERS);
* Returns : Nothing.
*
*********************************************************************/
-static void handle_established_connection(struct client_state *csp,
- const struct forward_spec *fwd)
+static void handle_established_connection(struct client_state *csp)
{
- char buf[BUFFER_SIZE];
char *hdr;
char *p;
int n;
int watch_client_socket;
#endif
- memset(buf, 0, sizeof(buf));
+ csp->receive_buffer_size = csp->config->receive_buffer_size;
+ csp->receive_buffer = zalloc(csp->receive_buffer_size + 1);
+ if (csp->receive_buffer == NULL)
+ {
+ log_error(LOG_LEVEL_ERROR,
+ "Out of memory. Failed to allocate the receive buffer.");
+ rsp = cgi_error_memory();
+ send_crunch_response(csp, rsp);
+ return;
+ }
http = csp->http;
if (n == 0)
{
- log_error(LOG_LEVEL_ERROR,
- "Didn't receive data in time: %s", http->url);
+ log_error(LOG_LEVEL_CONNECT, "Socket timeout %d reached: %s",
+ csp->config->socket_timeout, http->url);
if ((byte_count == 0) && (http->ssl == 0))
{
send_crunch_response(csp, error_response(csp, "connection-timeout"));
if (FD_ISSET(csp->cfd, &rfds))
#endif /* def HAVE_POLL*/
{
- int max_bytes_to_read = sizeof(buf) - 1;
+ int max_bytes_to_read = (int)csp->receive_buffer_size;
#ifdef FEATURE_CONNECTION_KEEP_ALIVE
if ((csp->flags & CSP_FLAG_CLIENT_REQUEST_COMPLETELY_READ))
*/
watch_client_socket = 0;
log_error(LOG_LEVEL_CONNECT,
- "Stopping to watch the client socket %d. "
+ "Stop watching client socket %d. "
"There's already another request waiting.",
csp->cfd);
continue;
}
if (csp->expected_client_content_length != 0)
{
- if (csp->expected_client_content_length < (sizeof(buf) - 1))
+ if (csp->expected_client_content_length < csp->receive_buffer_size)
{
max_bytes_to_read = (int)csp->expected_client_content_length;
}
"Waiting for up to %d bytes from the client.",
max_bytes_to_read);
}
- assert(max_bytes_to_read < sizeof(buf));
+ assert(max_bytes_to_read <= csp->receive_buffer_size);
#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
- len = read_socket(csp->cfd, buf, max_bytes_to_read);
+ len = read_socket(csp->cfd, csp->receive_buffer, max_bytes_to_read);
if (len <= 0)
{
}
#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
- if (write_socket(csp->server_connection.sfd, buf, (size_t)len))
+ if (write_socket(csp->server_connection.sfd, csp->receive_buffer, (size_t)len))
{
log_error(LOG_LEVEL_ERROR, "write to: %s failed: %E", http->host);
mark_server_socket_tainted(csp);
}
#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
- len = read_socket(csp->server_connection.sfd, buf, sizeof(buf) - 1);
+ len = read_socket(csp->server_connection.sfd, csp->receive_buffer, (int)csp->receive_buffer_size);
if (len < 0)
{
log_error(LOG_LEVEL_ERROR, "read from: %s failed: %E", http->host);
- if (http->ssl && (fwd->forward_host == NULL))
+ if (http->ssl && (csp->fwd == NULL))
{
/*
* Just hang up. We already confirmed the client's CONNECT
#ifdef FEATURE_CONNECTION_KEEP_ALIVE
if (csp->flags & CSP_FLAG_CHUNKED)
{
- if ((len >= 5) && !memcmp(buf+len-5, "0\r\n\r\n", 5))
+ if ((len >= 5) && !memcmp(csp->receive_buffer+len-5, "0\r\n\r\n", 5))
{
/* XXX: this is a temporary hack */
log_error(LOG_LEVEL_CONNECT,
reading_done:
#endif /* FEATURE_CONNECTION_KEEP_ALIVE */
+ /*
+ * This is guaranteed by allocating with zalloc_or_die()
+ * and never (intentionally) writing to the last byte.
+ *
+ * csp->receive_buffer_size is the size of the part of the
+ * buffer we intentionally write to, but we actually
+ * allocated csp->receive_buffer_size+1 bytes so the assertion
+ * stays within the allocated range.
+ */
+ assert(csp->receive_buffer[csp->receive_buffer_size] == '\0');
+
/*
* Add a trailing zero to let be able to use string operations.
* XXX: do we still need this with filter_popups gone?
*/
- buf[len] = '\0';
+ assert(len <= csp->receive_buffer_size);
+ csp->receive_buffer[len] = '\0';
/*
* Normally, this would indicate that we've read
* This is NOT the body, so
* Let's pretend the server just sent us a blank line.
*/
- snprintf(buf, sizeof(buf), "\r\n");
- len = (int)strlen(buf);
+ snprintf(csp->receive_buffer, csp->receive_buffer_size, "\r\n");
+ len = (int)strlen(csp->receive_buffer);
/*
* Now, let the normal header parsing algorithm below do its
* has been reached, switch to non-filtering mode, i.e. make & write the
* header, flush the iob and buf, and get out of the way.
*/
- if (add_to_iob(csp->iob, csp->config->buffer_limit, buf, len))
+ if (add_to_iob(csp->iob, csp->config->buffer_limit, csp->receive_buffer, len))
{
size_t hdrlen;
long flushed;
if (write_socket(csp->cfd, hdr, hdrlen)
|| ((flushed = flush_socket(csp->cfd, csp->iob)) < 0)
- || (write_socket(csp->cfd, buf, (size_t)len)))
+ || (write_socket(csp->cfd, csp->receive_buffer, (size_t)len)))
{
log_error(LOG_LEVEL_CONNECT,
"Flush header and buffers to client failed: %E");
}
else
{
- if (write_socket(csp->cfd, buf, (size_t)len))
+ if (write_socket(csp->cfd, csp->receive_buffer, (size_t)len))
{
log_error(LOG_LEVEL_ERROR, "write to client failed: %E");
mark_server_socket_tainted(csp);
* Buffer up the data we just read. If that fails, there's
* little we can do but send our static out-of-memory page.
*/
- if (add_to_iob(csp->iob, csp->config->buffer_limit, buf, len))
+ if (add_to_iob(csp->iob, csp->config->buffer_limit, csp->receive_buffer, len))
{
log_error(LOG_LEVEL_ERROR, "Out of memory while looking for end of server headers.");
rsp = cgi_error_memory();
* delivered the crunch response to the client
* and are done here after cleaning up.
*/
- freez(hdr);
- mark_server_socket_tainted(csp);
- return;
+ freez(hdr);
+ mark_server_socket_tainted(csp);
+ return;
}
/* Buffer and pcrs filter this if appropriate. */
/* XXX: should the time start earlier for optimistically sent data? */
csp->server_connection.request_sent = time(NULL);
- handle_established_connection(csp, fwd);
+ handle_established_connection(csp);
+ freez(csp->receive_buffer);
}
fuzz_input_file);
}
}
+ csp->fwd = &fwd;
csp->content_type |= CT_GIF;
csp->action->flags |= ACTION_DEANIMATE;
csp->action->string[ACTION_STRING_DEANIMATE] = "last";
cgi_init_error_messages();
- handle_established_connection(csp, &fwd);
+ handle_established_connection(csp);
+ freez(csp->receive_buffer);
return 0;
}
drain_and_close_socket(csp->cfd);
}
+ free_csp_resources(csp);
+
csp->flags &= ~CSP_FLAG_ACTIVE;
}
{
exit(process_fuzzed_input(fuzz_input_type, fuzz_input_file));
}
+ log_error(LOG_LEVEL_FATAL,
+ "When compiled with fuzzing support, Privoxy should only be used for fuzzing. "
+ "Various data structures are static which is unsafe when using threads.");
#endif
if (do_config_test)
* As soon as we have written the PID file, we can switch
* to the user and group ID indicated by the --user option
*/
- write_pid_file();
-
+ if (pidfile != NULL)
+ {
+ write_pid_file(pidfile);
+ }
if (NULL != pw)
{
if (setgid((NULL != grp) ? grp->gr_gid : pw->pw_gid))
* 1 : haddr = Host address to bind to. Use NULL to bind to
* INADDR_ANY.
* 2 : hport = Specifies port to bind to.
+ * 3 : backlog = Listen backlog.
*
* Returns : Port that was opened.
*
*********************************************************************/
-static jb_socket bind_port_helper(const char *haddr, int hport)
+static jb_socket bind_port_helper(const char *haddr, int hport, int backlog)
{
int result;
jb_socket bfd;
- result = bind_port(haddr, hport, &bfd);
+ result = bind_port(haddr, hport, backlog, &bfd);
if (result < 0)
{
{
if (config->hport[i])
{
- sockets[i] = bind_port_helper(config->haddr[i], config->hport[i]);
+ sockets[i] = bind_port_helper(config->haddr[i],
+ config->hport[i], config->listen_backlog);
+#if defined(FEATURE_ACCEPT_FILTER) && defined(SO_ACCEPTFILTER)
+ if (config->enable_accept_filter && sockets[i] != JB_INVALID_SOCKET)
+ {
+ struct accept_filter_arg af_options;
+ bzero(&af_options, sizeof(af_options));
+ strlcpy(af_options.af_name, "httpready", sizeof(af_options.af_name));
+ if (setsockopt(sockets[i], SOL_SOCKET, SO_ACCEPTFILTER, &af_options,
+ sizeof(af_options)))
+ {
+ log_error(LOG_LEVEL_ERROR,
+ "Enabling accept filter for socket %d failed: %E", sockets[i]);
+ }
+ }
+#endif
}
else
{
jb_socket bfds[MAX_LISTENING_SOCKETS];
struct configuration_spec *config;
unsigned int active_threads = 0;
+#if defined(FEATURE_PTHREAD)
+ pthread_attr_t attrs;
+
+ pthread_attr_init(&attrs);
+ pthread_attr_setdetachstate(&attrs, PTHREAD_CREATE_DETACHED);
+#endif
config = load_config();
* new one.
*
* Which-ever is correct, we will serve 1 more page via the
- * old settings. This should probably be a "show-proxy-args"
+ * old settings. This should probably be a "show-status"
* request. This should not be a so common of an operation
* that this will hurt people's feelings.
*/
#define SELECTED_ONE_OPTION
{
pthread_t the_thread;
- pthread_attr_t attrs;
- pthread_attr_init(&attrs);
- pthread_attr_setdetachstate(&attrs, PTHREAD_CREATE_DETACHED);
errno = pthread_create(&the_thread, &attrs,
(void * (*)(void *))serve, csp);
child_id = errno ? -1 : 0;
- pthread_attr_destroy(&attrs);
}
#endif
}
}
+#if defined(FEATURE_PTHREAD)
+ pthread_attr_destroy(&attrs);
+#endif
+
/* NOTREACHED unless FEATURE_GRACEFUL_TERMINATION is defined */
/* Clean up. Aim: free all memory (no leaks) */
projects / privoxy.git / blobdiff