Keep a thread around to timeout alive connections
[privoxy.git] / jcc.c
diff --git a/jcc.c b/jcc.c
index 0d82c1d..f9d39e6 100644 (file)
--- a/jcc.c
+++ b/jcc.c
@@ -1,4 +1,4 @@
-const char jcc_rcs[] = "$Id: jcc.c,v 1.194 2008/10/12 18:35:18 fabiankeil Exp $";
+const char jcc_rcs[] = "$Id: jcc.c,v 1.214 2008/12/20 14:53:55 fabiankeil Exp $";
 /*********************************************************************
  *
  * File        :  $Source: /cvsroot/ijbswa/current/jcc.c,v $
@@ -33,6 +33,87 @@ const char jcc_rcs[] = "$Id: jcc.c,v 1.194 2008/10/12 18:35:18 fabiankeil Exp $"
  *
  * Revisions   :
  *    $Log: jcc.c,v $
+ *    Revision 1.214  2008/12/20 14:53:55  fabiankeil
+ *    Add config option socket-timeout to control the time
+ *    Privoxy waits for data to arrive on a socket. Useful
+ *    in case of stale ssh tunnels or when fuzz-testing.
+ *
+ *    Revision 1.213  2008/12/15 18:45:51  fabiankeil
+ *    When logging crunches, log the whole URL, so one can easily
+ *    differentiate between vanilla HTTP and CONNECT requests.
+ *
+ *    Revision 1.212  2008/12/14 15:46:22  fabiankeil
+ *    Give crunched requests their own log level.
+ *
+ *    Revision 1.211  2008/12/06 10:05:03  fabiankeil
+ *    Downgrade "Received x bytes while expecting y." message to
+ *    LOG_LEVEL_CONNECT as it doesn't necessarily indicate an error.
+ *
+ *    Revision 1.210  2008/12/02 22:03:18  fabiankeil
+ *    Don't miscalculate byte_count if we don't get all the
+ *    server headers with one read_socket() call. With keep-alive
+ *    support enabled, this caused delays until the server closed
+ *    the connection.
+ *
+ *    Revision 1.209  2008/11/27 09:44:04  fabiankeil
+ *    Cosmetics for the last commit: Don't watch out for
+ *    the last chunk if the content isn't chunk-encoded or
+ *    if we already determined the content length previously.
+ *
+ *    Revision 1.208  2008/11/26 18:24:17  fabiankeil
+ *    Recognize that the server response is complete if the
+ *    last chunk is read together with the server headers.
+ *    Reported by Lee.
+ *
+ *    Revision 1.207  2008/11/25 17:25:16  fabiankeil
+ *    Don't convert the client-header list to text until we need to.
+ *
+ *    Revision 1.206  2008/11/23 17:00:11  fabiankeil
+ *    Some more chat() cosmetics.
+ *
+ *    Revision 1.205  2008/11/16 12:43:49  fabiankeil
+ *    Turn keep-alive support into a runtime feature
+ *    that is disabled by setting keep-alive-timeout
+ *    to a negative value.
+ *
+ *    Revision 1.204  2008/11/06 19:42:17  fabiankeil
+ *    Fix last-chunk detection hack to also apply
+ *    if buf[] contains nothing but the last-chunk.
+ *
+ *    Revision 1.203  2008/11/06 18:34:35  fabiankeil
+ *    Factor receive_client_request() and
+ *    parse_client_request() out of chat().
+ *
+ *    Revision 1.202  2008/11/02 18:40:34  fabiankeil
+ *    If we received a different amount of data than we expected,
+ *    log a warning and make sure the server socket isn't reused.
+ *
+ *    Revision 1.201  2008/11/02 16:48:20  fabiankeil
+ *    Revert revision 1.195 and try again.
+ *
+ *    Revision 1.200  2008/10/26 16:53:18  fabiankeil
+ *    Fix gcc44 warning.
+ *
+ *    Revision 1.199  2008/10/26 15:36:10  fabiankeil
+ *    Remove two debug messages with LOG_LEVEL_INFO.
+ *
+ *    Revision 1.198  2008/10/22 15:19:55  fabiankeil
+ *    Once More, With Feeling: if there is no logfile
+ *    because the user didn't specify one, we shouldn't
+ *    call init_error_log() after receiving SIGHUP either.
+ *
+ *    Revision 1.197  2008/10/20 17:02:40  fabiankeil
+ *    If SIGHUP is received while we aren't running in daemon
+ *    mode, calling init_error_log() would be a mistake.
+ *
+ *    Revision 1.196  2008/10/16 09:16:41  fabiankeil
+ *    - Fix two gcc44 conversion warnings.
+ *    - Don't bother logging the last five bytes
+ *      of the 0-chunk.
+ *
+ *    Revision 1.195  2008/10/13 16:04:37  fabiankeil
+ *    Make sure we don't try to reuse tainted server sockets.
+ *
  *    Revision 1.194  2008/10/12 18:35:18  fabiankeil
  *    The last commit was a bit too ambitious, apparently the content
  *    length adjustment is only necessary if we aren't buffering.
@@ -1172,9 +1253,9 @@ static jb_err get_request_destination_elsewhere(struct client_state *csp, struct
 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(const struct client_state *csp, struct http_response *rsp);
-/*
- * static int request_contains_null_bytes(const struct client_state *csp, char *buf, int len);
- */
+static char *get_request_line(struct client_state *csp);
+static jb_err receive_client_request(struct client_state *csp);
+static jb_err parse_client_request(struct client_state *csp);
 static void build_request_line(struct client_state *csp, const struct forward_spec *fwd, char **request_line);
 static jb_err change_request_destination(struct client_state *csp);
 static void chat(struct client_state *csp);
