X-Git-Url: http://www.privoxy.org/gitweb/?p=privoxy.git;a=blobdiff_plain;f=jcc.c;h=cde64b09426c8590ff3f79a8b9f314aaa80a7314;hp=8c22dcc9fd714f2de1cab8efe935eea9cc4e911b;hb=cd275efe90ca39d461537daf389e79a3cd79e507;hpb=4c7a629c82d606ac774892e8113c078d16619597

diff --git a/jcc.c b/jcc.c
index 8c22dcc9..cde64b09 100644
--- a/jcc.c
+++ b/jcc.c
@@ -1,4 +1,4 @@
-const char jcc_rcs[] = "$Id: jcc.c,v 1.198 2008/10/22 15:19:55 fabiankeil Exp $";
+const char jcc_rcs[] = "$Id: jcc.c,v 1.204 2008/11/06 19:42:17 fabiankeil Exp $";
 /*********************************************************************
  *
  * File        :  $Source: /cvsroot/ijbswa/current/jcc.c,v $
@@ -33,6 +33,27 @@ const char jcc_rcs[] = "$Id: jcc.c,v 1.198 2008/10/22 15:19:55 fabiankeil Exp $"
  *
  * Revisions   :
  *    $Log: jcc.c,v $
+ *    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
@@ -1189,9 +1210,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);
@@ -2062,69 +2083,54 @@ 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
    {
       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
@@ -2132,41 +2138,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;
+
+   http = csp->http;
+
+   memset(buf, 0, sizeof(buf));
 
-   } while ((NULL != req) && ('\0' == *req));
+   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))
       {
@@ -2175,7 +2198,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
@@ -2197,8 +2220,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)
       {
@@ -2216,7 +2239,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 */
@@ -2242,7 +2265,7 @@ static void chat(struct client_state *csp)
          {
             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))
@@ -2252,7 +2275,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
@@ -2283,7 +2306,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;
       }
    }
 
@@ -2306,23 +2329,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;
 
@@ -2336,10 +2386,72 @@ 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;
+
+   memset(buf, 0, sizeof(buf));
+
+   http = csp->http;
+
+   if (receive_client_request(csp) != JB_ERR_OK)
+   {
+      return;
+   }
+   if (parse_client_request(csp) != JB_ERR_OK)
+   {
       return;
    }
 
@@ -2572,7 +2684,8 @@ static void chat(struct client_state *csp)
       if (n < 0)
       {
          log_error(LOG_LEVEL_ERROR, "select() failed!: %E");
-         break;
+         mark_server_socket_tainted(csp);
+         return;
       }
 
       /*
@@ -2585,13 +2698,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;
       }
@@ -2632,7 +2748,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);
@@ -2647,7 +2764,7 @@ 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,
@@ -2727,7 +2844,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);
@@ -2784,7 +2902,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);
 
@@ -2795,7 +2914,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;
                   }
 
                   /*
@@ -2814,7 +2934,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;
@@ -2833,7 +2954,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;
@@ -2869,7 +2991,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);
@@ -2893,7 +3016,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;
             }
 
             /*
@@ -2920,7 +3044,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. */
 
@@ -2949,7 +3074,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;
@@ -2962,7 +3088,7 @@ static void chat(struct client_state *csp)
                 */
                int header_length = csp->iob->cur - header_start;
                assert(csp->iob->cur > header_start);
-               byte_count += (size_t)len - header_length;
+               byte_count += (size_t)(len - header_length);
             }
 
             /* we're finished with the server's header */
@@ -2984,17 +3110,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)
@@ -3006,6 +3123,15 @@ 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_ERROR,
+         "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);
 }
@@ -3036,7 +3162,8 @@ 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))
+      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));
       }