]> sjero.net Git - wget/blobdiff - src/http.c
[svn] Remove the "rbuf" buffering layer. Provide peeking primitives instead.
[wget] / src / http.c
index 10451f9b35b0c05ad826daf49e2f7d0315813b4f..de1cb084dbb1d15baabb8266332d5558d54c06cc 100644 (file)
@@ -1,5 +1,5 @@
 /* HTTP support.
 /* HTTP support.
-   Copyright (C) 1995, 1996, 1997, 1998, 2000, 2001
+   Copyright (C) 1995, 1996, 1997, 1998, 2000, 2001, 2002
    Free Software Foundation, Inc.
 
 This file is part of GNU Wget.
    Free Software Foundation, Inc.
 
 This file is part of GNU Wget.
@@ -7,7 +7,7 @@ This file is part of GNU Wget.
 GNU Wget is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 GNU Wget is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+ (at your option) any later version.
 
 GNU Wget is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 
 GNU Wget is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -16,7 +16,17 @@ GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with Wget; if not, write to the Free Software
 
 You should have received a copy of the GNU General Public License
 along with Wget; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+In addition, as a special exception, the Free Software Foundation
+gives permission to link the code of its release of Wget with the
+OpenSSL project's "OpenSSL" library (or with modified versions of it
+that use the same license as the "OpenSSL" library), and distribute
+the linked executables.  You must obey the GNU General Public License
+in all respects for all of the code used other than "OpenSSL".  If you
+modify this file, you may extend this exception to your version of the
+file, but you are not obligated to do so.  If you do not wish to do
+so, delete this exception statement from your version.  */
 
 #include <config.h>
 
 
 #include <config.h>
 
@@ -43,52 +53,44 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #  include <time.h>
 # endif
 #endif
 #  include <time.h>
 # endif
 #endif
-
-#ifdef WINDOWS
-# include <winsock.h>
-#else
-# include <netdb.h>            /* for h_errno */
+#ifndef errno
+extern int errno;
 #endif
 
 #include "wget.h"
 #include "utils.h"
 #include "url.h"
 #include "host.h"
 #endif
 
 #include "wget.h"
 #include "utils.h"
 #include "url.h"
 #include "host.h"
-#include "rbuf.h"
 #include "retr.h"
 #include "headers.h"
 #include "connect.h"
 #include "retr.h"
 #include "headers.h"
 #include "connect.h"
-#include "fnmatch.h"
 #include "netrc.h"
 #include "netrc.h"
-#if USE_DIGEST
-# include "md5.h"
-#endif
 #ifdef HAVE_SSL
 # include "gen_sslfunc.h"
 #endif /* HAVE_SSL */
 #include "cookies.h"
 #ifdef HAVE_SSL
 # include "gen_sslfunc.h"
 #endif /* HAVE_SSL */
 #include "cookies.h"
+#ifdef USE_DIGEST
+# include "gen-md5.h"
+#endif
+#include "convert.h"
 
 extern char *version_string;
 
 extern char *version_string;
+extern LARGE_INT total_downloaded_bytes;
 
 
-#ifndef errno
-extern int errno;
-#endif
-#ifndef h_errno
-# ifndef __CYGWIN__
-extern int h_errno;
-# endif
-#endif
 \f
 static int cookies_loaded_p;
 \f
 static int cookies_loaded_p;
+struct cookie_jar *wget_cookie_jar;
 
 #define TEXTHTML_S "text/html"
 
 #define TEXTHTML_S "text/html"
+#define TEXTXHTML_S "application/xhtml+xml"
 #define HTTP_ACCEPT "*/*"
 
 /* Some status code validation macros: */
 #define H_20X(x)        (((x) >= 200) && ((x) < 300))
 #define H_PARTIAL(x)    ((x) == HTTP_STATUS_PARTIAL_CONTENTS)
 #define HTTP_ACCEPT "*/*"
 
 /* Some status code validation macros: */
 #define H_20X(x)        (((x) >= 200) && ((x) < 300))
 #define H_PARTIAL(x)    ((x) == HTTP_STATUS_PARTIAL_CONTENTS)
-#define H_REDIRECTED(x) (((x) == HTTP_STATUS_MOVED_PERMANENTLY)        \
-                        || ((x) == HTTP_STATUS_MOVED_TEMPORARILY))
+#define H_REDIRECTED(x) ((x) == HTTP_STATUS_MOVED_PERMANENTLY  \
+                         || (x) == HTTP_STATUS_MOVED_TEMPORARILY \
+                        || (x) == HTTP_STATUS_TEMPORARY_REDIRECT)
 
 /* HTTP/1.0 status codes from RFC1945, provided for reference.  */
 /* Successful 2xx.  */
 
 /* HTTP/1.0 status codes from RFC1945, provided for reference.  */
 /* Successful 2xx.  */
@@ -103,6 +105,7 @@ static int cookies_loaded_p;
 #define HTTP_STATUS_MOVED_PERMANENTLY  301
 #define HTTP_STATUS_MOVED_TEMPORARILY  302
 #define HTTP_STATUS_NOT_MODIFIED       304
 #define HTTP_STATUS_MOVED_PERMANENTLY  301
 #define HTTP_STATUS_MOVED_TEMPORARILY  302
 #define HTTP_STATUS_NOT_MODIFIED       304
+#define HTTP_STATUS_TEMPORARY_REDIRECT  307
 
 /* Client error 4xx.  */
 #define HTTP_STATUS_BAD_REQUEST                400
 
 /* Client error 4xx.  */
 #define HTTP_STATUS_BAD_REQUEST                400
@@ -180,6 +183,73 @@ parse_http_status_line (const char *line, const char **reason_phrase_ptr)
 
   return statcode;
 }
 
   return statcode;
 }
+\f
+#define WMIN(x, y) ((x) > (y) ? (y) : (x))
+
+/* Send the contents of FILE_NAME to SOCK/SSL.  Make sure that exactly
+   PROMISED_SIZE bytes are sent over the wire -- if the file is
+   longer, read only that much; if the file is shorter, report an error.  */
+
+static int
+post_file (int sock, const char *file_name, long promised_size)
+{
+  static char chunk[8192];
+  long written = 0;
+  int write_error;
+  FILE *fp;
+
+  DEBUGP (("[writing POST file %s ... ", file_name));
+
+  fp = fopen (file_name, "rb");
+  if (!fp)
+    return -1;
+  while (!feof (fp) && written < promised_size)
+    {
+      int towrite;
+      int length = fread (chunk, 1, sizeof (chunk), fp);
+      if (length == 0)
+       break;
+      towrite = WMIN (promised_size - written, length);
+      write_error = fd_write (sock, chunk, towrite, -1);
+      if (write_error < 0)
+       {
+         fclose (fp);
+         return -1;
+       }
+      written += towrite;
+    }
+  fclose (fp);
+
+  /* If we've written less than was promised, report a (probably
+     nonsensical) error rather than break the promise.  */
+  if (written < promised_size)
+    {
+      errno = EINVAL;
+      return -1;
+    }
+
+  assert (written == promised_size);
+  DEBUGP (("done]\n"));
+  return 0;
+}
+\f
+static const char *
+next_header (const char *h)
+{
+  const char *end = NULL;
+  const char *p = h;
+  do
+    {
+      p = strchr (p, '\n');
+      if (!p)
+       return end;
+      end = ++p;
+    }
+  while (*p == ' ' || *p == '\t');
+
+  return end;
+}
+
 \f
 /* Functions to be used as arguments to header_process(): */
 
 \f
 /* Functions to be used as arguments to header_process(): */
 
@@ -205,6 +275,10 @@ http_process_range (const char *hdr, void *arg)
   if (!strncasecmp (hdr, "bytes", 5))
     {
       hdr += 5;
   if (!strncasecmp (hdr, "bytes", 5))
     {
       hdr += 5;
+      /* "JavaWebServer/1.1.1" sends "bytes: x-y/z", contrary to the
+        HTTP spec. */
+      if (*hdr == ':')
+       ++hdr;
       hdr += skip_lws (hdr);
       if (!*hdr)
        return 0;
       hdr += skip_lws (hdr);
       if (!*hdr)
        return 0;
@@ -267,44 +341,55 @@ http_process_connection (const char *hdr, void *arg)
     *flag = 1;
   return 1;
 }
     *flag = 1;
   return 1;
 }
+
+/* Commit the cookie to the cookie jar. */
+
+int
+http_process_set_cookie (const char *hdr, void *arg)
+{
+  struct url *u = (struct url *)arg;
+
+  /* The jar should have been created by now. */
+  assert (wget_cookie_jar != NULL);
+
+  cookie_handle_set_cookie (wget_cookie_jar, u->host, u->port, u->path, hdr);
+  return 1;
+}
+
 \f
 /* Persistent connections.  Currently, we cache the most recently used
    connection as persistent, provided that the HTTP server agrees to
    make it such.  The persistence data is stored in the variables
 \f
 /* Persistent connections.  Currently, we cache the most recently used
    connection as persistent, provided that the HTTP server agrees to
    make it such.  The persistence data is stored in the variables
-   below.  Ideally, it would be in a structure, and it should be
-   possible to cache an arbitrary fixed number of these connections.
-
-   I think the code is quite easy to extend in that direction.  */
+   below.  Ideally, it should be possible to cache an arbitrary fixed
+   number of these connections.  */
 
 /* Whether a persistent connection is active. */
 
 /* Whether a persistent connection is active. */