@@ -1752,8 +1833,7 @@ static void send_crunch_response(const struct client_state *csp, struct http_res
       }
 
       /* Log that the request was crunched and why. */
-      log_error(LOG_LEVEL_GPC, "%s%s crunch! (%s)",
-         http->hostport, http->path, crunch_reason(rsp));
+      log_error(LOG_LEVEL_CRUNCH, "%s: %s", crunch_reason(rsp), http->url);
       log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" %s %d",
          csp->ip_addr_str, http->ocmd, status_code, rsp->content_length);
 
@@ -2027,7 +2107,6 @@ static int server_response_is_complete(struct client_state *csp, size_t content_
        * "HEAD" implies no body, we are thus expecting
        * no content. XXX: incomplete "list" of methods?
        */
-      log_error(LOG_LEVEL_INFO, "Method %s implies no body.", csp->http->gpc);
       csp->expected_content_length = 0;
       content_length_known = TRUE;
    }
@@ -2037,7 +2116,6 @@ static int server_response_is_complete(struct client_state *csp, size_t content_
       /*
        * Expect no body. XXX: incomplete "list" of status codes?
        */
-      log_error(LOG_LEVEL_INFO, "Status code %d implies no body.", csp->http->status);
       csp->expected_content_length = 0;
       content_length_known = TRUE;
    }
@@ -2047,69 +2125,61 @@ static int server_response_is_complete(struct client_state *csp, size_t content_
 }
 #endif /* FEATURE_CONNECTION_KEEP_ALIVE */
 
-
 /*********************************************************************
  *
- * Function    :  chat
+ * Function    :  mark_server_socket_tainted
  *
- * Description :  Once a connection to the client has been accepted,
- *                this function is called (via serve()) to handle the
- *                main business of the communication.  When this
- *                function returns, the caller must close the client
- *                socket handle.
+ * Description :  Makes sure we don't reuse a server socket
+ *                (if we didn't read everything the server sent
+ *                us reusing the socket would lead to garbage).
  *
- *                FIXME: chat is nearly thousand lines long.
- *                Ridiculous.
+ * Parameters  :
+ *          1  :  csp = Current client state (buffers, headers, etc...)
+ *
+ * Returns     :  void.
+ *
+ *********************************************************************/
+static void mark_server_socket_tainted(struct client_state *csp)
+{
+   if ((csp->flags & CSP_FLAG_SERVER_CONNECTION_KEEP_ALIVE))
+   {
+      log_error(LOG_LEVEL_CONNECT, "Unsetting keep-alive flag.");
+      csp->flags &= ~CSP_FLAG_SERVER_CONNECTION_KEEP_ALIVE;
+   }
+}
+
+/*********************************************************************
+ *
+ * Function    :  get_request_line
+ *
+ * Description : Read the client request line.
  *
  * Parameters  :
  *          1  :  csp = Current client state (buffers, headers, etc...)
  *
- * Returns     :  Nothing.
+ * Returns     :  Pointer to request line or NULL in case of errors.
  *
  *********************************************************************/
