Remove CVS revision logs. TODO item #33.
[privoxy.git] / gateway.c
index f3e7520..7b601da 100644 (file)
--- a/gateway.c
+++ b/gateway.c
@@ -1,13 +1,13 @@
-const char gateway_rcs[] = "$Id: gateway.c,v 1.31 2008/10/16 07:31:11 fabiankeil Exp $";
+const char gateway_rcs[] = "$Id: gateway.c,v 1.52 2009/05/13 18:22:45 fabiankeil Exp $";
 /*********************************************************************
  *
  * File        :  $Source: /cvsroot/ijbswa/current/gateway.c,v $
  *
  * Purpose     :  Contains functions to connect to a server, possibly
  *                using a "forwarder" (i.e. HTTP proxy and/or a SOCKS4
- *                proxy).
+ *                or SOCKS5 proxy).
  *
- * Copyright   :  Written by and Copyright (C) 2001-2008 the SourceForge
+ * Copyright   :  Written by and Copyright (C) 2001-2009 the SourceForge
  *                Privoxy team. http://www.privoxy.org/
  *
  *                Based on the Internet Junkbuster originally written
@@ -32,152 +32,8 @@ const char gateway_rcs[] = "$Id: gateway.c,v 1.31 2008/10/16 07:31:11 fabiankeil
  *                or write to the Free Software Foundation, Inc., 59
  *                Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  *
- * Revisions   :
- *    $Log: gateway.c,v $
- *    Revision 1.31  2008/10/16 07:31:11  fabiankeil
- *    - Factor socket_is_still_usable() out of get_reusable_connection().
- *    - If poll() isn't available, show a warning and assume the socket
- *      is still usable.
- *
- *    Revision 1.30  2008/10/13 17:31:03  fabiankeil
- *    If a remembered connection is no longer usable and
- *    has been marked closed, don't bother checking if the
- *    destination matches.
- *
- *    Revision 1.29  2008/10/11 16:59:41  fabiankeil
- *    Add missing dots for two log messages.
- *
- *    Revision 1.28  2008/10/09 18:21:41  fabiankeil
- *    Flush work-in-progress changes to keep outgoing connections
- *    alive where possible. Incomplete and mostly #ifdef'd out.
- *
- *    Revision 1.27  2008/09/27 15:05:51  fabiankeil
- *    Return only once in forwarded_connect().
- *
- *    Revision 1.26  2008/08/18 17:42:06  fabiankeil
- *    Fix typo in macro name.
- *
- *    Revision 1.25  2008/02/07 18:09:46  fabiankeil
- *    In socks5_connect:
- *    - make the buffers quite a bit smaller.
- *    - properly report "socks5 server unreachable" failures.
- *    - let strncpy() use the whole buffer. Using a length of 0xffu wasn't actually
- *      wrong, but requires too much thinking as it doesn't depend on the buffer size.
- *    - log a message if the socks5 server sends more data than expected.
- *    - add some assertions and comments.
- *
- *    Revision 1.24  2008/02/04 14:56:29  fabiankeil
- *    - Fix a compiler warning.
- *    - Stop assuming that htonl(INADDR_NONE) equals INADDR_NONE.
- *
- *    Revision 1.23  2008/02/04 13:11:35  fabiankeil
- *    Remember the cause of the SOCKS5 error for the CGI message.
- *
- *    Revision 1.22  2008/02/03 13:46:15  fabiankeil
- *    Add SOCKS5 support. Patch #1862863 by Eric M. Hopper with minor changes.
- *
- *    Revision 1.21  2007/07/28 12:30:03  fabiankeil
- *    Modified patch from Song Weijia (#1762559) to
- *    fix socks requests on big-endian platforms.
- *
- *    Revision 1.20  2007/05/14 10:23:48  fabiankeil
- *    - Use strlcpy() instead of strcpy().
- *    - Use the same buffer for socks requests and socks responses.
- *    - Fix bogus warning about web_server_addr being used uninitialized.
- *
- *    Revision 1.19  2007/01/25 14:09:45  fabiankeil
- *    - Save errors in socks4_connect() to csp->error_message.
- *    - Silence some gcc43 warnings, hopefully the right way.
- *
- *    Revision 1.18  2006/07/18 14:48:46  david__schmidt
- *    Reorganizing the repository: swapping out what was HEAD (the old 3.1 branch)
- *    with what was really the latest development (the v_3_0_branch branch)
- *
- *    Revision 1.16  2002/05/12 21:36:29  jongfoster
- *    Correcting function comments
- *
- *    Revision 1.15  2002/03/26 22:29:54  swa
- *    we have a new homepage!
- *
- *    Revision 1.14  2002/03/24 13:25:43  swa
- *    name change related issues
- *
- *    Revision 1.13  2002/03/13 00:29:59  jongfoster
- *    Killing warnings
- *
- *    Revision 1.12  2002/03/09 20:03:52  jongfoster
- *    - Making various functions return int rather than size_t.
- *      (Undoing a recent change).  Since size_t is unsigned on
- *      Windows, functions like read_socket that return -1 on
- *      error cannot return a size_t.
- *
- *      THIS WAS A MAJOR BUG - it caused frequent, unpredictable
- *      crashes, and also frequently caused JB to jump to 100%
- *      CPU and stay there.  (Because it thought it had just
- *      read ((unsigned)-1) == 4Gb of data...)
- *
- *    - The signature of write_socket has changed, it now simply
- *      returns success=0/failure=nonzero.
- *
- *    - Trying to get rid of a few warnings --with-debug on
- *      Windows, I've introduced a new type "jb_socket".  This is
- *      used for the socket file descriptors.  On Windows, this
- *      is SOCKET (a typedef for unsigned).  Everywhere else, it's
- *      an int.  The error value can't be -1 any more, so it's
- *      now JB_INVALID_SOCKET (which is -1 on UNIX, and in
- *      Windows it maps to the #define INVALID_SOCKET.)
- *
- *    - The signature of bind_port has changed.
- *
- *    Revision 1.11  2002/03/08 17:46:04  jongfoster
- *    Fixing int/size_t warnings
- *
- *    Revision 1.10  2002/03/07 03:50:19  oes
- *     - Improved handling of failed DNS lookups
- *     - Fixed compiler warnings
- *
- *    Revision 1.9  2001/10/25 03:40:48  david__schmidt
- *    Change in porting tactics: OS/2's EMX porting layer doesn't allow multiple
- *    threads to call select() simultaneously.  So, it's time to do a real, live,
- *    native OS/2 port.  See defines for __EMX__ (the porting layer) vs. __OS2__
- *    (native). Both versions will work, but using __OS2__ offers multi-threading.
- *
- *    Revision 1.8  2001/09/13 20:10:12  jongfoster
- *    Fixing missing #include under Windows
- *
- *    Revision 1.7  2001/09/12 17:58:26  steudten
- *
- *    add #include <string.h>
- *
- *    Revision 1.6  2001/09/10 10:41:16  oes
- *    Added #include in.h
- *
- *    Revision 1.5  2001/07/29 18:47:57  jongfoster
- *    Adding missing #include project.h
- *
- *    Revision 1.4  2001/07/24 12:47:06  oes
- *    Applied BeOS support update by Eugenia
- *
- *    Revision 1.3  2001/06/09 10:55:28  jongfoster
- *    Changing BUFSIZ ==> BUFFER_SIZE
- *
- *    Revision 1.2  2001/06/07 23:11:38  jongfoster
- *    Removing gateways[] list - no longer used.
- *    Replacing function pointer in struct gateway with a directly
- *    called function forwarded_connect(), which can do the common
- *    task of deciding whether to connect to the web server or HTTP
- *    proxy.
- *    Replacing struct gateway with struct forward_spec
- *    Fixing bug with SOCKS4A and HTTP proxy server in combination.
- *    It was a bug which led to the connection being made to the web
- *    server rather than the HTTP proxy, and also a buffer overrun.
- *
- *    Revision 1.1.1.1  2001/05/15 13:58:54  oes
- *    Initial import of version 2.9.3 source tree
- *
- *
  *********************************************************************/
