-const char jcc_rcs[] = "$Id: jcc.c,v 1.287 2009/09/09 17:12:08 fabiankeil Exp $";
+const char jcc_rcs[] = "$Id: jcc.c,v 1.306 2009/12/22 13:04:10 fabiankeil Exp $";
/*********************************************************************
*
* File : $Source: /cvsroot/ijbswa/current/jcc.c,v $
status_code[2] = rsp->head[11];
status_code[3] = '\0';
+ /* Log that the request was crunched and why. */
+ log_error(LOG_LEVEL_CRUNCH, "%s: %s", crunch_reason(rsp), http->url);
+ log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" %s %u",
+ csp->ip_addr_str, http->ocmd, status_code, rsp->content_length);
+
/* Write the answer to the client */
if (write_socket(csp->cfd, rsp->head, rsp->head_length)
|| write_socket(csp->cfd, rsp->body, rsp->content_length))
{
/* There is nothing we can do about it. */
- log_error(LOG_LEVEL_ERROR, "write to: %s failed: %E", csp->http->host);
+ log_error(LOG_LEVEL_ERROR,
+ "Couldn't deliver the error message through client socket %d: %E",
+ csp->cfd);
}
- /* Log that the request was crunched and why. */
- log_error(LOG_LEVEL_CRUNCH, "%s: %s", crunch_reason(rsp), http->url);
- log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" %s %u",
- csp->ip_addr_str, http->ocmd, status_code, rsp->content_length);
-
/* Clean up and return */
if (cgi_error_memory() != rsp)
{
*********************************************************************/
static void mark_server_socket_tainted(struct client_state *csp)
{
- if ((csp->flags & CSP_FLAG_SERVER_CONNECTION_KEEP_ALIVE))
+ if ((csp->flags & CSP_FLAG_SERVER_CONNECTION_KEEP_ALIVE)
+ && !(csp->flags |= CSP_FLAG_SERVER_SOCKET_TAINTED))
{
log_error(LOG_LEVEL_CONNECT,
- "Marking the server socket %d tainted.", csp->sfd);
+ "Marking the server socket %d tainted.",
+ csp->server_connection.sfd);
csp->flags |= CSP_FLAG_SERVER_SOCKET_TAINTED;
}
}
{
if (!data_is_available(csp->cfd, csp->config->socket_timeout))
{
- log_error(LOG_LEVEL_ERROR,
- "Stopped waiting for the request line.");
+ log_error(LOG_LEVEL_CONNECT,
+ "Stopped waiting for the request line. Timeout: %d.",
+ csp->config->socket_timeout);
write_socket(csp->cfd, CLIENT_CONNECTION_TIMEOUT_RESPONSE,
strlen(CLIENT_CONNECTION_TIMEOUT_RESPONSE));
return NULL;
req = get_request_line(csp);
if (req == NULL)
{
+ mark_server_socket_tainted(csp);
return JB_ERR_PARSE;
}
assert(*req != '\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 = 1;
+#endif
memset(buf, 0, sizeof(buf));
/* here we connect to the server, gateway, or the forwarder */
#ifdef FEATURE_CONNECTION_KEEP_ALIVE
- if ((csp->sfd != JB_INVALID_SOCKET)
- && socket_is_still_usable(csp->sfd)
+ if ((csp->server_connection.sfd != JB_INVALID_SOCKET)
+ && socket_is_still_usable(csp->server_connection.sfd)
&& connection_destination_matches(&csp->server_connection, http, fwd))
{
log_error(LOG_LEVEL_CONNECT,
"Reusing server socket %u. Opened for %s.",
- csp->sfd, csp->server_connection.host);
+ csp->server_connection.sfd, csp->server_connection.host);
}
else
{
- if (csp->sfd != JB_INVALID_SOCKET)
+ if (csp->server_connection.sfd != JB_INVALID_SOCKET)
{
log_error(LOG_LEVEL_CONNECT,
"Closing server socket %u. Opened for %s.",
- csp->sfd, csp->server_connection.host);
- close_socket(csp->sfd);
+ csp->server_connection.sfd, csp->server_connection.host);
+ close_socket(csp->server_connection.sfd);
mark_connection_closed(&csp->server_connection);
}
#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
- while ((csp->sfd = forwarded_connect(fwd, http, csp))
+ while ((csp->server_connection.sfd = forwarded_connect(fwd, http, csp))
&& (errno == EINVAL)
&& (forwarded_connect_retries++ < max_forwarded_connect_retries))
{
forwarded_connect_retries, http->hostport);
}
- if (csp->sfd == JB_INVALID_SOCKET)
+ if (csp->server_connection.sfd == JB_INVALID_SOCKET)
{
if (fwd->type != SOCKS_NONE)
{
return;
}
#ifdef FEATURE_CONNECTION_KEEP_ALIVE
- save_connection_destination(csp->sfd, http, fwd, &csp->server_connection);
- csp->server_connection.keep_alive_timeout = (unsigned)csp->config->keep_alive_timeout;
+ save_connection_destination(csp->server_connection.sfd,
+ http, fwd, &csp->server_connection);
+ csp->server_connection.keep_alive_timeout =
+ (unsigned)csp->config->keep_alive_timeout;
}
#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
* Write the client's (modified) header to the server
* (along with anything else that may be in the buffer)
*/
- if (write_socket(csp->sfd, hdr, strlen(hdr))
- || (flush_socket(csp->sfd, csp->iob) < 0))
+ if (write_socket(csp->server_connection.sfd, hdr, strlen(hdr))
+ || (flush_socket(csp->server_connection.sfd, csp->iob) < 0))
{
log_error(LOG_LEVEL_CONNECT,
"write header to: %s failed: %E", http->hostport);
/* we're finished with the client's header */
freez(hdr);
- maxfd = (csp->cfd > csp->sfd) ? csp->cfd : csp->sfd;
+ maxfd = (csp->cfd > csp->server_connection.sfd) ?
+ csp->cfd : csp->server_connection.sfd;
/* pass data between the client and server
* until one or the other shuts down the connection.
FD_ZERO(&rfds);
#endif
#ifdef FEATURE_CONNECTION_KEEP_ALIVE
- if ((csp->flags & CSP_FLAG_CLIENT_REQUEST_COMPLETELY_READ))
+ if (!watch_client_socket)
{
- maxfd = csp->sfd;
+ maxfd = csp->server_connection.sfd;
}
else
#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
FD_SET(csp->cfd, &rfds);
}
- FD_SET(csp->sfd, &rfds);
+ FD_SET(csp->server_connection.sfd, &rfds);
#ifdef FEATURE_CONNECTION_KEEP_ALIVE
if ((csp->flags & CSP_FLAG_CHUNKED)
}
if (server_body && server_response_is_complete(csp, byte_count))
{
- log_error(LOG_LEVEL_CONNECT,
- "Done reading from server. Expected content length: %llu. "
- "Actual content length: %llu. Most recently received: %d.",
- csp->expected_content_length, byte_count, len);
+ if (csp->expected_content_length == byte_count)
+ {
+ log_error(LOG_LEVEL_CONNECT,
+ "Done reading from server. Content length: %llu as expected. "
+ "Bytes most recently read: %d.",
+ byte_count, len);
+ }
+ else
+ {
+ log_error(LOG_LEVEL_CONNECT,
+ "Done reading from server. Expected content length: %llu. "
+ "Actual content length: %llu. Bytes most recently read: %d.",
+ csp->expected_content_length, byte_count, len);
+ }
len = 0;
/*
* XXX: should not jump around,
int max_bytes_to_read = sizeof(buf) - 1;
#ifdef FEATURE_CONNECTION_KEEP_ALIVE
+ if ((csp->flags & CSP_FLAG_CLIENT_REQUEST_COMPLETELY_READ))
+ {
+ if (data_is_available(csp->cfd, 0))
+ {
+ /*
+ * If the next request is already waiting, we have
+ * to stop select()ing the client socket. Otherwise
+ * we would always return right away and get nothing
+ * else done.
+ */
+ watch_client_socket = 0;
+ log_error(LOG_LEVEL_CONNECT,
+ "Stopping to watch the client socket. "
+ "There's already another request waiting.");
+ continue;
+ }
+ /*
+ * If the client socket is set, but there's no data
+ * available on the socket, the client went fishing
+ * and continuing talking to the server makes no sense.
+ */
+ log_error(LOG_LEVEL_CONNECT,
+ "The client closed socket %d while "
+ "the server socket %d is still open.",
+ csp->cfd, csp->server_connection.sfd);
+ mark_server_socket_tainted(csp);
+ break;
+ }
if (csp->expected_client_content_length != 0)
{
if (csp->expected_client_content_length < (sizeof(buf) - 1))
}
#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
- if (write_socket(csp->sfd, buf, (size_t)len))
+ if (write_socket(csp->server_connection.sfd, buf, (size_t)len))
{
log_error(LOG_LEVEL_ERROR, "write to: %s failed: %E", http->host);
mark_server_socket_tainted(csp);
* If `hdr' is null, then it's the header otherwise it's the body.
* FIXME: Does `hdr' really mean `host'? No.
*/
- if (FD_ISSET(csp->sfd, &rfds))
+ if (FD_ISSET(csp->server_connection.sfd, &rfds))
{
#ifdef FEATURE_CONNECTION_KEEP_ALIVE
if (!socket_is_still_usable(csp->cfd))
#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
fflush(NULL);
- len = read_socket(csp->sfd, buf, sizeof(buf) - 1);
+ len = read_socket(csp->server_connection.sfd, buf, sizeof(buf) - 1);
if (len < 0)
{
* we can parse the headers we just continue here.
*/
log_error(LOG_LEVEL_CONNECT,
- "Continuing buffering headers. Most recently received: %d",
+ "Continuing buffering headers. Bytes most recently read: %d.",
len);
continue;
}
/* Did we actually get anything? */
if (NULL == csp->headers->first)
{
- log_error(LOG_LEVEL_ERROR,
- "Empty server or forwarder response received on socket %d.", csp->sfd);
+ if ((csp->flags & CSP_FLAG_REUSED_CLIENT_CONNECTION))
+ {
+ log_error(LOG_LEVEL_ERROR,
+ "Empty server or forwarder response received on socket %d. "
+ "Closing client connection %d without sending data.",
+ csp->server_connection.sfd, csp->cfd);
+ }
+ else
+ {
+ log_error(LOG_LEVEL_ERROR,
+ "Empty server or forwarder response received on socket %d.",
+ csp->server_connection.sfd);
+ send_crunch_response(csp, error_response(csp, "no-server-data"));
+ }
log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 502 0", csp->ip_addr_str, http->cmd);
- send_crunch_response(csp, error_response(csp, "no-server-data"));
free_http_request(http);
mark_server_socket_tainted(csp);
return;
static int monitor_thread_running = 0;
#endif /* def FEATURE_CONNECTION_SHARING */
int continue_chatting = 0;
- unsigned int latency = 0;
do
{
+ unsigned int latency;
+
chat(csp);
+ latency = (unsigned)(csp->server_connection.response_received -
+ csp->server_connection.request_sent) / 2;
+
continue_chatting = (csp->config->feature_flags
& RUNTIME_FEATURE_CONNECTION_KEEP_ALIVE)
&& (csp->flags & CSP_FLAG_SERVER_CONNECTION_KEEP_ALIVE)
&& !(csp->flags & CSP_FLAG_SERVER_SOCKET_TAINTED)
&& (csp->cfd != JB_INVALID_SOCKET)
- && (csp->sfd != JB_INVALID_SOCKET)
- && socket_is_still_usable(csp->sfd)
- && (latency < csp->server_connection.keep_alive_timeout);
+ && (csp->server_connection.sfd != JB_INVALID_SOCKET)
+ && socket_is_still_usable(csp->server_connection.sfd);
if (continue_chatting)
{
- unsigned int client_timeout;
-
if (!(csp->flags & CSP_FLAG_SERVER_KEEP_ALIVE_TIMEOUT_SET))
{
- log_error(LOG_LEVEL_CONNECT, "The server didn't specify how long "
- "the connection will stay open. Assume it's only a second.");
- csp->server_connection.keep_alive_timeout = 1;
+ csp->server_connection.keep_alive_timeout = csp->config->default_server_timeout;
+ log_error(LOG_LEVEL_CONNECT,
+ "The server didn't specify how long the connection will stay open. "
+ "Assumed timeout is: %u.", csp->server_connection.keep_alive_timeout);
}
+ continue_chatting = (latency < csp->server_connection.keep_alive_timeout);
+ }
+
+ if (continue_chatting)
+ {
+ unsigned int client_timeout;
client_timeout = (unsigned)csp->server_connection.keep_alive_timeout - latency;
log_error(LOG_LEVEL_CONNECT,
- "Waiting for the next client request. "
+ "Waiting for the next client request on socket %d. "
"Keeping the server socket %d to %s open.",
- csp->sfd, csp->server_connection.host);
-
+ csp->cfd, csp->server_connection.sfd, csp->server_connection.host);
if ((csp->flags & CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE)
&& data_is_available(csp->cfd, (int)client_timeout)
&& socket_is_still_usable(csp->cfd))
{
log_error(LOG_LEVEL_CONNECT, "Client request arrived in "
- "time or the client closed the connection.");
+ "time or the client closed the connection on socket %d.",
+ csp->cfd);
/*
* Get the csp in a mostly vergin state again.
* XXX: Should be done elsewhere.
}
/* XXX: Store per-connection flags someplace else. */
- csp->flags = CSP_FLAG_ACTIVE | (csp->flags & CSP_FLAG_TOGGLED_ON);
+ csp->flags = CSP_FLAG_ACTIVE |
+ (csp->flags & CSP_FLAG_TOGGLED_ON) | CSP_FLAG_REUSED_CLIENT_CONNECTION;
}
else
{
log_error(LOG_LEVEL_CONNECT,
- "No additional client request received in time.");
+ "No additional client request received in time on socket %d.",
+ csp->cfd);
#ifdef FEATURE_CONNECTION_SHARING
if ((csp->config->feature_flags & RUNTIME_FEATURE_CONNECTION_SHARING)
- && (socket_is_still_usable(csp->sfd)))
+ && (socket_is_still_usable(csp->server_connection.sfd)))
{
- remember_connection(csp, forward_url(csp, csp->http));
- csp->sfd = JB_INVALID_SOCKET;
+ time_t time_open = time(NULL) - csp->server_connection.timestamp;
+
+ if (csp->server_connection.keep_alive_timeout < time_open + latency)
+ {
+ break;
+ }
+
+ remember_connection(&csp->server_connection);
+ csp->server_connection.sfd = JB_INVALID_SOCKET;
close_socket(csp->cfd);
csp->cfd = JB_INVALID_SOCKET;
privoxy_mutex_lock(&connection_reuse_mutex);
break;
}
}
- else if (csp->sfd != JB_INVALID_SOCKET)
+ else if (csp->server_connection.sfd != JB_INVALID_SOCKET)
{
log_error(LOG_LEVEL_CONNECT,
"The connection on server socket %d to %s isn't reusable. "
- "Closing.", csp->sfd, csp->server_connection.host);
+ "Closing.", csp->server_connection.sfd, csp->server_connection.host);
}
} while (continue_chatting);
- mark_connection_closed(&csp->server_connection);
#else
chat(csp);
#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
- if (csp->sfd != JB_INVALID_SOCKET)
+ if (csp->server_connection.sfd != JB_INVALID_SOCKET)
{
#ifdef FEATURE_CONNECTION_SHARING
- forget_connection(csp->sfd);
+ if (csp->config->feature_flags & RUNTIME_FEATURE_CONNECTION_SHARING)
+ {
+ forget_connection(csp->server_connection.sfd);
+ }
#endif /* def FEATURE_CONNECTION_SHARING */
- close_socket(csp->sfd);
+ close_socket(csp->server_connection.sfd);
}
+#ifdef FEATURE_CONNECTION_KEEP_ALIVE
+ mark_connection_closed(&csp->server_connection);
+#endif
+
if (csp->cfd != JB_INVALID_SOCKET)
{
close_socket(csp->cfd);
#if defined(unix)
{
pid_t pid = 0;
-#if 0
- int fd;
-#endif
if (!no_daemon)
{
exit( 0 );
}
/* child */
-#if 1
- /* Should be more portable, but not as well tested */
+
setsid();
-#else /* !1 */
-#ifdef __FreeBSD__
- setpgrp(0,0);
-#else /* ndef __FreeBSD__ */
- setpgrp();
-#endif /* ndef __FreeBSD__ */
- fd = open("/dev/tty", O_RDONLY);
- if ( fd )
- {
- /* no error check here */
- ioctl( fd, TIOCNOTTY,0 );
- close ( fd );
- }
-#endif /* 1 */
+
/*
* stderr (fd 2) will be closed later on,
* when the config file has been parsed.
}
csp->flags |= CSP_FLAG_ACTIVE;
- csp->sfd = JB_INVALID_SOCKET;
+ csp->server_connection.sfd = JB_INVALID_SOCKET;
csp->config = config = load_config();