-static void chat(struct client_state *csp)
+static char *get_request_line(struct client_state *csp)
 {
    char buf[BUFFER_SIZE];
-   char *hdr;
-   char *p;
-   char *req = NULL;
-   fd_set rfds;
-   int n;
-   jb_socket maxfd;
-   int server_body;
-   int ms_iis5_hack = 0;
-   size_t byte_count = 0;
-   int forwarded_connect_retries = 0;
-   int max_forwarded_connect_retries = csp->config->forwarded_connect_retries;
-   const struct forward_spec * fwd;
-   struct http_request *http;
-   int len; /* for buffer sizes (and negative error codes) */
-   jb_err err;
-
-   /* Function that does the content filtering for the current request */
-   filter_function_ptr content_filter = NULL;
-
-   /* Skeleton for HTTP response, if we should intercept the request */
-   struct http_response *rsp;
-
-   /* Temporary copy of the client's headers before they get enlisted in csp->headers */
-   struct list header_list;
-   struct list *headers = &header_list;
-
-   http = csp->http;
+   char *request_line = NULL;
+   int len;
 
    memset(buf, 0, sizeof(buf));
 
-   /*
-    * Read the client's request.  Note that since we're not using select() we
-    * could get blocked here if a client connected, then didn't say anything!
-    */
-
    do
    {
+      if (!data_is_available(csp->cfd, csp->config->socket_timeout))
+      {
+         log_error(LOG_LEVEL_ERROR,
+            "Stopped waiting for the request line.");
+         return '\0';
+      }
+
       len = read_socket(csp->cfd, buf, sizeof(buf) - 1);
 
-      if (len <= 0) break;      /* error! */
+      if (len <= 0) return NULL;
 
       /*
        * If there is no memory left for buffering the
@@ -2117,41 +2187,58 @@ static void chat(struct client_state *csp)
        */
       if (add_to_iob(csp, buf, len))
       {
-         return;
+         return NULL;
       }
 
-      req = get_header(csp->iob);
+      request_line = get_header(csp->iob);
+
+   } while ((NULL != request_line) && ('\0' == *request_line));
+
+   return request_line;
+
+}
+
+
+/*********************************************************************
+ *
+ * Function    :  receive_client_request
+ *
+ * Description : Read the client's request (more precisely the
+ *               client headers) and answer it if necessary.
+ *
+ *               Note that since we're not using select() we could get
+ *               blocked here if a client connected, then didn't say
+ *               anything!
+ *
+ * Parameters  :
+ *          1  :  csp = Current client state (buffers, headers, etc...)
+ *
+ * Returns     :  JB_ERR_OK, JB_ERR_PARSE or JB_ERR_MEMORY
+ *
+ *********************************************************************/
+static jb_err receive_client_request(struct client_state *csp)
+{
+   char buf[BUFFER_SIZE];
+   char *p;
+   char *req = NULL;
+   struct http_request *http;
+   int len;
+   jb_err err;
+
+   /* Temporary copy of the client's headers before they get enlisted in csp->headers */
+   struct list header_list;
+   struct list *headers = &header_list;
 
-   } while ((NULL != req) && ('\0' == *req));
+   http = csp->http;
+
+   memset(buf, 0, sizeof(buf));
+
+   req = get_request_line(csp);
 
    if ((NULL != req) && ('\0' != *req))
    {
       /* Request received. Validate and parse it. */
 
-#if 0
-      /*
-       * XXX: Temporary disabled to prevent problems
-       * with POST requests whose bodies are allowed to
-       * contain NULL bytes. BR#1730105.
-       *
-       * The main purpose of this check is to properly
-       * log stuff like BitTorrent traffic and other junk
-       * that hits public proxies. It's not required for
-       * Privoxy to functions as those requests are discarded
-       * later on anyway.
-       *
-       * It probably should be rewritten to only check
-       * the head of the request. Another option would
-       * be to let all POST requests pass, although that
-       * may not be good enough.
-       */
-      if (request_contains_null_bytes(csp, buf, len))
-      {
-         /* NULL bytes found and dealt with, just hang up. */
-         return;
-      }
-#endif
-
       /* Does the request line look invalid? */
       if (client_protocol_is_unsupported(csp, req))
       {
@@ -2160,7 +2247,7 @@ static void chat(struct client_state *csp)
           * answered with a error response, the buffers
           * were freed and we're done with chatting.
           */
-         return;
+         return JB_ERR_PARSE;
       }
 
 #ifdef FEATURE_FORCE_LOAD
@@ -2182,8 +2269,8 @@ static void chat(struct client_state *csp)
             csp->flags |= CSP_FLAG_FORCED;
          }
       }