-\f
+
 
 #include "config.h"
 
@@ -272,25 +128,10 @@ static const char socks_userid[] = "anonymous";
 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
 
 #define MAX_REUSABLE_CONNECTIONS 100
-
-struct reusable_connection
-{
-   jb_socket sfd;
-   int       in_use;
-   char      *host;
-   int       port;
-
-   int       forwarder_type;
-   char      *gateway_host;
-   int       gateway_port;
-   char      *forward_host;
-   int       forward_port;
-};
+static unsigned int keep_alive_timeout = DEFAULT_KEEP_ALIVE_TIMEOUT;
 
 static struct reusable_connection reusable_connection[MAX_REUSABLE_CONNECTIONS];
-
 static int mark_connection_unused(jb_socket sfd);
-static void mark_connection_closed(struct reusable_connection *closed_connection);
 
 /*********************************************************************
  *
@@ -308,9 +149,12 @@ extern void initialize_reusable_connections(void)
 {
    unsigned int slot = 0;
 
+#if !defined(HAVE_POLL) && !defined(_WIN32)
    log_error(LOG_LEVEL_INFO,
-      "Support for 'Connection: keep-alive' is experimental, "
-      "incomplete and known not to work properly in some situations.");
+      "Detecting already dead connections might not work "
+      "correctly on your platform. In case of problems, "
+      "unset the keep-alive-timeout option.");
+#endif
 
    for (slot = 0; slot < SZ(reusable_connection); slot++)
    {
@@ -331,12 +175,16 @@ extern void initialize_reusable_connections(void)
  *          1  :  sfd  = Open socket to remember.
  *          2  :  http = The destination for the connection.
  *          3  :  fwd  = The forwarder settings used.
+ *          4  :  timeout = Number of seconds after which the
+ *                          connection shouldn't be reused.
  *
  * Returns     : void
  *
  *********************************************************************/
