X-Git-Url: http://www.privoxy.org/gitweb/?p=privoxy.git;a=blobdiff_plain;f=gateway.c;h=4b6fab60571b0c2d786803bf9cf7ecb8733348df;hp=5a0eac15eef06856915204c1deb5fc535e872d9b;hb=ed843f64b12b464fe56428faffb3c7740bccfe55;hpb=0fc7c2f71f3a69e88ae6b7370e63c99afe5cb889

diff --git a/gateway.c b/gateway.c
index 5a0eac15..4b6fab60 100644
--- a/gateway.c
+++ b/gateway.c
@@ -1,4 +1,4 @@
-const char gateway_rcs[] = "$Id: gateway.c,v 1.20 2007/05/14 10:23:48 fabiankeil Exp $";
+const char gateway_rcs[] = "$Id: gateway.c,v 1.36 2008/10/18 19:49:15 fabiankeil Exp $";
 /*********************************************************************
  *
  * File        :  $Source: /cvsroot/ijbswa/current/gateway.c,v $
@@ -7,7 +7,7 @@ const char gateway_rcs[] = "$Id: gateway.c,v 1.20 2007/05/14 10:23:48 fabiankeil
  *                using a "forwarder" (i.e. HTTP proxy and/or a SOCKS4
  *                proxy).
  *
- * Copyright   :  Written by and Copyright (C) 2001-2007 the SourceForge
+ * Copyright   :  Written by and Copyright (C) 2001-2008 the SourceForge
  *                Privoxy team. http://www.privoxy.org/
  *
  *                Based on the Internet Junkbuster originally written
@@ -34,6 +34,73 @@ const char gateway_rcs[] = "$Id: gateway.c,v 1.20 2007/05/14 10:23:48 fabiankeil
  *
  * Revisions   :
  *    $Log: gateway.c,v $
+ *    Revision 1.36  2008/10/18 19:49:15  fabiankeil
+ *    - Factor close_unusable_connections() out of
+ *      get_reusable_connection() to make sure we really check
+ *      all the remembered connections, not just the ones before
+ *      the next reusable one.
+ *    - Plug two file descriptor leaks. Internally marking
+ *      connections as closed doesn't cut it.
+ *
+ *    Revision 1.35  2008/10/17 17:12:01  fabiankeil
+ *    In socket_is_still_usable(), use select()
+ *    and FD_ISSET() if poll() isn't available.
+ *
+ *    Revision 1.34  2008/10/17 17:07:13  fabiankeil
+ *    Add preliminary timeout support.
+ *
+ *    Revision 1.33  2008/10/16 16:34:21  fabiankeil
+ *    Fix two gcc44 warnings.
+ *
+ *    Revision 1.32  2008/10/16 16:27:22  fabiankeil
+ *    Fix compiler warning.
+ *
+ *    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.
@@ -164,6 +231,15 @@ const char gateway_rcs[] = "$Id: gateway.c,v 1.20 2007/05/14 10:23:48 fabiankeil
 #include "jbsockets.h"
 #include "gateway.h"
 #include "miscutil.h"
+#ifdef FEATURE_CONNECTION_KEEP_ALIVE
+#ifdef HAVE_POLL
+#ifdef __GLIBC__ 
+#include <sys/poll.h>
+#else
+#include <poll.h>
+#endif /* def __GLIBC__ */
+#endif /* HAVE_POLL */
+#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
 
 const char gateway_h_rcs[] = GATEWAY_H_VERSION;
 
@@ -172,12 +248,27 @@ static jb_socket socks4_connect(const struct forward_spec * fwd,
                                 int target_port,
                                 struct client_state *csp);
 
+static jb_socket socks5_connect(const struct forward_spec *fwd,
+                                const char *target_host,
+                                int target_port,
+                                struct client_state *csp);
+
 
 #define SOCKS_REQUEST_GRANTED          90
 #define SOCKS_REQUEST_REJECT           91
 #define SOCKS_REQUEST_IDENT_FAILED     92
 #define SOCKS_REQUEST_IDENT_CONFLICT   93
 