-
 #endif /* def FEATURE_FORCE_LOAD */
+
       err = parse_http_request(req, http, csp);
       if (JB_ERR_OK != err)
       {
@@ -2201,7 +2288,7 @@ static void chat(struct client_state *csp)
       log_error(LOG_LEVEL_ERROR, "Invalid header received from %s.", csp->ip_addr_str);
 
       free_http_request(http);
-      return;
+      return JB_ERR_PARSE;
    }
 
    /* grab the rest of the client's headers */
@@ -2222,12 +2309,19 @@ static void chat(struct client_state *csp)
           * We didn't receive a complete header
           * line yet, get the rest of it.
           */
+         if (!data_is_available(csp->cfd, csp->config->socket_timeout))
+         {
+            log_error(LOG_LEVEL_ERROR,
+               "Stopped grabbing the client headers.");
+            return JB_ERR_PARSE;
+         }
+
          len = read_socket(csp->cfd, buf, sizeof(buf) - 1);
          if (len <= 0)
          {
             log_error(LOG_LEVEL_ERROR, "read from client failed: %E");
             destroy_list(headers);
-            return;
+            return JB_ERR_PARSE;
          }
          
          if (add_to_iob(csp, buf, len))
@@ -2237,7 +2331,7 @@ static void chat(struct client_state *csp)
              * request, there is nothing we can do but hang up
              */
             destroy_list(headers);
-            return;
+            return JB_ERR_MEMORY;
          }
       }
       else
@@ -2268,7 +2362,7 @@ static void chat(struct client_state *csp)
           * An error response has already been send
           * and we're done here.
           */
-         return;
+         return JB_ERR_PARSE;
       }
    }
 
@@ -2291,23 +2385,50 @@ static void chat(struct client_state *csp)
     * Save a copy of the original request for logging
     */
    http->ocmd = strdup(http->cmd);
-
    if (http->ocmd == NULL)
    {
-      log_error(LOG_LEVEL_FATAL, "Out of memory copying HTTP request line");
+      log_error(LOG_LEVEL_FATAL,
+         "Out of memory copying HTTP request line");
    }
-
    enlist(csp->headers, http->cmd);
 
    /* Append the previously read headers */
    list_append_list_unique(csp->headers, headers);
    destroy_list(headers);
 