-static int pc_active_p;
-/* Host and port of currently active persistent connection. */
-static unsigned char pc_last_host[4];
-static unsigned short pc_last_port;
+static int pconn_active;
 
 
-/* File descriptor of the currently active persistent connection. */
-static int pc_last_fd;
+static struct {
+  /* The socket of the connection.  */
+  int socket;
 
 
-#ifdef HAVE_SSL
-/* Whether a ssl handshake has occoured on this connection */
-static int pc_active_ssl;
-/* SSL connection of the currently active persistent connection. */
-static SSL *pc_last_ssl;
-#endif /* HAVE_SSL */
+  /* Host and port of the currently active persistent connection. */
+  char *host;
+  int port;
 
 
-/* Mark the persistent connection as invalid.  This is used by the
-   CLOSE_* macros after they forcefully close a registered persistent
-   connection.  This does not close the file descriptor -- it is left
-   to the caller to do that.  (Maybe it should, though.)  */
+  /* Whether a ssl handshake has occoured on this connection.  */
+  int ssl;
+} pconn;
+
+/* Mark the persistent connection as invalid and free the resources it
+   uses.  This is used by the CLOSE_* macros after they forcefully
+   close a registered persistent connection.  */
 
 static void
 invalidate_persistent (void)
 {
 
 static void
 invalidate_persistent (void)
 {
-  pc_active_p = 0;
-#ifdef HAVE_SSL
-  pc_active_ssl = 0;
-#endif /* HAVE_SSL */
-  DEBUGP (("Invalidating fd %d from further reuse.\n", pc_last_fd));
+  DEBUGP (("Disabling further reuse of socket %d.\n", pconn.socket));
+  pconn_active = 0;
+  fd_close (pconn.socket);
+  xfree (pconn.host);
+  xzero (pconn);
 }
 
 /* Register FD, which should be a TCP/IP connection to HOST:PORT, as
 }
 
 /* Register FD, which should be a TCP/IP connection to HOST:PORT, as
@@ -316,112 +401,126 @@ invalidate_persistent (void)
    If a previous connection was persistent, it is closed. */
 
 static void
    If a previous connection was persistent, it is closed. */
 
 static void
-register_persistent (const char *host, unsigned short port, int fd
-#ifdef HAVE_SSL
-                    , SSL *ssl
-#endif
-                    )
+register_persistent (const char *host, int port, int fd, int ssl)
 {
 {
-  int success;
-
-  if (pc_active_p)
+  if (pconn_active)
     {
     {
-      if (pc_last_fd == fd)
+      if (pconn.socket == fd)
        {
        {
-         /* The connection FD is already registered.  Nothing to
-            do. */
+         /* The connection FD is already registered. */
          return;
        }
       else
        {
          return;
        }
       else
        {
-         /* The old persistent connection is still active; let's
-            close it first.  This situation arises whenever a
-            persistent connection exists, but we then connect to a
-            different host, and try to register a persistent
-            connection to that one.  */
-#ifdef HAVE_SSL
-         /* The ssl disconnect has to take place before the closing
-             of pc_last_fd.  */
-         if (pc_last_ssl)
-           shutdown_ssl(pc_last_ssl);
-#endif
-         CLOSE (pc_last_fd);
+         /* The old persistent connection is still active; close it
+            first.  This situation arises whenever a persistent
+            connection exists, but we then connect to a different
+            host, and try to register a persistent connection to that
+            one.  */
          invalidate_persistent ();
        }
     }
 
          invalidate_persistent ();
        }
     }
 
-  /* This store_hostaddress may not fail, because it has the results
-     in the cache.  */
-  success = store_hostaddress (pc_last_host, host);
-  assert (success);
-  pc_last_port = port;
-  pc_last_fd = fd;
-  pc_active_p = 1;
-#ifdef HAVE_SSL
-  pc_last_ssl = ssl;
-  pc_active_ssl = ssl ? 1 : 0;
-#endif
-  DEBUGP (("Registered fd %d for persistent reuse.\n", fd));
+  pconn_active = 1;
+  pconn.socket = fd;
+  pconn.host = xstrdup (host);
+  pconn.port = port;
+  pconn.ssl = ssl;
+
+  DEBUGP (("Registered socket %d for persistent reuse.\n", fd));
 }
 
 /* Return non-zero if a persistent connection is available for
    connecting to HOST:PORT.  */
 
 static int
 }
 
 /* Return non-zero if a persistent connection is available for
    connecting to HOST:PORT.  */
 
 static int
-persistent_available_p (const char *host, unsigned short port
-#ifdef HAVE_SSL
-                       , int ssl
-#endif
-                       )
+persistent_available_p (const char *host, int port, int ssl,
+                       int *host_lookup_failed)
 {
 {
-  unsigned char this_host[4];
   /* First, check whether a persistent connection is active at all.  */
   /* First, check whether a persistent connection is active at all.  */
-  if (!pc_active_p)
-    return 0;
-  /* Second, check if the active connection pertains to the correct
-     (HOST, PORT) ordered pair.  */
-  if (port != pc_last_port)
+  if (!pconn_active)
     return 0;
     return 0;
-#ifdef HAVE_SSL
-  /* Second, a): check if current connection is (not) ssl, too.  This
-     test is unlikely to fail because HTTP and HTTPS typicaly use
-     different ports.  Yet it is possible, or so I [Christian
-     Fraenkel] have been told, to run HTTPS and HTTP simultaneus on
-     the same port.  */
-  if (ssl != pc_active_ssl)
-    return 0;
-#endif /* HAVE_SSL */
-  if (!store_hostaddress (this_host, host))
+
+  /* If we want SSL and the last connection wasn't or vice versa,
+     don't use it.  Checking for host and port is not enough because
+     HTTP and HTTPS can apparently coexist on the same port.  */
+  if (ssl != pconn.ssl)
     return 0;
     return 0;
-  if (memcmp (pc_last_host, this_host, 4))
+
+  /* If we're not connecting to the same port, we're not interested. */
+  if (port != pconn.port)
     return 0;
     return 0;
-  /* Third: check whether the connection is still open.  This is
+
+  /* If the host is the same, we're in business.  If not, there is
+     still hope -- read below.  */
+  if (0 != strcasecmp (host, pconn.host))
+    {
+      /* If pconn.socket is already talking to HOST, we needn't
+        reconnect.  This happens often when both sites are virtual
+        hosts distinguished only by name and served by the same
+        network interface, and hence the same web server (possibly
+        set up by the ISP and serving many different web sites).
+        This admittedly non-standard optimization does not contradict
+        HTTP and works well with popular server software.  */
+
+      int found;
+      ip_address ip;
+      struct address_list *al;
+
+      if (ssl)
+       /* Don't try to talk to two different SSL sites over the same
+          secure connection!  (Besides, it's not clear if name-based
+          virtual hosting is even possible with SSL.)  */
+       return 0;
+
+      /* If pconn.socket's peer is one of the IP addresses HOST
+        resolves to, pconn.socket is for all intents and purposes
+        already talking to HOST.  */
+
+      if (!socket_ip_address (pconn.socket, &ip, ENDPOINT_PEER))
+       {
+         /* Can't get the peer's address -- something must be very
+            wrong with the connection.  */
+         invalidate_persistent ();
+         return 0;
+       }
+      al = lookup_host (host, 0);
+      if (!al)
+       {
+         *host_lookup_failed = 1;
+         return 0;
+       }
+
+      found = address_list_contains (al, &ip);
+      address_list_release (al);
+
+      if (!found)
+       return 0;
+
+      /* The persistent connection's peer address was found among the
+        addresses HOST resolved to; therefore, pconn.sock is in fact
+        already talking to HOST -- no need to reconnect.  */
+    }
+
+  /* Finally, check whether the connection is still open.  This is
      important because most server implement a liberal (short) timeout
      on persistent connections.  Wget can of course always reconnect
      if the connection doesn't work out, but it's nicer to know in
      advance.  This test is a logical followup of the first test, but
      is "expensive" and therefore placed at the end of the list.  */
      important because most server implement a liberal (short) timeout
      on persistent connections.  Wget can of course always reconnect
      if the connection doesn't work out, but it's nicer to know in
      advance.  This test is a logical followup of the first test, but
      is "expensive" and therefore placed at the end of the list.  */
-  if (!test_socket_open (pc_last_fd))
+
+  if (!test_socket_open (pconn.socket))
     {
       /* Oops, the socket is no longer open.  Now that we know that,
          let's invalidate the persistent connection before returning
          0.  */
     {
       /* Oops, the socket is no longer open.  Now that we know that,
          let's invalidate the persistent connection before returning
          0.  */
-      CLOSE (pc_last_fd);
       invalidate_persistent ();
       return 0;
     }
       invalidate_persistent ();
       return 0;
     }
+
   return 1;
 }
 
   return 1;
 }
 
-#ifdef HAVE_SSL
-# define SHUTDOWN_SSL(ssl) do {                \
-  if (ssl)                             \
-    shutdown_ssl (ssl);                        \
-} while (0)
-#else
-# define SHUTDOWN_SSL(ssl) 
-#endif
-
 /* The idea behind these two CLOSE macros is to distinguish between
    two cases: one when the job we've been doing is finished, and we
    want to close the connection and leave, and two when something is
 /* The idea behind these two CLOSE macros is to distinguish between
    two cases: one when the job we've been doing is finished, and we
    want to close the connection and leave, and two when something is
@@ -440,18 +539,18 @@ persistent_available_p (const char *host, unsigned short port
 #define CLOSE_FINISH(fd) do {                  \
   if (!keep_alive)                             \
     {                                          \
 #define CLOSE_FINISH(fd) do {                  \
   if (!keep_alive)                             \
     {                                          \
-      SHUTDOWN_SSL (ssl);                      \
-      CLOSE (fd);                              \
-      if (pc_active_p && (fd) == pc_last_fd)   \
+      if (pconn_active && (fd) == pconn.socket)        \
        invalidate_persistent ();               \
        invalidate_persistent ();               \
+      else                                     \
+       fd_close (fd);                          \
     }                                          \
 } while (0)
 
 #define CLOSE_INVALIDATE(fd) do {              \
     }                                          \
 } while (0)
 
 #define CLOSE_INVALIDATE(fd) do {              \
-  SHUTDOWN_SSL (ssl);                          \
-  CLOSE (fd);                                  \
-  if (pc_active_p && (fd) == pc_last_fd)       \
+  if (pconn_active && (fd) == pconn.socket)    \
     invalidate_persistent ();                  \
     invalidate_persistent ();                  \
+  else                                         \
+    fd_close (fd);                             \
 } while (0)
 \f
 struct http_stat
 } while (0)
 \f
 struct http_stat
@@ -464,19 +563,25 @@ struct http_stat
   char *remote_time;           /* remote time-stamp string */
   char *error;                 /* textual HTTP error */
   int statcode;                        /* status code */
   char *remote_time;           /* remote time-stamp string */
   char *error;                 /* textual HTTP error */
   int statcode;                        /* status code */
-  long dltime;                 /* time of the download */
+  double dltime;               /* time of the download in msecs */
   int no_truncate;             /* whether truncating the file is
                                   forbidden. */
   int no_truncate;             /* whether truncating the file is
                                   forbidden. */
+  const char *referer;         /* value of the referer header. */
+  char **local_file;           /* local file. */
 };
 
 };
 