+#define SOCKS5_REQUEST_GRANTED             0
+#define SOCKS5_REQUEST_FAILED              1
+#define SOCKS5_REQUEST_DENIED              2
+#define SOCKS5_REQUEST_NETWORK_UNREACHABLE 3
+#define SOCKS5_REQUEST_HOST_UNREACHABLE    4
+#define SOCKS5_REQUEST_CONNECTION_REFUSED  5
+#define SOCKS5_REQUEST_TTL_EXPIRED         6
+#define SOCKS5_REQUEST_PROTOCOL_ERROR      7
+#define SOCKS5_REQUEST_BAD_ADDRESS_TYPE    8
+
 /* structure of a socks client operation */
 struct socks_op {
    unsigned char vn;          /* socks version number */
@@ -199,6 +290,533 @@ struct socks_reply {
 
 static const char socks_userid[] = "anonymous";
 
+#ifdef FEATURE_CONNECTION_KEEP_ALIVE
+
+#define MAX_REUSABLE_CONNECTIONS 100
+/* XXX: should be a config option. */
+#define CONNECTION_KEEP_ALIVE_TIMEOUT 3 * 60
+
+struct reusable_connection
+{
+   jb_socket sfd;
+   int       in_use;
+   char      *host;
+   int       port;
+   time_t    timestamp;
+
+   int       forwarder_type;
+   char      *gateway_host;
+   int       gateway_port;
+   char      *forward_host;
+   int       forward_port;
+};
+
+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);
+static int socket_is_still_usable(jb_socket sfd);
+
+
+/*********************************************************************
+ *
+ * Function    :  initialize_reusable_connections
+ *
+ * Description :  Initializes the reusable_connection structures.
+ *                Must be called with connection_reuse_mutex locked.
+ *
+ * Parameters  : N/A
+ *
+ * Returns     : void
+ *
+ *********************************************************************/
+extern void initialize_reusable_connections(void)
+{
+   unsigned int slot = 0;
+
+   log_error(LOG_LEVEL_INFO,
+      "Support for 'Connection: keep-alive' is experimental, "
+      "incomplete and known not to work properly in some situations.");
+
+   for (slot = 0; slot < SZ(reusable_connection); slot++)
+   {
+      mark_connection_closed(&reusable_connection[slot]);
+   }
+
+   log_error(LOG_LEVEL_CONNECT, "Initialized %d socket slots.", slot);
+}
+
+
+/*********************************************************************
+ *
+ * Function    :  remember_connection
+ *
+ * Description :  Remembers a connection for reuse later on.
+ *
+ * Parameters  :
+ *          1  :  sfd  = Open socket to remember.
+ *          2  :  http = The destination for the connection.
+ *          3  :  fwd  = The forwarder settings used.
+ *
+ * Returns     : void
+ *
+ *********************************************************************/
+void remember_connection(jb_socket sfd, const struct http_request *http,
+                                        const struct forward_spec *fwd)
+{
+   unsigned int slot = 0;
+   int free_slot_found = FALSE;
+
+   assert(sfd != JB_INVALID_SOCKET);
+
+   if (mark_connection_unused(sfd))
+   {
+      return;
+   }
+
+   privoxy_mutex_lock(&connection_reuse_mutex);
+
+   /* Find free socket slot. */
+   for (slot = 0; slot < SZ(reusable_connection); slot++)
+   {
+      if (reusable_connection[slot].sfd == JB_INVALID_SOCKET)
+      {
+         assert(reusable_connection[slot].in_use == 0);
+         log_error(LOG_LEVEL_CONNECT,
+            "Remembering socket %d for %s:%d in slot %d.",
+            sfd, http->host, http->port, slot);
+         free_slot_found = TRUE;
+         break;
+      }
+   }
+
+   if (!free_slot_found)
+   {
+      log_error(LOG_LEVEL_CONNECT,
+        "No free slots found to remembering socket for %s:%d. Last slot %d.",
+        http->host, http->port, slot);
+      privoxy_mutex_unlock(&connection_reuse_mutex);
+      close_socket(sfd);
+      return;
+   }
+
+   assert(NULL != http->host);
+   reusable_connection[slot].host = strdup(http->host);
+   if (NULL == reusable_connection[slot].host)
+   {
+      log_error(LOG_LEVEL_FATAL, "Out of memory saving socket.");
+   }
+   reusable_connection[slot].sfd = sfd;
+   reusable_connection[slot].port = http->port;
+   reusable_connection[slot].in_use = 0;
+   reusable_connection[slot].timestamp = time(NULL);
+
+   assert(NULL != fwd);
+   assert(reusable_connection[slot].gateway_host == NULL);
+   assert(reusable_connection[slot].gateway_port == 0);
+   assert(reusable_connection[slot].forwarder_type == SOCKS_NONE);
+   assert(reusable_connection[slot].forward_host == NULL);
+   assert(reusable_connection[slot].forward_port == 0);
+
+   reusable_connection[slot].forwarder_type = fwd->type;
+   if (NULL != fwd->gateway_host)
+   {
+      reusable_connection[slot].gateway_host = strdup(fwd->gateway_host);
+      if (NULL == reusable_connection[slot].gateway_host)
+      {
+         log_error(LOG_LEVEL_FATAL, "Out of memory saving gateway_host.");
+      }
+   }
+   else
+   {
+      reusable_connection[slot].gateway_host = NULL;
+   }
+   reusable_connection[slot].gateway_port = fwd->gateway_port;
+
+   if (NULL != fwd->forward_host)
+   {
+      reusable_connection[slot].forward_host = strdup(fwd->forward_host);
+      if (NULL == reusable_connection[slot].forward_host)
+      {
+         log_error(LOG_LEVEL_FATAL, "Out of memory saving forward_host.");
+      }
+   }
+   else
+   {
+      reusable_connection[slot].forward_host = NULL;
+   }
+   reusable_connection[slot].forward_port = fwd->forward_port;
+
+   privoxy_mutex_unlock(&connection_reuse_mutex);
+}
+
+
+/*********************************************************************
+ *
+ * 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.
+ *
+ * Returns     : void
+ *
+ *********************************************************************/
+static 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->forwarder_type = SOCKS_NONE;
+   freez(closed_connection->gateway_host);
+   closed_connection->gateway_port = 0;
+   freez(closed_connection->forward_host);
+   closed_connection->forward_port = 0;
+}
+
+
+/*********************************************************************
+ *
+ * Function    :  forget_connection
+ *
+ * Description :  Removes a previously remembered connection from
+ *                the list of reusable connections.
+ *
+ * Parameters  :
+ *          1  :  sfd = The socket belonging to the connection in question.
+ *
+ * Returns     : void
+ *
+ *********************************************************************/
+void forget_connection(jb_socket sfd)
+{
+   unsigned int slot = 0;
+
+   assert(sfd != JB_INVALID_SOCKET);
+
+   privoxy_mutex_lock(&connection_reuse_mutex);
+
+   for (slot = 0; slot < SZ(reusable_connection); slot++)
+   {
+      if (reusable_connection[slot].sfd == sfd)
+      {
+         assert(reusable_connection[slot].in_use);
+
+         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,
+      "Socket %d already forgotten or never remembered.", sfd);
+
+   privoxy_mutex_unlock(&connection_reuse_mutex);
+}
+
+
+/*********************************************************************
+ *
+ * Function    :  connection_destination_matches
+ *
+ * Description :  Determines whether a remembered connection can
+ *                be reused. That is whether the destination and
+ *                the forwarding settings match.
+ *
+ * Parameters  :
+ *          1  :  connection = The connection to check.
+ *          2  :  http = The destination for the connection.
+ *          3  :  fwd  = The forwarder settings.
+ *
+ * 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)
+{
+   /* 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)
+    || (connection->port           != http->port))
+   {
+      return FALSE;
+   }
+
+   if ((    (NULL != connection->gateway_host)
+         && (NULL != fwd->gateway_host)
+         && strcmpic(connection->gateway_host, fwd->gateway_host))
+       && (connection->gateway_host != fwd->gateway_host))
+   {
+      log_error(LOG_LEVEL_CONNECT, "Gateway mismatch.");
+      return FALSE;
+   }
+
+   if ((    (NULL != connection->forward_host)
+         && (NULL != fwd->forward_host)
+         && strcmpic(connection->forward_host, fwd->forward_host))
+      && (connection->forward_host != fwd->forward_host))
+   {
+      log_error(LOG_LEVEL_CONNECT, "Forwarding proxy mismatch.");
+      return FALSE;
+   }
+
+   return (!strcmpic(connection->host, http->host));
+
+}
+
+
+/*********************************************************************
+ *
+ * Function    :  close_unusable_connections
+ *
+ * Description :  Closes remembered connections that have timed
+ *                out or have been closed on the other side.
+ *
+ * Parameters  :  none
+ *
+ * Returns     :  void
+ *
+ *********************************************************************/
+static void close_unusable_connections(void)
+{
+   unsigned int slot = 0;
+
+   for (slot = 0; slot < SZ(reusable_connection); slot++)
+   {
+      if (!reusable_connection[slot].in_use
+         && (JB_INVALID_SOCKET != reusable_connection[slot].sfd))
+      {
+         time_t time_open = time(NULL) - reusable_connection[slot].timestamp;
+
+         if (CONNECTION_KEEP_ALIVE_TIMEOUT < time_open)
+         {
+            log_error(LOG_LEVEL_CONNECT,
+               "The connection to %s:%d in slot %d timed out. Closing.",
+               reusable_connection[slot].host, reusable_connection[slot].port,
+               slot);
+            close_socket(reusable_connection[slot].sfd);
+            mark_connection_closed(&reusable_connection[slot]);
+            continue;
+         }
+
+         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);
+            close_socket(reusable_connection[slot].sfd);
+            mark_connection_closed(&reusable_connection[slot]);
+            continue;
+         }
+      }
+   }
+}
+
+
+/*********************************************************************
+ *
+ * Function    :  socket_is_still_usable
+ *
+ * Description :  Decides whether or not an open socket is still usable.
+ *
+ * Parameters  :
+ *          1  :  sfd = The socket to check.
+ *
+ * Returns     :  TRUE for yes, otherwise FALSE.
+ *
+ *********************************************************************/
+static int socket_is_still_usable(jb_socket sfd)
+{
+#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;
+
+   poll_result = poll(poll_fd, 1, 0);
+
+   if (-1 != poll_result)
+   {
+      return !(poll_fd[0].revents & POLLIN);
+   }
+   else
+   {
+      log_error(LOG_LEVEL_CONNECT, "Polling socket %d failed.", sfd);
+      return FALSE;
+   }
+#else
+   fd_set readable_fds;
+   struct timeval timeout;
+   int ret;
+   int socket_is_alive = 0;
+
+   memset(&timeout, '\0', sizeof(timeout));
+   /*   timeout.tv_usec = 150;*/
+   FD_ZERO(&readable_fds);
+   FD_SET(sfd, &readable_fds);
+
+   ret = select((int)sfd+1, &readable_fds, NULL, NULL, &timeout);
+   if (ret < 0)
+   {
+      log_error(LOG_LEVEL_ERROR, "select() failed!: %E");
+   }
+
+   /*
+    * XXX: I'm not sure why !FD_ISSET() works,
+    * but apparently it does.
+    */
+   socket_is_alive = !FD_ISSET(sfd, &readable_fds);
+
+   log_error(LOG_LEVEL_INFO,
+      "Detecting already dead sockets might not work correctly "
+      "on your platform. Anyway, socket %d appears to be %s.",
+      sfd, (socket_is_alive ? "still alive" : "already dead"));
+
+   return socket_is_alive;
+#endif /* def HAVE_POLL */
+}
+
+
+/*********************************************************************
+ *
+ * Function    :  get_reusable_connection
+ *
+ * Description :  Returns an open socket to a previously remembered
+ *                open connection (if there is one).
+ *
+ * Parameters  :
+ *          1  :  http = The destination for the connection.
+ *          2  :  fwd  = The forwarder settings.
+ *
+ * Returns     :  JB_INVALID_SOCKET => No reusable connection found,
+ *                otherwise a usable socket.
+ *
+ *********************************************************************/
+static jb_socket get_reusable_connection(const struct http_request *http,
+                                         const struct forward_spec *fwd)
+{
+   jb_socket sfd = JB_INVALID_SOCKET;
+   unsigned int slot = 0;
+
+   privoxy_mutex_lock(&connection_reuse_mutex);
+
+   close_unusable_connections();
+
+   for (slot = 0; slot < SZ(reusable_connection); slot++)
+   {
+      if (!reusable_connection[slot].in_use
+         && (JB_INVALID_SOCKET != reusable_connection[slot].sfd))
+      {
+         if (connection_destination_matches(&reusable_connection[slot], http, fwd))
+         {
+            reusable_connection[slot].in_use = TRUE;
+            sfd = reusable_connection[slot].sfd;
+            log_error(LOG_LEVEL_CONNECT,
+               "Found reusable socket %d for %s:%d in slot %d.",
+               sfd, reusable_connection[slot].host, reusable_connection[slot].port, slot);
+            break;
+         }
+      }
+   }
+
+   privoxy_mutex_unlock(&connection_reuse_mutex);
+
+   return sfd;
+
+}
+
+
+/*********************************************************************
+ *
+ * Function    :  mark_connection_unused
+ *
+ * Description :  Gives a remembered connection free for reuse.
+ *
+ * Parameters  :
+ *          1  :  sfd = The socket belonging to the connection in question.
+ *
+ * Returns     :  TRUE => Socket found and marked as unused.
+ *                FALSE => Socket not found.
+ *
+ *********************************************************************/
+static int mark_connection_unused(jb_socket sfd)
+{
+   unsigned int slot = 0;
+   int socket_found = FALSE;
+
+   assert(sfd != JB_INVALID_SOCKET);
+
+   privoxy_mutex_lock(&connection_reuse_mutex);
+
+   for (slot = 0; slot < SZ(reusable_connection); slot++)
+   {
+      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;
+      }
+   }
+
+   privoxy_mutex_unlock(&connection_reuse_mutex);
+
+   return socket_found;
+
+}
+#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
+
 
 /*********************************************************************
  *
@@ -221,6 +839,21 @@ jb_socket forwarded_connect(const struct forward_spec * fwd,
 {
    const char * dest_host;
    int dest_port;
+   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
+   {
+      return sfd;
+   }
+#endif /* def FEATURE_CONNECTION_KEEP_ALIVE */
 
    /* Figure out if we need to connect to the web server or a HTTP proxy. */
    if (fwd->forward_host)