+   return JB_ERR_OK;
+
+}
+
+
+/*********************************************************************
+ *
+ * Function    : parse_client_request
+ *
+ * Description : Parses the client's request and decides what to do
+ *               with it.
+ *
+ *               Note that since we're not using select() we could get
+ *               blocked here if a client connected, then didn't say
+ *               anything!
+ *
+ * Parameters  :
+ *          1  :  csp = Current client state (buffers, headers, etc...)
+ *
+ * Returns     :  JB_ERR_OK or JB_ERR_PARSE
+ *
+ *********************************************************************/
+static jb_err parse_client_request(struct client_state *csp)
+{
+   struct http_request *http = csp->http;
+   jb_err err;
+
    err = sed(csp, FILTER_CLIENT_HEADERS);
    if (JB_ERR_OK != err)
    {
+      /* XXX: Should be handled in sed(). */
       assert(err == JB_ERR_PARSE);
-      log_error(LOG_LEVEL_FATAL, "Failed to parse client headers");
+      log_error(LOG_LEVEL_FATAL, "Failed to parse client headers.");
    }
    csp->flags |= CSP_FLAG_CLIENT_HEADER_PARSING_DONE;
 
@@ -2321,10 +2442,75 @@ static void chat(struct client_state *csp)
        */
       write_socket(csp->cfd, MESSED_UP_REQUEST_RESPONSE, strlen(MESSED_UP_REQUEST_RESPONSE));
       /* XXX: Use correct size */
-      log_error(LOG_LEVEL_CLF, "%s - - [%T] \"Invalid request generated\" 500 0", csp->ip_addr_str);
-      log_error(LOG_LEVEL_ERROR, "Invalid request line after applying header filters.");
-
+      log_error(LOG_LEVEL_CLF,
+         "%s - - [%T] \"Invalid request generated\" 500 0", csp->ip_addr_str);
+      log_error(LOG_LEVEL_ERROR,
+         "Invalid request line after applying header filters.");
       free_http_request(http);
+
+      return JB_ERR_PARSE;
+   }
+
+   return JB_ERR_OK;
+
+}
+
+
+/*********************************************************************
+ *
+ * Function    :  chat
+ *
+ * Description :  Once a connection to the client has been accepted,
+ *                this function is called (via serve()) to handle the
+ *                main business of the communication.  When this
+ *                function returns, the caller must close the client
+ *                socket handle.
+ *
+ *                FIXME: chat is nearly thousand lines long.
+ *                Ridiculous.
+ *
+ * Parameters  :
+ *          1  :  csp = Current client state (buffers, headers, etc...)
+ *
+ * Returns     :  Nothing.
+ *
+ *********************************************************************/
+static void chat(struct client_state *csp)
+{
+   char buf[BUFFER_SIZE];
+   char *hdr;
+   char *p;
+   fd_set rfds;
+   int n;
+   jb_socket maxfd;
+   int server_body;
+   int ms_iis5_hack = 0;
+   size_t byte_count = 0;
+   int forwarded_connect_retries = 0;
+   int max_forwarded_connect_retries = csp->config->forwarded_connect_retries;
+   const struct forward_spec *fwd;
+   struct http_request *http;
+   int len; /* for buffer sizes (and negative error codes) */
+
+   /* Function that does the content filtering for the current request */
+   filter_function_ptr content_filter = NULL;
+
+   /* Skeleton for HTTP response, if we should intercept the request */
+   struct http_response *rsp;
+   struct timeval timeout;
+
+   memset(buf, 0, sizeof(buf));
+   memset(&timeout, 0, sizeof(timeout));
+   timeout.tv_sec = csp->config->socket_timeout;
+
+   http = csp->http;
+
+   if (receive_client_request(csp) != JB_ERR_OK)
+   {
+      return;
+   }
+   if (parse_client_request(csp) != JB_ERR_OK)
+   {
       return;
    }
 
@@ -2391,13 +2577,6 @@ static void chat(struct client_state *csp)
       build_request_line(csp, fwd, &csp->headers->first->str);
    }
 
-   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");
-   }
-
    /*
     * We have a request. Check if one of the crunchers wants it.
     */
@@ -2407,28 +2586,18 @@ static void chat(struct client_state *csp)
        * Yes. The client got the crunch response
        * and we are done here after cleaning up.
        */
-      freez(hdr);
+      /* XXX: why list_remove_all()? */
       list_remove_all(csp->headers);
 
       return;
    }
 