-void remember_connection(jb_socket sfd, const struct http_request *http,
-                                        const struct forward_spec *fwd)
+void remember_connection(jb_socket sfd,
+                         const struct http_request *http,
+                         const struct forward_spec *fwd,
+                         unsigned int timeout)
 {
    unsigned int slot = 0;
    int free_slot_found = FALSE;
@@ -383,6 +231,8 @@ void remember_connection(jb_socket sfd, const struct http_request *http,
    reusable_connection[slot].sfd = sfd;
    reusable_connection[slot].port = http->port;
    reusable_connection[slot].in_use = 0;
+   reusable_connection[slot].timestamp = time(NULL);
+   reusable_connection[slot].keep_alive_timeout = timeout;
 
    assert(NULL != fwd);
    assert(reusable_connection[slot].gateway_host == NULL);
@@ -429,7 +279,6 @@ void remember_connection(jb_socket sfd, const struct http_request *http,
  * Function    :  mark_connection_closed
  *
  * Description : Marks a reused connection closed.
- *               Must be called with connection_reuse_mutex locked.
  *
  * Parameters  :
  *          1  :  closed_connection = The connection to mark as closed.
@@ -437,12 +286,14 @@ void remember_connection(jb_socket sfd, const struct http_request *http,
  * Returns     : void
  *
  *********************************************************************/
-static void mark_connection_closed(struct reusable_connection *closed_connection)
+void mark_connection_closed(struct reusable_connection *closed_connection)
 {
    closed_connection->in_use = FALSE;
    closed_connection->sfd = JB_INVALID_SOCKET;
    freez(closed_connection->host);
    closed_connection->port = 0;
+   closed_connection->timestamp = 0;
+   closed_connection->keep_alive_timeout = 0;
    closed_connection->forwarder_type = SOCKS_NONE;
    freez(closed_connection->gateway_host);
    closed_connection->gateway_port = 0;
@@ -477,23 +328,20 @@ void forget_connection(jb_socket sfd)
       if (reusable_connection[slot].sfd == sfd)
       {
          assert(reusable_connection[slot].in_use);
-         break;
-      }
-   }
 
-   if (reusable_connection[slot].sfd != sfd)
-   {
-      log_error(LOG_LEVEL_CONNECT,
-        "Socket %d already forgotten or never remembered.", sfd);
-      privoxy_mutex_unlock(&connection_reuse_mutex);
-      return;
+         log_error(LOG_LEVEL_CONNECT,
+            "Forgetting socket %d for %s:%d in slot %d.",
+            sfd, reusable_connection[slot].host,
+            reusable_connection[slot].port, slot);
+         mark_connection_closed(&reusable_connection[slot]);
+         privoxy_mutex_unlock(&connection_reuse_mutex);
+
+         return;
+      }
    }
 
    log_error(LOG_LEVEL_CONNECT,
-      "Forgetting socket %d for %s:%d in slot %d.",
-      sfd, reusable_connection[slot].host, reusable_connection[slot].port, slot);
-
-   mark_connection_closed(&reusable_connection[slot]);
+      "Socket %d already forgotten or never remembered.", sfd);
 
    privoxy_mutex_unlock(&connection_reuse_mutex);
 }
@@ -504,7 +352,7 @@ void forget_connection(jb_socket sfd)
  * Function    :  connection_destination_matches
  *
  * Description :  Determines whether a remembered connection can
- *                be reused. That is whether the destination and
+ *                be reused. That is, whether the destination and
  *                the forwarding settings match.
  *
  * Parameters  :
@@ -515,43 +363,10 @@ void forget_connection(jb_socket sfd)
  * Returns     :  TRUE for yes, FALSE otherwise.
  *
  *********************************************************************/
-static int connection_destination_matches(const struct reusable_connection *connection,
-                                          const struct http_request *http,
-                                          const struct forward_spec *fwd)
+int connection_destination_matches(const struct reusable_connection *connection,
+                                   const struct http_request *http,
+                                   const struct forward_spec *fwd)
 {
-   /* XXX: Start of duplicated checks for debugging purposes. */
-   if (strcmpic(connection->host, http->host))
-   {
-      return FALSE;
-   }
-
-   if (connection->forwarder_type != fwd->type)
-   {
-      log_error(LOG_LEVEL_CONNECT, "Type mismatch: %d %d (%s)",
-         connection->forwarder_type, fwd->type, http->host);
-      return FALSE;
-   }
-   if (connection->gateway_port   != fwd->gateway_port)
-   {
-      log_error(LOG_LEVEL_CONNECT, "Gateway port mismatch: %d %d (%s)",
-         connection->gateway_port, fwd->gateway_port, http->host);
-      return FALSE;
-   }
-   if (connection->forward_port   != fwd->forward_port)
-   {
-      log_error(LOG_LEVEL_CONNECT, "Forward port mismatch: %d %d (%s)",
-         connection->forward_port, fwd->forward_port, http->host);
-      return FALSE;
-   }
-   if (connection->forward_port   != fwd->forward_port)
-   {
-      log_error(LOG_LEVEL_CONNECT, "Server port mismatch: %d %d (%s)",
-         connection->forward_port, fwd->forward_port, http->host);
-      return FALSE;
-   }
-
-   /* XXX: End of duplicated checks for debugging purposes. */
-
    if ((connection->forwarder_type != fwd->type)
     || (connection->gateway_port   != fwd->gateway_port)
     || (connection->forward_port   != fwd->forward_port)
@@ -585,43 +400,63 @@ static int connection_destination_matches(const struct reusable_connection *conn
 
 /*********************************************************************
  *
- * Function    :  socket_is_still_usable
+ * Function    :  close_unusable_connections
  *
- * Description :  Decides whether or not an open socket is still usable.
+ * Description :  Closes remembered connections that have timed
+ *                out or have been closed on the other side.
  *
- * Parameters  :
- *          1  :  sfd = The socket to check.
+ * Parameters  :  none
  *
- * Returns     :  TRUE for yes, otherwise FALSE.
+ * Returns     :  Number of connections that are still alive.
  *
  *********************************************************************/
-static int socket_is_still_usable(jb_socket sfd)
+int close_unusable_connections(void)
 {
-#ifdef HAVE_POLL
-   int poll_result;
-   struct pollfd poll_fd[1];
-   memset(poll_fd, 0, sizeof(poll_fd));
-   poll_fd[0].fd = sfd;
-   poll_fd[0].events = POLLIN;
+   unsigned int slot = 0;
+   int connections_alive = 0;
 
-   poll_result = poll(poll_fd, 1, 0);
+   privoxy_mutex_lock(&connection_reuse_mutex);
 
-   if (-1 != poll_result)
-   {
-      return !(poll_fd[0].revents & POLLIN);
-   }
-   else
+   for (slot = 0; slot < SZ(reusable_connection); slot++)
    {
-      log_error(LOG_LEVEL_CONNECT, "Polling socket %d failed.", sfd);
-      return FALSE;
+      if (!reusable_connection[slot].in_use
+         && (JB_INVALID_SOCKET != reusable_connection[slot].sfd))
+      {
+         time_t time_open = time(NULL) - reusable_connection[slot].timestamp;
+
+         if (reusable_connection[slot].keep_alive_timeout < time_open)
+         {
+            log_error(LOG_LEVEL_CONNECT,
+               "The connection to %s:%d in slot %d timed out. "
+               "Closing socket %d. Timeout is: %d.",
+               reusable_connection[slot].host,
+               reusable_connection[slot].port, slot,
+               reusable_connection[slot].sfd,
+               reusable_connection[slot].keep_alive_timeout);
+            close_socket(reusable_connection[slot].sfd);
+            mark_connection_closed(&reusable_connection[slot]);
+         }
+         else if (!socket_is_still_usable(reusable_connection[slot].sfd))
+         {
+            log_error(LOG_LEVEL_CONNECT,
+               "The connection to %s:%d in slot %d is no longer usable. "
+               "Closing socket %d.", reusable_connection[slot].host,
+               reusable_connection[slot].port, slot,
+               reusable_connection[slot].sfd);
+            close_socket(reusable_connection[slot].sfd);
+            mark_connection_closed(&reusable_connection[slot]);
+         }
+         else
+         {
+            connections_alive++;
+         }
+      }
    }
-#else
-   log_error(LOG_LEVEL_INFO,
-      "Detecting already dead sockets isn't implemented for your "
-      "platform yet. Assuming sockets stay alive forever, expect "
-      "an increase in connection problems.");
-   return TRUE;
-#endif /* def HAVE_POLL */
+
+   privoxy_mutex_unlock(&connection_reuse_mutex);
+
+   return connections_alive;
+
 }
 
 
@@ -646,6 +481,8 @@ static jb_socket get_reusable_connection(const struct http_request *http,
    jb_socket sfd = JB_INVALID_SOCKET;
    unsigned int slot = 0;
 
+   close_unusable_connections();
+
    privoxy_mutex_lock(&connection_reuse_mutex);
 
    for (slot = 0; slot < SZ(reusable_connection); slot++)
@@ -653,16 +490,6 @@ static jb_socket get_reusable_connection(const struct http_request *http,
       if (!reusable_connection[slot].in_use
          && (JB_INVALID_SOCKET != reusable_connection[slot].sfd))
       {
-         if (!socket_is_still_usable(reusable_connection[slot].sfd))
-         {
-            log_error(LOG_LEVEL_CONNECT,
-               "Socket %d for %s:%d in slot %d is no longer usable. Closing.",
-               reusable_connection[slot].sfd, reusable_connection[slot].host,
-               reusable_connection[slot].port, slot);
-            mark_connection_closed(&reusable_connection[slot]);
-            continue;
-         }
-
          if (connection_destination_matches(&reusable_connection[slot], http, fwd))
          {
             reusable_connection[slot].in_use = TRUE;
@@ -709,24 +536,41 @@ static int mark_connection_unused(jb_socket sfd)
       if (reusable_connection[slot].sfd == sfd)
       {
          assert(reusable_connection[slot].in_use);
+         socket_found = TRUE;
+         log_error(LOG_LEVEL_CONNECT,
+            "Marking open socket %d for %s:%d in slot %d as unused.",
+            sfd, reusable_connection[slot].host,
+            reusable_connection[slot].port, slot);
+         reusable_connection[slot].in_use = 0;
+         reusable_connection[slot].timestamp = time(NULL);
          break;
       }
    }
 
-   if (reusable_connection[slot].sfd == sfd)
-   {
-      socket_found = TRUE;
-      log_error(LOG_LEVEL_CONNECT,
-         "Marking open socket %d for %s:%d in slot %d as unused.",
-         sfd, reusable_connection[slot].host, reusable_connection[slot].port, slot);
-      reusable_connection[slot].in_use = 0;
-   }
-
    privoxy_mutex_unlock(&connection_reuse_mutex);
 
    return socket_found;
 
 }
+
+
+/*********************************************************************
+ *
+ * Function    :  set_keep_alive_timeout
+ *
+ * Description :  Sets the timeout after which open
+ *                connections will no longer be reused.
+ *
+ * Parameters  :
+ *          1  :  timeout = The timeout in seconds.
+ *
+ * Returns     :  void
+ *
+ *********************************************************************/
+void set_keep_alive_timeout(unsigned int timeout)
+{
+   keep_alive_timeout = timeout;
+}
 #endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
 
 
@@ -754,16 +598,13 @@ jb_socket forwarded_connect(const struct forward_spec * fwd,
    jb_socket sfd = JB_INVALID_SOCKET;
 
 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
-   sfd = get_reusable_connection(http, fwd);
-   if (JB_INVALID_SOCKET == sfd)
-   {
-      log_error(LOG_LEVEL_CONNECT,
-         "No reusable socket for %s:%d found. Opening a new one.",
-         http->host, http->port);
-   }
-   else
+   if ((csp->config->feature_flags & RUNTIME_FEATURE_CONNECTION_SHARING))
    {
-      return sfd;
+      sfd = get_reusable_connection(http, fwd);
+      if (JB_INVALID_SOCKET != sfd)
+      {
+         return sfd;
+      }
    }
 #endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
 
@@ -800,6 +641,13 @@ jb_socket forwarded_connect(const struct forward_spec * fwd,
             "SOCKS4 impossible internal error - bad SOCKS type.");
    }
 
+   if (JB_INVALID_SOCKET != sfd)
+   {
+      log_error(LOG_LEVEL_CONNECT,
+         "Created new connection to %s:%d on socket %d.",
+         http->host, http->port, sfd);
+   }
+
    return sfd;
 
 }
@@ -972,7 +820,6 @@ static jb_socket socks4_connect(const struct forward_spec * fwd,
    {
       case SOCKS_REQUEST_GRANTED:
          return(sfd);
-         break;
       case SOCKS_REQUEST_REJECT:
          errstr = "SOCKS request rejected or failed.";
          errno = EINVAL;
@@ -1095,7 +942,7 @@ static jb_socket socks5_connect(const struct forward_spec *fwd,
    }
 
    hostlen = strlen(target_host);
-   if (hostlen > 255)
+   if (hostlen > (size_t)255)
    {
       errstr = "target host name is longer than 255 characters";
       err = 1;
@@ -1183,12 +1030,12 @@ static jb_socket socks5_connect(const struct forward_spec *fwd,
    cbuf[client_pos++] = '\x00'; /* Reserved, must be 0x00 */
    cbuf[client_pos++] = '\x03'; /* Address is domain name */
    cbuf[client_pos++] = (char)(hostlen & 0xffu);
-   assert(sizeof(cbuf) - client_pos > 255);
+   assert(sizeof(cbuf) - client_pos > (size_t)255);
    /* Using strncpy because we really want the nul byte padding. */
    strncpy(cbuf + client_pos, target_host, sizeof(cbuf) - client_pos);
    client_pos += (hostlen & 0xffu);
-   cbuf[client_pos++] = (char)((target_port >> 8) & 0xffu);
-   cbuf[client_pos++] = (char)((target_port     ) & 0xffu);
+   cbuf[client_pos++] = (char)((target_port >> 8) & 0xff);
+   cbuf[client_pos++] = (char)((target_port     ) & 0xff);
 
    if (write_socket(sfd, cbuf, client_pos))
    {