-/* Free the elements of hstat X.  */
-#define FREEHSTAT(x) do                                        \
-{                                                      \
-  FREE_MAYBE ((x).newloc);                             \
-  FREE_MAYBE ((x).remote_time);                                \
-  FREE_MAYBE ((x).error);                              \
-  (x).newloc = (x).remote_time = (x).error = NULL;     \
-} while (0)
+static void
+free_hstat (struct http_stat *hs)
+{
+  xfree_null (hs->newloc);
+  xfree_null (hs->remote_time);
+  xfree_null (hs->error);
+
+  /* Guard against being called twice. */
+  hs->newloc = NULL;
+  hs->remote_time = NULL;
+  hs->error = NULL;
+}
 
 static char *create_authorization_line PARAMS ((const char *, const char *,
                                                const char *, const char *,
 
 static char *create_authorization_line PARAMS ((const char *, const char *,
                                                const char *, const char *,
@@ -485,7 +590,7 @@ static char *basic_authentication_encode PARAMS ((const char *, const char *,
                                                  const char *));
 static int known_authentication_scheme_p PARAMS ((const char *));
 
                                                  const char *));
 static int known_authentication_scheme_p PARAMS ((const char *));
 
-time_t http_atotm PARAMS ((char *));
+time_t http_atotm PARAMS ((const char *));
 
 #define BEGINS_WITH(line, string_constant)                             \
   (!strncasecmp (line, string_constant, sizeof (string_constant) - 1)  \
 
 #define BEGINS_WITH(line, string_constant)                             \
   (!strncasecmp (line, string_constant, sizeof (string_constant) - 1)  \
@@ -498,38 +603,32 @@ time_t http_atotm PARAMS ((char *));
    will print it if there is enough information to do so (almost
    always), returning the error to the caller (i.e. http_loop).
 
    will print it if there is enough information to do so (almost
    always), returning the error to the caller (i.e. http_loop).
 
-   Various HTTP parameters are stored to hs.  Although it parses the
-   response code correctly, it is not used in a sane way.  The caller
-   can do that, though.
+   Various HTTP parameters are stored to hs.
 
 
-   If u->proxy is non-NULL, the URL u will be taken as a proxy URL,
-   and u->proxy->url will be given to the proxy server (bad naming,
-   I'm afraid).  */
+   If PROXY is non-NULL, the connection will be made to the proxy
+   server, and u->url will be requested.  */
 static uerr_t
 static uerr_t
-gethttp (struct urlinfo *u, struct http_stat *hs, int *dt)
+gethttp (struct url *u, struct http_stat *hs, int *dt, struct url *proxy)
 {
 {
-  char *request, *type, *command, *path;
+  char *request, *type, *command, *full_path;
   char *user, *passwd;
   char *user, *passwd;
-  char *pragma_h, *referer, *useragent, *range, *wwwauth, *remhost;
+  char *pragma_h, *referer, *useragent, *range, *wwwauth;
   char *authenticate_h;
   char *proxyauth;
   char *authenticate_h;
   char *proxyauth;
-  char *all_headers;
   char *port_maybe;
   char *request_keep_alive;
   char *port_maybe;
   char *request_keep_alive;
-  int sock, hcount, num_written, all_length, remport, statcode;
+  int sock, hcount, statcode;
+  int write_error;
   long contlen, contrange;
   long contlen, contrange;
-  struct urlinfo *ou;
-  uerr_t err;
+  struct url *conn;
   FILE *fp;
   int auth_tried_already;
   FILE *fp;
   int auth_tried_already;
-  struct rbuf rbuf;
-#ifdef HAVE_SSL
-  static SSL_CTX *ssl_ctx = NULL;
-  SSL *ssl = NULL;
-#endif /* HAVE_SSL */
-  struct wget_timer *timer;
+  int using_ssl = 0;
   char *cookies = NULL;
 
   char *cookies = NULL;
 
+  char *head;
+  const char *hdr_beg, *hdr_end;
+
   /* Whether this connection will be kept alive after the HTTP request
      is done. */
   int keep_alive;
   /* Whether this connection will be kept alive after the HTTP request
      is done. */
   int keep_alive;
@@ -541,53 +640,55 @@ gethttp (struct urlinfo *u, struct http_stat *hs, int *dt)
   /* Whether keep-alive should be inhibited. */
   int inhibit_keep_alive;
 
   /* Whether keep-alive should be inhibited. */
   int inhibit_keep_alive;
 
+  /* Whether we need to print the host header with braces around host,
+     e.g. "Host: [3ffe:8100:200:2::2]:1234" instead of the usual
+     "Host: symbolic-name:1234". */
+  int squares_around_host = 0;
+
+  /* Headers sent when using POST. */
+  char *post_content_type, *post_content_length;
+  long post_data_size = 0;
+
+  int host_lookup_failed;
+
 #ifdef HAVE_SSL
 #ifdef HAVE_SSL
-  /* initialize ssl_ctx on first run */
-  if (!ssl_ctx)
+  /* Initialize the SSL context.  After the first run, this is a
+     no-op.  */
+  switch (ssl_init ())
     {
     {
-      err=init_ssl (&ssl_ctx);
-      if (err != 0)
-       {
-         switch (err)
-           {
-           case SSLERRCTXCREATE:
-             /* this is fatal */
-             logprintf (LOG_NOTQUIET, _("Failed to set up an SSL context\n"));
-             ssl_printerrors ();
-             return err;
-           case SSLERRCERTFILE:
-             /* try without certfile */
-             logprintf (LOG_NOTQUIET,
-                        _("Failed to load certificates from %s\n"),
-                        opt.sslcertfile);
-             ssl_printerrors ();
-             logprintf (LOG_NOTQUIET,
-                        _("Trying without the specified certificate\n"));
-             break;
-           case SSLERRCERTKEY:
-             logprintf (LOG_NOTQUIET,
-                        _("Failed to get certificate key from %s\n"),
-                        opt.sslcertkey);
-             ssl_printerrors ();
-             logprintf (LOG_NOTQUIET,
-                        _("Trying without the specified certificate\n"));
-             break;
-           default:
-             break;
-           }
-       }
+    case SSLERRCTXCREATE:
+      /* this is fatal */
+      logprintf (LOG_NOTQUIET, _("Failed to set up an SSL context\n"));
+      return SSLERRCTXCREATE;
+    case SSLERRCERTFILE:
+      /* try without certfile */
+      logprintf (LOG_NOTQUIET,
+                _("Failed to load certificates from %s\n"),
+                opt.sslcertfile);
+      logprintf (LOG_NOTQUIET,
+                _("Trying without the specified certificate\n"));
+      break;
+    case SSLERRCERTKEY:
+      logprintf (LOG_NOTQUIET,
+                _("Failed to get certificate key from %s\n"),
+                opt.sslcertkey);
+      logprintf (LOG_NOTQUIET,
+                _("Trying without the specified certificate\n"));
+      break;
+    default:
+      break;
     }
 #endif /* HAVE_SSL */
 
   if (!(*dt & HEAD_ONLY))
     /* If we're doing a GET on the URL, as opposed to just a HEAD, we need to
        know the local filename so we can save to it. */
     }
 #endif /* HAVE_SSL */
 
   if (!(*dt & HEAD_ONLY))
     /* If we're doing a GET on the URL, as opposed to just a HEAD, we need to
        know the local filename so we can save to it. */
-    assert (u->local != NULL);
+    assert (*hs->local_file != NULL);
 
   authenticate_h = 0;
   auth_tried_already = 0;
 
 
   authenticate_h = 0;
   auth_tried_already = 0;
 
-  inhibit_keep_alive = (!opt.http_keep_alive || u->proxy != NULL);
+  inhibit_keep_alive = !opt.http_keep_alive || proxy != NULL;
 
  again:
   /* We need to come back here when the initial attempt to retrieve
 
  again:
   /* We need to come back here when the initial attempt to retrieve
@@ -597,6 +698,9 @@ gethttp (struct urlinfo *u, struct http_stat *hs, int *dt)
   keep_alive = 0;
   http_keep_alive_1 = http_keep_alive_2 = 0;
 
   keep_alive = 0;
   http_keep_alive_1 = http_keep_alive_2 = 0;
 
+  post_content_type = NULL;
+  post_content_length = NULL;
+
   /* Initialize certain elements of struct http_stat.  */
   hs->len = 0L;
   hs->contlen = -1;
   /* Initialize certain elements of struct http_stat.  */
   hs->len = 0L;
   hs->contlen = -1;
@@ -605,95 +709,78 @@ gethttp (struct urlinfo *u, struct http_stat *hs, int *dt)
   hs->remote_time = NULL;
   hs->error = NULL;
 
   hs->remote_time = NULL;
   hs->error = NULL;
 
-  /* Which structure to use to retrieve the original URL data.  */
-  if (u->proxy)
-    ou = u->proxy;
-  else
-    ou = u;
+  /* If we're using a proxy, we will be connecting to the proxy
+     server. */
+  conn = proxy ? proxy : u;
+
+  host_lookup_failed = 0;
 
   /* First: establish the connection.  */
   if (inhibit_keep_alive
 
   /* First: establish the connection.  */
   if (inhibit_keep_alive
-      ||
-#ifndef HAVE_SSL
-      !persistent_available_p (u->host, u->port)
+      || !persistent_available_p (conn->host, conn->port,
+#ifdef HAVE_SSL
+                                 u->scheme == SCHEME_HTTPS
 #else
 #else
-      !persistent_available_p (u->host, u->port, (u->proto==URLHTTPS ? 1 : 0))
-#endif /* HAVE_SSL */
-      )
+                                 0
+#endif
+                                 , &host_lookup_failed))
     {
     {
-      logprintf (LOG_VERBOSE, _("Connecting to %s:%hu... "), u->host, u->port);
-      err = make_connection (&sock, u->host, u->port);
-      switch (err)
-       {
-       case HOSTERR:
-         logputs (LOG_VERBOSE, "\n");
-         logprintf (LOG_NOTQUIET, "%s: %s.\n", u->host, herrmsg (h_errno));
-         return HOSTERR;
-         break;
-       case CONSOCKERR:
-         logputs (LOG_VERBOSE, "\n");
-         logprintf (LOG_NOTQUIET, "socket: %s\n", strerror (errno));
-         return CONSOCKERR;
-         break;
-       case CONREFUSED:
-         logputs (LOG_VERBOSE, "\n");
-         logprintf (LOG_NOTQUIET,
-                    _("Connection to %s:%hu refused.\n"), u->host, u->port);
-         CLOSE (sock);
-         return CONREFUSED;
-       case CONERROR:
-         logputs (LOG_VERBOSE, "\n");
-         logprintf (LOG_NOTQUIET, "connect: %s\n", strerror (errno));
-         CLOSE (sock);
-         return CONERROR;
-         break;
-       case NOCONERROR:
-         /* Everything is fine!  */
-         logputs (LOG_VERBOSE, _("connected!\n"));
-         break;
-       default:
-         abort ();
-         break;
-       }
+      /* In its current implementation, persistent_available_p will
+        look up conn->host in some cases.  If that lookup failed, we
+        don't need to bother with connect_to_host.  */
+      if (host_lookup_failed)
+       return HOSTERR;
+
+      sock = connect_to_host (conn->host, conn->port);
+      if (sock == E_HOST)
+       return HOSTERR;
+      else if (sock < 0)
+       return (retryable_socket_connect_error (errno)
+               ? CONERROR : CONIMPOSSIBLE);
+
 #ifdef HAVE_SSL
 #ifdef HAVE_SSL
-     if (u->proto == URLHTTPS)
-       if (connect_ssl (&ssl, ssl_ctx,sock) != 0)
-        {
-          logputs (LOG_VERBOSE, "\n");
-          logprintf (LOG_NOTQUIET, _("Unable to establish SSL connection.\n"));
-          CLOSE (sock);
-          return CONSSLERR;
-        }
+     if (conn->scheme == SCHEME_HTTPS)
+       {
+        if (!ssl_connect (sock))
+          {
+            logputs (LOG_VERBOSE, "\n");
+            logprintf (LOG_NOTQUIET,
+                       _("Unable to establish SSL connection.\n"));
+            fd_close (sock);
+            return CONSSLERR;
+          }
+        using_ssl = 1;
+       }
 #endif /* HAVE_SSL */
     }
   else
     {
 #endif /* HAVE_SSL */
     }
   else
     {
-      logprintf (LOG_VERBOSE, _("Reusing connection to %s:%hu.\n"), u->host, u->port);
-      /* #### pc_last_fd should be accessed through an accessor
-         function.  */
-      sock = pc_last_fd;
-#ifdef HAVE_SSL
-      ssl = pc_last_ssl;
-#endif /* HAVE_SSL */
+      logprintf (LOG_VERBOSE, _("Reusing existing connection to %s:%d.\n"),
+                pconn.host, pconn.port);
+      sock = pconn.socket;
+      using_ssl = pconn.ssl;
       DEBUGP (("Reusing fd %d.\n", sock));
     }
 
       DEBUGP (("Reusing fd %d.\n", sock));
     }
 
-  if (u->proxy)
-    path = u->proxy->url;
+  if (*dt & HEAD_ONLY)
+    command = "HEAD";
+  else if (opt.post_file_name || opt.post_data)
+    command = "POST";
   else
   else
-    path = u->path;
-  
-  command = (*dt & HEAD_ONLY) ? "HEAD" : "GET";
+    command = "GET";
+
   referer = NULL;
   referer = NULL;
-  if (ou->referer)
+  if (hs->referer)
     {
     {
-      referer = (char *)alloca (9 + strlen (ou->referer) + 3);
-      sprintf (referer, "Referer: %s\r\n", ou->referer);
+      referer = (char *)alloca (9 + strlen (hs->referer) + 3);
+      sprintf (referer, "Referer: %s\r\n", hs->referer);
     }
     }
+
   if (*dt & SEND_NOCACHE)
     pragma_h = "Pragma: no-cache\r\n";
   else
     pragma_h = "";
   if (*dt & SEND_NOCACHE)
     pragma_h = "Pragma: no-cache\r\n";
   else
     pragma_h = "";
+
   if (hs->restval)
     {
       range = (char *)alloca (13 + numdigit (hs->restval) + 4);
   if (hs->restval)
     {
       range = (char *)alloca (13 + numdigit (hs->restval) + 4);
@@ -716,9 +803,9 @@ gethttp (struct urlinfo *u, struct http_stat *hs, int *dt)
       sprintf (useragent, "Wget/%s", version_string);
     }
   /* Construct the authentication, if userid is present.  */
       sprintf (useragent, "Wget/%s", version_string);
     }
   /* Construct the authentication, if userid is present.  */
-  user = ou->user;
-  passwd = ou->passwd;
-  search_netrc (ou->host, (const char **)&user, (const char **)&passwd, 0);
+  user = u->user;
+  passwd = u->passwd;
+  search_netrc (u->host, (const char **)&user, (const char **)&passwd, 0);
   user = user ? user : opt.http_user;
   passwd = passwd ? passwd : opt.http_passwd;
 
   user = user ? user : opt.http_user;
   passwd = passwd ? passwd : opt.http_passwd;
 
@@ -751,13 +838,18 @@ gethttp (struct urlinfo *u, struct http_stat *hs, int *dt)
        }
       else
        {
        }
       else
        {
+         /* Use the full path, i.e. one that includes the leading
+            slash and the query string, but is independent of proxy
+            setting.  */
+         char *pth = url_full_path (u);
          wwwauth = create_authorization_line (authenticate_h, user, passwd,
          wwwauth = create_authorization_line (authenticate_h, user, passwd,
-                                              command, ou->path);
+                                              command, pth);
+         xfree (pth);
        }
     }
 
   proxyauth = NULL;
        }
     }
 
   proxyauth = NULL;
-  if (u->proxy)
+  if (proxy)
     {
       char *proxy_user, *proxy_passwd;
       /* For normal username and password, URL components override
     {
       char *proxy_user, *proxy_passwd;
       /* For normal username and password, URL components override
@@ -772,31 +864,22 @@ gethttp (struct urlinfo *u, struct http_stat *hs, int *dt)
        }
       else
        {
        }
       else
        {
-         proxy_user = u->user;
-         proxy_passwd = u->passwd;
+         proxy_user = proxy->user;
+         proxy_passwd = proxy->passwd;
        }
        }
-      /* #### This is junky.  Can't the proxy request, say, `Digest'
-         authentication?  */
+      /* #### This does not appear right.  Can't the proxy request,
+         say, `Digest' authentication?  */
       if (proxy_user && proxy_passwd)
        proxyauth = basic_authentication_encode (proxy_user, proxy_passwd,
                                                 "Proxy-Authorization");
     }
       if (proxy_user && proxy_passwd)
        proxyauth = basic_authentication_encode (proxy_user, proxy_passwd,
                                                 "Proxy-Authorization");
     }
-  remhost = ou->host;
-  remport = ou->port;
 
   /* String of the form :PORT.  Used only for non-standard ports. */
   port_maybe = NULL;
 
   /* String of the form :PORT.  Used only for non-standard ports. */
   port_maybe = NULL;
-  if (1
-#ifdef HAVE_SSL
-      && remport != (u->proto == URLHTTPS
-                    ? DEFAULT_HTTPS_PORT : DEFAULT_HTTP_PORT)
-#else
-      && remport != DEFAULT_HTTP_PORT
-#endif
-      )
+  if (u->port != scheme_default_port (u->scheme))
     {
     {
-      port_maybe = (char *)alloca (numdigit (remport) + 2);
-      sprintf (port_maybe, ":%d", remport);
+      port_maybe = (char *)alloca (numdigit (u->port) + 2);
+      sprintf (port_maybe, ":%d", u->port);
     }
 
   if (!inhibit_keep_alive)
     }
 
   if (!inhibit_keep_alive)
@@ -805,13 +888,50 @@ gethttp (struct urlinfo *u, struct http_stat *hs, int *dt)
     request_keep_alive = NULL;
 
   if (opt.cookies)
     request_keep_alive = NULL;
 
   if (opt.cookies)
-    cookies = build_cookies_request (ou->host, ou->port, ou->path,
-                                    ou->proto == URLHTTPS);
+    cookies = cookie_header (wget_cookie_jar, u->host, u->port, u->path,
+#ifdef HAVE_SSL
+                            u->scheme == SCHEME_HTTPS
+#else
+                            0
+#endif
+                            );
+
+  if (opt.post_data || opt.post_file_name)
+    {
+      post_content_type = "Content-Type: application/x-www-form-urlencoded\r\n";
+      if (opt.post_data)
+       post_data_size = strlen (opt.post_data);
+      else
+       {
+         post_data_size = file_size (opt.post_file_name);
+         if (post_data_size == -1)
+           {
+             logprintf (LOG_NOTQUIET, "POST data file missing: %s\n",
+                        opt.post_file_name);
+             post_data_size = 0;
+           }
+       }
+      post_content_length = xmalloc (16 + numdigit (post_data_size) + 2 + 1);
+      sprintf (post_content_length,
+              "Content-Length: %ld\r\n", post_data_size);
+    }
+
+  if (proxy)
+    full_path = xstrdup (u->url);
+  else
+    /* Use the full path, i.e. one that includes the leading slash and
+       the query string.  E.g. if u->path is "foo/bar" and u->query is
+       "param=value", full_path will be "/foo/bar?param=value".  */
+    full_path = url_full_path (u);
+
+  if (strchr (u->host, ':'))
+    squares_around_host = 1;
 
   /* Allocate the memory for the request.  */
 
   /* Allocate the memory for the request.  */
-  request = (char *)alloca (strlen (command) + strlen (path)
+  request = (char *)alloca (strlen (command)
+                           + strlen (full_path)
                            + strlen (useragent)
                            + strlen (useragent)
-                           + strlen (remhost)
+                           + strlen (u->host)
                            + (port_maybe ? strlen (port_maybe) : 0)
                            + strlen (HTTP_ACCEPT)
                            + (request_keep_alive
                            + (port_maybe ? strlen (port_maybe) : 0)
                            + strlen (HTTP_ACCEPT)
                            + (request_keep_alive
@@ -822,16 +942,22 @@ gethttp (struct urlinfo *u, struct http_stat *hs, int *dt)
                            + (proxyauth ? strlen (proxyauth) : 0)
                            + (range ? strlen (range) : 0)
                            + strlen (pragma_h)
                            + (proxyauth ? strlen (proxyauth) : 0)
                            + (range ? strlen (range) : 0)
                            + strlen (pragma_h)
+                           + (post_content_type
+                              ? strlen (post_content_type) : 0)
+                           + (post_content_length
+                              ? strlen (post_content_length) : 0)
                            + (opt.user_header ? strlen (opt.user_header) : 0)
                            + 64);
   /* Construct the request.  */
   sprintf (request, "\
 %s %s HTTP/1.0\r\n\
 User-Agent: %s\r\n\
                            + (opt.user_header ? strlen (opt.user_header) : 0)
                            + 64);
   /* Construct the request.  */
   sprintf (request, "\
 %s %s HTTP/1.0\r\n\
 User-Agent: %s\r\n\
-Host: %s%s\r\n\
+Host: %s%s%s%s\r\n\
 Accept: %s\r\n\
 Accept: %s\r\n\
-%s%s%s%s%s%s%s%s\r\n",
-          command, path, useragent, remhost,
+%s%s%s%s%s%s%s%s%s%s\r\n",
+          command, full_path,
+          useragent,
+          squares_around_host ? "[" : "", u->host, squares_around_host ? "]" : "",
           port_maybe ? port_maybe : "",
           HTTP_ACCEPT,
           request_keep_alive ? request_keep_alive : "",
           port_maybe ? port_maybe : "",
           HTTP_ACCEPT,
           request_keep_alive ? request_keep_alive : "",
@@ -840,23 +966,34 @@ Accept: %s\r\n\
           wwwauth ? wwwauth : "", 
           proxyauth ? proxyauth : "", 
           range ? range : "",
           wwwauth ? wwwauth : "", 
           proxyauth ? proxyauth : "", 
           range ? range : "",
-          pragma_h, 
+          pragma_h,
+          post_content_type ? post_content_type : "",
+          post_content_length ? post_content_length : "",
           opt.user_header ? opt.user_header : "");
           opt.user_header ? opt.user_header : "");
-  DEBUGP (("---request begin---\n%s---request end---\n", request));
-   /* Free the temporary memory.  */
-  FREE_MAYBE (wwwauth);
-  FREE_MAYBE (proxyauth);
-  FREE_MAYBE (cookies);
+  DEBUGP (("\n---request begin---\n%s", request));
+
+  /* Free the temporary memory.  */
+  xfree_null (wwwauth);
+  xfree_null (proxyauth);
+  xfree_null (cookies);
+  xfree (full_path);
 
   /* Send the request to server.  */
 
   /* Send the request to server.  */
-#ifdef HAVE_SSL
-  if (u->proto == URLHTTPS)
-    num_written = ssl_iwrite (ssl, request, strlen (request));
-  else
-#endif /* HAVE_SSL */
-    num_written = iwrite (sock, request, strlen (request));
+  write_error = fd_write (sock, request, strlen (request), -1);
+
+  if (write_error >= 0)
+    {
+      if (opt.post_data)
+       {
+         DEBUGP (("[POST data: %s]\n", opt.post_data));
+         write_error = fd_write (sock, opt.post_data, post_data_size, -1);
+       }
+      else if (opt.post_file_name && post_data_size != 0)
+       write_error = post_file (sock, opt.post_file_name, post_data_size);
+    }
+  DEBUGP (("---request end---\n"));
 
 
-  if (num_written < 0)
+  if (write_error < 0)
     {
       logprintf (LOG_VERBOSE, _("Failed writing HTTP request: %s.\n"),
                 strerror (errno));
     {
       logprintf (LOG_VERBOSE, _("Failed writing HTTP request: %s.\n"),
                 strerror (errno));
@@ -864,83 +1001,49 @@ Accept: %s\r\n\
       return WRITEFAILED;
     }
   logprintf (LOG_VERBOSE, _("%s request sent, awaiting response... "),
       return WRITEFAILED;
     }
   logprintf (LOG_VERBOSE, _("%s request sent, awaiting response... "),
-            u->proxy ? "Proxy" : "HTTP");
+            proxy ? "Proxy" : "HTTP");
   contlen = contrange = -1;
   type = NULL;
   statcode = -1;
   *dt &= ~RETROKF;
 
   contlen = contrange = -1;
   type = NULL;
   statcode = -1;
   *dt &= ~RETROKF;
 
-  /* Before reading anything, initialize the rbuf.  */
-  rbuf_initialize (&rbuf, sock);
-#ifdef HAVE_SSL
-  if (u->proto == URLHTTPS)
-    rbuf.ssl = ssl;
-  else
-    rbuf.ssl = NULL;
-#endif /* HAVE_SSL */
-  all_headers = NULL;
-  all_length = 0;
-  /* Header-fetching loop.  */
-  hcount = 0;
-  while (1)
-    {
-      char *hdr;
-      int status;
-
-      ++hcount;
-      /* Get the header.  */
-      status = header_get (&rbuf, &hdr,
-                          /* Disallow continuations for status line.  */
-                          (hcount == 1 ? HG_NO_CONTINUATIONS : HG_NONE));
+  DEBUGP (("\n---response begin---\n"));
 
 
-      /* Check for errors.  */
-      if (status == HG_EOF && *hdr)
+  head = fd_read_head (sock);
+  if (!head)
+    {
+      logputs (LOG_VERBOSE, "\n");
+      if (errno == 0)
        {
        {
-         /* This used to be an unconditional error, but that was
-             somewhat controversial, because of a large number of
-             broken CGI's that happily "forget" to send the second EOL
-             before closing the connection of a HEAD request.
-
-            So, the deal is to check whether the header is empty
-            (*hdr is zero if it is); if yes, it means that the
-            previous header was fully retrieved, and that -- most
-            probably -- the request is complete.  "...be liberal in
-            what you accept."  Oh boy.  */
-         logputs (LOG_VERBOSE, "\n");
-         logputs (LOG_NOTQUIET, _("End of file while parsing headers.\n"));
-         xfree (hdr);
-         FREE_MAYBE (type);
-         FREE_MAYBE (all_headers);
+         logputs (LOG_NOTQUIET, _("No data received.\n"));
          CLOSE_INVALIDATE (sock);
          return HEOF;
        }
          CLOSE_INVALIDATE (sock);
          return HEOF;
        }
-      else if (status == HG_ERROR)
+      else
        {
        {
-         logputs (LOG_VERBOSE, "\n");
          logprintf (LOG_NOTQUIET, _("Read error (%s) in headers.\n"),
                     strerror (errno));
          logprintf (LOG_NOTQUIET, _("Read error (%s) in headers.\n"),
                     strerror (errno));
-         xfree (hdr);
-         FREE_MAYBE (type);
-         FREE_MAYBE (all_headers);
          CLOSE_INVALIDATE (sock);
          return HERR;
        }
          CLOSE_INVALIDATE (sock);
          return HERR;
        }
+    }
 
 
-      /* If the headers are to be saved to a file later, save them to
-        memory now.  */
-      if (opt.save_headers)
-       {
-         int lh = strlen (hdr);
-         all_headers = (char *)xrealloc (all_headers, all_length + lh + 2);
-         memcpy (all_headers + all_length, hdr, lh);
-         all_length += lh;
-         all_headers[all_length++] = '\n';
-         all_headers[all_length] = '\0';
-       }
+  /* Loop through the headers and process them. */
 
 
-      /* Print the header if requested.  */
-      if (opt.server_response && hcount != 1)
-       logprintf (LOG_VERBOSE, "\n%d %s", hcount, hdr);
+  hcount = 0;
+  for (hdr_beg = head;
+       (hdr_end = next_header (hdr_beg));
+       hdr_beg = hdr_end)
+    {
+      char *hdr = strdupdelim (hdr_beg, hdr_end);
+      {
+       char *tmp = hdr + strlen (hdr);
+       if (tmp > hdr && tmp[-1] == '\n')
+         *--tmp = '\0';
+       if (tmp > hdr && tmp[-1] == '\r')
+         *--tmp = '\0';
+      }
+      ++hcount;
 
       /* Check for status line.  */
       if (hcount == 1)
 
       /* Check for status line.  */
       if (hcount == 1)
@@ -968,11 +1071,16 @@ Accept: %s\r\n\
            hs->error = xstrdup (error);
 
          if ((statcode != -1)
            hs->error = xstrdup (error);
 
          if ((statcode != -1)
-#ifdef DEBUG
+#ifdef ENABLE_DEBUG
              && !opt.debug
 #endif
              )
              && !opt.debug
 #endif
              )
-           logprintf (LOG_VERBOSE, "%d %s", statcode, error);
+           {
+             if (opt.server_response)
+              logprintf (LOG_VERBOSE, "\n%2d %s", hcount, hdr);
+             else
+              logprintf (LOG_VERBOSE, "%2d %s", statcode, error);
+           }
 
          goto done_header;
        }
 
          goto done_header;
        }
@@ -984,6 +1092,10 @@ Accept: %s\r\n\
          break;
        }
 
          break;
        }
 
+      /* Print the header if requested.  */
+      if (opt.server_response && hcount != 1)
+       logprintf (LOG_VERBOSE, "\n%2d %s", hcount, hdr);
+
       /* Try getting content-length.  */
       if (contlen == -1 && !opt.ignore_length)
        if (header_process (hdr, "Content-Length", header_extract_number,
       /* Try getting content-length.  */
       if (contlen == -1 && !opt.ignore_length)
        if (header_process (hdr, "Content-Length", header_extract_number,
@@ -1004,7 +1116,7 @@ Accept: %s\r\n\
          goto done_header;
       /* Try getting cookies. */
       if (opt.cookies)
          goto done_header;
       /* Try getting cookies. */
       if (opt.cookies)
-       if (header_process (hdr, "Set-Cookie", set_cookie_header_cb, u))
+       if (header_process (hdr, "Set-Cookie", http_process_set_cookie, u))
          goto done_header;
       /* Try getting www-authentication.  */
       if (!authenticate_h)
          goto done_header;
       /* Try getting www-authentication.  */
       if (!authenticate_h)
@@ -1054,6 +1166,7 @@ Accept: %s\r\n\
     done_header:
       xfree (hdr);
     }
     done_header:
       xfree (hdr);
     }
+  DEBUGP (("---response end---\n"));
 
   logputs (LOG_VERBOSE, "\n");
 
 
   logputs (LOG_VERBOSE, "\n");
 
@@ -1066,19 +1179,15 @@ Accept: %s\r\n\
   if (keep_alive)
     /* The server has promised that it will not close the connection
        when we're done.  This means that we can register it.  */
   if (keep_alive)
     /* The server has promised that it will not close the connection
        when we're done.  This means that we can register it.  */
-#ifndef HAVE_SSL
-    register_persistent (u->host, u->port, sock);
-#else
-    register_persistent (u->host, u->port, sock, ssl);
-#endif /* HAVE_SSL */
+    register_persistent (conn->host, conn->port, sock, using_ssl);
 
   if ((statcode == HTTP_STATUS_UNAUTHORIZED)
       && authenticate_h)
     {
       /* Authorization is required.  */
 
   if ((statcode == HTTP_STATUS_UNAUTHORIZED)
       && authenticate_h)
     {
       /* Authorization is required.  */
-      FREE_MAYBE (type);
+      xfree_null (type);
       type = NULL;
       type = NULL;
-      FREEHSTAT (*hs);
+      free_hstat (hs);
       CLOSE_INVALIDATE (sock); /* would be CLOSE_FINISH, but there
                                   might be more bytes in the body. */
       if (auth_tried_already)
       CLOSE_INVALIDATE (sock); /* would be CLOSE_FINISH, but there
                                   might be more bytes in the body. */
       if (auth_tried_already)
@@ -1138,16 +1247,19 @@ Accept: %s\r\n\
                     hs->newloc ? _(" [following]") : "");
          CLOSE_INVALIDATE (sock);      /* would be CLOSE_FINISH, but there
                                           might be more bytes in the body. */
                     hs->newloc ? _(" [following]") : "");
          CLOSE_INVALIDATE (sock);      /* would be CLOSE_FINISH, but there
                                           might be more bytes in the body. */
-         FREE_MAYBE (type);
-         FREE_MAYBE (all_headers);
+         xfree_null (type);
          return NEWLOCATION;
        }
     }
 
          return NEWLOCATION;
        }
     }
 