-   /*
-    * The headers can't be removed earlier because
-    * they were still needed for the referrer check
-    * in case of CGI crunches.
-    *
-    * XXX: Would it be worth to move the referrer check
-    * into client_referrer() and set a flag if it's trusted?
-    */
-   list_remove_all(csp->headers);
-
    log_error(LOG_LEVEL_GPC, "%s%s", http->hostport, http->path);
 
    if (fwd->forward_host)
    {
       log_error(LOG_LEVEL_CONNECT, "via %s:%d to: %s",
-               fwd->forward_host, fwd->forward_port, http->hostport);
+         fwd->forward_host, fwd->forward_port, http->hostport);
    }
    else
    {
@@ -2437,11 +2606,13 @@ static void chat(struct client_state *csp)
 
    /* here we connect to the server, gateway, or the forwarder */
 
-   while ( (csp->sfd = forwarded_connect(fwd, http, csp))
-         && (errno == EINVAL) && (forwarded_connect_retries++ < max_forwarded_connect_retries))
+   while ((csp->sfd = forwarded_connect(fwd, http, csp))
+      && (errno == EINVAL)
+      && (forwarded_connect_retries++ < max_forwarded_connect_retries))
    {
-      log_error(LOG_LEVEL_ERROR, "failed request #%u to connect to %s. Trying again.",
-                forwarded_connect_retries, http->hostport);
+      log_error(LOG_LEVEL_ERROR,
+         "failed request #%u to connect to %s. Trying again.",
+         forwarded_connect_retries, http->hostport);
    }
 
    if (csp->sfd == JB_INVALID_SOCKET)
@@ -2459,7 +2630,7 @@ static void chat(struct client_state *csp)
       {
          rsp = error_response(csp, "connect-failed", errno);
          log_error(LOG_LEVEL_CONNECT, "connect to: %s failed: %E",
-                http->hostport);
+            http->hostport);
       }
 
       /* Write the answer to the client */
@@ -2468,10 +2639,17 @@ static void chat(struct client_state *csp)
          send_crunch_response(csp, rsp);
       }
 
-      freez(hdr);
       return;
    }
 
+   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);
+
    if (fwd->forward_host || (http->ssl == 0))
    {
       /*
@@ -2537,6 +2715,18 @@ static void chat(struct client_state *csp)
       FD_SET(csp->sfd, &rfds);
 
 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
+      if ((csp->flags & CSP_FLAG_CHUNKED)
+         && !(csp->flags & CSP_FLAG_CONTENT_LENGTH_SET)
+         && ((csp->iob->eod - csp->iob->cur) >= 5)
+         && !memcmp(csp->iob->eod-5, "0\r\n\r\n", 5))
+      {
+         log_error(LOG_LEVEL_CONNECT,
+            "Looks like we read the last chunk together with "
+            "the server headers. We better stop reading.");
+         byte_count = (size_t)(csp->iob->eod - csp->iob->cur);
+         csp->expected_content_length = byte_count;
+         csp->flags |= CSP_FLAG_CONTENT_LENGTH_SET;
+      }
       if (server_body && server_response_is_complete(csp, byte_count))
       {
          log_error(LOG_LEVEL_CONNECT,
@@ -2552,12 +2742,19 @@ static void chat(struct client_state *csp)
       }
 #endif  /* FEATURE_CONNECTION_KEEP_ALIVE */
 
-      n = select((int)maxfd+1, &rfds, NULL, NULL, NULL);
+      n = select((int)maxfd+1, &rfds, NULL, NULL, &timeout);
 
-      if (n < 0)
+      if (n == 0)
+      {
+         log_error(LOG_LEVEL_ERROR, "Didn't receive data in time.");
+         mark_server_socket_tainted(csp);
+         return;
+      }
+      else if (n < 0)
       {
          log_error(LOG_LEVEL_ERROR, "select() failed!: %E");
-         break;
+         mark_server_socket_tainted(csp);
+         return;
       }
 
       /*
@@ -2570,13 +2767,16 @@ static void chat(struct client_state *csp)
 
          if (len <= 0)
          {
+            /* XXX: not sure if this is necessary. */
+            mark_server_socket_tainted(csp);
             break; /* "game over, man" */
          }
 
          if (write_socket(csp->sfd, buf, (size_t)len))
          {
             log_error(LOG_LEVEL_ERROR, "write to: %s failed: %E", http->host);
-            break;
+            mark_server_socket_tainted(csp);
+            return;
          }
          continue;
       }
@@ -2617,7 +2817,8 @@ static void chat(struct client_state *csp)
                 */
                log_error(LOG_LEVEL_ERROR, "Already forwarded the original headers. "
                   "Unable to tell the client about the problem.");
-               break;
+               mark_server_socket_tainted(csp);
+               return;
             }
 
             rsp = error_response(csp, "connect-failed", errno);