@@ -240,18 +873,23 @@ jb_socket forwarded_connect(const struct forward_spec * fwd,
    switch (fwd->type)
    {
       case SOCKS_NONE:
-         return (connect_to(dest_host, dest_port, csp));
-
+         sfd = connect_to(dest_host, dest_port, csp);
+         break;
       case SOCKS_4:
       case SOCKS_4A:
-         return (socks4_connect(fwd, dest_host, dest_port, csp));
-
+         sfd = socks4_connect(fwd, dest_host, dest_port, csp);
+         break;
+      case SOCKS_5:
+         sfd = socks5_connect(fwd, dest_host, dest_port, csp);
+         break;
       default:
          /* Should never get here */
-         log_error(LOG_LEVEL_FATAL, "SOCKS4 impossible internal error - bad SOCKS type.");
-         errno = EINVAL;
-         return(JB_INVALID_SOCKET);
+         log_error(LOG_LEVEL_FATAL,
+            "SOCKS4 impossible internal error - bad SOCKS type.");
    }
+
+   return sfd;
+
 }
 
 
@@ -283,7 +921,7 @@ static jb_socket socks4_connect(const struct forward_spec * fwd,
                                 int target_port,
                                 struct client_state *csp)
 {
-   int web_server_addr;
+   unsigned int web_server_addr;
    char buf[BUFFER_SIZE];
    struct socks_op    *c = (struct socks_op    *)buf;
    struct socks_reply *s = (struct socks_reply *)buf;
@@ -323,13 +961,17 @@ static jb_socket socks4_connect(const struct forward_spec * fwd,
    switch (fwd->type)
    {
       case SOCKS_4:
-         web_server_addr = htonl(resolve_hostname_to_ip(target_host));
+         web_server_addr = resolve_hostname_to_ip(target_host);
          if (web_server_addr == INADDR_NONE)
          {
             errstr = "could not resolve target host";
             log_error(LOG_LEVEL_CONNECT, "socks4_connect: %s %s", errstr, target_host);
             err = 1;
          }
+         else
+         {
+            web_server_addr = htonl(web_server_addr);
+         }
          break;
       case SOCKS_4A:
          web_server_addr = 0x00000001;
@@ -449,6 +1091,248 @@ static jb_socket socks4_connect(const struct forward_spec * fwd,
 
 }
 
+/*********************************************************************
+ *
+ * Function    :  translate_socks5_error
+ *
+ * Description :  Translates a SOCKS errors to a string.
+ *
+ * Parameters  :
+ *          1  :  socks_error = The error code to translate.
+ *
+ * Returns     :  The string translation.
+ *
+ *********************************************************************/
+static const char *translate_socks5_error(int socks_error)
+{
+   switch (socks_error)
+   {
+      /* XXX: these should be more descriptive */
+      case SOCKS5_REQUEST_FAILED:
+         return "SOCKS5 request failed";
+      case SOCKS5_REQUEST_DENIED:
+         return "SOCKS5 request denied";
+      case SOCKS5_REQUEST_NETWORK_UNREACHABLE:
+         return "SOCKS5 network unreachable";
+      case SOCKS5_REQUEST_HOST_UNREACHABLE:
+         return "SOCKS5 host unreachable";
+      case SOCKS5_REQUEST_CONNECTION_REFUSED:
+         return "SOCKS5 connection refused";
+      case SOCKS5_REQUEST_TTL_EXPIRED:
+         return "SOCKS5 TTL expired";
+      case SOCKS5_REQUEST_PROTOCOL_ERROR:
+         return "SOCKS5 client protocol error";
+      case SOCKS5_REQUEST_BAD_ADDRESS_TYPE:
+         return "SOCKS5 domain names unsupported";
+      case SOCKS5_REQUEST_GRANTED:
+         return "everything's peachy";
+      default:
+         return "SOCKS5 negotiation protocol error";
+   }
+}
+
+/*********************************************************************
+ *
+ * Function    :  socks5_connect
+ *
+ * Description :  Connect to the SOCKS server, and connect through
+ *                it to the specified server.   This handles
+ *                all the SOCKS negotiation, and returns a file
+ *                descriptor for a socket which can be treated as a
+ *                normal (non-SOCKS) socket.
+ *
+ * Parameters  :
+ *          1  :  fwd = Specifies the SOCKS proxy to use.
+ *          2  :  target_host = The final server to connect to.
+ *          3  :  target_port = The final port to connect to.
+ *          4  :  csp = Current client state (buffers, headers, etc...)
+ *
+ * Returns     :  JB_INVALID_SOCKET => failure, else a socket file descriptor.
+ *
+ *********************************************************************/
+static jb_socket socks5_connect(const struct forward_spec *fwd,
+                                const char *target_host,
+                                int target_port,
+                                struct client_state *csp)
+{
+   int err = 0;
+   char cbuf[300];
+   char sbuf[30];
+   size_t client_pos = 0;
+   int server_size = 0;
+   size_t hostlen = 0;
+   jb_socket sfd;
+   const char *errstr = NULL;
+
+   assert(fwd->gateway_host);
+   if ((fwd->gateway_host == NULL) || (*fwd->gateway_host == '\0'))
+   {
+      errstr = "NULL gateway host specified";
+      err = 1;
+   }
+
+   if (fwd->gateway_port <= 0)
+   {
+      /*
+       * XXX: currently this can't happen because in
+       * case of invalid gateway ports we use the defaults.
+       * Of course we really shouldn't do that.
+       */
+      errstr = "invalid gateway port specified";
+      err = 1;
+   }
+
+   hostlen = strlen(target_host);
+   if (hostlen > 255)
+   {
+      errstr = "target host name is longer than 255 characters";
+      err = 1;
+   }
+
+   if (fwd->type != SOCKS_5)
+   {
+      /* Should never get here */
+      log_error(LOG_LEVEL_FATAL,
+         "SOCKS5 impossible internal error - bad SOCKS type");
+      err = 1;
+   }
+
+   if (err)
+   {
+      errno = EINVAL;
+      assert(errstr != NULL);
+      log_error(LOG_LEVEL_CONNECT, "socks5_connect: %s", errstr);
+      csp->error_message = strdup(errstr);
+      return(JB_INVALID_SOCKET);
+   }
+
+   /* pass the request to the socks server */
+   sfd = connect_to(fwd->gateway_host, fwd->gateway_port, csp);
+
+   if (sfd == JB_INVALID_SOCKET)
+   {
+      errstr = "socks5 server unreachable";
+      log_error(LOG_LEVEL_CONNECT, "socks5_connect: %s", errstr);
+      csp->error_message = strdup(errstr);
+      return(JB_INVALID_SOCKET);
+   }
+
+   client_pos = 0;
+   cbuf[client_pos++] = '\x05'; /* Version */
+   cbuf[client_pos++] = '\x01'; /* One authentication method supported */
+   cbuf[client_pos++] = '\x00'; /* The no authentication authentication method */
+
+   if (write_socket(sfd, cbuf, client_pos))
+   {
+      errstr = "SOCKS5 negotiation write failed";
+      csp->error_message = strdup(errstr);
+      log_error(LOG_LEVEL_CONNECT, "%s", errstr);
+      close_socket(sfd);
+      return(JB_INVALID_SOCKET);
+   }
+
+   if (read_socket(sfd, sbuf, sizeof(sbuf)) != 2)
+   {
+      errstr = "SOCKS5 negotiation read failed";
+      err = 1;
+   }
+
+   if (!err && (sbuf[0] != '\x05'))
+   {
+      errstr = "SOCKS5 negotiation protocol version error";
+      err = 1;
+   }
+
+   if (!err && (sbuf[1] == '\xff'))
+   {
+      errstr = "SOCKS5 authentication required";
+      err = 1;
+   }
+
+   if (!err && (sbuf[1] != '\x00'))
+   {
+      errstr = "SOCKS5 negotiation protocol error";
+      err = 1;
+   }
+
+   if (err)
+   {
+      assert(errstr != NULL);
+      log_error(LOG_LEVEL_CONNECT, "socks5_connect: %s", errstr);
+      csp->error_message = strdup(errstr);
+      close_socket(sfd);
+      errno = EINVAL;
+      return(JB_INVALID_SOCKET);
+   }
+
+   client_pos = 0;
+   cbuf[client_pos++] = '\x05'; /* Version */
+   cbuf[client_pos++] = '\x01'; /* TCP connect */
+   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);
+   /* 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) & 0xff);
+   cbuf[client_pos++] = (char)((target_port     ) & 0xff);
+
+   if (write_socket(sfd, cbuf, client_pos))
+   {
+      errstr = "SOCKS5 negotiation read failed";
+      csp->error_message = strdup(errstr);
+      log_error(LOG_LEVEL_CONNECT, "%s", errstr);
+      close_socket(sfd);
+      errno = EINVAL;
+      return(JB_INVALID_SOCKET);
+   }
+
+   server_size = read_socket(sfd, sbuf, sizeof(sbuf));
+   if (server_size < 3)
+   {
+      errstr = "SOCKS5 negotiation read failed";
+      err = 1;
+   }
+   else if (server_size > 20)
+   {
+      /* This is somewhat unexpected but doesn't realy matter. */
+      log_error(LOG_LEVEL_CONNECT, "socks5_connect: read %d bytes "
+         "from socks server. Would have accepted up to %d.",
+         server_size, sizeof(sbuf));
+   }
+
+   if (!err && (sbuf[0] != '\x05'))
+   {
+      errstr = "SOCKS5 negotiation protocol version error";
+      err = 1;
+   }
+
+   if (!err && (sbuf[2] != '\x00'))
+   {
+      errstr = "SOCKS5 negotiation protocol error";
+      err = 1;
+   }
+
+   if (!err)
+   {
+      if (sbuf[1] == SOCKS5_REQUEST_GRANTED)
+      {
+         return(sfd);
+      }
+      errstr = translate_socks5_error(sbuf[1]);
+      err = 1;
+   }
+
+   assert(errstr != NULL);
+   csp->error_message = strdup(errstr);
+   log_error(LOG_LEVEL_CONNECT, "socks5_connect: %s", errstr);
+   close_socket(sfd);
+   errno = EINVAL;
+
+   return(JB_INVALID_SOCKET);
+
+}
 
 /*
   Local Variables: