-const char jcc_rcs[] = "$Id: jcc.c,v 1.462 2017/06/26 12:10:31 fabiankeil Exp $";
/*********************************************************************
*
* File : $Source: /cvsroot/ijbswa/current/jcc.c,v $
# 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
*
* 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 *receive_buffer;
char *hdr;
char *p;
int n;
#ifdef FEATURE_CONNECTION_KEEP_ALIVE
int watch_client_socket;
#endif
- const size_t receive_buffer_size = csp->config->receive_buffer_size;
- receive_buffer = zalloc(receive_buffer_size + 1);
- if (receive_buffer == NULL)
+ 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.");
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"));
}
mark_server_socket_tainted(csp);
- freez(receive_buffer);
return;
}
else if (n < 0)
log_error(LOG_LEVEL_ERROR, "select() failed!: %E");
#endif
mark_server_socket_tainted(csp);
- freez(receive_buffer);
return;
}
if (FD_ISSET(csp->cfd, &rfds))
#endif /* def HAVE_POLL*/
{
- int max_bytes_to_read = (int)receive_buffer_size;
+ 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 < receive_buffer_size)
+ 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 <= receive_buffer_size);
+ assert(max_bytes_to_read <= csp->receive_buffer_size);
#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
- len = read_socket(csp->cfd, receive_buffer, 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, receive_buffer, (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);
- freez(receive_buffer);
return;
}
continue;
log_error(LOG_LEVEL_CONNECT,
"The server still wants to talk, but the client hung up on us.");
mark_server_socket_tainted(csp);
- freez(receive_buffer);
return;
#endif /* def _WIN32 */
}
#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
- len = read_socket(csp->server_connection.sfd, receive_buffer, (int)receive_buffer_size);
+ 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
*/
log_error(LOG_LEVEL_ERROR,
"CONNECT already confirmed. Unable to tell the client about the problem.");
- freez(receive_buffer);
return;
}
else if (byte_count)
log_error(LOG_LEVEL_ERROR, "Already forwarded the original headers. "
"Unable to tell the client about the problem.");
mark_server_socket_tainted(csp);
- freez(receive_buffer);
return;
}
/*
#ifdef FEATURE_CONNECTION_KEEP_ALIVE
if (csp->flags & CSP_FLAG_CHUNKED)
{
- if ((len >= 5) && !memcmp(receive_buffer+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,
* This is guaranteed by allocating with zalloc_or_die()
* and never (intentionally) writing to the last byte.
*
- * receive_buffer_size is the size of the part of the
+ * csp->receive_buffer_size is the size of the part of the
* buffer we intentionally write to, but we actually
- * allocated receive_buffer_size+1 bytes so the assertion
+ * allocated csp->receive_buffer_size+1 bytes so the assertion
* stays within the allocated range.
*/
- assert(receive_buffer[receive_buffer_size] == '\0');
+ 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?
*/
- assert(len <= receive_buffer_size);
- receive_buffer[len] = '\0';
+ assert(len <= csp->receive_buffer_size);
+ csp->receive_buffer[len] = '\0';
/*
* Normally, this would indicate that we've read
freez(hdr);
freez(p);
mark_server_socket_tainted(csp);
- freez(receive_buffer);
return;
}
* This is NOT the body, so
* Let's pretend the server just sent us a blank line.
*/
- snprintf(receive_buffer, receive_buffer_size, "\r\n");
- len = (int)strlen(receive_buffer);
+ 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, receive_buffer, len))
+ if (add_to_iob(csp->iob, csp->config->buffer_limit, csp->receive_buffer, len))
{
size_t hdrlen;
long flushed;
rsp = cgi_error_memory();
send_crunch_response(csp, rsp);
mark_server_socket_tainted(csp);
- freez(receive_buffer);
return;
}
hdrlen = strlen(hdr);
if (write_socket(csp->cfd, hdr, hdrlen)
|| ((flushed = flush_socket(csp->cfd, csp->iob)) < 0)
- || (write_socket(csp->cfd, receive_buffer, (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");
freez(hdr);
mark_server_socket_tainted(csp);
- freez(receive_buffer);
return;
}
}
else
{
- if (write_socket(csp->cfd, receive_buffer, (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);
- freez(receive_buffer);
return;
}
}
* 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, receive_buffer, 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();
send_crunch_response(csp, rsp);
mark_server_socket_tainted(csp);
- freez(receive_buffer);
return;
}
write_socket(csp->cfd, INVALID_SERVER_HEADERS_RESPONSE,
strlen(INVALID_SERVER_HEADERS_RESPONSE));
mark_server_socket_tainted(csp);
- freez(receive_buffer);
return;
}
else
}
free_http_request(http);
mark_server_socket_tainted(csp);
- freez(receive_buffer);
return;
}
strlen(INVALID_SERVER_HEADERS_RESPONSE));
free_http_request(http);
mark_server_socket_tainted(csp);
- freez(receive_buffer);
return;
}
hdr = list_to_text(csp->headers);
*/
freez(hdr);
mark_server_socket_tainted(csp);
- freez(receive_buffer);
return;
}
/* Buffer and pcrs filter this if appropriate. */
*/
freez(hdr);
mark_server_socket_tainted(csp);
- freez(receive_buffer);
return;
}
}
write_socket(csp->cfd, INVALID_SERVER_HEADERS_RESPONSE,
strlen(INVALID_SERVER_HEADERS_RESPONSE));
mark_server_socket_tainted(csp);
- freez(receive_buffer);
return;
}
}
continue;
}
mark_server_socket_tainted(csp);
- freez(receive_buffer);
return; /* huh? we should never get here */
}
- freez(receive_buffer);
if (csp->content_length == 0)
{
/* 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;
}
* 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)
{
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();
#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) */