-  if (type && !strncasecmp (type, TEXTHTML_S, strlen (TEXTHTML_S)))
+  /* If content-type is not given, assume text/html.  This is because
+     of the multitude of broken CGI's that "forget" to generate the
+     content-type.  */
+  if (!type ||
+        0 == strncasecmp (type, TEXTHTML_S, strlen (TEXTHTML_S)) ||
+        0 == strncasecmp (type, TEXTXHTML_S, strlen (TEXTXHTML_S)))
     *dt |= TEXTHTML;
   else
     *dt |= TEXTHTML;
   else
-    /* We don't assume text/html by default.  */
     *dt &= ~TEXTHTML;
 
   if (opt.html_extension && (*dt & TEXTHTML))
     *dt &= ~TEXTHTML;
 
   if (opt.html_extension && (*dt & TEXTHTML))
@@ -1155,16 +1267,17 @@ Accept: %s\r\n\
        text/html file.  If some case-insensitive variation on ".htm[l]" isn't
        already the file's suffix, tack on ".html". */
     {
        text/html file.  If some case-insensitive variation on ".htm[l]" isn't
        already the file's suffix, tack on ".html". */
     {
-      char*  last_period_in_local_filename = strrchr(u->local, '.');
+      char*  last_period_in_local_filename = strrchr(*hs->local_file, '.');
 
 
-      if (last_period_in_local_filename == NULL ||
-         !(strcasecmp(last_period_in_local_filename, ".htm") == EQ ||
-           strcasecmp(last_period_in_local_filename, ".html") == EQ))
+      if (last_period_in_local_filename == NULL
+         || !(0 == strcasecmp (last_period_in_local_filename, ".htm")
+              || 0 == strcasecmp (last_period_in_local_filename, ".html")))
        {
        {
-         size_t  local_filename_len = strlen(u->local);
+         size_t  local_filename_len = strlen(*hs->local_file);
          
          
-         u->local = xrealloc(u->local, local_filename_len + sizeof(".html"));
-         strcpy(u->local + local_filename_len, ".html");
+         *hs->local_file = xrealloc(*hs->local_file,
+                                    local_filename_len + sizeof(".html"));
+         strcpy(*hs->local_file + local_filename_len, ".html");
 
          *dt |= ADDED_HTML_EXTENSION;
        }
 
          *dt |= ADDED_HTML_EXTENSION;
        }
@@ -1202,8 +1315,9 @@ Accept: %s\r\n\
              /* In case the caller inspects. */
              hs->len = contlen;
              hs->res = 0;
              /* In case the caller inspects. */
              hs->len = contlen;
              hs->res = 0;
-             FREE_MAYBE (type);
-             FREE_MAYBE (all_headers);
+             /* Mark as successfully retrieved. */
+             *dt |= RETROKF;
+             xfree_null (type);
              CLOSE_INVALIDATE (sock);  /* would be CLOSE_FINISH, but there
                                           might be more bytes in the body. */
              return RETRUNNEEDED;
              CLOSE_INVALIDATE (sock);  /* would be CLOSE_FINISH, but there
                                           might be more bytes in the body. */
              return RETRUNNEEDED;
@@ -1216,9 +1330,8 @@ Accept: %s\r\n\
                         _("\
 \n\
 Continued download failed on this file, which conflicts with `-c'.\n\
                         _("\
 \n\
 Continued download failed on this file, which conflicts with `-c'.\n\
-Refusing to truncate existing file `%s'.\n\n"), u->local);
-             FREE_MAYBE (type);
-             FREE_MAYBE (all_headers);
+Refusing to truncate existing file `%s'.\n\n"), *hs->local_file);
+             xfree_null (type);
              CLOSE_INVALIDATE (sock);
              return CONTNOTSUPPORTED;
            }
              CLOSE_INVALIDATE (sock);
              return CONTNOTSUPPORTED;
            }
@@ -1233,8 +1346,7 @@ Refusing to truncate existing file `%s'.\n\n"), u->local);
     {
       /* This means the whole request was somehow misunderstood by the
         server.  Bail out.  */
     {
       /* This means the whole request was somehow misunderstood by the
         server.  Bail out.  */
-      FREE_MAYBE (type);
-      FREE_MAYBE (all_headers);
+      xfree_null (type);
       CLOSE_INVALIDATE (sock);
       return RANGEERR;
     }
       CLOSE_INVALIDATE (sock);
       return RANGEERR;
     }
@@ -1273,7 +1385,7 @@ Refusing to truncate existing file `%s'.\n\n"), u->local);
            logputs (LOG_VERBOSE, "\n");
        }
     }
            logputs (LOG_VERBOSE, "\n");
        }
     }
-  FREE_MAYBE (type);
+  xfree_null (type);
   type = NULL;                 /* We don't need it any more.  */
 
   /* Return if we have no intention of further downloading.  */
   type = NULL;                 /* We don't need it any more.  */
 
   /* Return if we have no intention of further downloading.  */
@@ -1282,8 +1394,7 @@ Refusing to truncate existing file `%s'.\n\n"), u->local);
       /* In case the caller cares to look...  */
       hs->len = 0L;
       hs->res = 0;
       /* In case the caller cares to look...  */
       hs->len = 0L;
       hs->res = 0;
-      FREE_MAYBE (type);
-      FREE_MAYBE (all_headers);
+      xfree_null (type);
       CLOSE_INVALIDATE (sock); /* would be CLOSE_FINISH, but there
                                   might be more bytes in the body. */
       return RETRFINISHED;
       CLOSE_INVALIDATE (sock); /* would be CLOSE_FINISH, but there
                                   might be more bytes in the body. */
       return RETRFINISHED;
@@ -1292,16 +1403,15 @@ Refusing to truncate existing file `%s'.\n\n"), u->local);
   /* Open the local file.  */
   if (!opt.dfp)
     {
   /* Open the local file.  */
   if (!opt.dfp)
     {
-      mkalldirs (u->local);
+      mkalldirs (*hs->local_file);
       if (opt.backups)
       if (opt.backups)
-       rotate_backups (u->local);
-      fp = fopen (u->local, hs->restval ? "ab" : "wb");
+       rotate_backups (*hs->local_file);
+      fp = fopen (*hs->local_file, hs->restval ? "ab" : "wb");
       if (!fp)
        {
       if (!fp)
        {
-         logprintf (LOG_NOTQUIET, "%s: %s\n", u->local, strerror (errno));
+         logprintf (LOG_NOTQUIET, "%s: %s\n", *hs->local_file, strerror (errno));
          CLOSE_INVALIDATE (sock); /* would be CLOSE_FINISH, but there
                                      might be more bytes in the body. */
          CLOSE_INVALIDATE (sock); /* would be CLOSE_FINISH, but there
                                      might be more bytes in the body. */
-         FREE_MAYBE (all_headers);
          return FOPENERR;
        }
     }
          return FOPENERR;
        }
     }
@@ -1321,8 +1431,12 @@ Refusing to truncate existing file `%s'.\n\n"), u->local);
 
          #### A possible solution to this would be to remember the
         file position in the output document and to seek to that
 
          #### A possible solution to this would be to remember the
         file position in the output document and to seek to that
-        position, instead of rewinding.  */
-      if (!hs->restval && global_download_count == 0)
+        position, instead of rewinding.
+
+         We don't truncate stdout, since that breaks
+        "wget -O - [...] >> foo".
+      */
+      if (!hs->restval && global_download_count == 0 && opt.dfp != stdout)
        {
          /* This will silently fail for streams that don't correspond
             to regular files, but that's OK.  */
        {
          /* This will silently fail for streams that don't correspond
             to regular files, but that's OK.  */
@@ -1337,14 +1451,18 @@ Refusing to truncate existing file `%s'.\n\n"), u->local);
   /* #### This confuses the code that checks for file size.  There
      should be some overhead information.  */
   if (opt.save_headers)
   /* #### This confuses the code that checks for file size.  There
      should be some overhead information.  */
   if (opt.save_headers)
-    fwrite (all_headers, 1, all_length, fp);
-  timer = wtimer_new ();
+    fwrite (head, 1, strlen (head), fp);
+
   /* Get the contents of the document.  */
   /* Get the contents of the document.  */
-  hs->res = get_contents (sock, fp, &hs->len, hs->restval,
+  hs->res = fd_read_body (sock, fp, &hs->len, hs->restval,
                          (contlen != -1 ? contlen : 0),
                          (contlen != -1 ? contlen : 0),
-                         &rbuf, keep_alive);
-  hs->dltime = wtimer_elapsed (timer);
-  wtimer_delete (timer);
+                         keep_alive, &hs->dltime);
+
+  if (hs->res >= 0)
+    CLOSE_FINISH (sock);
+  else
+    CLOSE_INVALIDATE (sock);
+
   {
     /* Close or flush the file.  We have to be careful to check for
        error here.  Checking the result of fwrite() is not enough --
   {
     /* Close or flush the file.  We have to be careful to check for
        error here.  Checking the result of fwrite() is not enough --
@@ -1357,8 +1475,6 @@ Refusing to truncate existing file `%s'.\n\n"), u->local);
     if (flush_res == EOF)
       hs->res = -2;
   }
     if (flush_res == EOF)
       hs->res = -2;
   }
-  FREE_MAYBE (all_headers);
-  CLOSE_FINISH (sock);
   if (hs->res == -2)
     return FWRITEERR;
   return RETRFINISHED;
   if (hs->res == -2)
     return FWRITEERR;
   return RETRFINISHED;
@@ -1367,27 +1483,34 @@ Refusing to truncate existing file `%s'.\n\n"), u->local);
 /* The genuine HTTP loop!  This is the part where the retrieval is
    retried, and retried, and retried, and...  */
 uerr_t
 /* The genuine HTTP loop!  This is the part where the retrieval is
    retried, and retried, and retried, and...  */
 uerr_t
-http_loop (struct urlinfo *u, char **newloc, int *dt)
+http_loop (struct url *u, char **newloc, char **local_file, const char *referer,
+          int *dt, struct url *proxy)
 {
   int count;
   int use_ts, got_head = 0;    /* time-stamping info */
   char *filename_plus_orig_suffix;
   char *local_filename = NULL;
 {
   int count;
   int use_ts, got_head = 0;    /* time-stamping info */
   char *filename_plus_orig_suffix;
   char *local_filename = NULL;
-  char *tms, *suf, *locf, *tmrate;
+  char *tms, *locf, *tmrate;
   uerr_t err;
   time_t tml = -1, tmr = -1;   /* local and remote time-stamps */
   long local_size = 0;         /* the size of the local file */
   size_t filename_len;
   struct http_stat hstat;      /* HTTP status */
   struct stat st;
   uerr_t err;
   time_t tml = -1, tmr = -1;   /* local and remote time-stamps */
   long local_size = 0;         /* the size of the local file */
   size_t filename_len;
   struct http_stat hstat;      /* HTTP status */
   struct stat st;
+  char *dummy = NULL;
 
   /* This used to be done in main(), but it's a better idea to do it
      here so that we don't go through the hoops if we're just using
      FTP or whatever. */
 
   /* This used to be done in main(), but it's a better idea to do it
      here so that we don't go through the hoops if we're just using
      FTP or whatever. */
-  if (opt.cookies && opt.cookies_input && !cookies_loaded_p)
+  if (opt.cookies)
     {
     {
-      load_cookies (opt.cookies_input);
-      cookies_loaded_p = 1;
+      if (!wget_cookie_jar)
+       wget_cookie_jar = cookie_jar_new ();
+      if (opt.cookies_input && !cookies_loaded_p)
+       {
+         cookie_jar_load (wget_cookie_jar, opt.cookies_input);
+         cookies_loaded_p = 1;
+       }
     }
 
   *newloc = NULL;
     }
 
   *newloc = NULL;
@@ -1399,41 +1522,51 @@ http_loop (struct urlinfo *u, char **newloc, int *dt)
     logputs (LOG_VERBOSE, _("Warning: wildcards not supported in HTTP.\n"));
 
   /* Determine the local filename.  */
     logputs (LOG_VERBOSE, _("Warning: wildcards not supported in HTTP.\n"));
 
   /* Determine the local filename.  */
-  if (!u->local)
-    u->local = url_filename (u->proxy ? u->proxy : u);
+  if (local_file && *local_file)
+    hstat.local_file = local_file;
+  else if (local_file)
+    {
+      *local_file = url_file_name (u);
+      hstat.local_file = local_file;
+    }
+  else
+    {
+      dummy = url_file_name (u);
+      hstat.local_file = &dummy;
+    }
 
   if (!opt.output_document)
 
   if (!opt.output_document)
-    locf = u->local;
+    locf = *hstat.local_file;
   else
     locf = opt.output_document;
 
   else
     locf = opt.output_document;
 
-  filename_len = strlen (u->local);
+  hstat.referer = referer;
+
+  filename_len = strlen (*hstat.local_file);
   filename_plus_orig_suffix = alloca (filename_len + sizeof (".orig"));
 
   filename_plus_orig_suffix = alloca (filename_len + sizeof (".orig"));
 
-  if (opt.noclobber && file_exists_p (u->local))
+  if (opt.noclobber && file_exists_p (*hstat.local_file))
     {
       /* If opt.noclobber is turned on and file already exists, do not
         retrieve the file */
       logprintf (LOG_VERBOSE, _("\
     {
       /* If opt.noclobber is turned on and file already exists, do not
         retrieve the file */
       logprintf (LOG_VERBOSE, _("\
-File `%s' already there, will not retrieve.\n"), u->local);
+File `%s' already there, will not retrieve.\n"), *hstat.local_file);
       /* If the file is there, we suppose it's retrieved OK.  */
       *dt |= RETROKF;
 
       /* #### Bogusness alert.  */
       /* If the file is there, we suppose it's retrieved OK.  */
       *dt |= RETROKF;
 
       /* #### Bogusness alert.  */
-      /* If its suffix is "html" or (yuck!) "htm", we suppose it's
-        text/html, a harmless lie.  */
-      if (((suf = suffix (u->local)) != NULL)
-         && (!strcmp (suf, "html") || !strcmp (suf, "htm")))
+      /* If its suffix is "html" or "htm" or similar, assume text/html.  */
+      if (has_html_suffix_p (*hstat.local_file))
        *dt |= TEXTHTML;
        *dt |= TEXTHTML;
-      xfree (suf);
-      /* Another harmless lie: */
+
+      xfree_null (dummy);
       return RETROK;
     }
 
   use_ts = 0;
   if (opt.timestamping)
     {
       return RETROK;
     }
 
   use_ts = 0;
   if (opt.timestamping)
     {
-      boolean  local_dot_orig_file_exists = FALSE;
+      int local_dot_orig_file_exists = 0;
 
       if (opt.backup_converted)
        /* If -K is specified, we'll act on the assumption that it was specified
 
       if (opt.backup_converted)
        /* If -K is specified, we'll act on the assumption that it was specified
@@ -1453,22 +1586,22 @@ File `%s' already there, will not retrieve.\n"), u->local);
             in url.c.  Replacing sprintf with inline calls to
             strcpy() and long_to_string() made a difference.
             --hniksic */
             in url.c.  Replacing sprintf with inline calls to
             strcpy() and long_to_string() made a difference.
             --hniksic */
-         memcpy (filename_plus_orig_suffix, u->local, filename_len);
+         memcpy (filename_plus_orig_suffix, *hstat.local_file, filename_len);
          memcpy (filename_plus_orig_suffix + filename_len,
                  ".orig", sizeof (".orig"));
 
          /* Try to stat() the .orig file. */
          if (stat (filename_plus_orig_suffix, &st) == 0)
            {
          memcpy (filename_plus_orig_suffix + filename_len,
                  ".orig", sizeof (".orig"));
 
          /* Try to stat() the .orig file. */
          if (stat (filename_plus_orig_suffix, &st) == 0)
            {
-             local_dot_orig_file_exists = TRUE;
+             local_dot_orig_file_exists = 1;
              local_filename = filename_plus_orig_suffix;
            }
        }      
 
       if (!local_dot_orig_file_exists)
        /* Couldn't stat() <file>.orig, so try to stat() <file>. */
              local_filename = filename_plus_orig_suffix;
            }
        }      
 
       if (!local_dot_orig_file_exists)
        /* Couldn't stat() <file>.orig, so try to stat() <file>. */
-       if (stat (u->local, &st) == 0)
-         local_filename = u->local;
+       if (stat (*hstat.local_file, &st) == 0)
+         local_filename = *hstat.local_file;
 
       if (local_filename != NULL)
        /* There was a local file, so we'll check later to see if the version
 
       if (local_filename != NULL)
        /* There was a local file, so we'll check later to see if the version
@@ -1477,6 +1610,11 @@ File `%s' already there, will not retrieve.\n"), u->local);
        {
          use_ts = 1;
          tml = st.st_mtime;
        {
          use_ts = 1;
          tml = st.st_mtime;
+#ifdef WINDOWS
+         /* Modification time granularity is 2 seconds for Windows, so
+            increase local time by 1 second for later comparison. */
+         tml++;
+#endif
          local_size = st.st_size;
          got_head = 0;
        }
          local_size = st.st_size;
          got_head = 0;
        }
