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   struct wget_timer *timer;
 530   char *cookies = NULL;
 531
 532   /* Whether this connection will be kept alive after the HTTP request
 533      is done. */
 534   int keep_alive;
 535
 536   /* Flags that detect the two ways of specifying HTTP keep-alive
 537      response.  */
 538   int http_keep_alive_1, http_keep_alive_2;
 539
 540   /* Whether keep-alive should be inhibited. */
 541   int inhibit_keep_alive;
 542
 543 #ifdef HAVE_SSL
 544   /* initialize ssl_ctx on first run */
 545   if (!ssl_ctx)
 546     {
 547       err=init_ssl (&ssl_ctx);
 548       if (err != 0)
 549         {
 550           switch (err)
 551             {
 552             case SSLERRCTXCREATE:
 553               /* this is fatal */
 554               logprintf (LOG_NOTQUIET, _("Failed to set up an SSL context\n"));
 555               ssl_printerrors ();
 556               return err;
 557             case SSLERRCERTFILE:
 558               /* try without certfile */
 559               logprintf (LOG_NOTQUIET,
 560                          _("Failed to load certificates from %s\n"),
 561                          opt.sslcertfile);
 562               ssl_printerrors ();
 563               logprintf (LOG_NOTQUIET,
 564                          _("Trying without the specified certificate\n"));
 565               break;
 566             case SSLERRCERTKEY:
 567               logprintf (LOG_NOTQUIET,
 568                          _("Failed to get certificate key from %s\n"),
 569                          opt.sslcertkey);
 570               ssl_printerrors ();
 571               logprintf (LOG_NOTQUIET,
 572                          _("Trying without the specified certificate\n"));
 573               break;
 574             default:
 575               break;
 576             }
 577         }
 578     }
 579 #endif /* HAVE_SSL */
 580
 581   if (!(*dt & HEAD_ONLY))
 582     /* If we're doing a GET on the URL, as opposed to just a HEAD, we need to
 583        know the local filename so we can save to it. */
 584     assert (u->local != NULL);
 585
 586   authenticate_h = 0;
 587   auth_tried_already = 0;
 588
 589   inhibit_keep_alive = (!opt.http_keep_alive || u->proxy != NULL);
 590
 591  again:
 592   /* We need to come back here when the initial attempt to retrieve
 593      without authorization header fails.  (Expected to happen at least
 594      for the Digest authorization scheme.)  */
 595
 596   keep_alive = 0;
 597   http_keep_alive_1 = http_keep_alive_2 = 0;
 598
 599   if (opt.cookies)
 600     cookies = build_cookies_request (u->host, u->port, u->path,
 601                                      u->proto == URLHTTPS);
 602
 603   /* Initialize certain elements of struct http_stat.  */
 604   hs->len = 0L;
 605   hs->contlen = -1;
 606   hs->res = -1;
 607   hs->newloc = NULL;
 608   hs->remote_time = NULL;
 609   hs->error = NULL;
 610
 611   /* Which structure to use to retrieve the original URL data.  */
 612   if (u->proxy)
 613     ou = u->proxy;
 614   else
 615     ou = u;
 616
 617   /* First: establish the connection.  */
 618   if (inhibit_keep_alive
 619       ||
 620 #ifndef HAVE_SSL
 621       !persistent_available_p (u->host, u->port)
 622 #else
 623       !persistent_available_p (u->host, u->port, (u->proto==URLHTTPS ? 1 : 0))
 624 #endif /* HAVE_SSL */
 625       )
 626     {
 627       logprintf (LOG_VERBOSE, _("Connecting to %s:%hu... "), u->host, u->port);
 628       err = make_connection (&sock, u->host, u->port);
 629       switch (err)
 630         {
 631         case HOSTERR:
 632           logputs (LOG_VERBOSE, "\n");
 633           logprintf (LOG_NOTQUIET, "%s: %s.\n", u->host, herrmsg (h_errno));
 634           return HOSTERR;
 635           break;
 636         case CONSOCKERR:
 637           logputs (LOG_VERBOSE, "\n");
 638           logprintf (LOG_NOTQUIET, "socket: %s\n", strerror (errno));
 639           return CONSOCKERR;
 640           break;
 641         case CONREFUSED:
 642           logputs (LOG_VERBOSE, "\n");
 643           logprintf (LOG_NOTQUIET,
 644                      _("Connection to %s:%hu refused.\n"), u->host, u->port);
 645           CLOSE (sock);
 646           return CONREFUSED;
 647         case CONERROR:
 648           logputs (LOG_VERBOSE, "\n");
 649           logprintf (LOG_NOTQUIET, "connect: %s\n", strerror (errno));
 650           CLOSE (sock);
 651           return CONERROR;
 652           break;
 653         case NOCONERROR:
 654           /* Everything is fine!  */
 655           logputs (LOG_VERBOSE, _("connected!\n"));
 656           break;
 657         default:
 658           abort ();
 659           break;
 660         }
 661 #ifdef HAVE_SSL
 662      if (u->proto == URLHTTPS)
 663        if (connect_ssl (&ssl, ssl_ctx,sock) != 0)
 664          {
 665            logputs (LOG_VERBOSE, "\n");
 666            logprintf (LOG_NOTQUIET, _("Unable to establish SSL connection.\n"));
 667            CLOSE (sock);
 668            return CONSSLERR;
 669          }
 670 #endif /* HAVE_SSL */
 671     }
 672   else
 673     {
 674       logprintf (LOG_VERBOSE, _("Reusing connection to %s:%hu.\n"), u->host, u->port);
 675       /* #### pc_last_fd should be accessed through an accessor
 676          function.  */
 677       sock = pc_last_fd;
 678 #ifdef HAVE_SSL
 679       ssl = pc_last_ssl;
 680 #endif /* HAVE_SSL */
 681       DEBUGP (("Reusing fd %d.\n", sock));
 682     }
 683
 684   if (u->proxy)
 685     path = u->proxy->url;
 686   else
 687     path = u->path;
 688
 689   command = (*dt & HEAD_ONLY) ? "HEAD" : "GET";
 690   referer = NULL;
 691   if (ou->referer)
 692     {
 693       referer = (char *)alloca (9 + strlen (ou->referer) + 3);
 694       sprintf (referer, "Referer: %s\r\n", ou->referer);
 695     }
 696   if (*dt & SEND_NOCACHE)
 697     pragma_h = "Pragma: no-cache\r\n";
 698   else
 699     pragma_h = "";
 700   if (hs->restval)
 701     {
 702       range = (char *)alloca (13 + numdigit (hs->restval) + 4);
 703       /* Gag me!  Some servers (e.g. WebSitePro) have been known to
 704          respond to the following `Range' format by generating a
 705          multipart/x-byte-ranges MIME document!  This MIME type was
 706          present in an old draft of the byteranges specification.
 707          HTTP/1.1 specifies a multipart/byte-ranges MIME type, but
 708          only if multiple non-overlapping ranges are requested --
 709          which Wget never does.  */
 710       sprintf (range, "Range: bytes=%ld-\r\n", hs->restval);
 711     }
 712   else
 713     range = NULL;
 714   if (opt.useragent)
 715     STRDUP_ALLOCA (useragent, opt.useragent);
 716   else
 717     {
 718       useragent = (char *)alloca (10 + strlen (version_string));
 719       sprintf (useragent, "Wget/%s", version_string);
 720     }
 721   /* Construct the authentication, if userid is present.  */
 722   user = ou->user;
 723   passwd = ou->passwd;
 724   search_netrc (u->host, (const char **)&user, (const char **)&passwd, 0);
 725   user = user ? user : opt.http_user;
 726   passwd = passwd ? passwd : opt.http_passwd;
 727
 728   wwwauth = NULL;
 729   if (user && passwd)
 730     {
 731       if (!authenticate_h)
 732         {
 733           /* We have the username and the password, but haven't tried
 734              any authorization yet.  Let's see if the "Basic" method
 735              works.  If not, we'll come back here and construct a
 736              proper authorization method with the right challenges.
 737
 738              If we didn't employ this kind of logic, every URL that
 739              requires authorization would have to be processed twice,
 740              which is very suboptimal and generates a bunch of false
 741              "unauthorized" errors in the server log.
 742
 743              #### But this logic also has a serious problem when used
 744              with stronger authentications: we *first* transmit the
 745              username and the password in clear text, and *then*
 746              attempt a stronger authentication scheme.  That cannot be
 747              right!  We are only fortunate that almost everyone still
 748              uses the `Basic' scheme anyway.
 749
 750              There should be an option to prevent this from happening,
 751              for those who use strong authentication schemes and value
 752              their passwords.  */
 753           wwwauth = basic_authentication_encode (user, passwd, "Authorization");
 754         }
 755       else
 756         {
 757           wwwauth = create_authorization_line (authenticate_h, user, passwd,
 758                                                command, ou->path);
 759         }
 760     }
 761
 762   proxyauth = NULL;
 763   if (u->proxy)
 764     {
 765       char *proxy_user, *proxy_passwd;
 766       /* For normal username and password, URL components override
 767          command-line/wgetrc parameters.  With proxy authentication,
 768          it's the reverse, because proxy URLs are normally the
 769          "permanent" ones, so command-line args should take
 770          precedence.  */
 771       if (opt.proxy_user && opt.proxy_passwd)
 772         {
 773           proxy_user = opt.proxy_user;
 774           proxy_passwd = opt.proxy_passwd;
 775         }
 776       else
 777         {
 778           proxy_user = u->user;
 779           proxy_passwd = u->passwd;
 780         }
 781       /* #### This is junky.  Can't the proxy request, say, `Digest'
 782          authentication?  */
 783       if (proxy_user && proxy_passwd)
 784         proxyauth = basic_authentication_encode (proxy_user, proxy_passwd,
 785                                                  "Proxy-Authorization");
 786     }
 787   remhost = ou->host;
 788   remport = ou->port;
 789
 790   /* String of the form :PORT.  Used only for non-standard ports. */
 791   port_maybe = NULL;
 792   if (1
 793 #ifdef HAVE_SSL
 794       && remport != (u->proto == URLHTTPS
 795                      ? DEFAULT_HTTPS_PORT : DEFAULT_HTTP_PORT)
 796 #else
 797       && remport != DEFAULT_HTTP_PORT
 798 #endif
 799       )
 800     {
 801       port_maybe = (char *)alloca (numdigit (remport) + 2);
 802       sprintf (port_maybe, ":%d", remport);
 803     }
 804
 805   if (!inhibit_keep_alive)
 806     request_keep_alive = "Connection: Keep-Alive\r\n";
 807   else
 808     request_keep_alive = NULL;
 809
 810   /* Allocate the memory for the request.  */
 811   request = (char *)alloca (strlen (command) + strlen (path)
 812                             + strlen (useragent)
 813                             + strlen (remhost)
 814                             + (port_maybe ? strlen (port_maybe) : 0)
 815                             + strlen (HTTP_ACCEPT)
 816                             + (request_keep_alive
 817                                ? strlen (request_keep_alive) : 0)
 818                             + (referer ? strlen (referer) : 0)
 819                             + (cookies ? strlen (cookies) : 0)
 820                             + (wwwauth ? strlen (wwwauth) : 0)
 821                             + (proxyauth ? strlen (proxyauth) : 0)
 822                             + (range ? strlen (range) : 0)
 823                             + strlen (pragma_h)
 824                             + (opt.user_header ? strlen (opt.user_header) : 0)
 825                             + 64);
 826   /* Construct the request.  */
 827   sprintf (request, "\
 828 %s %s HTTP/1.0\r\n\
 829 User-Agent: %s\r\n\
 830 Host: %s%s\r\n\
 831 Accept: %s\r\n\
 832 %s%s%s%s%s%s%s%s\r\n",
 833            command, path, useragent, remhost,
 834            port_maybe ? port_maybe : "",
 835            HTTP_ACCEPT,
 836            request_keep_alive ? request_keep_alive : "",
 837            referer ? referer : "",
 838            cookies ? cookies : "",
 839            wwwauth ? wwwauth : "",
 840            proxyauth ? proxyauth : "",
 841            range ? range : "",
 842            pragma_h,
 843            opt.user_header ? opt.user_header : "");
 844   DEBUGP (("---request begin---\n%s---request end---\n", request));
 845    /* Free the temporary memory.  */
 846   FREE_MAYBE (wwwauth);
 847   FREE_MAYBE (proxyauth);
 848   FREE_MAYBE (cookies);
 849
 850   /* Send the request to server.  */
 851 #ifdef HAVE_SSL
 852   if (u->proto == URLHTTPS)
 853     num_written = ssl_iwrite (ssl, request, strlen (request));
 854   else
 855 #endif /* HAVE_SSL */
 856     num_written = iwrite (sock, request, strlen (request));
 857
 858   if (num_written < 0)
 859     {
 860       logprintf (LOG_VERBOSE, _("Failed writing HTTP request: %s.\n"),
 861                  strerror (errno));
 862       CLOSE_INVALIDATE (sock);
 863       return WRITEFAILED;
 864     }
 865   logprintf (LOG_VERBOSE, _("%s request sent, awaiting response... "),
 866              u->proxy ? "Proxy" : "HTTP");
 867   contlen = contrange = -1;
 868   type = NULL;
 869   statcode = -1;
 870   *dt &= ~RETROKF;
 871
 872   /* Before reading anything, initialize the rbuf.  */
 873   rbuf_initialize (&rbuf, sock);
 874 #ifdef HAVE_SSL
 875   if (u->proto == URLHTTPS)
 876     rbuf.ssl = ssl;
 877   else
 878     rbuf.ssl = NULL;
 879 #endif /* HAVE_SSL */
 880   all_headers = NULL;
 881   all_length = 0;
 882   /* Header-fetching loop.  */
 883   hcount = 0;
 884   while (1)
 885     {
 886       char *hdr;
 887       int status;
 888
 889       ++hcount;
 890       /* Get the header.  */
 891       status = header_get (&rbuf, &hdr,
 892                            /* Disallow continuations for status line.  */
 893                            (hcount == 1 ? HG_NO_CONTINUATIONS : HG_NONE));
 894
 895       /* Check for errors.  */
 896       if (status == HG_EOF && *hdr)
 897         {
 898           /* This used to be an unconditional error, but that was
 899              somewhat controversial, because of a large number of
 900              broken CGI's that happily "forget" to send the second EOL
 901              before closing the connection of a HEAD request.
 902
 903              So, the deal is to check whether the header is empty
 904              (*hdr is zero if it is); if yes, it means that the
 905              previous header was fully retrieved, and that -- most
 906              probably -- the request is complete.  "...be liberal in
 907              what you accept."  Oh boy.  */
 908           logputs (LOG_VERBOSE, "\n");
 909           logputs (LOG_NOTQUIET, _("End of file while parsing headers.\n"));
 910           xfree (hdr);
 911           FREE_MAYBE (type);
 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 (all_headers);
 924           CLOSE_INVALIDATE (sock);
 925           return HERR;
 926         }
 927
 928       /* If the headers are to be saved to a file later, save them to
 929          memory now.  */
 930       if (opt.save_headers)
 931         {
 932           int lh = strlen (hdr);
 933           all_headers = (char *)xrealloc (all_headers, all_length + lh + 2);
 934           memcpy (all_headers + all_length, hdr, lh);
 935           all_length += lh;
 936           all_headers[all_length++] = '\n';
 937           all_headers[all_length] = '\0';
 938         }
 939
 940       /* Print the header if requested.  */
 941       if (opt.server_response && hcount != 1)
 942         logprintf (LOG_VERBOSE, "\n%d %s", hcount, hdr);
 943
 944       /* Check for status line.  */
 945       if (hcount == 1)
 946         {
 947           const char *error;
 948           /* Parse the first line of server response.  */
 949           statcode = parse_http_status_line (hdr, &error);
 950           hs->statcode = statcode;
 951           /* Store the descriptive response.  */
 952           if (statcode == -1) /* malformed response */
 953             {
 954               /* A common reason for "malformed response" error is the
 955                  case when no data was actually received.  Handle this
 956                  special case.  */
 957               if (!*hdr)
 958                 hs->error = xstrdup (_("No data received"));
 959               else
 960                 hs->error = xstrdup (_("Malformed status line"));
 961               xfree (hdr);
 962               break;
 963             }
 964           else if (!*error)
 965             hs->error = xstrdup (_("(no description)"));
 966           else
 967             hs->error = xstrdup (error);
 968
 969           if ((statcode != -1)
 970 #ifdef DEBUG
 971               && !opt.debug
 972 #endif
 973               )
 974             logprintf (LOG_VERBOSE, "%d %s", statcode, error);
 975
 976           goto done_header;
 977         }
 978
 979       /* Exit on empty header.  */
 980       if (!*hdr)
 981         {
 982           xfree (hdr);
 983           break;
 984         }
 985
 986       /* Try getting content-length.  */
 987       if (contlen == -1 && !opt.ignore_length)
 988         if (header_process (hdr, "Content-Length", header_extract_number,
 989                             &contlen))
 990           goto done_header;
 991       /* Try getting content-type.  */
 992       if (!type)
 993         if (header_process (hdr, "Content-Type", http_process_type, &type))
 994           goto done_header;
 995       /* Try getting location.  */
 996       if (!hs->newloc)
 997         if (header_process (hdr, "Location", header_strdup, &hs->newloc))
 998           goto done_header;
 999       /* Try getting last-modified.  */
1000       if (!hs->remote_time)
1001         if (header_process (hdr, "Last-Modified", header_strdup,
1002                             &hs->remote_time))
1003           goto done_header;
1004       /* Try getting cookies. */
1005       if (opt.cookies)
1006         if (header_process (hdr, "Set-Cookie", set_cookie_header_cb, u))
1007           goto done_header;
1008       /* Try getting www-authentication.  */
1009       if (!authenticate_h)
1010         if (header_process (hdr, "WWW-Authenticate", header_strdup,
1011                             &authenticate_h))
1012           goto done_header;
1013       /* Check for accept-ranges header.  If it contains the word
1014          `none', disable the ranges.  */
1015       if (*dt & ACCEPTRANGES)
1016         {
1017           int nonep;
1018           if (header_process (hdr, "Accept-Ranges", http_process_none, &nonep))
1019             {
1020               if (nonep)
1021                 *dt &= ~ACCEPTRANGES;
1022               goto done_header;
1023             }
1024         }
1025       /* Try getting content-range.  */
1026       if (contrange == -1)
1027         {
1028           struct http_process_range_closure closure;
1029           if (header_process (hdr, "Content-Range", http_process_range, &closure))
1030             {
1031               contrange = closure.first_byte_pos;
1032               goto done_header;
1033             }
1034         }
1035       /* Check for keep-alive related responses. */
1036       if (!inhibit_keep_alive)
1037         {
1038           /* Check for the `Keep-Alive' header. */
1039           if (!http_keep_alive_1)
1040             {
1041               if (header_process (hdr, "Keep-Alive", header_exists,
1042                                   &http_keep_alive_1))
1043                 goto done_header;
1044             }
1045           /* Check for `Connection: Keep-Alive'. */
1046           if (!http_keep_alive_2)
1047             {
1048               if (header_process (hdr, "Connection", http_process_connection,
1049                                   &http_keep_alive_2))
1050                 goto done_header;
1051             }
1052         }
1053     done_header:
1054       xfree (hdr);
1055     }
1056
1057   logputs (LOG_VERBOSE, "\n");
1058
1059   if (contlen != -1
1060       && (http_keep_alive_1 || http_keep_alive_2))
1061     {
1062       assert (inhibit_keep_alive == 0);
1063       keep_alive = 1;
1064     }
1065   if (keep_alive)
1066     /* The server has promised that it will not close the connection
1067        when we're done.  This means that we can register it.  */
1068 #ifndef HAVE_SSL
1069     register_persistent (u->host, u->port, sock);
1070 #else
1071     register_persistent (u->host, u->port, sock, ssl);
1072 #endif /* HAVE_SSL */
1073
1074   if ((statcode == HTTP_STATUS_UNAUTHORIZED)
1075       && authenticate_h)
1076     {
1077       /* Authorization is required.  */
1078       FREE_MAYBE (type);
1079       type = NULL;
1080       FREEHSTAT (*hs);
1081       CLOSE_INVALIDATE (sock);  /* would be CLOSE_FINISH, but there
1082                                    might be more bytes in the body. */
1083       if (auth_tried_already)
1084         {
1085           /* If we have tried it already, then there is not point
1086              retrying it.  */
1087         failed:
1088           logputs (LOG_NOTQUIET, _("Authorization failed.\n"));
1089           xfree (authenticate_h);
1090           return AUTHFAILED;
1091         }
1092       else if (!known_authentication_scheme_p (authenticate_h))
1093         {
1094           xfree (authenticate_h);
1095           logputs (LOG_NOTQUIET, _("Unknown authentication scheme.\n"));
1096           return AUTHFAILED;
1097         }
1098       else if (BEGINS_WITH (authenticate_h, "Basic"))
1099         {
1100           /* The authentication scheme is basic, the one we try by
1101              default, and it failed.  There's no sense in trying
1102              again.  */
1103           goto failed;
1104         }
1105       else
1106         {
1107           auth_tried_already = 1;
1108           goto again;
1109         }
1110     }
1111   /* We do not need this anymore.  */
1112   if (authenticate_h)
1113     {
1114       xfree (authenticate_h);
1115       authenticate_h = NULL;
1116     }
1117
1118   /* 20x responses are counted among successful by default.  */
1119   if (H_20X (statcode))
1120     *dt |= RETROKF;
1121
1122   /* Return if redirected.  */
1123   if (H_REDIRECTED (statcode) || statcode == HTTP_STATUS_MULTIPLE_CHOICES)
1124     {
1125       /* RFC2068 says that in case of the 300 (multiple choices)
1126          response, the server can output a preferred URL through
1127          `Location' header; otherwise, the request should be treated
1128          like GET.  So, if the location is set, it will be a
1129          redirection; otherwise, just proceed normally.  */
1130       if (statcode == HTTP_STATUS_MULTIPLE_CHOICES && !hs->newloc)
1131         *dt |= RETROKF;
1132       else
1133         {
1134           logprintf (LOG_VERBOSE,
1135                      _("Location: %s%s\n"),
1136                      hs->newloc ? hs->newloc : _("unspecified"),
1137                      hs->newloc ? _(" [following]") : "");
1138           CLOSE_INVALIDATE (sock);      /* would be CLOSE_FINISH, but there
1139                                            might be more bytes in the body. */
1140           FREE_MAYBE (type);
1141           FREE_MAYBE (all_headers);
1142           return NEWLOCATION;
1143         }
1144     }
1145
1146   if (type && !strncasecmp (type, TEXTHTML_S, strlen (TEXTHTML_S)))
1147     *dt |= TEXTHTML;
1148   else
1149     /* We don't assume text/html by default.  */
1150     *dt &= ~TEXTHTML;
1151
1152   if (opt.html_extension && (*dt & TEXTHTML))
1153     /* -E / --html-extension / html_extension = on was specified, and this is a
1154        text/html file.  If some case-insensitive variation on ".htm[l]" isn't
1155        already the file's suffix, tack on ".html". */
1156     {
1157       char*  last_period_in_local_filename = strrchr(u->local, '.');
1158
1159       if (last_period_in_local_filename == NULL ||
1160           !(strcasecmp(last_period_in_local_filename, ".htm") == EQ ||
1161             strcasecmp(last_period_in_local_filename, ".html") == EQ))
1162         {
1163           size_t  local_filename_len = strlen(u->local);
1164
1165           u->local = xrealloc(u->local, local_filename_len + sizeof(".html"));
1166           strcpy(u->local + local_filename_len, ".html");
1167
1168           *dt |= ADDED_HTML_EXTENSION;
1169         }
1170     }
1171
1172   if (contrange == -1)
1173     {
1174       /* We did not get a content-range header.  This means that the
1175          server did not honor our `Range' request.  Normally, this
1176          means we should reset hs->restval and continue normally.  */
1177
1178       /* However, if `-c' is used, we need to be a bit more careful:
1179
1180          1. If `-c' is specified and the file already existed when
1181          Wget was started, it would be a bad idea for us to start
1182          downloading it from scratch, effectively truncating it.  I
1183          believe this cannot happen unless `-c' was specified.
1184
1185          2. If `-c' is used on a file that is already fully
1186          downloaded, we're requesting bytes after the end of file,
1187          which can result in server not honoring `Range'.  If this is
1188          the case, `Content-Length' will be equal to the length of the
1189          file.  */
1190       if (opt.always_rest)
1191         {
1192           /* Check for condition #2. */
1193           if (hs->restval >= contlen)
1194             {
1195               logputs (LOG_VERBOSE, _("\
1196 \n    The file is already fully retrieved; nothing to do.\n\n"));
1197               /* In case the caller inspects. */
1198               hs->len = contlen;
1199               hs->res = 0;
1200               FREE_MAYBE (type);
1201               FREE_MAYBE (all_headers);
1202               CLOSE_INVALIDATE (sock);  /* would be CLOSE_FINISH, but there
1203                                            might be more bytes in the body. */
1204               return RETRUNNEEDED;
1205             }
1206
1207           /* Check for condition #1. */
1208           if (hs->no_truncate)
1209             {
1210               logprintf (LOG_NOTQUIET,
1211                          _("\
1212 \n\
1213 The server does not support continued downloads, which conflicts with `-c'.\n\
1214 Refusing to truncate `%s'.\n\n"), u->local);
1215               FREE_MAYBE (type);
1216               FREE_MAYBE (all_headers);
1217               CLOSE_INVALIDATE (sock);
1218               return CONTNOTSUPPORTED;
1219             }
1220
1221           /* Fallthrough */
1222         }
1223
1224       hs->restval = 0;
1225     }
1226   else if (contrange != hs->restval ||
1227            (H_PARTIAL (statcode) && contrange == -1))
1228     {
1229       /* This means the whole request was somehow misunderstood by the
1230          server.  Bail out.  */
1231       FREE_MAYBE (type);
1232       FREE_MAYBE (all_headers);
1233       CLOSE_INVALIDATE (sock);
1234       return RANGEERR;
1235     }
1236
1237   if (hs->restval)
1238     {
1239       if (contlen != -1)
1240         contlen += contrange;
1241       else
1242         contrange = -1;        /* If conent-length was not sent,
1243                                   content-range will be ignored.  */
1244     }
1245   hs->contlen = contlen;
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   timer = wtimer_new ();
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 = wtimer_elapsed (timer);
1342   wtimer_delete (timer);
1343   {
1344     /* Close or flush the file.  We have to be careful to check for
1345        error here.  Checking the result of fwrite() is not enough --
1346        errors could go unnoticed!  */
1347     int flush_res;
1348     if (!opt.dfp)
1349       flush_res = fclose (fp);
1350     else
1351       flush_res = fflush (fp);
1352     if (flush_res == EOF)
1353       hs->res = -2;
1354   }
1355   FREE_MAYBE (all_headers);
1356   CLOSE_FINISH (sock);
1357   if (hs->res == -2)
1358     return FWRITEERR;
1359   return RETRFINISHED;
1360 }
1361
1362 /* The genuine HTTP loop!  This is the part where the retrieval is
1363    retried, and retried, and retried, and...  */
1364 uerr_t
1365 http_loop (struct urlinfo *u, char **newloc, int *dt)
1366 {
1367   int count;
1368   int use_ts, got_head = 0;     /* time-stamping info */
1369   char *filename_plus_orig_suffix;
1370   char *local_filename = NULL;
1371   char *tms, *suf, *locf, *tmrate;
1372   uerr_t err;
1373   time_t tml = -1, tmr = -1;    /* local and remote time-stamps */
1374   long local_size = 0;          /* the size of the local file */
1375   size_t filename_len;
1376   struct http_stat hstat;       /* HTTP status */
1377   struct stat st;
1378
1379   /* This used to be done in main(), but it's a better idea to do it
1380      here so that we don't go through the hoops if we're just using
1381      FTP or whatever. */
1382   if (opt.cookies && opt.cookies_input && !cookies_loaded_p)
1383     {
1384       load_cookies (opt.cookies_input);
1385       cookies_loaded_p = 1;
1386     }
1387
1388   *newloc = NULL;
1389
1390   /* Warn on (likely bogus) wildcard usage in HTTP.  Don't use
1391      has_wildcards_p because it would also warn on `?', and we know that
1392      shows up in CGI paths a *lot*.  */
1393   if (strchr (u->url, '*'))
1394     logputs (LOG_VERBOSE, _("Warning: wildcards not supported in HTTP.\n"));
1395
1396   /* Determine the local filename.  */
1397   if (!u->local)
1398     u->local = url_filename (u->proxy ? u->proxy : u);
1399
1400   if (!opt.output_document)
1401     locf = u->local;
1402   else
1403     locf = opt.output_document;
1404
1405   /* Yuck.  Multiple returns suck.  We need to remember to free() the space we
1406      xmalloc() here before EACH return.  This is one reason it's better to set
1407      flags that influence flow control and then return once at the end. */
1408   filename_len = strlen(u->local);
1409   filename_plus_orig_suffix = xmalloc(filename_len + sizeof(".orig"));
1410
1411   if (opt.noclobber && file_exists_p (u->local))
1412     {
1413       /* If opt.noclobber is turned on and file already exists, do not
1414          retrieve the file */
1415       logprintf (LOG_VERBOSE, _("\
1416 File `%s' already there, will not retrieve.\n"), u->local);
1417       /* If the file is there, we suppose it's retrieved OK.  */
1418       *dt |= RETROKF;
1419
1420       /* #### Bogusness alert.  */
1421       /* If its suffix is "html" or (yuck!) "htm", we suppose it's
1422          text/html, a harmless lie.  */
1423       if (((suf = suffix (u->local)) != NULL)
1424           && (!strcmp (suf, "html") || !strcmp (suf, "htm")))
1425         *dt |= TEXTHTML;
1426       xfree (suf);
1427       xfree (filename_plus_orig_suffix); /* must precede every return! */
1428       /* Another harmless lie: */
1429       return RETROK;
1430     }
1431
1432   use_ts = 0;
1433   if (opt.timestamping)
1434     {
1435       boolean  local_dot_orig_file_exists = FALSE;
1436
1437       if (opt.backup_converted)
1438         /* If -K is specified, we'll act on the assumption that it was specified
1439            last time these files were downloaded as well, and instead of just
1440            comparing local file X against server file X, we'll compare local
1441            file X.orig (if extant, else X) against server file X.  If -K
1442            _wasn't_ specified last time, or the server contains files called
1443            *.orig, -N will be back to not operating correctly with -k. */
1444         {
1445           /* Would a single s[n]printf() call be faster?  --dan
1446
1447              Definitely not.  sprintf() is horribly slow.  It's a
1448              different question whether the difference between the two
1449              affects a program.  Usually I'd say "no", but at one
1450              point I profiled Wget, and found that a measurable and
1451              non-negligible amount of time was lost calling sprintf()
1452              in url.c.  Replacing sprintf with inline calls to
1453              strcpy() and long_to_string() made a difference.
1454              --hniksic */
1455           strcpy(filename_plus_orig_suffix, u->local);
1456           strcpy(filename_plus_orig_suffix + filename_len, ".orig");
1457
1458           /* Try to stat() the .orig file. */
1459           if (stat(filename_plus_orig_suffix, &st) == 0)
1460             {
1461               local_dot_orig_file_exists = TRUE;
1462               local_filename = filename_plus_orig_suffix;
1463             }
1464         }
1465
1466       if (!local_dot_orig_file_exists)
1467         /* Couldn't stat() <file>.orig, so try to stat() <file>. */
1468         if (stat (u->local, &st) == 0)
1469           local_filename = u->local;
1470
1471       if (local_filename != NULL)
1472         /* There was a local file, so we'll check later to see if the version
1473            the server has is the same version we already have, allowing us to
1474            skip a download. */
1475         {
1476           use_ts = 1;
1477           tml = st.st_mtime;
1478           local_size = st.st_size;
1479           got_head = 0;
1480         }
1481     }
1482   /* Reset the counter.  */
1483   count = 0;
1484   *dt = 0 | ACCEPTRANGES;
1485   /* THE loop */
1486   do
1487     {
1488       /* Increment the pass counter.  */
1489       ++count;
1490       sleep_between_retrievals (count);
1491       /* Get the current time string.  */
1492       tms = time_str (NULL);
1493       /* Print fetch message, if opt.verbose.  */
1494       if (opt.verbose)
1495         {
1496           char *hurl = str_url (u->proxy ? u->proxy : u, 1);
1497           char tmp[15];
1498           strcpy (tmp, "        ");
1499           if (count > 1)
1500             sprintf (tmp, _("(try:%2d)"), count);
1501           logprintf (LOG_VERBOSE, "--%s--  %s\n  %s => `%s'\n",
1502                      tms, hurl, tmp, locf);
1503 #ifdef WINDOWS
1504           ws_changetitle (hurl, 1);
1505 #endif
1506           xfree (hurl);
1507         }
1508
1509       /* Default document type is empty.  However, if spider mode is
1510          on or time-stamping is employed, HEAD_ONLY commands is
1511          encoded within *dt.  */
1512       if (opt.spider || (use_ts && !got_head))
1513         *dt |= HEAD_ONLY;
1514       else
1515         *dt &= ~HEAD_ONLY;
1516       /* Assume no restarting.  */
1517       hstat.restval = 0L;
1518       /* Decide whether or not to restart.  */
1519       if (((count > 1 && (*dt & ACCEPTRANGES)) || opt.always_rest)
1520           && file_exists_p (locf))
1521         if (stat (locf, &st) == 0 && S_ISREG (st.st_mode))
1522           hstat.restval = st.st_size;
1523
1524       /* In `-c' is used and the file is existing and non-empty,
1525          refuse to truncate it if the server doesn't support continued
1526          downloads.  */
1527       if (opt.always_rest && hstat.restval)
1528         hstat.no_truncate = file_exists_p (locf);
1529
1530       /* Decide whether to send the no-cache directive.  We send it in
1531          two cases:
1532            a) we're using a proxy, and we're past our first retrieval.
1533               Some proxies are notorious for caching incomplete data, so
1534               we require a fresh get.
1535            b) caching is explicitly inhibited. */
1536       if ((u->proxy && count > 1) /* a */
1537           || !opt.allow_cache     /* b */
1538           )
1539         *dt |= SEND_NOCACHE;
1540       else
1541         *dt &= ~SEND_NOCACHE;
1542
1543       /* Try fetching the document, or at least its head.  :-) */
1544       err = gethttp (u, &hstat, dt);
1545
1546       /* It's unfortunate that wget determines the local filename before finding
1547          out the Content-Type of the file.  Barring a major restructuring of the
1548          code, we need to re-set locf here, since gethttp() may have xrealloc()d
1549          u->local to tack on ".html". */
1550       if (!opt.output_document)
1551         locf = u->local;
1552       else
1553         locf = opt.output_document;
1554
1555       /* Time?  */
1556       tms = time_str (NULL);
1557       /* Get the new location (with or without the redirection).  */
1558       if (hstat.newloc)
1559         *newloc = xstrdup (hstat.newloc);
1560       switch (err)
1561         {
1562         case HERR: case HEOF: case CONSOCKERR: case CONCLOSED:
1563         case CONERROR: case READERR: case WRITEFAILED:
1564         case RANGEERR:
1565           /* Non-fatal errors continue executing the loop, which will
1566              bring them to "while" statement at the end, to judge
1567              whether the number of tries was exceeded.  */
1568           FREEHSTAT (hstat);
1569           printwhat (count, opt.ntry);
1570           continue;
1571           break;
1572         case HOSTERR: case CONREFUSED: case PROXERR: case AUTHFAILED:
1573         case SSLERRCTXCREATE: case CONTNOTSUPPORTED:
1574           /* Fatal errors just return from the function.  */
1575           FREEHSTAT (hstat);
1576           xfree (filename_plus_orig_suffix); /* must precede every return! */
1577           return err;
1578           break;
1579         case FWRITEERR: case FOPENERR:
1580           /* Another fatal error.  */
1581           logputs (LOG_VERBOSE, "\n");
1582           logprintf (LOG_NOTQUIET, _("Cannot write to `%s' (%s).\n"),
1583                      u->local, strerror (errno));
1584           FREEHSTAT (hstat);
1585           return err;
1586           break;
1587         case CONSSLERR:
1588           /* Another fatal error.  */
1589           logputs (LOG_VERBOSE, "\n");
1590           logprintf (LOG_NOTQUIET, _("Unable to establish SSL connection.\n"));
1591           FREEHSTAT (hstat);
1592           xfree (filename_plus_orig_suffix); /* must precede every return! */
1593           return err;
1594           break;
1595         case NEWLOCATION:
1596           /* Return the new location to the caller.  */
1597           if (!hstat.newloc)
1598             {
1599               logprintf (LOG_NOTQUIET,
1600                          _("ERROR: Redirection (%d) without location.\n"),
1601                          hstat.statcode);
1602               xfree (filename_plus_orig_suffix); /* must precede every return! */
1603               return WRONGCODE;
1604             }
1605           FREEHSTAT (hstat);
1606           xfree (filename_plus_orig_suffix); /* must precede every return! */
1607           return NEWLOCATION;
1608           break;
1609         case RETRUNNEEDED:
1610           /* The file was already fully retrieved. */
1611           FREEHSTAT (hstat);
1612           xfree (filename_plus_orig_suffix); /* must precede every return! */
1613           return RETROK;
1614           break;
1615         case RETRFINISHED:
1616           /* Deal with you later.  */
1617           break;
1618         default:
1619           /* All possibilities should have been exhausted.  */
1620           abort ();
1621         }
1622       if (!(*dt & RETROKF))
1623         {
1624           if (!opt.verbose)
1625             {
1626               /* #### Ugly ugly ugly! */
1627               char *hurl = str_url (u->proxy ? u->proxy : u, 1);
1628               logprintf (LOG_NONVERBOSE, "%s:\n", hurl);
1629               xfree (hurl);
1630             }
1631           logprintf (LOG_NOTQUIET, _("%s ERROR %d: %s.\n"),
1632                      tms, hstat.statcode, hstat.error);
1633           logputs (LOG_VERBOSE, "\n");
1634           FREEHSTAT (hstat);
1635           xfree (filename_plus_orig_suffix); /* must precede every return! */
1636           return WRONGCODE;
1637         }
1638
1639       /* Did we get the time-stamp?  */
1640       if (!got_head)
1641         {
1642           if (opt.timestamping && !hstat.remote_time)
1643             {
1644               logputs (LOG_NOTQUIET, _("\
1645 Last-modified header missing -- time-stamps turned off.\n"));
1646             }
1647           else if (hstat.remote_time)
1648             {
1649               /* Convert the date-string into struct tm.  */
1650               tmr = http_atotm (hstat.remote_time);
1651               if (tmr == (time_t) (-1))
1652                 logputs (LOG_VERBOSE, _("\
1653 Last-modified header invalid -- time-stamp ignored.\n"));
1654             }
1655         }
1656
1657       /* The time-stamping section.  */
1658       if (use_ts)
1659         {
1660           got_head = 1;
1661           *dt &= ~HEAD_ONLY;
1662           use_ts = 0;           /* no more time-stamping */
1663           count = 0;            /* the retrieve count for HEAD is
1664                                    reset */
1665           if (hstat.remote_time && tmr != (time_t) (-1))
1666             {
1667               /* Now time-stamping can be used validly.  Time-stamping
1668                  means that if the sizes of the local and remote file
1669                  match, and local file is newer than the remote file,
1670                  it will not be retrieved.  Otherwise, the normal
1671                  download procedure is resumed.  */
1672               if (tml >= tmr &&
1673                   (hstat.contlen == -1 || local_size == hstat.contlen))
1674                 {
1675                   logprintf (LOG_VERBOSE, _("\
1676 Server file no newer than local file `%s' -- not retrieving.\n\n"),
1677                              local_filename);
1678                   FREEHSTAT (hstat);
1679                   xfree (filename_plus_orig_suffix); /*must precede every return!*/
1680                   return RETROK;
1681                 }
1682               else if (tml >= tmr)
1683                 logprintf (LOG_VERBOSE, _("\
1684 The sizes do not match (local %ld) -- retrieving.\n"), local_size);
1685               else
1686                 logputs (LOG_VERBOSE,
1687                          _("Remote file is newer, retrieving.\n"));
1688             }
1689           FREEHSTAT (hstat);
1690           continue;
1691         }
1692       if ((tmr != (time_t) (-1))
1693           && !opt.spider
1694           && ((hstat.len == hstat.contlen) ||
1695               ((hstat.res == 0) &&
1696                ((hstat.contlen == -1) ||
1697                 (hstat.len >= hstat.contlen && !opt.kill_longer)))))
1698         {
1699           /* #### This code repeats in http.c and ftp.c.  Move it to a
1700              function!  */
1701           const char *fl = NULL;
1702           if (opt.output_document)
1703             {
1704               if (opt.od_known_regular)
1705                 fl = opt.output_document;
1706             }
1707           else
1708             fl = u->local;
1709           if (fl)
1710             touch (fl, tmr);
1711         }
1712       /* End of time-stamping section.  */
1713
1714       if (opt.spider)
1715         {
1716           logprintf (LOG_NOTQUIET, "%d %s\n\n", hstat.statcode, hstat.error);
1717           xfree (filename_plus_orig_suffix); /* must precede every return! */
1718           return RETROK;
1719         }
1720
1721       /* It is now safe to free the remainder of hstat, since the
1722          strings within it will no longer be used.  */
1723       FREEHSTAT (hstat);
1724
1725       tmrate = rate (hstat.len - hstat.restval, hstat.dltime, 0);
1726
1727       if (hstat.len == hstat.contlen)
1728         {
1729           if (*dt & RETROKF)
1730             {
1731               logprintf (LOG_VERBOSE,
1732                          _("%s (%s) - `%s' saved [%ld/%ld]\n\n"),
1733                          tms, tmrate, locf, hstat.len, hstat.contlen);
1734               logprintf (LOG_NONVERBOSE,
1735                          "%s URL:%s [%ld/%ld] -> \"%s\" [%d]\n",
1736                          tms, u->url, hstat.len, hstat.contlen, locf, count);
1737             }
1738           ++opt.numurls;
1739           downloaded_increase (hstat.len);
1740
1741           /* Remember that we downloaded the file for later ".orig" code. */
1742           if (*dt & ADDED_HTML_EXTENSION)
1743             downloaded_file(FILE_DOWNLOADED_AND_HTML_EXTENSION_ADDED, locf);
1744           else
1745             downloaded_file(FILE_DOWNLOADED_NORMALLY, locf);
1746
1747           xfree(filename_plus_orig_suffix); /* must precede every return! */
1748           return RETROK;
1749         }
1750       else if (hstat.res == 0) /* No read error */
1751         {
1752           if (hstat.contlen == -1)  /* We don't know how much we were supposed
1753                                        to get, so assume we succeeded. */
1754             {
1755               if (*dt & RETROKF)
1756                 {
1757                   logprintf (LOG_VERBOSE,
1758                              _("%s (%s) - `%s' saved [%ld]\n\n"),
1759                              tms, tmrate, locf, hstat.len);
1760                   logprintf (LOG_NONVERBOSE,
1761                              "%s URL:%s [%ld] -> \"%s\" [%d]\n",
1762                              tms, u->url, hstat.len, locf, count);
1763                 }
1764               ++opt.numurls;
1765               downloaded_increase (hstat.len);
1766
1767               /* Remember that we downloaded the file for later ".orig" code. */
1768               if (*dt & ADDED_HTML_EXTENSION)
1769                 downloaded_file(FILE_DOWNLOADED_AND_HTML_EXTENSION_ADDED, locf);
1770               else
1771                 downloaded_file(FILE_DOWNLOADED_NORMALLY, locf);
1772
1773               xfree (filename_plus_orig_suffix); /* must precede every return! */
1774               return RETROK;
1775             }
1776           else if (hstat.len < hstat.contlen) /* meaning we lost the
1777                                                  connection too soon */
1778             {
1779               logprintf (LOG_VERBOSE,
1780                          _("%s (%s) - Connection closed at byte %ld. "),
1781                          tms, tmrate, hstat.len);
1782               printwhat (count, opt.ntry);
1783               continue;
1784             }
1785           else if (!opt.kill_longer) /* meaning we got more than expected */
1786             {
1787               logprintf (LOG_VERBOSE,
1788                          _("%s (%s) - `%s' saved [%ld/%ld])\n\n"),
1789                          tms, tmrate, locf, hstat.len, hstat.contlen);
1790               logprintf (LOG_NONVERBOSE,
1791                          "%s URL:%s [%ld/%ld] -> \"%s\" [%d]\n",
1792                          tms, u->url, hstat.len, hstat.contlen, locf, count);
1793               ++opt.numurls;
1794               downloaded_increase (hstat.len);
1795
1796               /* Remember that we downloaded the file for later ".orig" code. */
1797               if (*dt & ADDED_HTML_EXTENSION)
1798                 downloaded_file(FILE_DOWNLOADED_AND_HTML_EXTENSION_ADDED, locf);
1799               else
1800                 downloaded_file(FILE_DOWNLOADED_NORMALLY, locf);
1801
1802               xfree (filename_plus_orig_suffix); /* must precede every return! */
1803               return RETROK;
1804             }
1805           else                  /* the same, but not accepted */
1806             {
1807               logprintf (LOG_VERBOSE,
1808                          _("%s (%s) - Connection closed at byte %ld/%ld. "),
1809                          tms, tmrate, hstat.len, hstat.contlen);
1810               printwhat (count, opt.ntry);
1811               continue;
1812             }
1813         }
1814       else                      /* now hstat.res can only be -1 */
1815         {
1816           if (hstat.contlen == -1)
1817             {
1818               logprintf (LOG_VERBOSE,
1819                          _("%s (%s) - Read error at byte %ld (%s)."),
1820                          tms, tmrate, hstat.len, strerror (errno));
1821               printwhat (count, opt.ntry);
1822               continue;
1823             }
1824           else                  /* hstat.res == -1 and contlen is given */
1825             {
1826               logprintf (LOG_VERBOSE,
1827                          _("%s (%s) - Read error at byte %ld/%ld (%s). "),
1828                          tms, tmrate, hstat.len, hstat.contlen,
1829                          strerror (errno));
1830               printwhat (count, opt.ntry);
1831               continue;
1832             }
1833         }
1834       /* not reached */
1835       break;
1836     }
1837   while (!opt.ntry || (count < opt.ntry));
1838   xfree (filename_plus_orig_suffix); /* must precede every return! */
1839   return TRYLIMEXC;
1840 }
1841 \f
1842 /* Converts struct tm to time_t, assuming the data in tm is UTC rather
1843    than local timezone.
1844
1845    mktime is similar but assumes struct tm, also known as the
1846    "broken-down" form of time, is in local time zone.  mktime_from_utc
1847    uses mktime to make the conversion understanding that an offset
1848    will be introduced by the local time assumption.
1849
1850    mktime_from_utc then measures the introduced offset by applying
1851    gmtime to the initial result and applying mktime to the resulting
1852    "broken-down" form.  The difference between the two mktime results
1853    is the measured offset which is then subtracted from the initial
1854    mktime result to yield a calendar time which is the value returned.
1855
1856    tm_isdst in struct tm is set to 0 to force mktime to introduce a
1857    consistent offset (the non DST offset) since tm and tm+o might be
1858    on opposite sides of a DST change.
1859
1860    Some implementations of mktime return -1 for the nonexistent
1861    localtime hour at the beginning of DST.  In this event, use
1862    mktime(tm - 1hr) + 3600.
1863
1864    Schematically
1865      mktime(tm)   --> t+o
1866      gmtime(t+o)  --> tm+o
1867      mktime(tm+o) --> t+2o
1868      t+o - (t+2o - t+o) = t
1869
1870    Note that glibc contains a function of the same purpose named
1871    `timegm' (reverse of gmtime).  But obviously, it is not universally
1872    available, and unfortunately it is not straightforwardly
1873    extractable for use here.  Perhaps configure should detect timegm
1874    and use it where available.
1875
1876    Contributed by Roger Beeman <beeman@cisco.com>, with the help of
1877    Mark Baushke <mdb@cisco.com> and the rest of the Gurus at CISCO.
1878    Further improved by Roger with assistance from Edward J. Sabol
1879    based on input by Jamie Zawinski.  */
1880
1881 static time_t
1882 mktime_from_utc (struct tm *t)
1883 {
1884   time_t tl, tb;
1885   struct tm *tg;
1886
1887   tl = mktime (t);
1888   if (tl == -1)
1889     {
1890       t->tm_hour--;
1891       tl = mktime (t);
1892       if (tl == -1)
1893         return -1; /* can't deal with output from strptime */
1894       tl += 3600;
1895     }
1896   tg = gmtime (&tl);
1897   tg->tm_isdst = 0;
1898   tb = mktime (tg);
1899   if (tb == -1)
1900     {
1901       tg->tm_hour--;
1902       tb = mktime (tg);
1903       if (tb == -1)
1904         return -1; /* can't deal with output from gmtime */
1905       tb += 3600;
1906     }
1907   return (tl - (tb - tl));
1908 }
1909
1910 /* Check whether the result of strptime() indicates success.
1911    strptime() returns the pointer to how far it got to in the string.
1912    The processing has been successful if the string is at `GMT' or
1913    `+X', or at the end of the string.
1914
1915    In extended regexp parlance, the function returns 1 if P matches
1916    "^ *(GMT|[+-][0-9]|$)", 0 otherwise.  P being NULL (which strptime
1917    can return) is considered a failure and 0 is returned.  */
1918 static int
1919 check_end (const char *p)
1920 {
1921   if (!p)
1922     return 0;
1923   while (ISSPACE (*p))
1924     ++p;
1925   if (!*p
1926       || (p[0] == 'G' && p[1] == 'M' && p[2] == 'T')
1927       || ((p[0] == '+' || p[0] == '-') && ISDIGIT (p[1])))
1928     return 1;
1929   else
1930     return 0;
1931 }
1932
1933 /* Convert the textual specification of time in TIME_STRING to the
1934    number of seconds since the Epoch.
1935
1936    TIME_STRING can be in any of the three formats RFC2068 allows the
1937    HTTP servers to emit -- RFC1123-date, RFC850-date or asctime-date.
1938    Timezones are ignored, and should be GMT.
1939
1940    Return the computed time_t representation, or -1 if the conversion
1941    fails.
1942
1943    This function uses strptime with various string formats for parsing
1944    TIME_STRING.  This results in a parser that is not as lenient in
1945    interpreting TIME_STRING as I would like it to be.  Being based on
1946    strptime, it always allows shortened months, one-digit days, etc.,
1947    but due to the multitude of formats in which time can be
1948    represented, an ideal HTTP time parser would be even more
1949    forgiving.  It should completely ignore things like week days and
1950    concentrate only on the various forms of representing years,
1951    months, days, hours, minutes, and seconds.  For example, it would
1952    be nice if it accepted ISO 8601 out of the box.
1953
1954    I've investigated free and PD code for this purpose, but none was
1955    usable.  getdate was big and unwieldy, and had potential copyright
1956    issues, or so I was informed.  Dr. Marcus Hennecke's atotm(),
1957    distributed with phttpd, is excellent, but we cannot use it because
1958    it is not assigned to the FSF.  So I stuck it with strptime.  */
1959
1960 time_t
1961 http_atotm (char *time_string)
1962 {
1963   /* NOTE: Solaris strptime man page claims that %n and %t match white
1964      space, but that's not universally available.  Instead, we simply
1965      use ` ' to mean "skip all WS", which works under all strptime
1966      implementations I've tested.  */
1967
1968   static const char *time_formats[] = {
1969     "%a, %d %b %Y %T",          /* RFC1123: Thu, 29 Jan 1998 22:12:57 */
1970     "%A, %d-%b-%y %T",          /* RFC850:  Thursday, 29-Jan-98 22:12:57 */
1971     "%a, %d-%b-%Y %T",          /* pseudo-RFC850:  Thu, 29-Jan-1998 22:12:57
1972                                    (google.com uses this for their cookies.) */
1973     "%a %b %d %T %Y"            /* asctime: Thu Jan 29 22:12:57 1998 */
1974   };
1975
1976   int i;
1977   struct tm t;
1978
1979   /* According to Roger Beeman, we need to initialize tm_isdst, since
1980      strptime won't do it.  */
1981   t.tm_isdst = 0;
1982
1983   /* Note that under foreign locales Solaris strptime() fails to
1984      recognize English dates, which renders this function useless.  We
1985      solve this by being careful not to affect LC_TIME when
1986      initializing locale.
1987
1988      Another solution would be to temporarily set locale to C, invoke
1989      strptime(), and restore it back.  This is slow and dirty,
1990      however, and locale support other than LC_MESSAGES can mess other
1991      things, so I rather chose to stick with just setting LC_MESSAGES.
1992
1993      GNU strptime does not have this problem because it recognizes
1994      both international and local dates.  */
1995
1996   for (i = 0; i < ARRAY_SIZE (time_formats); i++)
1997     if (check_end (strptime (time_string, time_formats[i], &t)))
1998       return mktime_from_utc (&t);
1999
2000   /* All formats have failed.  */
2001   return -1;
2002 }
2003 \f
2004 /* Authorization support: We support two authorization schemes:
2005
2006    * `Basic' scheme, consisting of base64-ing USER:PASSWORD string;
2007
2008    * `Digest' scheme, added by Junio Hamano <junio@twinsun.com>,
2009    consisting of answering to the server's challenge with the proper
2010    MD5 digests.  */
2011
2012 /* How many bytes it will take to store LEN bytes in base64.  */
2013 #define BASE64_LENGTH(len) (4 * (((len) + 2) / 3))
2014
2015 /* Encode the string S of length LENGTH to base64 format and place it
2016    to STORE.  STORE will be 0-terminated, and must point to a writable
2017    buffer of at least 1+BASE64_LENGTH(length) bytes.  */
2018 static void
2019 base64_encode (const char *s, char *store, int length)
2020 {
2021   /* Conversion table.  */
2022   static char tbl[64] = {
2023     'A','B','C','D','E','F','G','H',
2024     'I','J','K','L','M','N','O','P',
2025     'Q','R','S','T','U','V','W','X',
2026     'Y','Z','a','b','c','d','e','f',
2027     'g','h','i','j','k','l','m','n',
2028     'o','p','q','r','s','t','u','v',
2029     'w','x','y','z','0','1','2','3',
2030     '4','5','6','7','8','9','+','/'
2031   };
2032   int i;
2033   unsigned char *p = (unsigned char *)store;
2034
2035   /* Transform the 3x8 bits to 4x6 bits, as required by base64.  */
2036   for (i = 0; i < length; i += 3)
2037     {
2038       *p++ = tbl[s[0] >> 2];
2039       *p++ = tbl[((s[0] & 3) << 4) + (s[1] >> 4)];
2040       *p++ = tbl[((s[1] & 0xf) << 2) + (s[2] >> 6)];
2041       *p++ = tbl[s[2] & 0x3f];
2042       s += 3;
2043     }
2044   /* Pad the result if necessary...  */
2045   if (i == length + 1)
2046     *(p - 1) = '=';
2047   else if (i == length + 2)
2048     *(p - 1) = *(p - 2) = '=';
2049   /* ...and zero-terminate it.  */
2050   *p = '\0';
2051 }
2052
2053 /* Create the authentication header contents for the `Basic' scheme.
2054    This is done by encoding the string `USER:PASS' in base64 and
2055    prepending `HEADER: Basic ' to it.  */
2056 static char *
2057 basic_authentication_encode (const char *user, const char *passwd,
2058                              const char *header)
2059 {
2060   char *t1, *t2, *res;
2061   int len1 = strlen (user) + 1 + strlen (passwd);
2062   int len2 = BASE64_LENGTH (len1);
2063
2064   t1 = (char *)alloca (len1 + 1);
2065   sprintf (t1, "%s:%s", user, passwd);
2066   t2 = (char *)alloca (1 + len2);
2067   base64_encode (t1, t2, len1);
2068   res = (char *)xmalloc (len2 + 11 + strlen (header));
2069   sprintf (res, "%s: Basic %s\r\n", header, t2);
2070
2071   return res;
2072 }
2073
2074 #ifdef USE_DIGEST
2075 /* Parse HTTP `WWW-Authenticate:' header.  AU points to the beginning
2076    of a field in such a header.  If the field is the one specified by
2077    ATTR_NAME ("realm", "opaque", and "nonce" are used by the current
2078    digest authorization code), extract its value in the (char*)
2079    variable pointed by RET.  Returns negative on a malformed header,
2080    or number of bytes that have been parsed by this call.  */
2081 static int
2082 extract_header_attr (const char *au, const char *attr_name, char **ret)
2083 {
2084   const char *cp, *ep;
2085
2086   ep = cp = au;
2087
2088   if (strncmp (cp, attr_name, strlen (attr_name)) == 0)
2089     {
2090       cp += strlen (attr_name);
2091       if (!*cp)
2092         return -1;
2093       cp += skip_lws (cp);
2094       if (*cp != '=')
2095         return -1;
2096       if (!*++cp)
2097         return -1;
2098       cp += skip_lws (cp);
2099       if (*cp != '\"')
2100         return -1;
2101       if (!*++cp)
2102         return -1;
2103       for (ep = cp; *ep && *ep != '\"'; ep++)
2104         ;
2105       if (!*ep)
2106         return -1;
2107       FREE_MAYBE (*ret);
2108       *ret = strdupdelim (cp, ep);
2109       return ep - au + 1;
2110     }
2111   else
2112     return 0;
2113 }
2114
2115 /* Dump the hexadecimal representation of HASH to BUF.  HASH should be
2116    an array of 16 bytes containing the hash keys, and BUF should be a
2117    buffer of 33 writable characters (32 for hex digits plus one for
2118    zero termination).  */
2119 static void
2120 dump_hash (unsigned char *buf, const unsigned char *hash)
2121 {
2122   int i;
2123
2124   for (i = 0; i < MD5_HASHLEN; i++, hash++)
2125     {
2126       *buf++ = XDIGIT_TO_xchar (*hash >> 4);
2127       *buf++ = XDIGIT_TO_xchar (*hash & 0xf);
2128     }
2129   *buf = '\0';
2130 }
2131
2132 /* Take the line apart to find the challenge, and compose a digest
2133    authorization header.  See RFC2069 section 2.1.2.  */
2134 char *
2135 digest_authentication_encode (const char *au, const char *user,
2136                               const char *passwd, const char *method,
2137                               const char *path)
2138 {
2139   static char *realm, *opaque, *nonce;
2140   static struct {
2141     const char *name;
2142     char **variable;
2143   } options[] = {
2144     { "realm", &realm },
2145     { "opaque", &opaque },
2146     { "nonce", &nonce }
2147   };
2148   char *res;
2149
2150   realm = opaque = nonce = NULL;
2151
2152   au += 6;                      /* skip over `Digest' */
2153   while (*au)
2154     {
2155       int i;
2156
2157       au += skip_lws (au);
2158       for (i = 0; i < ARRAY_SIZE (options); i++)
2159         {
2160           int skip = extract_header_attr (au, options[i].name,
2161                                           options[i].variable);
2162           if (skip < 0)
2163             {
2164               FREE_MAYBE (realm);
2165               FREE_MAYBE (opaque);
2166               FREE_MAYBE (nonce);
2167               return NULL;
2168             }
2169           else if (skip)
2170             {
2171               au += skip;
2172               break;
2173             }
2174         }
2175       if (i == ARRAY_SIZE (options))
2176         {
2177           while (*au && *au != '=')
2178             au++;
2179           if (*au && *++au)
2180             {
2181               au += skip_lws (au);
2182               if (*au == '\"')
2183                 {
2184                   au++;
2185                   while (*au && *au != '\"')
2186                     au++;
2187                   if (*au)
2188                     au++;
2189                 }
2190             }
2191         }
2192       while (*au && *au != ',')
2193         au++;
2194       if (*au)
2195         au++;
2196     }
2197   if (!realm || !nonce || !user || !passwd || !path || !method)
2198     {
2199       FREE_MAYBE (realm);
2200       FREE_MAYBE (opaque);
2201       FREE_MAYBE (nonce);
2202       return NULL;
2203     }
2204
2205   /* Calculate the digest value.  */
2206   {
2207     struct md5_ctx ctx;
2208     unsigned char hash[MD5_HASHLEN];
2209     unsigned char a1buf[MD5_HASHLEN * 2 + 1], a2buf[MD5_HASHLEN * 2 + 1];
2210     unsigned char response_digest[MD5_HASHLEN * 2 + 1];
2211
2212     /* A1BUF = H(user ":" realm ":" password) */
2213     md5_init_ctx (&ctx);
2214     md5_process_bytes (user, strlen (user), &ctx);
2215     md5_process_bytes (":", 1, &ctx);
2216     md5_process_bytes (realm, strlen (realm), &ctx);
2217     md5_process_bytes (":", 1, &ctx);
2218     md5_process_bytes (passwd, strlen (passwd), &ctx);
2219     md5_finish_ctx (&ctx, hash);
2220     dump_hash (a1buf, hash);
2221
2222     /* A2BUF = H(method ":" path) */
2223     md5_init_ctx (&ctx);
2224     md5_process_bytes (method, strlen (method), &ctx);
2225     md5_process_bytes (":", 1, &ctx);
2226     md5_process_bytes (path, strlen (path), &ctx);
2227     md5_finish_ctx (&ctx, hash);
2228     dump_hash (a2buf, hash);
2229
2230     /* RESPONSE_DIGEST = H(A1BUF ":" nonce ":" A2BUF) */
2231     md5_init_ctx (&ctx);
2232     md5_process_bytes (a1buf, MD5_HASHLEN * 2, &ctx);
2233     md5_process_bytes (":", 1, &ctx);
2234     md5_process_bytes (nonce, strlen (nonce), &ctx);
2235     md5_process_bytes (":", 1, &ctx);
2236     md5_process_bytes (a2buf, MD5_HASHLEN * 2, &ctx);
2237     md5_finish_ctx (&ctx, hash);
2238     dump_hash (response_digest, hash);
2239
2240     res = (char*) xmalloc (strlen (user)
2241                            + strlen (user)
2242                            + strlen (realm)
2243                            + strlen (nonce)
2244                            + strlen (path)
2245                            + 2 * MD5_HASHLEN /*strlen (response_digest)*/
2246                            + (opaque ? strlen (opaque) : 0)
2247                            + 128);
2248     sprintf (res, "Authorization: Digest \
2249 username=\"%s\", realm=\"%s\", nonce=\"%s\", uri=\"%s\", response=\"%s\"",
2250              user, realm, nonce, path, response_digest);
2251     if (opaque)
2252       {
2253         char *p = res + strlen (res);
2254         strcat (p, ", opaque=\"");
2255         strcat (p, opaque);
2256         strcat (p, "\"");
2257       }
2258     strcat (res, "\r\n");
2259   }
2260   return res;
2261 }
2262 #endif /* USE_DIGEST */
2263
2264
2265 #define BEGINS_WITH(line, string_constant)                              \
2266   (!strncasecmp (line, string_constant, sizeof (string_constant) - 1)   \
2267    && (ISSPACE (line[sizeof (string_constant) - 1])                     \
2268        || !line[sizeof (string_constant) - 1]))
2269
2270 static int
2271 known_authentication_scheme_p (const char *au)
2272 {
2273   return BEGINS_WITH (au, "Basic")
2274     || BEGINS_WITH (au, "Digest")
2275     || BEGINS_WITH (au, "NTLM");
2276 }
2277
2278 #undef BEGINS_WITH
2279
2280 /* Create the HTTP authorization request header.  When the
2281    `WWW-Authenticate' response header is seen, according to the
2282    authorization scheme specified in that header (`Basic' and `Digest'
2283    are supported by the current implementation), produce an
2284    appropriate HTTP authorization request header.  */
2285 static char *
2286 create_authorization_line (const char *au, const char *user,
2287                            const char *passwd, const char *method,
2288                            const char *path)
2289 {
2290   char *wwwauth = NULL;
2291
2292   if (!strncasecmp (au, "Basic", 5))
2293     wwwauth = basic_authentication_encode (user, passwd, "Authorization");
2294   if (!strncasecmp (au, "NTLM", 4))
2295     wwwauth = basic_authentication_encode (user, passwd, "Authorization");
2296 #ifdef USE_DIGEST
2297   else if (!strncasecmp (au, "Digest", 6))
2298     wwwauth = digest_authentication_encode (au, user, passwd, method, path);
2299 #endif /* USE_DIGEST */
2300   return wwwauth;
2301 }