sjero.net Git - wget/blob - src/http.c

   1 /* HTTP support.
   2    Copyright (C) 1995, 1996, 1997, 1998, 2000 Free Software Foundation, Inc.
   3
   4 This file is part of Wget.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #include <config.h>
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <sys/types.h>
  25 #ifdef HAVE_STRING_H
  26 # include <string.h>
  27 #else
  28 # include <strings.h>
  29 #endif
  30 #ifdef HAVE_UNISTD_H
  31 # include <unistd.h>
  32 #endif
  33 #include <assert.h>
  34 #include <errno.h>
  35 #if TIME_WITH_SYS_TIME
  36 # include <sys/time.h>
  37 # include <time.h>
  38 #else
  39 # if HAVE_SYS_TIME_H
  40 #  include <sys/time.h>
  41 # else
  42 #  include <time.h>
  43 # endif
  44 #endif
  45
  46 #ifdef WINDOWS
  47 # include <winsock.h>
  48 #else
  49 # include <netdb.h>             /* for h_errno */
  50 #endif
  51
  52 #include "wget.h"
  53 #include "utils.h"
  54 #include "url.h"
  55 #include "host.h"
  56 #include "rbuf.h"
  57 #include "retr.h"
  58 #include "headers.h"
  59 #include "connect.h"
  60 #include "fnmatch.h"
  61 #include "netrc.h"
  62 #if USE_DIGEST
  63 # include "md5.h"
  64 #endif
  65 #ifdef HAVE_SSL
  66 # include "gen_sslfunc.h"
  67 #endif /* HAVE_SSL */
  68 #include "cookies.h"
  69
  70 extern char *version_string;
  71
  72 #ifndef errno
  73 extern int errno;
  74 #endif
  75 #ifndef h_errno
  76 # ifndef __CYGWIN__
  77 extern int h_errno;
  78 # endif
  79 #endif
  80 \f
  81 static int cookies_loaded_p;
  82
  83 #define TEXTHTML_S "text/html"
  84 #define HTTP_ACCEPT "*/*"
  85
  86 /* Some status code validation macros: */
  87 #define H_20X(x)        (((x) >= 200) && ((x) < 300))
  88 #define H_PARTIAL(x)    ((x) == HTTP_STATUS_PARTIAL_CONTENTS)
  89 #define H_REDIRECTED(x) (((x) == HTTP_STATUS_MOVED_PERMANENTLY) \
  90                          || ((x) == HTTP_STATUS_MOVED_TEMPORARILY))
  91
  92 /* HTTP/1.0 status codes from RFC1945, provided for reference.  */
  93 /* Successful 2xx.  */
  94 #define HTTP_STATUS_OK                  200
  95 #define HTTP_STATUS_CREATED             201
  96 #define HTTP_STATUS_ACCEPTED            202
  97 #define HTTP_STATUS_NO_CONTENT          204
  98 #define HTTP_STATUS_PARTIAL_CONTENTS    206
  99
 100 /* Redirection 3xx.  */
 101 #define HTTP_STATUS_MULTIPLE_CHOICES    300
 102 #define HTTP_STATUS_MOVED_PERMANENTLY   301
 103 #define HTTP_STATUS_MOVED_TEMPORARILY   302
 104 #define HTTP_STATUS_NOT_MODIFIED        304
 105
 106 /* Client error 4xx.  */
 107 #define HTTP_STATUS_BAD_REQUEST         400
 108 #define HTTP_STATUS_UNAUTHORIZED        401
 109 #define HTTP_STATUS_FORBIDDEN           403
 110 #define HTTP_STATUS_NOT_FOUND           404
 111
 112 /* Server errors 5xx.  */
 113 #define HTTP_STATUS_INTERNAL            500
 114 #define HTTP_STATUS_NOT_IMPLEMENTED     501
 115 #define HTTP_STATUS_BAD_GATEWAY         502
 116 #define HTTP_STATUS_UNAVAILABLE         503
 117
 118 \f
 119 /* Parse the HTTP status line, which is of format:
 120
 121    HTTP-Version SP Status-Code SP Reason-Phrase
 122
 123    The function returns the status-code, or -1 if the status line is
 124    malformed.  The pointer to reason-phrase is returned in RP.  */
 125 static int
 126 parse_http_status_line (const char *line, const char **reason_phrase_ptr)
 127 {
 128   /* (the variables must not be named `major' and `minor', because
 129      that breaks compilation with SunOS4 cc.)  */
 130   int mjr, mnr, statcode;
 131   const char *p;
 132
 133   *reason_phrase_ptr = NULL;
 134
 135   /* The standard format of HTTP-Version is: `HTTP/X.Y', where X is
 136      major version, and Y is minor version.  */
 137   if (strncmp (line, "HTTP/", 5) != 0)
 138     return -1;
 139   line += 5;
 140
 141   /* Calculate major HTTP version.  */
 142   p = line;
 143   for (mjr = 0; ISDIGIT (*line); line++)
 144     mjr = 10 * mjr + (*line - '0');
 145   if (*line != '.' || p == line)
 146     return -1;
 147   ++line;
 148
 149   /* Calculate minor HTTP version.  */
 150   p = line;
 151   for (mnr = 0; ISDIGIT (*line); line++)
 152     mnr = 10 * mnr + (*line - '0');
 153   if (*line != ' ' || p == line)
 154     return -1;
 155   /* Wget will accept only 1.0 and higher HTTP-versions.  The value of
 156      minor version can be safely ignored.  */
 157   if (mjr < 1)
 158     return -1;
 159   ++line;
 160
 161   /* Calculate status code.  */
 162   if (!(ISDIGIT (*line) && ISDIGIT (line[1]) && ISDIGIT (line[2])))
 163     return -1;
 164   statcode = 100 * (*line - '0') + 10 * (line[1] - '0') + (line[2] - '0');
 165
 166   /* Set up the reason phrase pointer.  */
 167   line += 3;
 168   /* RFC2068 requires SPC here, but we allow the string to finish
 169      here, in case no reason-phrase is present.  */
 170   if (*line != ' ')
 171     {
 172       if (!*line)
 173         *reason_phrase_ptr = line;
 174       else
 175         return -1;
 176     }
 177   else
 178     *reason_phrase_ptr = line + 1;
 179
 180   return statcode;
 181 }
 182 \f
 183 /* Functions to be used as arguments to header_process(): */
 184
 185 struct http_process_range_closure {
 186   long first_byte_pos;
 187   long last_byte_pos;
 188   long entity_length;
 189 };
 190
 191 /* Parse the `Content-Range' header and extract the information it
 192    contains.  Returns 1 if successful, -1 otherwise.  */
 193 static int
 194 http_process_range (const char *hdr, void *arg)
 195 {
 196   struct http_process_range_closure *closure
 197     = (struct http_process_range_closure *)arg;
 198   long num;
 199
 200   /* Certain versions of Nutscape proxy server send out
 201      `Content-Length' without "bytes" specifier, which is a breach of
 202      RFC2068 (as well as the HTTP/1.1 draft which was current at the
 203      time).  But hell, I must support it...  */
 204   if (!strncasecmp (hdr, "bytes", 5))
 205     {
 206       hdr += 5;
 207       hdr += skip_lws (hdr);
 208       if (!*hdr)
 209         return 0;
 210     }
 211   if (!ISDIGIT (*hdr))
 212     return 0;
 213   for (num = 0; ISDIGIT (*hdr); hdr++)
 214     num = 10 * num + (*hdr - '0');
 215   if (*hdr != '-' || !ISDIGIT (*(hdr + 1)))
 216     return 0;
 217   closure->first_byte_pos = num;
 218   ++hdr;
 219   for (num = 0; ISDIGIT (*hdr); hdr++)
 220     num = 10 * num + (*hdr - '0');
 221   if (*hdr != '/' || !ISDIGIT (*(hdr + 1)))
 222     return 0;
 223   closure->last_byte_pos = num;
 224   ++hdr;
 225   for (num = 0; ISDIGIT (*hdr); hdr++)
 226     num = 10 * num + (*hdr - '0');
 227   closure->entity_length = num;
 228   return 1;
 229 }
 230
 231 /* Place 1 to ARG if the HDR contains the word "none", 0 otherwise.
 232    Used for `Accept-Ranges'.  */
 233 static int
 234 http_process_none (const char *hdr, void *arg)
 235 {
 236   int *where = (int *)arg;
 237
 238   if (strstr (hdr, "none"))
 239     *where = 1;
 240   else
 241     *where = 0;
 242   return 1;
 243 }
 244
 245 /* Place the malloc-ed copy of HDR hdr, to the first `;' to ARG.  */
 246 static int
 247 http_process_type (const char *hdr, void *arg)
 248 {
 249   char **result = (char **)arg;
 250   /* Locate P on `;' or the terminating zero, whichever comes first. */
 251   const char *p = strchr (hdr, ';');
 252   if (!p)
 253     p = hdr + strlen (hdr);
 254   while (p > hdr && ISSPACE (*(p - 1)))
 255     --p;
 256   *result = strdupdelim (hdr, p);
 257   return 1;
 258 }
 259
 260 /* Check whether the `Connection' header is set to "keep-alive". */
 261 static int
 262 http_process_connection (const char *hdr, void *arg)
 263 {
 264   int *flag = (int *)arg;
 265   if (!strcasecmp (hdr, "Keep-Alive"))
 266     *flag = 1;
 267   return 1;
 268 }
 269 \f
 270 /* Persistent connections.  Currently, we cache the most recently used
 271    connection as persistent, provided that the HTTP server agrees to
 272    make it such.  The persistence data is stored in the variables
 273    below.  Ideally, it would be in a structure, and it should be
 274    possible to cache an arbitrary fixed number of these connections.
 275
 276    I think the code is quite easy to extend in that direction.  */
 277
 278 /* Whether a persistent connection is active. */
 279 static int pc_active_p;
 280 /* Host and port of currently active persistent connection. */
 281 static unsigned char pc_last_host[4];
 282 static unsigned short pc_last_port;
 283
 284 /* File descriptor of the currently active persistent connection. */
 285 static int pc_last_fd;
 286
 287 #ifdef HAVE_SSL
 288 /* Whether a ssl handshake has occoured on this connection */
 289 static int pc_active_ssl;
 290 /* SSL connection of the currently active persistent connection. */
 291 static SSL *pc_last_ssl;
 292 #endif /* HAVE_SSL */
 293
 294 /* Mark the persistent connection as invalid.  This is used by the
 295    CLOSE_* macros after they forcefully close a registered persistent
 296    connection.  This does not close the file descriptor -- it is left
 297    to the caller to do that.  (Maybe it should, though.)  */
 298
 299 static void
 300 invalidate_persistent (void)
 301 {
 302   pc_active_p = 0;
 303 #ifdef HAVE_SSL
 304   pc_active_ssl = 0;
 305 #endif /* HAVE_SSL */
 306   DEBUGP (("Invalidating fd %d from further reuse.\n", pc_last_fd));
 307 }
 308
 309 /* Register FD, which should be a TCP/IP connection to HOST:PORT, as
 310    persistent.  This will enable someone to use the same connection
 311    later.  In the context of HTTP, this must be called only AFTER the
 312    response has been received and the server has promised that the
 313    connection will remain alive.
 314
 315    If a previous connection was persistent, it is closed. */
 316
 317 static void
 318 register_persistent (const char *host, unsigned short port, int fd
 319 #ifdef HAVE_SSL
 320                      , SSL *ssl
 321 #endif
 322                      )
 323 {
 324   int success;
 325
 326   if (pc_active_p)
 327     {
 328       if (pc_last_fd == fd)
 329         {
 330           /* The connection FD is already registered.  Nothing to
 331              do. */
 332           return;
 333         }
 334       else
 335         {
 336           /* The old persistent connection is still active; let's
 337              close it first.  This situation arises whenever a
 338              persistent connection exists, but we then connect to a
 339              different host, and try to register a persistent
 340              connection to that one.  */
 341 #ifdef HAVE_SSL
 342           /* The ssl disconnect has to take place before the closing
 343              of pc_last_fd.  */
 344           if (pc_last_ssl)
 345             shutdown_ssl(pc_last_ssl);
 346 #endif
 347           CLOSE (pc_last_fd);
 348           invalidate_persistent ();
 349         }
 350     }
 351
 352   /* This store_hostaddress may not fail, because it has the results
 353      in the cache.  */
 354   success = store_hostaddress (pc_last_host, host);
 355   assert (success);
 356   pc_last_port = port;
 357   pc_last_fd = fd;
 358   pc_active_p = 1;
 359 #ifdef HAVE_SSL
 360   pc_last_ssl = ssl;
 361   pc_active_ssl = ssl ? 1 : 0;
 362 #endif
 363   DEBUGP (("Registered fd %d for persistent reuse.\n", fd));
 364 }
 365
 366 /* Return non-zero if a persistent connection is available for
 367    connecting to HOST:PORT.  */
 368
 369 static int
 370 persistent_available_p (const char *host, unsigned short port
 371 #ifdef HAVE_SSL
 372                         , int ssl
 373 #endif
 374                         )
 375 {
 376   unsigned char this_host[4];
 377   /* First, check whether a persistent connection is active at all.  */
 378   if (!pc_active_p)
 379     return 0;
 380   /* Second, check if the active connection pertains to the correct
 381      (HOST, PORT) ordered pair.  */
 382   if (port != pc_last_port)
 383     return 0;
 384 #ifdef HAVE_SSL
 385   /* Second, a): check if current connection is (not) ssl, too.  This
 386      test is unlikely to fail because HTTP and HTTPS typicaly use
 387      different ports.  Yet it is possible, or so I [Christian
 388      Fraenkel] have been told, to run HTTPS and HTTP simultaneus on
 389      the same port.  */
 390   if (ssl != pc_active_ssl)
 391     return 0;
 392 #endif /* HAVE_SSL */
 393   if (!store_hostaddress (this_host, host))
 394     return 0;
 395   if (memcmp (pc_last_host, this_host, 4))
 396     return 0;
 397   /* Third: check whether the connection is still open.  This is
 398      important because most server implement a liberal (short) timeout
 399      on persistent connections.  Wget can of course always reconnect
 400      if the connection doesn't work out, but it's nicer to know in
 401      advance.  This test is a logical followup of the first test, but
 402      is "expensive" and therefore placed at the end of the list.  */
 403   if (!test_socket_open (pc_last_fd))
 404     {
 405       /* Oops, the socket is no longer open.  Now that we know that,
 406          let's invalidate the persistent connection before returning
 407          0.  */
 408       CLOSE (pc_last_fd);
 409       invalidate_persistent ();
 410       return 0;
 411     }
 412   return 1;
 413 }
 414
 415 #ifdef HAVE_SSL
 416 # define SHUTDOWN_SSL(ssl) do {         \
 417   if (ssl)                              \
 418     shutdown_ssl (ssl);                 \
 419 } while (0)
 420 #else
 421 # define SHUTDOWN_SSL(ssl)
 422 #endif
 423
 424 /* The idea behind these two CLOSE macros is to distinguish between
 425    two cases: one when the job we've been doing is finished, and we
 426    want to close the connection and leave, and two when something is
 427    seriously wrong and we're closing the connection as part of
 428    cleanup.
 429
 430    In case of keep_alive, CLOSE_FINISH should leave the connection
 431    open, while CLOSE_INVALIDATE should still close it.
 432
 433    Note that the semantics of the flag `keep_alive' is "this
 434    connection *will* be reused (the server has promised not to close
 435    the connection once we're done)", while the semantics of
 436    `pc_active_p && (fd) == pc_last_fd' is "we're *now* using an
 437    active, registered connection".  */
 438
 439 #define CLOSE_FINISH(fd) do {                   \
 440   if (!keep_alive)                              \
 441     {                                           \
 442       SHUTDOWN_SSL (ssl);                       \
 443       CLOSE (fd);                               \
 444       if (pc_active_p && (fd) == pc_last_fd)    \
 445         invalidate_persistent ();               \
 446     }                                           \
 447 } while (0)
 448
 449 #define CLOSE_INVALIDATE(fd) do {               \
 450   SHUTDOWN_SSL (ssl);                           \
 451   CLOSE (fd);                                   \
 452   if (pc_active_p && (fd) == pc_last_fd)        \
 453     invalidate_persistent ();                   \
 454 } while (0)
 455 \f
 456 struct http_stat
 457 {
 458   long len;                     /* received length */
 459   long contlen;                 /* expected length */
 460   long restval;                 /* the restart value */
 461   int res;                      /* the result of last read */
 462   char *newloc;                 /* new location (redirection) */
 463   char *remote_time;            /* remote time-stamp string */
 464   char *error;                  /* textual HTTP error */
 465   int statcode;                 /* status code */
 466   long dltime;                  /* time of the download */
 467   int no_truncate;              /* whether truncating the file is
 468                                    forbidden. */
 469 };
 470
 471 /* Free the elements of hstat X.  */
 472 #define FREEHSTAT(x) do                                 \
 473 {                                                       \
 474   FREE_MAYBE ((x).newloc);                              \
 475   FREE_MAYBE ((x).remote_time);                         \
 476   FREE_MAYBE ((x).error);                               \
 477   (x).newloc = (x).remote_time = (x).error = NULL;      \
 478 } while (0)
 479
 480 static char *create_authorization_line PARAMS ((const char *, const char *,
 481                                                 const char *, const char *,
 482                                                 const char *));
 483 static char *basic_authentication_encode PARAMS ((const char *, const char *,
 484                                                   const char *));
 485 static int known_authentication_scheme_p PARAMS ((const char *));
 486
 487 time_t http_atotm PARAMS ((char *));
 488
 489 #define BEGINS_WITH(line, string_constant)                              \
 490   (!strncasecmp (line, string_constant, sizeof (string_constant) - 1)   \
 491    && (ISSPACE (line[sizeof (string_constant) - 1])                     \
 492        || !line[sizeof (string_constant) - 1]))
 493
 494 /* Retrieve a document through HTTP protocol.  It recognizes status
 495    code, and correctly handles redirections.  It closes the network
 496    socket.  If it receives an error from the functions below it, it
 497    will print it if there is enough information to do so (almost
 498    always), returning the error to the caller (i.e. http_loop).
 499
 500    Various HTTP parameters are stored to hs.  Although it parses the
 501    response code correctly, it is not used in a sane way.  The caller
 502    can do that, though.
 503
 504    If u->proxy is non-NULL, the URL u will be taken as a proxy URL,
 505    and u->proxy->url will be given to the proxy server (bad naming,
 506    I'm afraid).  */
 507 static uerr_t
 508 gethttp (struct urlinfo *u, struct http_stat *hs, int *dt)
 509 {
 510   char *request, *type, *command, *path;
 511   char *user, *passwd;
 512   char *pragma_h, *referer, *useragent, *range, *wwwauth, *remhost;
 513   char *authenticate_h;
 514   char *proxyauth;
 515   char *all_headers;
 516   char *port_maybe;
 517   char *request_keep_alive;
 518   int sock, hcount, num_written, all_length, remport, statcode;
 519   long contlen, contrange;
 520   struct urlinfo *ou;
 521   uerr_t err;
 522   FILE *fp;
 523   int auth_tried_already;
 524   struct rbuf rbuf;
 525 #ifdef HAVE_SSL
 526   static SSL_CTX *ssl_ctx = NULL;
 527   SSL *ssl = NULL;
 528 #endif /* HAVE_SSL */
 529   char *cookies = NULL;
 530
 531   /* Whether this connection will be kept alive after the HTTP request
 532      is done. */
 533   int keep_alive;
 534
 535   /* Flags that detect the two ways of specifying HTTP keep-alive
 536      response.  */
 537   int http_keep_alive_1, http_keep_alive_2;
 538
 539   /* Whether keep-alive should be inhibited. */
 540   int inhibit_keep_alive;
 541
 542 #ifdef HAVE_SSL
 543   /* initialize ssl_ctx on first run */
 544   if (!ssl_ctx)
 545     {
 546       err=init_ssl (&ssl_ctx);
 547       if (err != 0)
 548         {
 549           switch (err)
 550             {
 551             case SSLERRCTXCREATE:
 552               /* this is fatal */
 553               logprintf (LOG_NOTQUIET, _("Failed to set up an SSL context\n"));
 554               ssl_printerrors ();
 555               return err;
 556             case SSLERRCERTFILE:
 557               /* try without certfile */
 558               logprintf (LOG_NOTQUIET,
 559                          _("Failed to load certificates from %s\n"),
 560                          opt.sslcertfile);
 561               ssl_printerrors ();
 562               logprintf (LOG_NOTQUIET,
 563                          _("Trying without the specified certificate\n"));
 564               break;
 565             case SSLERRCERTKEY:
 566               logprintf (LOG_NOTQUIET,
 567                          _("Failed to get certificate key from %s\n"),
 568                          opt.sslcertkey);
 569               ssl_printerrors ();
 570               logprintf (LOG_NOTQUIET,
 571                          _("Trying without the specified certificate\n"));
 572               break;
 573             default:
 574               break;
 575             }
 576         }
 577     }
 578 #endif /* HAVE_SSL */
 579
 580   if (!(*dt & HEAD_ONLY))
 581     /* If we're doing a GET on the URL, as opposed to just a HEAD, we need to
 582        know the local filename so we can save to it. */
 583     assert (u->local != NULL);
 584
 585   authenticate_h = 0;
 586   auth_tried_already = 0;
 587
 588   inhibit_keep_alive = (!opt.http_keep_alive || u->proxy != NULL);
 589
 590  again:
 591   /* We need to come back here when the initial attempt to retrieve
 592      without authorization header fails.  (Expected to happen at least
 593      for the Digest authorization scheme.)  */
 594
 595   keep_alive = 0;
 596   http_keep_alive_1 = http_keep_alive_2 = 0;
 597
 598   if (opt.cookies)
 599     cookies = build_cookies_request (u->host, u->port, u->path,
 600                                      u->proto == URLHTTPS);
 601
 602   /* Initialize certain elements of struct http_stat.  */
 603   hs->len = 0L;
 604   hs->contlen = -1;
 605   hs->res = -1;
 606   hs->newloc = NULL;
 607   hs->remote_time = NULL;
 608   hs->error = NULL;
 609
 610   /* Which structure to use to retrieve the original URL data.  */
 611   if (u->proxy)
 612     ou = u->proxy;
 613   else
 614     ou = u;
 615
 616   /* First: establish the connection.  */
 617   if (inhibit_keep_alive
 618       ||
 619 #ifndef HAVE_SSL
 620       !persistent_available_p (u->host, u->port)
 621 #else
 622       !persistent_available_p (u->host, u->port, (u->proto==URLHTTPS ? 1 : 0))
 623 #endif /* HAVE_SSL */
 624       )
 625     {
 626       logprintf (LOG_VERBOSE, _("Connecting to %s:%hu... "), u->host, u->port);
 627       err = make_connection (&sock, u->host, u->port);
 628       switch (err)
 629         {
 630         case HOSTERR:
 631           logputs (LOG_VERBOSE, "\n");
 632           logprintf (LOG_NOTQUIET, "%s: %s.\n", u->host, herrmsg (h_errno));
 633           return HOSTERR;
 634           break;
 635         case CONSOCKERR:
 636           logputs (LOG_VERBOSE, "\n");
 637           logprintf (LOG_NOTQUIET, "socket: %s\n", strerror (errno));
 638           return CONSOCKERR;
 639           break;
 640         case CONREFUSED:
 641           logputs (LOG_VERBOSE, "\n");
 642           logprintf (LOG_NOTQUIET,
 643                      _("Connection to %s:%hu refused.\n"), u->host, u->port);
 644           CLOSE (sock);
 645           return CONREFUSED;
 646         case CONERROR:
 647           logputs (LOG_VERBOSE, "\n");
 648           logprintf (LOG_NOTQUIET, "connect: %s\n", strerror (errno));
 649           CLOSE (sock);
 650           return CONERROR;
 651           break;
 652         case NOCONERROR:
 653           /* Everything is fine!  */
 654           logputs (LOG_VERBOSE, _("connected!\n"));
 655           break;
 656         default:
 657           abort ();
 658           break;
 659         }
 660 #ifdef HAVE_SSL
 661      if (u->proto == URLHTTPS)
 662        if (connect_ssl (&ssl, ssl_ctx,sock) != 0)
 663          {
 664            logputs (LOG_VERBOSE, "\n");
 665            logprintf (LOG_NOTQUIET, _("Unable to establish SSL connection.\n"));
 666            CLOSE (sock);
 667            return CONSSLERR;
 668          }
 669 #endif /* HAVE_SSL */
 670     }
 671   else
 672     {
 673       logprintf (LOG_VERBOSE, _("Reusing connection to %s:%hu.\n"), u->host, u->port);
 674       /* #### pc_last_fd should be accessed through an accessor
 675          function.  */
 676       sock = pc_last_fd;
 677 #ifdef HAVE_SSL
 678       ssl = pc_last_ssl;
 679 #endif /* HAVE_SSL */
 680       DEBUGP (("Reusing fd %d.\n", sock));
 681     }
 682
 683   if (u->proxy)
 684     path = u->proxy->url;
 685   else
 686     path = u->path;
 687
 688   command = (*dt & HEAD_ONLY) ? "HEAD" : "GET";
 689   referer = NULL;
 690   if (ou->referer)
 691     {
 692       referer = (char *)alloca (9 + strlen (ou->referer) + 3);
 693       sprintf (referer, "Referer: %s\r\n", ou->referer);
 694     }
 695   if (*dt & SEND_NOCACHE)
 696     pragma_h = "Pragma: no-cache\r\n";
 697   else
 698     pragma_h = "";
 699   if (hs->restval)
 700     {
 701       range = (char *)alloca (13 + numdigit (hs->restval) + 4);
 702       /* Gag me!  Some servers (e.g. WebSitePro) have been known to
 703          respond to the following `Range' format by generating a
 704          multipart/x-byte-ranges MIME document!  This MIME type was
 705          present in an old draft of the byteranges specification.
 706          HTTP/1.1 specifies a multipart/byte-ranges MIME type, but
 707          only if multiple non-overlapping ranges are requested --
 708          which Wget never does.  */
 709       sprintf (range, "Range: bytes=%ld-\r\n", hs->restval);
 710     }
 711   else
 712     range = NULL;
 713   if (opt.useragent)
 714     STRDUP_ALLOCA (useragent, opt.useragent);
 715   else
 716     {
 717       useragent = (char *)alloca (10 + strlen (version_string));
 718       sprintf (useragent, "Wget/%s", version_string);
 719     }
 720   /* Construct the authentication, if userid is present.  */
 721   user = ou->user;
 722   passwd = ou->passwd;
 723   search_netrc (u->host, (const char **)&user, (const char **)&passwd, 0);
 724   user = user ? user : opt.http_user;
 725   passwd = passwd ? passwd : opt.http_passwd;
 726
 727   wwwauth = NULL;
 728   if (user && passwd)
 729     {
 730       if (!authenticate_h)
 731         {
 732           /* We have the username and the password, but haven't tried
 733              any authorization yet.  Let's see if the "Basic" method
 734              works.  If not, we'll come back here and construct a
 735              proper authorization method with the right challenges.
 736
 737              If we didn't employ this kind of logic, every URL that
 738              requires authorization would have to be processed twice,
 739              which is very suboptimal and generates a bunch of false
 740              "unauthorized" errors in the server log.
 741
 742              #### But this logic also has a serious problem when used
 743              with stronger authentications: we *first* transmit the
 744              username and the password in clear text, and *then*
 745              attempt a stronger authentication scheme.  That cannot be
 746              right!  We are only fortunate that almost everyone still
 747              uses the `Basic' scheme anyway.
 748
 749              There should be an option to prevent this from happening,
 750              for those who use strong authentication schemes and value
 751              their passwords.  */
 752           wwwauth = basic_authentication_encode (user, passwd, "Authorization");
 753         }
 754       else
 755         {
 756           wwwauth = create_authorization_line (authenticate_h, user, passwd,
 757                                                command, ou->path);
 758         }
 759     }
 760
 761   proxyauth = NULL;
 762   if (u->proxy)
 763     {
 764       char *proxy_user, *proxy_passwd;
 765       /* For normal username and password, URL components override
 766          command-line/wgetrc parameters.  With proxy authentication,
 767          it's the reverse, because proxy URLs are normally the
 768          "permanent" ones, so command-line args should take
 769          precedence.  */
 770       if (opt.proxy_user && opt.proxy_passwd)
 771         {
 772           proxy_user = opt.proxy_user;
 773           proxy_passwd = opt.proxy_passwd;
 774         }
 775       else
 776         {
 777           proxy_user = u->user;
 778           proxy_passwd = u->passwd;
 779         }
 780       /* #### This is junky.  Can't the proxy request, say, `Digest'
 781          authentication?  */
 782       if (proxy_user && proxy_passwd)
 783         proxyauth = basic_authentication_encode (proxy_user, proxy_passwd,
 784                                                  "Proxy-Authorization");
 785     }
 786   remhost = ou->host;
 787   remport = ou->port;
 788
 789   /* String of the form :PORT.  Used only for non-standard ports. */
 790   port_maybe = NULL;
 791   if (1
 792 #ifdef HAVE_SSL
 793       && remport != (u->proto == URLHTTPS
 794                      ? DEFAULT_HTTPS_PORT : DEFAULT_HTTP_PORT)
 795 #else
 796       && remport != DEFAULT_HTTP_PORT
 797 #endif
 798       )
 799     {
 800       port_maybe = (char *)alloca (numdigit (remport) + 2);
 801       sprintf (port_maybe, ":%d", remport);
 802     }
 803
 804   if (!inhibit_keep_alive)
 805     request_keep_alive = "Connection: Keep-Alive\r\n";
 806   else
 807     request_keep_alive = NULL;
 808
 809   /* Allocate the memory for the request.  */
 810   request = (char *)alloca (strlen (command) + strlen (path)
 811                             + strlen (useragent)
 812                             + strlen (remhost)
 813                             + (port_maybe ? strlen (port_maybe) : 0)
 814                             + strlen (HTTP_ACCEPT)
 815                             + (request_keep_alive
 816                                ? strlen (request_keep_alive) : 0)
 817                             + (referer ? strlen (referer) : 0)
 818                             + (cookies ? strlen (cookies) : 0)
 819                             + (wwwauth ? strlen (wwwauth) : 0)
 820                             + (proxyauth ? strlen (proxyauth) : 0)
 821                             + (range ? strlen (range) : 0)
 822                             + strlen (pragma_h)
 823                             + (opt.user_header ? strlen (opt.user_header) : 0)
 824                             + 64);
 825   /* Construct the request.  */
 826   sprintf (request, "\
 827 %s %s HTTP/1.0\r\n\
 828 User-Agent: %s\r\n\
 829 Host: %s%s\r\n\
 830 Accept: %s\r\n\
 831 %s%s%s%s%s%s%s%s\r\n",
 832            command, path, useragent, remhost,
 833            port_maybe ? port_maybe : "",
 834            HTTP_ACCEPT,
 835            request_keep_alive ? request_keep_alive : "",
 836            referer ? referer : "",
 837            cookies ? cookies : "",
 838            wwwauth ? wwwauth : "",
 839            proxyauth ? proxyauth : "",
 840            range ? range : "",
 841            pragma_h,
 842            opt.user_header ? opt.user_header : "");
 843   DEBUGP (("---request begin---\n%s---request end---\n", request));
 844    /* Free the temporary memory.  */
 845   FREE_MAYBE (wwwauth);
 846   FREE_MAYBE (proxyauth);
 847   FREE_MAYBE (cookies);
 848
 849   /* Send the request to server.  */
 850 #ifdef HAVE_SSL
 851   if (u->proto == URLHTTPS)
 852     num_written = ssl_iwrite (ssl, request, strlen (request));
 853   else
 854 #endif /* HAVE_SSL */
 855     num_written = iwrite (sock, request, strlen (request));
 856
 857   if (num_written < 0)
 858     {
 859       logprintf (LOG_VERBOSE, _("Failed writing HTTP request: %s.\n"),
 860                  strerror (errno));
 861       CLOSE_INVALIDATE (sock);
 862       return WRITEFAILED;
 863     }
 864   logprintf (LOG_VERBOSE, _("%s request sent, awaiting response... "),
 865              u->proxy ? "Proxy" : "HTTP");
 866   contlen = contrange = -1;
 867   type = NULL;
 868   statcode = -1;
 869   *dt &= ~RETROKF;
 870
 871   /* Before reading anything, initialize the rbuf.  */
 872   rbuf_initialize (&rbuf, sock);
 873 #ifdef HAVE_SSL
 874   if (u->proto == URLHTTPS)
 875     rbuf.ssl = ssl;
 876   else
 877     rbuf.ssl = NULL;
 878 #endif /* HAVE_SSL */
 879   all_headers = NULL;
 880   all_length = 0;
 881   /* Header-fetching loop.  */
 882   hcount = 0;
 883   while (1)
 884     {
 885       char *hdr;
 886       int status;
 887
 888       ++hcount;
 889       /* Get the header.  */
 890       status = header_get (&rbuf, &hdr,
 891                            /* Disallow continuations for status line.  */
 892                            (hcount == 1 ? HG_NO_CONTINUATIONS : HG_NONE));
 893
 894       /* Check for errors.  */
 895       if (status == HG_EOF && *hdr)
 896         {
 897           /* This used to be an unconditional error, but that was
 898              somewhat controversial, because of a large number of
 899              broken CGI's that happily "forget" to send the second EOL
 900              before closing the connection of a HEAD request.
 901
 902              So, the deal is to check whether the header is empty
 903              (*hdr is zero if it is); if yes, it means that the
 904              previous header was fully retrieved, and that -- most
 905              probably -- the request is complete.  "...be liberal in
 906              what you accept."  Oh boy.  */
 907           logputs (LOG_VERBOSE, "\n");
 908           logputs (LOG_NOTQUIET, _("End of file while parsing headers.\n"));
 909           xfree (hdr);
 910           FREE_MAYBE (type);
 911           FREE_MAYBE (hs->newloc);
 912           FREE_MAYBE (all_headers);
 913           CLOSE_INVALIDATE (sock);
 914           return HEOF;
 915         }
 916       else if (status == HG_ERROR)
 917         {
 918           logputs (LOG_VERBOSE, "\n");
 919           logprintf (LOG_NOTQUIET, _("Read error (%s) in headers.\n"),
 920                      strerror (errno));
 921           xfree (hdr);
 922           FREE_MAYBE (type);
 923           FREE_MAYBE (hs->newloc);
 924           FREE_MAYBE (all_headers);
 925           CLOSE_INVALIDATE (sock);
 926           return HERR;
 927         }
 928
 929       /* If the headers are to be saved to a file later, save them to
 930          memory now.  */
 931       if (opt.save_headers)
 932         {
 933           int lh = strlen (hdr);
 934           all_headers = (char *)xrealloc (all_headers, all_length + lh + 2);
 935           memcpy (all_headers + all_length, hdr, lh);
 936           all_length += lh;
 937           all_headers[all_length++] = '\n';
 938           all_headers[all_length] = '\0';
 939         }
 940
 941       /* Print the header if requested.  */
 942       if (opt.server_response && hcount != 1)
 943         logprintf (LOG_VERBOSE, "\n%d %s", hcount, hdr);
 944
 945       /* Check for status line.  */
 946       if (hcount == 1)
 947         {
 948           const char *error;
 949           /* Parse the first line of server response.  */
 950           statcode = parse_http_status_line (hdr, &error);
 951           hs->statcode = statcode;
 952           /* Store the descriptive response.  */
 953           if (statcode == -1) /* malformed response */
 954             {
 955               /* A common reason for "malformed response" error is the
 956                  case when no data was actually received.  Handle this
 957                  special case.  */
 958               if (!*hdr)
 959                 hs->error = xstrdup (_("No data received"));
 960               else
 961                 hs->error = xstrdup (_("Malformed status line"));
 962               xfree (hdr);
 963               break;
 964             }
 965           else if (!*error)
 966             hs->error = xstrdup (_("(no description)"));
 967           else
 968             hs->error = xstrdup (error);
 969
 970           if ((statcode != -1)
 971 #ifdef DEBUG
 972               && !opt.debug
 973 #endif
 974               )
 975             logprintf (LOG_VERBOSE, "%d %s", statcode, error);
 976
 977           goto done_header;
 978         }
 979
 980       /* Exit on empty header.  */
 981       if (!*hdr)
 982         {
 983           xfree (hdr);
 984           break;
 985         }
 986
 987       /* Try getting content-length.  */
 988       if (contlen == -1 && !opt.ignore_length)
 989         if (header_process (hdr, "Content-Length", header_extract_number,
 990                             &contlen))
 991           goto done_header;
 992       /* Try getting content-type.  */
 993       if (!type)
 994         if (header_process (hdr, "Content-Type", http_process_type, &type))
 995           goto done_header;
 996       /* Try getting location.  */
 997       if (!hs->newloc)
 998         if (header_process (hdr, "Location", header_strdup, &hs->newloc))
 999           goto done_header;
1000       /* Try getting last-modified.  */
1001       if (!hs->remote_time)
1002         if (header_process (hdr, "Last-Modified", header_strdup,
1003                             &hs->remote_time))
1004           goto done_header;
1005       /* Try getting cookies. */
1006       if (opt.cookies)
1007         if (header_process (hdr, "Set-Cookie", set_cookie_header_cb, u))
1008           goto done_header;
1009       /* Try getting www-authentication.  */
1010       if (!authenticate_h)
1011         if (header_process (hdr, "WWW-Authenticate", header_strdup,
1012                             &authenticate_h))
1013           goto done_header;
1014       /* Check for accept-ranges header.  If it contains the word
1015          `none', disable the ranges.  */
1016       if (*dt & ACCEPTRANGES)
1017         {
1018           int nonep;
1019           if (header_process (hdr, "Accept-Ranges", http_process_none, &nonep))
1020             {
1021               if (nonep)
1022                 *dt &= ~ACCEPTRANGES;
1023               goto done_header;
1024             }
1025         }
1026       /* Try getting content-range.  */
1027       if (contrange == -1)
1028         {
1029           struct http_process_range_closure closure;
1030           if (header_process (hdr, "Content-Range", http_process_range, &closure))
1031             {
1032               contrange = closure.first_byte_pos;
1033               goto done_header;
1034             }
1035         }
1036       /* Check for keep-alive related responses. */
1037       if (!inhibit_keep_alive)
1038         {
1039           /* Check for the `Keep-Alive' header. */
1040           if (!http_keep_alive_1)
1041             {
1042               if (header_process (hdr, "Keep-Alive", header_exists,
1043                                   &http_keep_alive_1))
1044                 goto done_header;
1045             }
1046           /* Check for `Connection: Keep-Alive'. */
1047           if (!http_keep_alive_2)
1048             {
1049               if (header_process (hdr, "Connection", http_process_connection,
1050                                   &http_keep_alive_2))
1051                 goto done_header;
1052             }
1053         }
1054     done_header:
1055       xfree (hdr);
1056     }
1057
1058   logputs (LOG_VERBOSE, "\n");
1059
1060   if (contlen != -1
1061       && (http_keep_alive_1 || http_keep_alive_2))
1062     {
1063       assert (inhibit_keep_alive == 0);
1064       keep_alive = 1;
1065     }
1066   if (keep_alive)
1067     /* The server has promised that it will not close the connection
1068        when we're done.  This means that we can register it.  */
1069 #ifndef HAVE_SSL
1070     register_persistent (u->host, u->port, sock);
1071 #else
1072     register_persistent (u->host, u->port, sock, ssl);
1073 #endif /* HAVE_SSL */
1074
1075   if ((statcode == HTTP_STATUS_UNAUTHORIZED)
1076       && authenticate_h)
1077     {
1078       /* Authorization is required.  */
1079       FREE_MAYBE (type);
1080       type = NULL;
1081       FREEHSTAT (*hs);
1082       CLOSE_INVALIDATE (sock);  /* would be CLOSE_FINISH, but there
1083                                    might be more bytes in the body. */
1084       if (auth_tried_already)
1085         {
1086           /* If we have tried it already, then there is not point
1087              retrying it.  */
1088         failed:
1089           logputs (LOG_NOTQUIET, _("Authorization failed.\n"));
1090           xfree (authenticate_h);
1091           return AUTHFAILED;
1092         }
1093       else if (!known_authentication_scheme_p (authenticate_h))
1094         {
1095           xfree (authenticate_h);
1096           logputs (LOG_NOTQUIET, _("Unknown authentication scheme.\n"));
1097           return AUTHFAILED;
1098         }
1099       else if (BEGINS_WITH (authenticate_h, "Basic"))
1100         {
1101           /* The authentication scheme is basic, the one we try by
1102              default, and it failed.  There's no sense in trying
1103              again.  */
1104           goto failed;
1105         }
1106       else
1107         {
1108           auth_tried_already = 1;
1109           goto again;
1110         }
1111     }
1112   /* We do not need this anymore.  */
1113   if (authenticate_h)
1114     {
1115       xfree (authenticate_h);
1116       authenticate_h = NULL;
1117     }
1118
1119   /* 20x responses are counted among successful by default.  */
1120   if (H_20X (statcode))
1121     *dt |= RETROKF;
1122
1123   if (type && !strncasecmp (type, TEXTHTML_S, strlen (TEXTHTML_S)))
1124     *dt |= TEXTHTML;
1125   else
1126     /* We don't assume text/html by default.  */
1127     *dt &= ~TEXTHTML;
1128
1129   if (opt.html_extension && (*dt & TEXTHTML))
1130     /* -E / --html-extension / html_extension = on was specified, and this is a
1131        text/html file.  If some case-insensitive variation on ".htm[l]" isn't
1132        already the file's suffix, tack on ".html". */
1133     {
1134       char*  last_period_in_local_filename = strrchr(u->local, '.');
1135
1136       if (last_period_in_local_filename == NULL ||
1137           !(strcasecmp(last_period_in_local_filename, ".htm") == EQ ||
1138             strcasecmp(last_period_in_local_filename, ".html") == EQ))
1139         {
1140           size_t  local_filename_len = strlen(u->local);
1141
1142           u->local = xrealloc(u->local, local_filename_len + sizeof(".html"));
1143           strcpy(u->local + local_filename_len, ".html");
1144
1145           *dt |= ADDED_HTML_EXTENSION;
1146         }
1147     }
1148
1149   if (contrange == -1)
1150     {
1151       /* We did not get a content-range header.  This means that the
1152          server did not honor our `Range' request.  Normally, this
1153          means we should reset hs->restval and continue normally.  */
1154
1155       /* However, if `-c' is used, we need to be a bit more careful:
1156
1157          1. If `-c' is specified and the file already existed when
1158          Wget was started, it would be a bad idea for us to start
1159          downloading it from scratch, effectively truncating it.  I
1160          believe this cannot happen unless `-c' was specified.
1161
1162          2. If `-c' is used on a file that is already fully
1163          downloaded, we're requesting bytes after the end of file,
1164          which can result in server not honoring `Range'.  If this is
1165          the case, `Content-Length' will be equal to the length of the
1166          file.  */
1167       if (opt.always_rest)
1168         {
1169           /* Check for condition #2. */
1170           if (hs->restval == contlen)
1171             {
1172               logputs (LOG_VERBOSE, _("\
1173 \n    The file is already fully retrieved; nothing to do.\n\n"));
1174               /* In case the caller inspects. */
1175               hs->len = contlen;
1176               hs->res = 0;
1177               FREE_MAYBE (type);
1178               FREE_MAYBE (hs->newloc);
1179               FREE_MAYBE (all_headers);
1180               CLOSE_INVALIDATE (sock);  /* would be CLOSE_FINISH, but there
1181                                            might be more bytes in the body. */
1182               return RETRFINISHED;
1183             }
1184
1185           /* Check for condition #1. */
1186           if (hs->no_truncate)
1187             {
1188               logprintf (LOG_NOTQUIET,
1189                          _("\
1190 \n\
1191     The server does not support continued download;\n\
1192     refusing to truncate `%s'.\n\n"), u->local);
1193               return CONTNOTSUPPORTED;
1194             }
1195
1196           /* Fallthrough */
1197         }
1198
1199       hs->restval = 0;
1200     }
1201
1202   else if (contrange != hs->restval ||
1203            (H_PARTIAL (statcode) && contrange == -1))
1204     {
1205       /* This means the whole request was somehow misunderstood by the
1206          server.  Bail out.  */
1207       FREE_MAYBE (type);
1208       FREE_MAYBE (hs->newloc);
1209       FREE_MAYBE (all_headers);
1210       CLOSE_INVALIDATE (sock);
1211       return RANGEERR;
1212     }
1213
1214   if (hs->restval)
1215     {
1216       if (contlen != -1)
1217         contlen += contrange;
1218       else
1219         contrange = -1;        /* If conent-length was not sent,
1220                                   content-range will be ignored.  */
1221     }
1222   hs->contlen = contlen;
1223
1224   /* Return if redirected.  */
1225   if (H_REDIRECTED (statcode) || statcode == HTTP_STATUS_MULTIPLE_CHOICES)
1226     {
1227       /* RFC2068 says that in case of the 300 (multiple choices)
1228          response, the server can output a preferred URL through
1229          `Location' header; otherwise, the request should be treated
1230          like GET.  So, if the location is set, it will be a
1231          redirection; otherwise, just proceed normally.  */
1232       if (statcode == HTTP_STATUS_MULTIPLE_CHOICES && !hs->newloc)
1233         *dt |= RETROKF;
1234       else
1235         {
1236           logprintf (LOG_VERBOSE,
1237                      _("Location: %s%s\n"),
1238                      hs->newloc ? hs->newloc : _("unspecified"),
1239                      hs->newloc ? _(" [following]") : "");
1240           CLOSE_INVALIDATE (sock);      /* would be CLOSE_FINISH, but there
1241                                            might be more bytes in the body. */
1242           FREE_MAYBE (type);
1243           FREE_MAYBE (all_headers);
1244           return NEWLOCATION;
1245         }
1246     }
1247   if (opt.verbose)
1248     {
1249       if ((*dt & RETROKF) && !opt.server_response)
1250         {
1251           /* No need to print this output if the body won't be
1252              downloaded at all, or if the original server response is
1253              printed.  */
1254           logputs (LOG_VERBOSE, _("Length: "));
1255           if (contlen != -1)
1256             {
1257               logputs (LOG_VERBOSE, legible (contlen));
1258               if (contrange != -1)
1259                 logprintf (LOG_VERBOSE, _(" (%s to go)"),
1260                            legible (contlen - contrange));
1261             }
1262           else
1263             logputs (LOG_VERBOSE,
1264                      opt.ignore_length ? _("ignored") : _("unspecified"));
1265           if (type)
1266             logprintf (LOG_VERBOSE, " [%s]\n", type);
1267           else
1268             logputs (LOG_VERBOSE, "\n");
1269         }
1270     }
1271   FREE_MAYBE (type);
1272   type = NULL;                  /* We don't need it any more.  */
1273
1274   /* Return if we have no intention of further downloading.  */
1275   if (!(*dt & RETROKF) || (*dt & HEAD_ONLY))
1276     {
1277       /* In case the caller cares to look...  */
1278       hs->len = 0L;
1279       hs->res = 0;
1280       FREE_MAYBE (type);
1281       FREE_MAYBE (all_headers);
1282       CLOSE_INVALIDATE (sock);  /* would be CLOSE_FINISH, but there
1283                                    might be more bytes in the body. */
1284       return RETRFINISHED;
1285     }
1286
1287   /* Open the local file.  */
1288   if (!opt.dfp)
1289     {
1290       mkalldirs (u->local);
1291       if (opt.backups)
1292         rotate_backups (u->local);
1293       fp = fopen (u->local, hs->restval ? "ab" : "wb");
1294       if (!fp)
1295         {
1296           logprintf (LOG_NOTQUIET, "%s: %s\n", u->local, strerror (errno));
1297           CLOSE_INVALIDATE (sock); /* would be CLOSE_FINISH, but there
1298                                       might be more bytes in the body. */
1299           FREE_MAYBE (all_headers);
1300           return FOPENERR;
1301         }
1302     }
1303   else                          /* opt.dfp */
1304     {
1305       extern int global_download_count;
1306       fp = opt.dfp;
1307       /* To ensure that repeated "from scratch" downloads work for -O
1308          files, we rewind the file pointer, unless restval is
1309          non-zero.  (This works only when -O is used on regular files,
1310          but it's still a valuable feature.)
1311
1312          However, this loses when more than one URL is specified on
1313          the command line the second rewinds eradicates the contents
1314          of the first download.  Thus we disable the above trick for
1315          all the downloads except the very first one.
1316
1317          #### A possible solution to this would be to remember the
1318          file position in the output document and to seek to that
1319          position, instead of rewinding.  */
1320       if (!hs->restval && global_download_count == 0)
1321         {
1322           /* This will silently fail for streams that don't correspond
1323              to regular files, but that's OK.  */
1324           rewind (fp);
1325           /* ftruncate is needed because opt.dfp is opened in append
1326              mode if opt.always_rest is set.  */
1327           ftruncate (fileno (fp), 0);
1328           clearerr (fp);
1329         }
1330     }
1331
1332   /* #### This confuses the code that checks for file size.  There
1333      should be some overhead information.  */
1334   if (opt.save_headers)
1335     fwrite (all_headers, 1, all_length, fp);
1336   reset_timer ();
1337   /* Get the contents of the document.  */
1338   hs->res = get_contents (sock, fp, &hs->len, hs->restval,
1339                           (contlen != -1 ? contlen : 0),
1340                           &rbuf, keep_alive);
1341   hs->dltime = elapsed_time ();
1342   {
1343     /* Close or flush the file.  We have to be careful to check for
1344        error here.  Checking the result of fwrite() is not enough --
1345        errors could go unnoticed!  */
1346     int flush_res;
1347     if (!opt.dfp)
1348       flush_res = fclose (fp);
1349     else
1350       flush_res = fflush (fp);
1351     if (flush_res == EOF)
1352       hs->res = -2;
1353   }
1354   FREE_MAYBE (all_headers);
1355   CLOSE_FINISH (sock);
1356   if (hs->res == -2)
1357     return FWRITEERR;
1358   return RETRFINISHED;
1359 }
1360
1361 /* The genuine HTTP loop!  This is the part where the retrieval is
1362    retried, and retried, and retried, and...  */
1363 uerr_t
1364 http_loop (struct urlinfo *u, char **newloc, int *dt)
1365 {
1366   int count;
1367   int use_ts, got_head = 0;     /* time-stamping info */
1368   char *filename_plus_orig_suffix;
1369   char *local_filename = NULL;
1370   char *tms, *suf, *locf, *tmrate;
1371   uerr_t err;
1372   time_t tml = -1, tmr = -1;    /* local and remote time-stamps */
1373   long local_size = 0;          /* the size of the local file */
1374   size_t filename_len;
1375   struct http_stat hstat;       /* HTTP status */
1376   struct stat st;
1377
1378   /* This used to be done in main(), but it's a better idea to do it
1379      here so that we don't go through the hoops if we're just using
1380      FTP or whatever. */
1381   if (opt.cookies && opt.cookies_input && !cookies_loaded_p)
1382     load_cookies (opt.cookies_input);
1383
1384   *newloc = NULL;
1385
1386   /* Warn on (likely bogus) wildcard usage in HTTP.  Don't use
1387      has_wildcards_p because it would also warn on `?', and we know that
1388      shows up in CGI paths a *lot*.  */
1389   if (strchr (u->url, '*'))
1390     logputs (LOG_VERBOSE, _("Warning: wildcards not supported in HTTP.\n"));
1391
1392   /* Determine the local filename.  */
1393   if (!u->local)
1394     u->local = url_filename (u->proxy ? u->proxy : u);
1395
1396   if (!opt.output_document)
1397     locf = u->local;
1398   else
1399     locf = opt.output_document;
1400
1401   /* Yuck.  Multiple returns suck.  We need to remember to free() the space we
1402      xmalloc() here before EACH return.  This is one reason it's better to set
1403      flags that influence flow control and then return once at the end. */
1404   filename_len = strlen(u->local);
1405   filename_plus_orig_suffix = xmalloc(filename_len + sizeof(".orig"));
1406
1407   if (opt.noclobber && file_exists_p (u->local))
1408     {
1409       /* If opt.noclobber is turned on and file already exists, do not
1410          retrieve the file */
1411       logprintf (LOG_VERBOSE, _("\
1412 File `%s' already there, will not retrieve.\n"), u->local);
1413       /* If the file is there, we suppose it's retrieved OK.  */
1414       *dt |= RETROKF;
1415
1416       /* #### Bogusness alert.  */
1417       /* If its suffix is "html" or (yuck!) "htm", we suppose it's
1418          text/html, a harmless lie.  */
1419       if (((suf = suffix (u->local)) != NULL)
1420           && (!strcmp (suf, "html") || !strcmp (suf, "htm")))
1421         *dt |= TEXTHTML;
1422       xfree (suf);
1423       xfree (filename_plus_orig_suffix); /* must precede every return! */
1424       /* Another harmless lie: */
1425       return RETROK;
1426     }
1427
1428   use_ts = 0;
1429   if (opt.timestamping)
1430     {
1431       boolean  local_dot_orig_file_exists = FALSE;
1432
1433       if (opt.backup_converted)
1434         /* If -K is specified, we'll act on the assumption that it was specified
1435            last time these files were downloaded as well, and instead of just
1436            comparing local file X against server file X, we'll compare local
1437            file X.orig (if extant, else X) against server file X.  If -K
1438            _wasn't_ specified last time, or the server contains files called
1439            *.orig, -N will be back to not operating correctly with -k. */
1440         {
1441           /* Would a single s[n]printf() call be faster?  --dan
1442
1443              Definitely not.  sprintf() is horribly slow.  It's a
1444              different question whether the difference between the two
1445              affects a program.  Usually I'd say "no", but at one
1446              point I profiled Wget, and found that a measurable and
1447              non-negligible amount of time was lost calling sprintf()
1448              in url.c.  Replacing sprintf with inline calls to
1449              strcpy() and long_to_string() made a difference.
1450              --hniksic */
1451           strcpy(filename_plus_orig_suffix, u->local);
1452           strcpy(filename_plus_orig_suffix + filename_len, ".orig");
1453
1454           /* Try to stat() the .orig file. */
1455           if (stat(filename_plus_orig_suffix, &st) == 0)
1456             {
1457               local_dot_orig_file_exists = TRUE;
1458               local_filename = filename_plus_orig_suffix;
1459             }
1460         }
1461
1462       if (!local_dot_orig_file_exists)
1463         /* Couldn't stat() <file>.orig, so try to stat() <file>. */
1464         if (stat (u->local, &st) == 0)
1465           local_filename = u->local;
1466
1467       if (local_filename != NULL)
1468         /* There was a local file, so we'll check later to see if the version
1469            the server has is the same version we already have, allowing us to
1470            skip a download. */
1471         {
1472           use_ts = 1;
1473           tml = st.st_mtime;
1474           local_size = st.st_size;
1475           got_head = 0;
1476         }
1477     }
1478   /* Reset the counter.  */
1479   count = 0;
1480   *dt = 0 | ACCEPTRANGES;
1481   /* THE loop */
1482   do
1483     {
1484       /* Increment the pass counter.  */
1485       ++count;
1486       sleep_between_retrievals (count);
1487       /* Get the current time string.  */
1488       tms = time_str (NULL);
1489       /* Print fetch message, if opt.verbose.  */
1490       if (opt.verbose)
1491         {
1492           char *hurl = str_url (u->proxy ? u->proxy : u, 1);
1493           char tmp[15];
1494           strcpy (tmp, "        ");
1495           if (count > 1)
1496             sprintf (tmp, _("(try:%2d)"), count);
1497           logprintf (LOG_VERBOSE, "--%s--  %s\n  %s => `%s'\n",
1498                      tms, hurl, tmp, locf);
1499 #ifdef WINDOWS
1500           ws_changetitle (hurl, 1);
1501 #endif
1502           xfree (hurl);
1503         }
1504
1505       /* Default document type is empty.  However, if spider mode is
1506          on or time-stamping is employed, HEAD_ONLY commands is
1507          encoded within *dt.  */
1508       if (opt.spider || (use_ts && !got_head))
1509         *dt |= HEAD_ONLY;
1510       else
1511         *dt &= ~HEAD_ONLY;
1512       /* Assume no restarting.  */
1513       hstat.restval = 0L;
1514       /* Decide whether or not to restart.  */
1515       if (((count > 1 && (*dt & ACCEPTRANGES)) || opt.always_rest)
1516           && file_exists_p (locf))
1517         if (stat (locf, &st) == 0 && S_ISREG (st.st_mode))
1518           hstat.restval = st.st_size;
1519       /* Decide whether to send the no-cache directive.  */
1520       if (u->proxy && (count > 1 || (opt.proxy_cache == 0)))
1521         *dt |= SEND_NOCACHE;
1522       else
1523         *dt &= ~SEND_NOCACHE;
1524
1525       /* Try fetching the document, or at least its head.  :-) */
1526       err = gethttp (u, &hstat, dt);
1527
1528       /* It's unfortunate that wget determines the local filename before finding
1529          out the Content-Type of the file.  Barring a major restructuring of the
1530          code, we need to re-set locf here, since gethttp() may have xrealloc()d
1531          u->local to tack on ".html". */
1532       if (!opt.output_document)
1533         locf = u->local;
1534       else
1535         locf = opt.output_document;
1536
1537       /* In `-c' is used, check whether the file we're writing to
1538          exists before we've done anything.  If so, we'll refuse to
1539          truncate it if the server doesn't support continued
1540          downloads.  */
1541       if (opt.always_rest)
1542         hstat.no_truncate = file_exists_p (locf);
1543
1544       /* Time?  */
1545       tms = time_str (NULL);
1546       /* Get the new location (with or without the redirection).  */
1547       if (hstat.newloc)
1548         *newloc = xstrdup (hstat.newloc);
1549       switch (err)
1550         {
1551         case HERR: case HEOF: case CONSOCKERR: case CONCLOSED:
1552         case CONERROR: case READERR: case WRITEFAILED:
1553         case RANGEERR:
1554           /* Non-fatal errors continue executing the loop, which will
1555              bring them to "while" statement at the end, to judge
1556              whether the number of tries was exceeded.  */
1557           FREEHSTAT (hstat);
1558           printwhat (count, opt.ntry);
1559           continue;
1560           break;
1561         case HOSTERR: case CONREFUSED: case PROXERR: case AUTHFAILED:
1562         case SSLERRCTXCREATE: case CONTNOTSUPPORTED:
1563           /* Fatal errors just return from the function.  */
1564           FREEHSTAT (hstat);
1565           xfree (filename_plus_orig_suffix); /* must precede every return! */
1566           return err;
1567           break;
1568         case FWRITEERR: case FOPENERR:
1569           /* Another fatal error.  */
1570           logputs (LOG_VERBOSE, "\n");
1571           logprintf (LOG_NOTQUIET, _("Cannot write to `%s' (%s).\n"),
1572                      u->local, strerror (errno));
1573           FREEHSTAT (hstat);
1574           return err;
1575           break;
1576         case CONSSLERR:
1577           /* Another fatal error.  */
1578           logputs (LOG_VERBOSE, "\n");
1579           logprintf (LOG_NOTQUIET, _("Unable to establish SSL connection.\n"));
1580           FREEHSTAT (hstat);
1581           xfree (filename_plus_orig_suffix); /* must precede every return! */
1582           return err;
1583           break;
1584         case NEWLOCATION:
1585           /* Return the new location to the caller.  */
1586           if (!hstat.newloc)
1587             {
1588               logprintf (LOG_NOTQUIET,
1589                          _("ERROR: Redirection (%d) without location.\n"),
1590                          hstat.statcode);
1591               xfree (filename_plus_orig_suffix); /* must precede every return! */
1592               return WRONGCODE;
1593             }
1594           FREEHSTAT (hstat);
1595           xfree (filename_plus_orig_suffix); /* must precede every return! */
1596           return NEWLOCATION;
1597           break;
1598         case RETRFINISHED:
1599           /* Deal with you later.  */
1600           break;
1601         default:
1602           /* All possibilities should have been exhausted.  */
1603           abort ();
1604         }
1605       if (!(*dt & RETROKF))
1606         {
1607           if (!opt.verbose)
1608             {
1609               /* #### Ugly ugly ugly! */
1610               char *hurl = str_url (u->proxy ? u->proxy : u, 1);
1611               logprintf (LOG_NONVERBOSE, "%s:\n", hurl);
1612               xfree (hurl);
1613             }
1614           logprintf (LOG_NOTQUIET, _("%s ERROR %d: %s.\n"),
1615                      tms, hstat.statcode, hstat.error);
1616           logputs (LOG_VERBOSE, "\n");
1617           FREEHSTAT (hstat);
1618           xfree (filename_plus_orig_suffix); /* must precede every return! */
1619           return WRONGCODE;
1620         }
1621
1622       /* Did we get the time-stamp?  */
1623       if (!got_head)
1624         {
1625           if (opt.timestamping && !hstat.remote_time)
1626             {
1627               logputs (LOG_NOTQUIET, _("\
1628 Last-modified header missing -- time-stamps turned off.\n"));
1629             }
1630           else if (hstat.remote_time)
1631             {
1632               /* Convert the date-string into struct tm.  */
1633               tmr = http_atotm (hstat.remote_time);
1634               if (tmr == (time_t) (-1))
1635                 logputs (LOG_VERBOSE, _("\
1636 Last-modified header invalid -- time-stamp ignored.\n"));
1637             }
1638         }
1639
1640       /* The time-stamping section.  */
1641       if (use_ts)
1642         {
1643           got_head = 1;
1644           *dt &= ~HEAD_ONLY;
1645           use_ts = 0;           /* no more time-stamping */
1646           count = 0;            /* the retrieve count for HEAD is
1647                                    reset */
1648           if (hstat.remote_time && tmr != (time_t) (-1))
1649             {
1650               /* Now time-stamping can be used validly.  Time-stamping
1651                  means that if the sizes of the local and remote file
1652                  match, and local file is newer than the remote file,
1653                  it will not be retrieved.  Otherwise, the normal
1654                  download procedure is resumed.  */
1655               if (tml >= tmr &&
1656                   (hstat.contlen == -1 || local_size == hstat.contlen))
1657                 {
1658                   logprintf (LOG_VERBOSE, _("\
1659 Server file no newer than local file `%s' -- not retrieving.\n\n"),
1660                              local_filename);
1661                   FREEHSTAT (hstat);
1662                   xfree (filename_plus_orig_suffix); /*must precede every return!*/
1663                   return RETROK;
1664                 }
1665               else if (tml >= tmr)
1666                 logprintf (LOG_VERBOSE, _("\
1667 The sizes do not match (local %ld) -- retrieving.\n"), local_size);
1668               else
1669                 logputs (LOG_VERBOSE,
1670                          _("Remote file is newer, retrieving.\n"));
1671             }
1672           FREEHSTAT (hstat);
1673           continue;
1674         }
1675       if ((tmr != (time_t) (-1))
1676           && !opt.spider
1677           && ((hstat.len == hstat.contlen) ||
1678               ((hstat.res == 0) &&
1679                ((hstat.contlen == -1) ||
1680                 (hstat.len >= hstat.contlen && !opt.kill_longer)))))
1681         {
1682           /* #### This code repeats in http.c and ftp.c.  Move it to a
1683              function!  */
1684           const char *fl = NULL;
1685           if (opt.output_document)
1686             {
1687               if (opt.od_known_regular)
1688                 fl = opt.output_document;
1689             }
1690           else
1691             fl = u->local;
1692           if (fl)
1693             touch (fl, tmr);
1694         }
1695       /* End of time-stamping section.  */
1696
1697       if (opt.spider)
1698         {
1699           logprintf (LOG_NOTQUIET, "%d %s\n\n", hstat.statcode, hstat.error);
1700           xfree (filename_plus_orig_suffix); /* must precede every return! */
1701           return RETROK;
1702         }
1703
1704       /* It is now safe to free the remainder of hstat, since the
1705          strings within it will no longer be used.  */
1706       FREEHSTAT (hstat);
1707
1708       tmrate = rate (hstat.len - hstat.restval, hstat.dltime, 0);
1709
1710       if (hstat.len == hstat.contlen)
1711         {
1712           if (*dt & RETROKF)
1713             {
1714               logprintf (LOG_VERBOSE,
1715                          _("%s (%s) - `%s' saved [%ld/%ld]\n\n"),
1716                          tms, tmrate, locf, hstat.len, hstat.contlen);
1717               logprintf (LOG_NONVERBOSE,
1718                          "%s URL:%s [%ld/%ld] -> \"%s\" [%d]\n",
1719                          tms, u->url, hstat.len, hstat.contlen, locf, count);
1720             }
1721           ++opt.numurls;
1722           downloaded_increase (hstat.len);
1723
1724           /* Remember that we downloaded the file for later ".orig" code. */
1725           if (*dt & ADDED_HTML_EXTENSION)
1726             downloaded_file(FILE_DOWNLOADED_AND_HTML_EXTENSION_ADDED, locf);
1727           else
1728             downloaded_file(FILE_DOWNLOADED_NORMALLY, locf);
1729
1730           xfree(filename_plus_orig_suffix); /* must precede every return! */
1731           return RETROK;
1732         }
1733       else if (hstat.res == 0) /* No read error */
1734         {
1735           if (hstat.contlen == -1)  /* We don't know how much we were supposed
1736                                        to get, so assume we succeeded. */
1737             {
1738               if (*dt & RETROKF)
1739                 {
1740                   logprintf (LOG_VERBOSE,
1741                              _("%s (%s) - `%s' saved [%ld]\n\n"),
1742                              tms, tmrate, locf, hstat.len);
1743                   logprintf (LOG_NONVERBOSE,
1744                              "%s URL:%s [%ld] -> \"%s\" [%d]\n",
1745                              tms, u->url, hstat.len, locf, count);
1746                 }
1747               ++opt.numurls;
1748               downloaded_increase (hstat.len);
1749
1750               /* Remember that we downloaded the file for later ".orig" code. */
1751               if (*dt & ADDED_HTML_EXTENSION)
1752                 downloaded_file(FILE_DOWNLOADED_AND_HTML_EXTENSION_ADDED, locf);
1753               else
1754                 downloaded_file(FILE_DOWNLOADED_NORMALLY, locf);
1755
1756               xfree (filename_plus_orig_suffix); /* must precede every return! */
1757               return RETROK;
1758             }
1759           else if (hstat.len < hstat.contlen) /* meaning we lost the
1760                                                  connection too soon */
1761             {
1762               logprintf (LOG_VERBOSE,
1763                          _("%s (%s) - Connection closed at byte %ld. "),
1764                          tms, tmrate, hstat.len);
1765               printwhat (count, opt.ntry);
1766               continue;
1767             }
1768           else if (!opt.kill_longer) /* meaning we got more than expected */
1769             {
1770               logprintf (LOG_VERBOSE,
1771                          _("%s (%s) - `%s' saved [%ld/%ld])\n\n"),
1772                          tms, tmrate, locf, hstat.len, hstat.contlen);
1773               logprintf (LOG_NONVERBOSE,
1774                          "%s URL:%s [%ld/%ld] -> \"%s\" [%d]\n",
1775                          tms, u->url, hstat.len, hstat.contlen, locf, count);
1776               ++opt.numurls;
1777               downloaded_increase (hstat.len);
1778
1779               /* Remember that we downloaded the file for later ".orig" code. */
1780               if (*dt & ADDED_HTML_EXTENSION)
1781                 downloaded_file(FILE_DOWNLOADED_AND_HTML_EXTENSION_ADDED, locf);
1782               else
1783                 downloaded_file(FILE_DOWNLOADED_NORMALLY, locf);
1784
1785               xfree (filename_plus_orig_suffix); /* must precede every return! */
1786               return RETROK;
1787             }
1788           else                  /* the same, but not accepted */
1789             {
1790               logprintf (LOG_VERBOSE,
1791                          _("%s (%s) - Connection closed at byte %ld/%ld. "),
1792                          tms, tmrate, hstat.len, hstat.contlen);
1793               printwhat (count, opt.ntry);
1794               continue;
1795             }
1796         }
1797       else                      /* now hstat.res can only be -1 */
1798         {
1799           if (hstat.contlen == -1)
1800             {
1801               logprintf (LOG_VERBOSE,
1802                          _("%s (%s) - Read error at byte %ld (%s)."),
1803                          tms, tmrate, hstat.len, strerror (errno));
1804               printwhat (count, opt.ntry);
1805               continue;
1806             }
1807           else                  /* hstat.res == -1 and contlen is given */
1808             {
1809               logprintf (LOG_VERBOSE,
1810                          _("%s (%s) - Read error at byte %ld/%ld (%s). "),
1811                          tms, tmrate, hstat.len, hstat.contlen,
1812                          strerror (errno));
1813               printwhat (count, opt.ntry);
1814               continue;
1815             }
1816         }
1817       /* not reached */
1818       break;
1819     }
1820   while (!opt.ntry || (count < opt.ntry));
1821   xfree (filename_plus_orig_suffix); /* must precede every return! */
1822   return TRYLIMEXC;
1823 }
1824 \f
1825 /* Converts struct tm to time_t, assuming the data in tm is UTC rather
1826    than local timezone (mktime assumes the latter).
1827
1828    Contributed by Roger Beeman <beeman@cisco.com>, with the help of
1829    Mark Baushke <mdb@cisco.com> and the rest of the Gurus at CISCO.  */
1830 static time_t
1831 mktime_from_utc (struct tm *t)
1832 {
1833   time_t tl, tb;
1834
1835   tl = mktime (t);
1836   if (tl == -1)
1837     return -1;
1838   tb = mktime (gmtime (&tl));
1839   return (tl <= tb ? (tl + (tl - tb)) : (tl - (tb - tl)));
1840 }
1841
1842 /* Check whether the result of strptime() indicates success.
1843    strptime() returns the pointer to how far it got to in the string.
1844    The processing has been successful if the string is at `GMT' or
1845    `+X', or at the end of the string.
1846
1847    In extended regexp parlance, the function returns 1 if P matches
1848    "^ *(GMT|[+-][0-9]|$)", 0 otherwise.  P being NULL (a valid result of
1849    strptime()) is considered a failure and 0 is returned.  */
1850 static int
1851 check_end (const char *p)
1852 {
1853   if (!p)
1854     return 0;
1855   while (ISSPACE (*p))
1856     ++p;
1857   if (!*p
1858       || (p[0] == 'G' && p[1] == 'M' && p[2] == 'T')
1859       || ((p[0] == '+' || p[0] == '-') && ISDIGIT (p[1])))
1860     return 1;
1861   else
1862     return 0;
1863 }
1864
1865 /* Convert TIME_STRING time to time_t.  TIME_STRING can be in any of
1866    the three formats RFC2068 allows the HTTP servers to emit --
1867    RFC1123-date, RFC850-date or asctime-date.  Timezones are ignored,
1868    and should be GMT.
1869
1870    We use strptime() to recognize various dates, which makes it a
1871    little bit slacker than the RFC1123/RFC850/asctime (e.g. it always
1872    allows shortened dates and months, one-digit days, etc.).  It also
1873    allows more than one space anywhere where the specs require one SP.
1874    The routine should probably be even more forgiving (as recommended
1875    by RFC2068), but I do not have the time to write one.
1876
1877    Return the computed time_t representation, or -1 if all the
1878    schemes fail.
1879
1880    Needless to say, what we *really* need here is something like
1881    Marcus Hennecke's atotm(), which is forgiving, fast, to-the-point,
1882    and does not use strptime().  atotm() is to be found in the sources
1883    of `phttpd', a little-known HTTP server written by Peter Erikson.  */
1884 time_t
1885 http_atotm (char *time_string)
1886 {
1887   struct tm t;
1888
1889   /* Roger Beeman says: "This function dynamically allocates struct tm
1890      t, but does no initialization.  The only field that actually
1891      needs initialization is tm_isdst, since the others will be set by
1892      strptime.  Since strptime does not set tm_isdst, it will return
1893      the data structure with whatever data was in tm_isdst to begin
1894      with.  For those of us in timezones where DST can occur, there
1895      can be a one hour shift depending on the previous contents of the
1896      data area where the data structure is allocated."  */
1897   t.tm_isdst = -1;
1898
1899   /* Note that under foreign locales Solaris strptime() fails to
1900      recognize English dates, which renders this function useless.  I
1901      assume that other non-GNU strptime's are plagued by the same
1902      disease.  We solve this by setting only LC_MESSAGES in
1903      i18n_initialize(), instead of LC_ALL.
1904
1905      Another solution could be to temporarily set locale to C, invoke
1906      strptime(), and restore it back.  This is slow and dirty,
1907      however, and locale support other than LC_MESSAGES can mess other
1908      things, so I rather chose to stick with just setting LC_MESSAGES.
1909
1910      Also note that none of this is necessary under GNU strptime(),
1911      because it recognizes both international and local dates.  */
1912
1913   /* NOTE: We don't use `%n' for white space, as OSF's strptime uses
1914      it to eat all white space up to (and including) a newline, and
1915      the function fails if there is no newline (!).
1916
1917      Let's hope all strptime() implementations use ` ' to skip *all*
1918      whitespace instead of just one (it works that way on all the
1919      systems I've tested it on).  */
1920
1921   /* RFC1123: Thu, 29 Jan 1998 22:12:57 */
1922   if (check_end (strptime (time_string, "%a, %d %b %Y %T", &t)))
1923     return mktime_from_utc (&t);
1924   /* RFC850:  Thursday, 29-Jan-98 22:12:57 */
1925   if (check_end (strptime (time_string, "%A, %d-%b-%y %T", &t)))
1926     return mktime_from_utc (&t);
1927   /* pseudo-RFC850:  Thu, 29-Jan-1998 22:12:57
1928      (google.com uses this for their cookies.)*/
1929   if (check_end (strptime (time_string, "%a, %d-%b-%Y %T", &t)))
1930     return mktime_from_utc (&t);
1931   /* asctime: Thu Jan 29 22:12:57 1998 */
1932   if (check_end (strptime (time_string, "%a %b %d %T %Y", &t)))
1933     return mktime_from_utc (&t);
1934   /* Failure.  */
1935   return -1;
1936 }
1937 \f
1938 /* Authorization support: We support two authorization schemes:
1939
1940    * `Basic' scheme, consisting of base64-ing USER:PASSWORD string;
1941
1942    * `Digest' scheme, added by Junio Hamano <junio@twinsun.com>,
1943    consisting of answering to the server's challenge with the proper
1944    MD5 digests.  */
1945
1946 /* How many bytes it will take to store LEN bytes in base64.  */
1947 #define BASE64_LENGTH(len) (4 * (((len) + 2) / 3))
1948
1949 /* Encode the string S of length LENGTH to base64 format and place it
1950    to STORE.  STORE will be 0-terminated, and must point to a writable
1951    buffer of at least 1+BASE64_LENGTH(length) bytes.  */
1952 static void
1953 base64_encode (const char *s, char *store, int length)
1954 {
1955   /* Conversion table.  */
1956   static char tbl[64] = {
1957     'A','B','C','D','E','F','G','H',
1958     'I','J','K','L','M','N','O','P',
1959     'Q','R','S','T','U','V','W','X',
1960     'Y','Z','a','b','c','d','e','f',
1961     'g','h','i','j','k','l','m','n',
1962     'o','p','q','r','s','t','u','v',
1963     'w','x','y','z','0','1','2','3',
1964     '4','5','6','7','8','9','+','/'
1965   };
1966   int i;
1967   unsigned char *p = (unsigned char *)store;
1968
1969   /* Transform the 3x8 bits to 4x6 bits, as required by base64.  */
1970   for (i = 0; i < length; i += 3)
1971     {
1972       *p++ = tbl[s[0] >> 2];
1973       *p++ = tbl[((s[0] & 3) << 4) + (s[1] >> 4)];
1974       *p++ = tbl[((s[1] & 0xf) << 2) + (s[2] >> 6)];
1975       *p++ = tbl[s[2] & 0x3f];
1976       s += 3;
1977     }
1978   /* Pad the result if necessary...  */
1979   if (i == length + 1)
1980     *(p - 1) = '=';
1981   else if (i == length + 2)
1982     *(p - 1) = *(p - 2) = '=';
1983   /* ...and zero-terminate it.  */
1984   *p = '\0';
1985 }
1986
1987 /* Create the authentication header contents for the `Basic' scheme.
1988    This is done by encoding the string `USER:PASS' in base64 and
1989    prepending `HEADER: Basic ' to it.  */
1990 static char *
1991 basic_authentication_encode (const char *user, const char *passwd,
1992                              const char *header)
1993 {
1994   char *t1, *t2, *res;
1995   int len1 = strlen (user) + 1 + strlen (passwd);
1996   int len2 = BASE64_LENGTH (len1);
1997
1998   t1 = (char *)alloca (len1 + 1);
1999   sprintf (t1, "%s:%s", user, passwd);
2000   t2 = (char *)alloca (1 + len2);
2001   base64_encode (t1, t2, len1);
2002   res = (char *)xmalloc (len2 + 11 + strlen (header));
2003   sprintf (res, "%s: Basic %s\r\n", header, t2);
2004
2005   return res;
2006 }
2007
2008 #ifdef USE_DIGEST
2009 /* Parse HTTP `WWW-Authenticate:' header.  AU points to the beginning
2010    of a field in such a header.  If the field is the one specified by
2011    ATTR_NAME ("realm", "opaque", and "nonce" are used by the current
2012    digest authorization code), extract its value in the (char*)
2013    variable pointed by RET.  Returns negative on a malformed header,
2014    or number of bytes that have been parsed by this call.  */
2015 static int
2016 extract_header_attr (const char *au, const char *attr_name, char **ret)
2017 {
2018   const char *cp, *ep;
2019
2020   ep = cp = au;
2021
2022   if (strncmp (cp, attr_name, strlen (attr_name)) == 0)
2023     {
2024       cp += strlen (attr_name);
2025       if (!*cp)
2026         return -1;
2027       cp += skip_lws (cp);
2028       if (*cp != '=')
2029         return -1;
2030       if (!*++cp)
2031         return -1;
2032       cp += skip_lws (cp);
2033       if (*cp != '\"')
2034         return -1;
2035       if (!*++cp)
2036         return -1;
2037       for (ep = cp; *ep && *ep != '\"'; ep++)
2038         ;
2039       if (!*ep)
2040         return -1;
2041       FREE_MAYBE (*ret);
2042       *ret = strdupdelim (cp, ep);
2043       return ep - au + 1;
2044     }
2045   else
2046     return 0;
2047 }
2048
2049 /* Dump the hexadecimal representation of HASH to BUF.  HASH should be
2050    an array of 16 bytes containing the hash keys, and BUF should be a
2051    buffer of 33 writable characters (32 for hex digits plus one for
2052    zero termination).  */
2053 static void
2054 dump_hash (unsigned char *buf, const unsigned char *hash)
2055 {
2056   int i;
2057
2058   for (i = 0; i < MD5_HASHLEN; i++, hash++)
2059     {
2060       *buf++ = XDIGIT_TO_xchar (*hash >> 4);
2061       *buf++ = XDIGIT_TO_xchar (*hash & 0xf);
2062     }
2063   *buf = '\0';
2064 }
2065
2066 /* Take the line apart to find the challenge, and compose a digest
2067    authorization header.  See RFC2069 section 2.1.2.  */
2068 char *
2069 digest_authentication_encode (const char *au, const char *user,
2070                               const char *passwd, const char *method,
2071                               const char *path)
2072 {
2073   static char *realm, *opaque, *nonce;
2074   static struct {
2075     const char *name;
2076     char **variable;
2077   } options[] = {
2078     { "realm", &realm },
2079     { "opaque", &opaque },
2080     { "nonce", &nonce }
2081   };
2082   char *res;
2083
2084   realm = opaque = nonce = NULL;
2085
2086   au += 6;                      /* skip over `Digest' */
2087   while (*au)
2088     {
2089       int i;
2090
2091       au += skip_lws (au);
2092       for (i = 0; i < ARRAY_SIZE (options); i++)
2093         {
2094           int skip = extract_header_attr (au, options[i].name,
2095                                           options[i].variable);
2096           if (skip < 0)
2097             {
2098               FREE_MAYBE (realm);
2099               FREE_MAYBE (opaque);
2100               FREE_MAYBE (nonce);
2101               return NULL;
2102             }
2103           else if (skip)
2104             {
2105               au += skip;
2106               break;
2107             }
2108         }
2109       if (i == ARRAY_SIZE (options))
2110         {
2111           while (*au && *au != '=')
2112             au++;
2113           if (*au && *++au)
2114             {
2115               au += skip_lws (au);
2116               if (*au == '\"')
2117                 {
2118                   au++;
2119                   while (*au && *au != '\"')
2120                     au++;
2121                   if (*au)
2122                     au++;
2123                 }
2124             }
2125         }
2126       while (*au && *au != ',')
2127         au++;
2128       if (*au)
2129         au++;
2130     }
2131   if (!realm || !nonce || !user || !passwd || !path || !method)
2132     {
2133       FREE_MAYBE (realm);
2134       FREE_MAYBE (opaque);
2135       FREE_MAYBE (nonce);
2136       return NULL;
2137     }
2138
2139   /* Calculate the digest value.  */
2140   {
2141     struct md5_ctx ctx;
2142     unsigned char hash[MD5_HASHLEN];
2143     unsigned char a1buf[MD5_HASHLEN * 2 + 1], a2buf[MD5_HASHLEN * 2 + 1];
2144     unsigned char response_digest[MD5_HASHLEN * 2 + 1];
2145
2146     /* A1BUF = H(user ":" realm ":" password) */
2147     md5_init_ctx (&ctx);
2148     md5_process_bytes (user, strlen (user), &ctx);
2149     md5_process_bytes (":", 1, &ctx);
2150     md5_process_bytes (realm, strlen (realm), &ctx);
2151     md5_process_bytes (":", 1, &ctx);
2152     md5_process_bytes (passwd, strlen (passwd), &ctx);
2153     md5_finish_ctx (&ctx, hash);
2154     dump_hash (a1buf, hash);
2155
2156     /* A2BUF = H(method ":" path) */
2157     md5_init_ctx (&ctx);
2158     md5_process_bytes (method, strlen (method), &ctx);
2159     md5_process_bytes (":", 1, &ctx);
2160     md5_process_bytes (path, strlen (path), &ctx);
2161     md5_finish_ctx (&ctx, hash);
2162     dump_hash (a2buf, hash);
2163
2164     /* RESPONSE_DIGEST = H(A1BUF ":" nonce ":" A2BUF) */
2165     md5_init_ctx (&ctx);
2166     md5_process_bytes (a1buf, MD5_HASHLEN * 2, &ctx);
2167     md5_process_bytes (":", 1, &ctx);
2168     md5_process_bytes (nonce, strlen (nonce), &ctx);
2169     md5_process_bytes (":", 1, &ctx);
2170     md5_process_bytes (a2buf, MD5_HASHLEN * 2, &ctx);
2171     md5_finish_ctx (&ctx, hash);
2172     dump_hash (response_digest, hash);
2173
2174     res = (char*) xmalloc (strlen (user)
2175                            + strlen (user)
2176                            + strlen (realm)
2177                            + strlen (nonce)
2178                            + strlen (path)
2179                            + 2 * MD5_HASHLEN /*strlen (response_digest)*/
2180                            + (opaque ? strlen (opaque) : 0)
2181                            + 128);
2182     sprintf (res, "Authorization: Digest \
2183 username=\"%s\", realm=\"%s\", nonce=\"%s\", uri=\"%s\", response=\"%s\"",
2184              user, realm, nonce, path, response_digest);
2185     if (opaque)
2186       {
2187         char *p = res + strlen (res);
2188         strcat (p, ", opaque=\"");
2189         strcat (p, opaque);
2190         strcat (p, "\"");
2191       }
2192     strcat (res, "\r\n");
2193   }
2194   return res;
2195 }
2196 #endif /* USE_DIGEST */
2197
2198
2199 #define BEGINS_WITH(line, string_constant)                              \
2200   (!strncasecmp (line, string_constant, sizeof (string_constant) - 1)   \
2201    && (ISSPACE (line[sizeof (string_constant) - 1])                     \
2202        || !line[sizeof (string_constant) - 1]))
2203
2204 static int
2205 known_authentication_scheme_p (const char *au)
2206 {
2207   return BEGINS_WITH (au, "Basic")
2208     || BEGINS_WITH (au, "Digest")
2209     || BEGINS_WITH (au, "NTLM");
2210 }
2211
2212 #undef BEGINS_WITH
2213
2214 /* Create the HTTP authorization request header.  When the
2215    `WWW-Authenticate' response header is seen, according to the
2216    authorization scheme specified in that header (`Basic' and `Digest'
2217    are supported by the current implementation), produce an
2218    appropriate HTTP authorization request header.  */
2219 static char *
2220 create_authorization_line (const char *au, const char *user,
2221                            const char *passwd, const char *method,
2222                            const char *path)
2223 {
2224   char *wwwauth = NULL;
2225
2226   if (!strncasecmp (au, "Basic", 5))
2227     wwwauth = basic_authentication_encode (user, passwd, "Authorization");
2228   if (!strncasecmp (au, "NTLM", 4))
2229     wwwauth = basic_authentication_encode (user, passwd, "Authorization");
2230 #ifdef USE_DIGEST
2231   else if (!strncasecmp (au, "Digest", 6))
2232     wwwauth = digest_authentication_encode (au, user, passwd, method, path);
2233 #endif /* USE_DIGEST */
2234   return wwwauth;
2235 }