@@ -1495,7 +1633,7 @@ File `%s' already there, will not retrieve.\n"), u->local);
       /* Print fetch message, if opt.verbose.  */
       if (opt.verbose)
        {
       /* Print fetch message, if opt.verbose.  */
       if (opt.verbose)
        {
-         char *hurl = str_url (u->proxy ? u->proxy : u, 1);
+         char *hurl = url_string (u, 1);
          char tmp[15];
          strcpy (tmp, "        ");
          if (count > 1)
          char tmp[15];
          strcpy (tmp, "        ");
          if (count > 1)
@@ -1537,22 +1675,22 @@ File `%s' already there, will not retrieve.\n"), u->local);
              Some proxies are notorious for caching incomplete data, so
              we require a fresh get.
           b) caching is explicitly inhibited. */
              Some proxies are notorious for caching incomplete data, so
              we require a fresh get.
           b) caching is explicitly inhibited. */
-      if ((u->proxy && count > 1) /* a */
-         || !opt.allow_cache     /* b */
+      if ((proxy && count > 1) /* a */
+         || !opt.allow_cache   /* b */
          )
        *dt |= SEND_NOCACHE;
       else
        *dt &= ~SEND_NOCACHE;
 
          )
        *dt |= SEND_NOCACHE;
       else
        *dt &= ~SEND_NOCACHE;
 