@@ -2632,14 +2833,13 @@ static void chat(struct client_state *csp)
 #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(buf+len-5, "0\r\n\r\n", 5))
             {
                /* XXX: this is a temporary hack */
                log_error(LOG_LEVEL_CONNECT,
-                  "Looks like we reached the end of the last chunk: "
-                  "%d %d %d %d %d. We better stop reading.",
-                  buf[len-5], buf[len-4], buf[len-3], buf[len-2], buf[len-1]);
-               csp->expected_content_length = byte_count + len;
+                  "Looks like we reached the end of the last chunk. "
+                  "We better stop reading.");
+               csp->expected_content_length = byte_count + (size_t)len;
                csp->flags |= CSP_FLAG_CONTENT_LENGTH_SET;
             }
          }
@@ -2713,7 +2913,8 @@ static void chat(struct client_state *csp)
                      log_error(LOG_LEVEL_ERROR, "write modified content to client failed: %E");
                      freez(hdr);
                      freez(p);
-                     break;
+                     mark_server_socket_tainted(csp);
+                     return;
                   }
 
                   freez(hdr);
@@ -2770,7 +2971,8 @@ static void chat(struct client_state *csp)
                      log_error(LOG_LEVEL_ERROR, "Out of memory while trying to flush.");
                      rsp = cgi_error_memory();
                      send_crunch_response(csp, rsp);
-                     break;
+                     mark_server_socket_tainted(csp);
+                     return;
                   }
                   hdrlen = strlen(hdr);
 
@@ -2781,7 +2983,8 @@ static void chat(struct client_state *csp)
                      log_error(LOG_LEVEL_CONNECT,
                         "Flush header and buffers to client failed: %E");
                      freez(hdr);
-                     break;
+                     mark_server_socket_tainted(csp);
+                     return;
                   }
 
                   /*
@@ -2800,7 +3003,8 @@ static void chat(struct client_state *csp)
                if (write_socket(csp->cfd, buf, (size_t)len))
                {
                   log_error(LOG_LEVEL_ERROR, "write to client failed: %E");
-                  break;
+                  mark_server_socket_tainted(csp);
+                  return;
                }
             }
             byte_count += (size_t)len;
@@ -2819,7 +3023,8 @@ static void chat(struct client_state *csp)
                log_error(LOG_LEVEL_ERROR, "Out of memory while looking for end of server headers.");
                rsp = cgi_error_memory();
                send_crunch_response(csp, rsp);               
-               break;
+               mark_server_socket_tainted(csp);
+               return;
             }
 
             header_start = csp->iob->cur;
@@ -2844,6 +3049,12 @@ static void chat(struct client_state *csp)
                    * Since we have to wait for more from the server before
                    * we can parse the headers we just continue here.
                    */
+                  int header_offset = csp->iob->cur - header_start;
+                  assert(csp->iob->cur >= header_start);
+                  byte_count += (size_t)(len - header_offset);
+                  log_error(LOG_LEVEL_CONNECT, "Continuing buffering headers. "
+                     "byte_count: %d. header_offset: %d. len: %d.",
+                     byte_count, header_offset, len);
                   continue;
                }
             }
@@ -2855,7 +3066,8 @@ static void chat(struct client_state *csp)
                log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 502 0", csp->ip_addr_str, http->cmd);
                write_socket(csp->cfd, NO_SERVER_DATA_RESPONSE, strlen(NO_SERVER_DATA_RESPONSE));
                free_http_request(http);
-               break;
+               mark_server_socket_tainted(csp);
+               return;
             }
 
             assert(csp->headers->first->str);
@@ -2879,7 +3091,8 @@ static void chat(struct client_state *csp)
                write_socket(csp->cfd, INVALID_SERVER_HEADERS_RESPONSE,
                   strlen(INVALID_SERVER_HEADERS_RESPONSE));
                free_http_request(http);
-               break;
+               mark_server_socket_tainted(csp);
+               return;
             }
 
             /*
@@ -2906,7 +3119,8 @@ static void chat(struct client_state *csp)
                 * and are done here after cleaning up.
                 */
                 freez(hdr);
-                break;
+                mark_server_socket_tainted(csp);
+                return;
             }
             /* Buffer and pcrs filter this if appropriate. */
 
@@ -2935,7 +3149,8 @@ static void chat(struct client_state *csp)
                    * to the client... it probably can't hear us anyway.
                    */
                   freez(hdr);