-      /* Try fetching the document, or at least its head.  :-) */
-      err = gethttp (u, &hstat, dt);
+      /* Try fetching the document, or at least its head.  */
+      err = gethttp (u, &hstat, dt, proxy);
 
       /* It's unfortunate that wget determines the local filename before finding
         out the Content-Type of the file.  Barring a major restructuring of the
         code, we need to re-set locf here, since gethttp() may have xrealloc()d
 
       /* It's unfortunate that wget determines the local filename before finding
         out the Content-Type of the file.  Barring a major restructuring of the
         code, we need to re-set locf here, since gethttp() may have xrealloc()d
-        u->local to tack on ".html". */
+        *hstat.local_file to tack on ".html". */
       if (!opt.output_document)
       if (!opt.output_document)
-       locf = u->local;
+       locf = *hstat.local_file;
       else
        locf = opt.output_document;
 
       else
        locf = opt.output_document;
 
@@ -1569,29 +1707,32 @@ File `%s' already there, will not retrieve.\n"), u->local);
          /* Non-fatal errors continue executing the loop, which will
             bring them to "while" statement at the end, to judge
             whether the number of tries was exceeded.  */
          /* Non-fatal errors continue executing the loop, which will
             bring them to "while" statement at the end, to judge
             whether the number of tries was exceeded.  */
-         FREEHSTAT (hstat);
+         free_hstat (&hstat);
          printwhat (count, opt.ntry);
          continue;
          break;
          printwhat (count, opt.ntry);
          continue;
          break;
-       case HOSTERR: case CONREFUSED: case PROXERR: case AUTHFAILED: 
+       case HOSTERR: case CONIMPOSSIBLE: case PROXERR: case AUTHFAILED: 
        case SSLERRCTXCREATE: case CONTNOTSUPPORTED:
          /* Fatal errors just return from the function.  */
        case SSLERRCTXCREATE: case CONTNOTSUPPORTED:
          /* Fatal errors just return from the function.  */
-         FREEHSTAT (hstat);
+         free_hstat (&hstat);
+         xfree_null (dummy);
          return err;
          break;
        case FWRITEERR: case FOPENERR:
          /* Another fatal error.  */
          logputs (LOG_VERBOSE, "\n");
          logprintf (LOG_NOTQUIET, _("Cannot write to `%s' (%s).\n"),
          return err;
          break;
        case FWRITEERR: case FOPENERR:
          /* Another fatal error.  */
          logputs (LOG_VERBOSE, "\n");
          logprintf (LOG_NOTQUIET, _("Cannot write to `%s' (%s).\n"),
-                    u->local, strerror (errno));
-         FREEHSTAT (hstat);
+                    *hstat.local_file, strerror (errno));
+         free_hstat (&hstat);
+         xfree_null (dummy);
          return err;
          break;
        case CONSSLERR:
          /* Another fatal error.  */
          logputs (LOG_VERBOSE, "\n");
          logprintf (LOG_NOTQUIET, _("Unable to establish SSL connection.\n"));
          return err;
          break;
        case CONSSLERR:
          /* Another fatal error.  */
          logputs (LOG_VERBOSE, "\n");
          logprintf (LOG_NOTQUIET, _("Unable to establish SSL connection.\n"));
-         FREEHSTAT (hstat);
+         free_hstat (&hstat);
+         xfree_null (dummy);
          return err;
          break;
        case NEWLOCATION:
          return err;
          break;
        case NEWLOCATION:
@@ -1601,14 +1742,18 @@ File `%s' already there, will not retrieve.\n"), u->local);
              logprintf (LOG_NOTQUIET,
                         _("ERROR: Redirection (%d) without location.\n"),
                         hstat.statcode);
              logprintf (LOG_NOTQUIET,
                         _("ERROR: Redirection (%d) without location.\n"),
                         hstat.statcode);
+             free_hstat (&hstat);
+             xfree_null (dummy);
              return WRONGCODE;
            }
              return WRONGCODE;
            }
-         FREEHSTAT (hstat);
+         free_hstat (&hstat);
+         xfree_null (dummy);
          return NEWLOCATION;
          break;
        case RETRUNNEEDED:
          /* The file was already fully retrieved. */
          return NEWLOCATION;
          break;
        case RETRUNNEEDED:
          /* The file was already fully retrieved. */
-         FREEHSTAT (hstat);
+         free_hstat (&hstat);
+         xfree_null (dummy);
          return RETROK;
          break;
        case RETRFINISHED:
          return RETROK;
          break;
        case RETRFINISHED:
@@ -1623,14 +1768,15 @@ File `%s' already there, will not retrieve.\n"), u->local);
          if (!opt.verbose)
            {
              /* #### Ugly ugly ugly! */
          if (!opt.verbose)
            {
              /* #### Ugly ugly ugly! */
-             char *hurl = str_url (u->proxy ? u->proxy : u, 1);
+             char *hurl = url_string (u, 1);
              logprintf (LOG_NONVERBOSE, "%s:\n", hurl);
              xfree (hurl);
            }
          logprintf (LOG_NOTQUIET, _("%s ERROR %d: %s.\n"),
                     tms, hstat.statcode, hstat.error);
          logputs (LOG_VERBOSE, "\n");
              logprintf (LOG_NONVERBOSE, "%s:\n", hurl);
              xfree (hurl);
            }
          logprintf (LOG_NOTQUIET, _("%s ERROR %d: %s.\n"),
                     tms, hstat.statcode, hstat.error);
          logputs (LOG_VERBOSE, "\n");
-         FREEHSTAT (hstat);
+         free_hstat (&hstat);
+         xfree_null (dummy);
          return WRONGCODE;
        }
 
          return WRONGCODE;
        }
 
@@ -1673,7 +1819,8 @@ Last-modified header invalid -- time-stamp ignored.\n"));
                  logprintf (LOG_VERBOSE, _("\
 Server file no newer than local file `%s' -- not retrieving.\n\n"),
                             local_filename);
                  logprintf (LOG_VERBOSE, _("\
 Server file no newer than local file `%s' -- not retrieving.\n\n"),
                             local_filename);
-                 FREEHSTAT (hstat);
+                 free_hstat (&hstat);
+                 xfree_null (dummy);
                  return RETROK;
                }
              else if (tml >= tmr)
                  return RETROK;
                }
              else if (tml >= tmr)
@@ -1683,7 +1830,7 @@ The sizes do not match (local %ld) -- retrieving.\n"), local_size);
                logputs (LOG_VERBOSE,
                         _("Remote file is newer, retrieving.\n"));
            }
                logputs (LOG_VERBOSE,
                         _("Remote file is newer, retrieving.\n"));
            }
-         FREEHSTAT (hstat);
+         free_hstat (&hstat);
          continue;
        }
       if ((tmr != (time_t) (-1))
          continue;
        }
       if ((tmr != (time_t) (-1))
@@ -1702,7 +1849,7 @@ The sizes do not match (local %ld) -- retrieving.\n"), local_size);
                fl = opt.output_document;
            }
          else
                fl = opt.output_document;
            }
          else
-           fl = u->local;
+           fl = *hstat.local_file;
          if (fl)
            touch (fl, tmr);
        }
          if (fl)
            touch (fl, tmr);
        }
@@ -1711,14 +1858,11 @@ The sizes do not match (local %ld) -- retrieving.\n"), local_size);
       if (opt.spider)
        {
          logprintf (LOG_NOTQUIET, "%d %s\n\n", hstat.statcode, hstat.error);
       if (opt.spider)
        {
          logprintf (LOG_NOTQUIET, "%d %s\n\n", hstat.statcode, hstat.error);
+         xfree_null (dummy);
          return RETROK;
        }
 
          return RETROK;
        }
 
-      /* It is now safe to free the remainder of hstat, since the
-        strings within it will no longer be used.  */
-      FREEHSTAT (hstat);
-
-      tmrate = rate (hstat.len - hstat.restval, hstat.dltime, 0);
+      tmrate = retr_rate (hstat.len - hstat.restval, hstat.dltime, 0);
 
       if (hstat.len == hstat.contlen)
        {
 
       if (hstat.len == hstat.contlen)
        {
@@ -1732,7 +1876,7 @@ The sizes do not match (local %ld) -- retrieving.\n"), local_size);
                         tms, u->url, hstat.len, hstat.contlen, locf, count);
            }
          ++opt.numurls;
                         tms, u->url, hstat.len, hstat.contlen, locf, count);
            }
          ++opt.numurls;
-         downloaded_increase (hstat.len);
+         total_downloaded_bytes += hstat.len;
 
          /* Remember that we downloaded the file for later ".orig" code. */
          if (*dt & ADDED_HTML_EXTENSION)
 
          /* Remember that we downloaded the file for later ".orig" code. */
          if (*dt & ADDED_HTML_EXTENSION)
@@ -1740,6 +1884,8 @@ The sizes do not match (local %ld) -- retrieving.\n"), local_size);
          else
            downloaded_file(FILE_DOWNLOADED_NORMALLY, locf);
 
          else
            downloaded_file(FILE_DOWNLOADED_NORMALLY, locf);
 
+         free_hstat (&hstat);
+         xfree_null (dummy);
          return RETROK;
        }
       else if (hstat.res == 0) /* No read error */
          return RETROK;
        }
       else if (hstat.res == 0) /* No read error */
@@ -1757,7 +1903,7 @@ The sizes do not match (local %ld) -- retrieving.\n"), local_size);
                             tms, u->url, hstat.len, locf, count);
                }
              ++opt.numurls;
                             tms, u->url, hstat.len, locf, count);
                }
              ++opt.numurls;
-             downloaded_increase (hstat.len);
+             total_downloaded_bytes += hstat.len;
 
              /* Remember that we downloaded the file for later ".orig" code. */
              if (*dt & ADDED_HTML_EXTENSION)
 
              /* Remember that we downloaded the file for later ".orig" code. */
              if (*dt & ADDED_HTML_EXTENSION)
@@ -1765,6 +1911,8 @@ The sizes do not match (local %ld) -- retrieving.\n"), local_size);
              else
                downloaded_file(FILE_DOWNLOADED_NORMALLY, locf);
              
              else
                downloaded_file(FILE_DOWNLOADED_NORMALLY, locf);
              
+             free_hstat (&hstat);
+             xfree_null (dummy);
              return RETROK;
            }
          else if (hstat.len < hstat.contlen) /* meaning we lost the
              return RETROK;
            }
          else if (hstat.len < hstat.contlen) /* meaning we lost the
@@ -1774,6 +1922,7 @@ The sizes do not match (local %ld) -- retrieving.\n"), local_size);
                         _("%s (%s) - Connection closed at byte %ld. "),
                         tms, tmrate, hstat.len);
              printwhat (count, opt.ntry);
                         _("%s (%s) - Connection closed at byte %ld. "),
                         tms, tmrate, hstat.len);
              printwhat (count, opt.ntry);
+             free_hstat (&hstat);
              continue;
            }
          else if (!opt.kill_longer) /* meaning we got more than expected */
              continue;
            }
          else if (!opt.kill_longer) /* meaning we got more than expected */