-                  break;
+                  mark_server_socket_tainted(csp);
+                  return;
                }
 
                byte_count += (size_t)len;
@@ -2948,7 +3163,7 @@ static void chat(struct client_state *csp)
                 */
                int header_length = csp->iob->cur - header_start;
                assert(csp->iob->cur > header_start);
-               byte_count += len - header_length;
+               byte_count += (size_t)(len - header_length);
             }
 
             /* we're finished with the server's header */
@@ -2970,17 +3185,8 @@ static void chat(struct client_state *csp)
          }
          continue;
       }
-      /*
-       * If we reach this point, the server socket is tainted
-       * (most likely because we didn't read everything the
-       * server sent us) and reusing it would lead to garbage.
-       */
-      if ((csp->flags & CSP_FLAG_SERVER_CONNECTION_KEEP_ALIVE))
-      {
-         log_error(LOG_LEVEL_CONNECT, "Unsetting keep-alive flag.");
-         csp->flags &= ~CSP_FLAG_SERVER_CONNECTION_KEEP_ALIVE;
-      }
-      return;
+      mark_server_socket_tainted(csp);
+      return; /* huh? we should never get here */
    }
 
    if (csp->content_length == 0)
@@ -2992,11 +3198,48 @@ static void chat(struct client_state *csp)
       csp->content_length = byte_count;
    }
 
+   if ((csp->flags & CSP_FLAG_CONTENT_LENGTH_SET)
+      && (csp->expected_content_length != byte_count))
+   {
+      log_error(LOG_LEVEL_CONNECT,
+         "Received %d bytes while expecting %d.",
+         byte_count, csp->expected_content_length);
+      mark_server_socket_tainted(csp);
+   }
+
    log_error(LOG_LEVEL_CLF, "%s - - [%T] \"%s\" 200 %d",
       csp->ip_addr_str, http->ocmd, csp->content_length);
 }
 
 
+/*********************************************************************
+ *
+ * Function    :  wait_for_alive_connections
+ *
+ * Description :  Waits for alive connections to timeout.
+ *
+ * Parameters  :  N/A
+ *
+ * Returns     :  N/A
+ *
+ *********************************************************************/
+static void wait_for_alive_connections()
+{
+   int connections_alive = close_unusable_connections();
+
+   while (0 < connections_alive)
+   {
+      log_error(LOG_LEVEL_CONNECT,
+         "Waiting for %d connections to timeout.",
+         connections_alive);
+      sleep(60);
+      connections_alive = close_unusable_connections();
+   }
+
+   log_error(LOG_LEVEL_CONNECT, "No connections to wait for left.");
+
+}
+
 /*********************************************************************
  *
  * Function    :  serve
@@ -3022,9 +3265,22 @@ static void serve(struct client_state *csp)
    if (csp->sfd != JB_INVALID_SOCKET)
    {
 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
-      if ((csp->flags & CSP_FLAG_SERVER_CONNECTION_KEEP_ALIVE))
+      static int monitor_thread_running = 0;
+
+      if ((csp->config->feature_flags & RUNTIME_FEATURE_CONNECTION_KEEP_ALIVE)
+       && (csp->flags & CSP_FLAG_SERVER_CONNECTION_KEEP_ALIVE))
       {
          remember_connection(csp->sfd, csp->http, forward_url(csp, csp->http));
+         privoxy_mutex_lock(&connection_reuse_mutex);
+         if (!monitor_thread_running)
+         {
+            monitor_thread_running = 1;
+            privoxy_mutex_unlock(&connection_reuse_mutex);
+            wait_for_alive_connections();
+            privoxy_mutex_lock(&connection_reuse_mutex);
+            monitor_thread_running = 0;
+         }
+         privoxy_mutex_unlock(&connection_reuse_mutex);
       }
       else
       {
@@ -3796,7 +4052,10 @@ static void listen_loop(void)
        */
       if (received_hup_signal)
       {
-         init_error_log(Argv[0], config->logfile);
+         if (NULL != config->logfile)
+         {
+            init_error_log(Argv[0], config->logfile);
+         }
          received_hup_signal = 0;
       }
 #endif