@@ -1785,7 +1934,7 @@ The sizes do not match (local %ld) -- retrieving.\n"), local_size);
                         "%s URL:%s [%ld/%ld] -> \"%s\" [%d]\n",
                         tms, u->url, hstat.len, hstat.contlen, locf, count);
              ++opt.numurls;
                         "%s URL:%s [%ld/%ld] -> \"%s\" [%d]\n",
                         tms, u->url, hstat.len, hstat.contlen, locf, count);
              ++opt.numurls;
-             downloaded_increase (hstat.len);
+             total_downloaded_bytes += hstat.len;
 
              /* Remember that we downloaded the file for later ".orig" code. */
              if (*dt & ADDED_HTML_EXTENSION)
 
              /* Remember that we downloaded the file for later ".orig" code. */
              if (*dt & ADDED_HTML_EXTENSION)
@@ -1793,6 +1942,8 @@ The sizes do not match (local %ld) -- retrieving.\n"), local_size);
              else
                downloaded_file(FILE_DOWNLOADED_NORMALLY, locf);
              
              else
                downloaded_file(FILE_DOWNLOADED_NORMALLY, locf);
              
+             free_hstat (&hstat);
+             xfree_null (dummy);
              return RETROK;
            }
          else                  /* the same, but not accepted */
              return RETROK;
            }
          else                  /* the same, but not accepted */
@@ -1801,6 +1952,7 @@ The sizes do not match (local %ld) -- retrieving.\n"), local_size);
                         _("%s (%s) - Connection closed at byte %ld/%ld. "),
                         tms, tmrate, hstat.len, hstat.contlen);
              printwhat (count, opt.ntry);
                         _("%s (%s) - Connection closed at byte %ld/%ld. "),
                         tms, tmrate, hstat.len, hstat.contlen);
              printwhat (count, opt.ntry);
+             free_hstat (&hstat);
              continue;
            }
        }
              continue;
            }
        }
@@ -1812,6 +1964,7 @@ The sizes do not match (local %ld) -- retrieving.\n"), local_size);
                         _("%s (%s) - Read error at byte %ld (%s)."),
                         tms, tmrate, hstat.len, strerror (errno));
              printwhat (count, opt.ntry);
                         _("%s (%s) - Read error at byte %ld (%s)."),
                         tms, tmrate, hstat.len, strerror (errno));
              printwhat (count, opt.ntry);
+             free_hstat (&hstat);
              continue;
            }
          else                  /* hstat.res == -1 and contlen is given */
              continue;
            }
          else                  /* hstat.res == -1 and contlen is given */
@@ -1821,6 +1974,7 @@ The sizes do not match (local %ld) -- retrieving.\n"), local_size);
                         tms, tmrate, hstat.len, hstat.contlen,
                         strerror (errno));
              printwhat (count, opt.ntry);
                         tms, tmrate, hstat.len, hstat.contlen,
                         strerror (errno));
              printwhat (count, opt.ntry);
+             free_hstat (&hstat);
              continue;
            }
        }
              continue;
            }
        }
@@ -1950,7 +2104,7 @@ check_end (const char *p)
    it is not assigned to the FSF.  So I stuck it with strptime.  */
 
 time_t
    it is not assigned to the FSF.  So I stuck it with strptime.  */
 
 time_t
-http_atotm (char *time_string)
+http_atotm (const char *time_string)
 {
   /* NOTE: Solaris strptime man page claims that %n and %t match white
      space, but that's not universally available.  Instead, we simply
 {
   /* NOTE: Solaris strptime man page claims that %n and %t match white
      space, but that's not universally available.  Instead, we simply
@@ -1985,7 +2139,7 @@ http_atotm (char *time_string)
      GNU strptime does not have this problem because it recognizes
      both international and local dates.  */
 
      GNU strptime does not have this problem because it recognizes
      both international and local dates.  */
 
-  for (i = 0; i < ARRAY_SIZE (time_formats); i++)
+  for (i = 0; i < countof (time_formats); i++)
     if (check_end (strptime (time_string, time_formats[i], &t)))
       return mktime_from_utc (&t);
 
     if (check_end (strptime (time_string, time_formats[i], &t)))
       return mktime_from_utc (&t);
 
@@ -2096,7 +2250,7 @@ extract_header_attr (const char *au, const char *attr_name, char **ret)
        ;
       if (!*ep)
        return -1;
        ;
       if (!*ep)
        return -1;
-      FREE_MAYBE (*ret);
+      xfree_null (*ret);
       *ret = strdupdelim (cp, ep);
       return ep - au + 1;
     }
       *ret = strdupdelim (cp, ep);
       return ep - au + 1;
     }
@@ -2115,15 +2269,15 @@ dump_hash (unsigned char *buf, const unsigned char *hash)
 
   for (i = 0; i < MD5_HASHLEN; i++, hash++)
     {
 
   for (i = 0; i < MD5_HASHLEN; i++, hash++)
     {
-      *buf++ = XDIGIT_TO_xchar (*hash >> 4);
-      *buf++ = XDIGIT_TO_xchar (*hash & 0xf);
+      *buf++ = XNUM_TO_digit (*hash >> 4);
+      *buf++ = XNUM_TO_digit (*hash & 0xf);
     }
   *buf = '\0';
 }
 
 /* Take the line apart to find the challenge, and compose a digest
    authorization header.  See RFC2069 section 2.1.2.  */
     }
   *buf = '\0';
 }
 
 /* Take the line apart to find the challenge, and compose a digest
    authorization header.  See RFC2069 section 2.1.2.  */
-char *
+static char *
 digest_authentication_encode (const char *au, const char *user,
                              const char *passwd, const char *method,
                              const char *path)
 digest_authentication_encode (const char *au, const char *user,
                              const char *passwd, const char *method,
                              const char *path)
@@ -2147,15 +2301,15 @@ digest_authentication_encode (const char *au, const char *user,
       int i;
 
       au += skip_lws (au);
       int i;
 
       au += skip_lws (au);
-      for (i = 0; i < ARRAY_SIZE (options); i++)
+      for (i = 0; i < countof (options); i++)
        {
          int skip = extract_header_attr (au, options[i].name,
                                          options[i].variable);
          if (skip < 0)
            {
        {
          int skip = extract_header_attr (au, options[i].name,
                                          options[i].variable);
          if (skip < 0)
            {
-             FREE_MAYBE (realm);
-             FREE_MAYBE (opaque);
-             FREE_MAYBE (nonce);
+             xfree_null (realm);
+             xfree_null (opaque);
+             xfree_null (nonce);
              return NULL;
            }
          else if (skip)
              return NULL;
            }
          else if (skip)
@@ -2164,7 +2318,7 @@ digest_authentication_encode (const char *au, const char *user,
              break;
            }
        }
              break;
            }
        }
-      if (i == ARRAY_SIZE (options))
+      if (i == countof (options))
        {
          while (*au && *au != '=')
            au++;
        {
          while (*au && *au != '=')
            au++;
@@ -2188,45 +2342,45 @@ digest_authentication_encode (const char *au, const char *user,
     }
   if (!realm || !nonce || !user || !passwd || !path || !method)
     {
     }
   if (!realm || !nonce || !user || !passwd || !path || !method)
     {
-      FREE_MAYBE (realm);
-      FREE_MAYBE (opaque);
-      FREE_MAYBE (nonce);
+      xfree_null (realm);
+      xfree_null (opaque);
+      xfree_null (nonce);
       return NULL;
     }
 
   /* Calculate the digest value.  */
   {
       return NULL;
     }
 
   /* Calculate the digest value.  */
   {
-    struct md5_ctx ctx;
+    ALLOCA_MD5_CONTEXT (ctx);
     unsigned char hash[MD5_HASHLEN];
     unsigned char a1buf[MD5_HASHLEN * 2 + 1], a2buf[MD5_HASHLEN * 2 + 1];
     unsigned char response_digest[MD5_HASHLEN * 2 + 1];
 
     /* A1BUF = H(user ":" realm ":" password) */
     unsigned char hash[MD5_HASHLEN];
     unsigned char a1buf[MD5_HASHLEN * 2 + 1], a2buf[MD5_HASHLEN * 2 + 1];
     unsigned char response_digest[MD5_HASHLEN * 2 + 1];
 
     /* A1BUF = H(user ":" realm ":" password) */
-    md5_init_ctx (&ctx);
-    md5_process_bytes (user, strlen (user), &ctx);
-    md5_process_bytes (":", 1, &ctx);
-    md5_process_bytes (realm, strlen (realm), &ctx);
-    md5_process_bytes (":", 1, &ctx);
-    md5_process_bytes (passwd, strlen (passwd), &ctx);
-    md5_finish_ctx (&ctx, hash);
+    gen_md5_init (ctx);
+    gen_md5_update ((unsigned char *)user, strlen (user), ctx);
+    gen_md5_update ((unsigned char *)":", 1, ctx);
+    gen_md5_update ((unsigned char *)realm, strlen (realm), ctx);
+    gen_md5_update ((unsigned char *)":", 1, ctx);
+    gen_md5_update ((unsigned char *)passwd, strlen (passwd), ctx);
+    gen_md5_finish (ctx, hash);
     dump_hash (a1buf, hash);
 
     /* A2BUF = H(method ":" path) */
     dump_hash (a1buf, hash);
 
     /* A2BUF = H(method ":" path) */
-    md5_init_ctx (&ctx);
-    md5_process_bytes (method, strlen (method), &ctx);
-    md5_process_bytes (":", 1, &ctx);
-    md5_process_bytes (path, strlen (path), &ctx);
-    md5_finish_ctx (&ctx, hash);
+    gen_md5_init (ctx);
+    gen_md5_update ((unsigned char *)method, strlen (method), ctx);
+    gen_md5_update ((unsigned char *)":", 1, ctx);
+    gen_md5_update ((unsigned char *)path, strlen (path), ctx);
+    gen_md5_finish (ctx, hash);
     dump_hash (a2buf, hash);
 
     /* RESPONSE_DIGEST = H(A1BUF ":" nonce ":" A2BUF) */
     dump_hash (a2buf, hash);
 
     /* RESPONSE_DIGEST = H(A1BUF ":" nonce ":" A2BUF) */
-    md5_init_ctx (&ctx);
-    md5_process_bytes (a1buf, MD5_HASHLEN * 2, &ctx);
-    md5_process_bytes (":", 1, &ctx);
-    md5_process_bytes (nonce, strlen (nonce), &ctx);
-    md5_process_bytes (":", 1, &ctx);
-    md5_process_bytes (a2buf, MD5_HASHLEN * 2, &ctx);
-    md5_finish_ctx (&ctx, hash);
+    gen_md5_init (ctx);
+    gen_md5_update (a1buf, MD5_HASHLEN * 2, ctx);
+    gen_md5_update ((unsigned char *)":", 1, ctx);
+    gen_md5_update ((unsigned char *)nonce, strlen (nonce), ctx);
+    gen_md5_update ((unsigned char *)":", 1, ctx);
+    gen_md5_update (a2buf, MD5_HASHLEN * 2, ctx);
+    gen_md5_finish (ctx, hash);
     dump_hash (response_digest, hash);
 
     res = (char*) xmalloc (strlen (user)
     dump_hash (response_digest, hash);
 
     res = (char*) xmalloc (strlen (user)
@@ -2291,3 +2445,8 @@ create_authorization_line (const char *au, const char *user,
 #endif /* USE_DIGEST */
   return wwwauth;
 }
 #endif /* USE_DIGEST */
   return wwwauth;
 }
+\f
+void
+http_cleanup (void)
+{
+}