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 (hs->newloc);
 913           FREE_MAYBE (all_headers);
 914           CLOSE_INVALIDATE (sock);
 915           return HEOF;
 916         }
 917       else if (status == HG_ERROR)
 918         {
 919           logputs (LOG_VERBOSE, "\n");
 920           logprintf (LOG_NOTQUIET, _("Read error (%s) in headers.\n"),
 921                      strerror (errno));
 922           xfree (hdr);
 923           FREE_MAYBE (type);
 924           FREE_MAYBE (hs->newloc);
 925           FREE_MAYBE (all_headers);
 926           CLOSE_INVALIDATE (sock);
 927           return HERR;
 928         }
 929
 930       /* If the headers are to be saved to a file later, save them to
 931          memory now.  */
 932       if (opt.save_headers)
 933         {
 934           int lh = strlen (hdr);
 935           all_headers = (char *)xrealloc (all_headers, all_length + lh + 2);
 936           memcpy (all_headers + all_length, hdr, lh);
 937           all_length += lh;
 938           all_headers[all_length++] = '\n';
 939           all_headers[all_length] = '\0';
 940         }
 941
 942       /* Print the header if requested.  */
 943       if (opt.server_response && hcount != 1)
 944         logprintf (LOG_VERBOSE, "\n%d %s", hcount, hdr);
 945
 946       /* Check for status line.  */
 947       if (hcount == 1)
 948         {
 949           const char *error;
 950           /* Parse the first line of server response.  */
 951           statcode = parse_http_status_line (hdr, &error);
 952           hs->statcode = statcode;
 953           /* Store the descriptive response.  */
 954           if (statcode == -1) /* malformed response */
 955             {
 956               /* A common reason for "malformed response" error is the
 957                  case when no data was actually received.  Handle this
 958                  special case.  */
 959               if (!*hdr)
 960                 hs->error = xstrdup (_("No data received"));
 961               else
 962                 hs->error = xstrdup (_("Malformed status line"));
 963               xfree (hdr);
 964               break;
 965             }
 966           else if (!*error)
 967             hs->error = xstrdup (_("(no description)"));
 968           else
 969             hs->error = xstrdup (error);
 970
 971           if ((statcode != -1)
 972 #ifdef DEBUG
 973               && !opt.debug
 974 #endif
 975               )
 976             logprintf (LOG_VERBOSE, "%d %s", statcode, error);
 977
 978           goto done_header;
 979         }
 980
 981       /* Exit on empty header.  */
 982       if (!*hdr)
 983         {
 984           xfree (hdr);
 985           break;
 986         }
 987
 988       /* Try getting content-length.  */
 989       if (contlen == -1 && !opt.ignore_length)
 990         if (header_process (hdr, "Content-Length", header_extract_number,
 991                             &contlen))
 992           goto done_header;
 993       /* Try getting content-type.  */
 994       if (!type)
 995         if (header_process (hdr, "Content-Type", http_process_type, &type))
 996           goto done_header;
 997       /* Try getting location.  */
 998       if (!hs->newloc)
 999         if (header_process (hdr, "Location", header_strdup, &hs->newloc))
1000           goto done_header;
1001       /* Try getting last-modified.  */
1002       if (!hs->remote_time)
1003         if (header_process (hdr, "Last-Modified", header_strdup,
1004                             &hs->remote_time))
1005           goto done_header;
1006       /* Try getting cookies. */
1007       if (opt.cookies)
1008         if (header_process (hdr, "Set-Cookie", set_cookie_header_cb, u))
1009           goto done_header;
1010       /* Try getting www-authentication.  */
1011       if (!authenticate_h)
1012         if (header_process (hdr, "WWW-Authenticate", header_strdup,
1013                             &authenticate_h))
1014           goto done_header;
1015       /* Check for accept-ranges header.  If it contains the word
1016          `none', disable the ranges.  */
1017       if (*dt & ACCEPTRANGES)
1018         {
1019           int nonep;
1020           if (header_process (hdr, "Accept-Ranges", http_process_none, &nonep))
1021             {
1022               if (nonep)
1023                 *dt &= ~ACCEPTRANGES;
1024               goto done_header;
1025             }
1026         }
1027       /* Try getting content-range.  */
1028       if (contrange == -1)
1029         {
1030           struct http_process_range_closure closure;
1031           if (header_process (hdr, "Content-Range", http_process_range, &closure))
1032             {
1033               contrange = closure.first_byte_pos;
1034               goto done_header;
1035             }
1036         }
1037       /* Check for keep-alive related responses. */
1038       if (!inhibit_keep_alive)
1039         {
1040           /* Check for the `Keep-Alive' header. */
1041           if (!http_keep_alive_1)
1042             {
1043               if (header_process (hdr, "Keep-Alive", header_exists,
1044                                   &http_keep_alive_1))
1045                 goto done_header;
1046             }
1047           /* Check for `Connection: Keep-Alive'. */
1048           if (!http_keep_alive_2)
1049             {
1050               if (header_process (hdr, "Connection", http_process_connection,
1051                                   &http_keep_alive_2))
1052                 goto done_header;
1053             }
1054         }
1055     done_header:
1056       xfree (hdr);
1057     }
1058
1059   logputs (LOG_VERBOSE, "\n");
1060
1061   if (contlen != -1
1062       && (http_keep_alive_1 || http_keep_alive_2))
1063     {
1064       assert (inhibit_keep_alive == 0);
1065       keep_alive = 1;
1066     }
1067   if (keep_alive)
1068     /* The server has promised that it will not close the connection
1069        when we're done.  This means that we can register it.  */
1070 #ifndef HAVE_SSL
1071     register_persistent (u->host, u->port, sock);
1072 #else
1073     register_persistent (u->host, u->port, sock, ssl);
1074 #endif /* HAVE_SSL */
1075
1076   if ((statcode == HTTP_STATUS_UNAUTHORIZED)
1077       && authenticate_h)
1078     {
1079       /* Authorization is required.  */
1080       FREE_MAYBE (type);
1081       type = NULL;
1082       FREEHSTAT (*hs);
1083       CLOSE_INVALIDATE (sock);  /* would be CLOSE_FINISH, but there
1084                                    might be more bytes in the body. */
1085       if (auth_tried_already)
1086         {
1087           /* If we have tried it already, then there is not point
1088              retrying it.  */
1089         failed:
1090           logputs (LOG_NOTQUIET, _("Authorization failed.\n"));
1091           xfree (authenticate_h);
1092           return AUTHFAILED;
1093         }
1094       else if (!known_authentication_scheme_p (authenticate_h))
1095         {
1096           xfree (authenticate_h);
1097           logputs (LOG_NOTQUIET, _("Unknown authentication scheme.\n"));
1098           return AUTHFAILED;
1099         }
1100       else if (BEGINS_WITH (authenticate_h, "Basic"))
1101         {
1102           /* The authentication scheme is basic, the one we try by
1103              default, and it failed.  There's no sense in trying
1104              again.  */
1105           goto failed;
1106         }
1107       else
1108         {
1109           auth_tried_already = 1;
1110           goto again;
1111         }
1112     }
1113   /* We do not need this anymore.  */
1114   if (authenticate_h)
1115     {
1116       xfree (authenticate_h);
1117       authenticate_h = NULL;
1118     }
1119
1120   /* 20x responses are counted among successful by default.  */
1121   if (H_20X (statcode))
1122     *dt |= RETROKF;
1123
1124   if (type && !strncasecmp (type, TEXTHTML_S, strlen (TEXTHTML_S)))
1125     *dt |= TEXTHTML;
1126   else
1127     /* We don't assume text/html by default.  */
1128     *dt &= ~TEXTHTML;
1129
1130   if (opt.html_extension && (*dt & TEXTHTML))
1131     /* -E / --html-extension / html_extension = on was specified, and this is a
1132        text/html file.  If some case-insensitive variation on ".htm[l]" isn't
1133        already the file's suffix, tack on ".html". */
1134     {
1135       char*  last_period_in_local_filename = strrchr(u->local, '.');
1136
1137       if (last_period_in_local_filename == NULL ||
1138           !(strcasecmp(last_period_in_local_filename, ".htm") == EQ ||
1139             strcasecmp(last_period_in_local_filename, ".html") == EQ))
1140         {
1141           size_t  local_filename_len = strlen(u->local);
1142
1143           u->local = xrealloc(u->local, local_filename_len + sizeof(".html"));
1144           strcpy(u->local + local_filename_len, ".html");
1145
1146           *dt |= ADDED_HTML_EXTENSION;
1147         }
1148     }
1149
1150   if (contrange == -1)
1151     {
1152       /* We did not get a content-range header.  This means that the
1153          server did not honor our `Range' request.  Normally, this
1154          means we should reset hs->restval and continue normally.  */
1155
1156       /* However, if `-c' is used, we need to be a bit more careful:
1157
1158          1. If `-c' is specified and the file already existed when
1159          Wget was started, it would be a bad idea for us to start
1160          downloading it from scratch, effectively truncating it.  I
1161          believe this cannot happen unless `-c' was specified.
1162
1163          2. If `-c' is used on a file that is already fully
1164          downloaded, we're requesting bytes after the end of file,
1165          which can result in server not honoring `Range'.  If this is
1166          the case, `Content-Length' will be equal to the length of the
1167          file.  */
1168       if (opt.always_rest)
1169         {
1170           /* Check for condition #2. */
1171           if (hs->restval == contlen)
1172             {
1173               logputs (LOG_VERBOSE, _("\
1174 \n    The file is already fully retrieved; nothing to do.\n\n"));
1175               /* In case the caller inspects. */
1176               hs->len = contlen;
1177               hs->res = 0;
1178               FREE_MAYBE (type);
1179               FREE_MAYBE (hs->newloc);
1180               FREE_MAYBE (all_headers);
1181               CLOSE_INVALIDATE (sock);  /* would be CLOSE_FINISH, but there
1182                                            might be more bytes in the body. */
1183               return RETRFINISHED;
1184             }
1185
1186           /* Check for condition #1. */
1187           if (hs->no_truncate)
1188             {
1189               logprintf (LOG_NOTQUIET,
1190                          _("\
1191 \n\
1192     The server does not support continued download;\n\
1193     refusing to truncate `%s'.\n\n"), u->local);
1194               return CONTNOTSUPPORTED;
1195             }
1196
1197           /* Fallthrough */
1198         }
1199
1200       hs->restval = 0;
1201     }
1202
1203   else if (contrange != hs->restval ||
1204            (H_PARTIAL (statcode) && contrange == -1))
1205     {
1206       /* This means the whole request was somehow misunderstood by the
1207          server.  Bail out.  */
1208       FREE_MAYBE (type);
1209       FREE_MAYBE (hs->newloc);
1210       FREE_MAYBE (all_headers);
1211       CLOSE_INVALIDATE (sock);
1212       return RANGEERR;
1213     }
1214
1215   if (hs->restval)
1216     {
1217       if (contlen != -1)
1218         contlen += contrange;
1219       else
1220         contrange = -1;        /* If conent-length was not sent,
1221                                   content-range will be ignored.  */
1222     }
1223   hs->contlen = contlen;
1224
1225   /* Return if redirected.  */
1226   if (H_REDIRECTED (statcode) || statcode == HTTP_STATUS_MULTIPLE_CHOICES)
1227     {
1228       /* RFC2068 says that in case of the 300 (multiple choices)
1229          response, the server can output a preferred URL through
1230          `Location' header; otherwise, the request should be treated
1231          like GET.  So, if the location is set, it will be a
1232          redirection; otherwise, just proceed normally.  */
1233       if (statcode == HTTP_STATUS_MULTIPLE_CHOICES && !hs->newloc)
1234         *dt |= RETROKF;
1235       else
1236         {
1237           logprintf (LOG_VERBOSE,
1238                      _("Location: %s%s\n"),
1239                      hs->newloc ? hs->newloc : _("unspecified"),
1240                      hs->newloc ? _(" [following]") : "");
1241           CLOSE_INVALIDATE (sock);      /* would be CLOSE_FINISH, but there
1242                                            might be more bytes in the body. */
1243           FREE_MAYBE (type);
1244           FREE_MAYBE (all_headers);
1245           return NEWLOCATION;
1246         }
1247     }
1248   if (opt.verbose)
1249     {
1250       if ((*dt & RETROKF) && !opt.server_response)
1251         {
1252           /* No need to print this output if the body won't be
1253              downloaded at all, or if the original server response is
1254              printed.  */
1255           logputs (LOG_VERBOSE, _("Length: "));
1256           if (contlen != -1)
1257             {
1258               logputs (LOG_VERBOSE, legible (contlen));
1259               if (contrange != -1)
1260                 logprintf (LOG_VERBOSE, _(" (%s to go)"),
1261                            legible (contlen - contrange));
1262             }
1263           else
1264             logputs (LOG_VERBOSE,
1265                      opt.ignore_length ? _("ignored") : _("unspecified"));
1266           if (type)
1267             logprintf (LOG_VERBOSE, " [%s]\n", type);
1268           else
1269             logputs (LOG_VERBOSE, "\n");
1270         }
1271     }
1272   FREE_MAYBE (type);
1273   type = NULL;                  /* We don't need it any more.  */
1274
1275   /* Return if we have no intention of further downloading.  */
1276   if (!(*dt & RETROKF) || (*dt & HEAD_ONLY))
1277     {
1278       /* In case the caller cares to look...  */
1279       hs->len = 0L;
1280       hs->res = 0;
1281       FREE_MAYBE (type);
1282       FREE_MAYBE (all_headers);
1283       CLOSE_INVALIDATE (sock);  /* would be CLOSE_FINISH, but there
1284                                    might be more bytes in the body. */
1285       return RETRFINISHED;
1286     }
1287
1288   /* Open the local file.  */
1289   if (!opt.dfp)
1290     {
1291       mkalldirs (u->local);
1292       if (opt.backups)
1293         rotate_backups (u->local);
1294       fp = fopen (u->local, hs->restval ? "ab" : "wb");
1295       if (!fp)
1296         {
1297           logprintf (LOG_NOTQUIET, "%s: %s\n", u->local, strerror (errno));
1298           CLOSE_INVALIDATE (sock); /* would be CLOSE_FINISH, but there
1299                                       might be more bytes in the body. */
1300           FREE_MAYBE (all_headers);
1301           return FOPENERR;
1302         }
1303     }
1304   else                          /* opt.dfp */
1305     {
1306       extern int global_download_count;
1307       fp = opt.dfp;
1308       /* To ensure that repeated "from scratch" downloads work for -O
1309          files, we rewind the file pointer, unless restval is
1310          non-zero.  (This works only when -O is used on regular files,
1311          but it's still a valuable feature.)
1312
1313          However, this loses when more than one URL is specified on
1314          the command line the second rewinds eradicates the contents
1315          of the first download.  Thus we disable the above trick for
1316          all the downloads except the very first one.
1317
1318          #### A possible solution to this would be to remember the
1319          file position in the output document and to seek to that
1320          position, instead of rewinding.  */
1321       if (!hs->restval && global_download_count == 0)
1322         {
1323           /* This will silently fail for streams that don't correspond
1324              to regular files, but that's OK.  */
1325           rewind (fp);
1326           /* ftruncate is needed because opt.dfp is opened in append
1327              mode if opt.always_rest is set.  */
1328           ftruncate (fileno (fp), 0);
1329           clearerr (fp);
1330         }
1331     }
1332
1333   /* #### This confuses the code that checks for file size.  There
1334      should be some overhead information.  */
1335   if (opt.save_headers)
1336     fwrite (all_headers, 1, all_length, fp);
1337   timer = wtimer_new ();
1338   /* Get the contents of the document.  */
1339   hs->res = get_contents (sock, fp, &hs->len, hs->restval,
1340                           (contlen != -1 ? contlen : 0),
1341                           &rbuf, keep_alive);
1342   hs->dltime = wtimer_elapsed (timer);
1343   wtimer_delete (timer);
1344   {
1345     /* Close or flush the file.  We have to be careful to check for
1346        error here.  Checking the result of fwrite() is not enough --
1347        errors could go unnoticed!  */
1348     int flush_res;
1349     if (!opt.dfp)
1350       flush_res = fclose (fp);
1351     else
1352       flush_res = fflush (fp);
1353     if (flush_res == EOF)
1354       hs->res = -2;
1355   }
1356   FREE_MAYBE (all_headers);
1357   CLOSE_FINISH (sock);
1358   if (hs->res == -2)
1359     return FWRITEERR;
1360   return RETRFINISHED;
1361 }
1362
1363 /* The genuine HTTP loop!  This is the part where the retrieval is
1364    retried, and retried, and retried, and...  */
1365 uerr_t
1366 http_loop (struct urlinfo *u, char **newloc, int *dt)
1367 {
1368   int count;
1369   int use_ts, got_head = 0;     /* time-stamping info */
1370   char *filename_plus_orig_suffix;
1371   char *local_filename = NULL;
1372   char *tms, *suf, *locf, *tmrate;
1373   uerr_t err;
1374   time_t tml = -1, tmr = -1;    /* local and remote time-stamps */
1375   long local_size = 0;          /* the size of the local file */
1376   size_t filename_len;
1377   struct http_stat hstat;       /* HTTP status */
1378   struct stat st;
1379
1380   /* This used to be done in main(), but it's a better idea to do it
1381      here so that we don't go through the hoops if we're just using
1382      FTP or whatever. */
1383   if (opt.cookies && opt.cookies_input && !cookies_loaded_p)
1384     load_cookies (opt.cookies_input);
1385
1386   *newloc = NULL;
1387
1388   /* Warn on (likely bogus) wildcard usage in HTTP.  Don't use
1389      has_wildcards_p because it would also warn on `?', and we know that
1390      shows up in CGI paths a *lot*.  */
1391   if (strchr (u->url, '*'))
1392     logputs (LOG_VERBOSE, _("Warning: wildcards not supported in HTTP.\n"));
1393
1394   /* Determine the local filename.  */
1395   if (!u->local)
1396     u->local = url_filename (u->proxy ? u->proxy : u);
1397
1398   if (!opt.output_document)
1399     locf = u->local;
1400   else
1401     locf = opt.output_document;
1402
1403   /* Yuck.  Multiple returns suck.  We need to remember to free() the space we
1404      xmalloc() here before EACH return.  This is one reason it's better to set
1405      flags that influence flow control and then return once at the end. */
1406   filename_len = strlen(u->local);
1407   filename_plus_orig_suffix = xmalloc(filename_len + sizeof(".orig"));
1408
1409   if (opt.noclobber && file_exists_p (u->local))
1410     {
1411       /* If opt.noclobber is turned on and file already exists, do not
1412          retrieve the file */
1413       logprintf (LOG_VERBOSE, _("\
1414 File `%s' already there, will not retrieve.\n"), u->local);
1415       /* If the file is there, we suppose it's retrieved OK.  */
1416       *dt |= RETROKF;
1417
1418       /* #### Bogusness alert.  */
1419       /* If its suffix is "html" or (yuck!) "htm", we suppose it's
1420          text/html, a harmless lie.  */
1421       if (((suf = suffix (u->local)) != NULL)
1422           && (!strcmp (suf, "html") || !strcmp (suf, "htm")))
1423         *dt |= TEXTHTML;
1424       xfree (suf);
1425       xfree (filename_plus_orig_suffix); /* must precede every return! */
1426       /* Another harmless lie: */
1427       return RETROK;
1428     }
1429
1430   use_ts = 0;
1431   if (opt.timestamping)
1432     {
1433       boolean  local_dot_orig_file_exists = FALSE;
1434
1435       if (opt.backup_converted)
1436         /* If -K is specified, we'll act on the assumption that it was specified
1437            last time these files were downloaded as well, and instead of just
1438            comparing local file X against server file X, we'll compare local
1439            file X.orig (if extant, else X) against server file X.  If -K
1440            _wasn't_ specified last time, or the server contains files called
1441            *.orig, -N will be back to not operating correctly with -k. */
1442         {
1443           /* Would a single s[n]printf() call be faster?  --dan
1444
1445              Definitely not.  sprintf() is horribly slow.  It's a
1446              different question whether the difference between the two
1447              affects a program.  Usually I'd say "no", but at one
1448              point I profiled Wget, and found that a measurable and
1449              non-negligible amount of time was lost calling sprintf()
1450              in url.c.  Replacing sprintf with inline calls to
1451              strcpy() and long_to_string() made a difference.
1452              --hniksic */
1453           strcpy(filename_plus_orig_suffix, u->local);
1454           strcpy(filename_plus_orig_suffix + filename_len, ".orig");
1455
1456           /* Try to stat() the .orig file. */
1457           if (stat(filename_plus_orig_suffix, &st) == 0)
1458             {
1459               local_dot_orig_file_exists = TRUE;
1460               local_filename = filename_plus_orig_suffix;
1461             }
1462         }
1463
1464       if (!local_dot_orig_file_exists)
1465         /* Couldn't stat() <file>.orig, so try to stat() <file>. */
1466         if (stat (u->local, &st) == 0)
1467           local_filename = u->local;
1468
1469       if (local_filename != NULL)
1470         /* There was a local file, so we'll check later to see if the version
1471            the server has is the same version we already have, allowing us to
1472            skip a download. */
1473         {
1474           use_ts = 1;
1475           tml = st.st_mtime;
1476           local_size = st.st_size;
1477           got_head = 0;
1478         }
1479     }
1480   /* Reset the counter.  */
1481   count = 0;
1482   *dt = 0 | ACCEPTRANGES;
1483   /* THE loop */
1484   do
1485     {
1486       /* Increment the pass counter.  */
1487       ++count;
1488       sleep_between_retrievals (count);
1489       /* Get the current time string.  */
1490       tms = time_str (NULL);
1491       /* Print fetch message, if opt.verbose.  */
1492       if (opt.verbose)
1493         {
1494           char *hurl = str_url (u->proxy ? u->proxy : u, 1);
1495           char tmp[15];
1496           strcpy (tmp, "        ");
1497           if (count > 1)
1498             sprintf (tmp, _("(try:%2d)"), count);
1499           logprintf (LOG_VERBOSE, "--%s--  %s\n  %s => `%s'\n",
1500                      tms, hurl, tmp, locf);
1501 #ifdef WINDOWS
1502           ws_changetitle (hurl, 1);
1503 #endif
1504           xfree (hurl);
1505         }
1506
1507       /* Default document type is empty.  However, if spider mode is
1508          on or time-stamping is employed, HEAD_ONLY commands is
1509          encoded within *dt.  */
1510       if (opt.spider || (use_ts && !got_head))
1511         *dt |= HEAD_ONLY;
1512       else
1513         *dt &= ~HEAD_ONLY;
1514       /* Assume no restarting.  */
1515       hstat.restval = 0L;
1516       /* Decide whether or not to restart.  */
1517       if (((count > 1 && (*dt & ACCEPTRANGES)) || opt.always_rest)
1518           && file_exists_p (locf))
1519         if (stat (locf, &st) == 0 && S_ISREG (st.st_mode))
1520           hstat.restval = st.st_size;
1521       /* Decide whether to send the no-cache directive.  */
1522       if (u->proxy && (count > 1 || (opt.proxy_cache == 0)))
1523         *dt |= SEND_NOCACHE;
1524       else
1525         *dt &= ~SEND_NOCACHE;
1526
1527       /* Try fetching the document, or at least its head.  :-) */
1528       err = gethttp (u, &hstat, dt);
1529
1530       /* It's unfortunate that wget determines the local filename before finding
1531          out the Content-Type of the file.  Barring a major restructuring of the
1532          code, we need to re-set locf here, since gethttp() may have xrealloc()d
1533          u->local to tack on ".html". */
1534       if (!opt.output_document)
1535         locf = u->local;
1536       else
1537         locf = opt.output_document;
1538
1539       /* In `-c' is used, check whether the file we're writing to
1540          exists before we've done anything.  If so, we'll refuse to
1541          truncate it if the server doesn't support continued
1542          downloads.  */
1543       if (opt.always_rest)
1544         hstat.no_truncate = file_exists_p (locf);
1545
1546       /* Time?  */
1547       tms = time_str (NULL);
1548       /* Get the new location (with or without the redirection).  */
1549       if (hstat.newloc)
1550         *newloc = xstrdup (hstat.newloc);
1551       switch (err)
1552         {
1553         case HERR: case HEOF: case CONSOCKERR: case CONCLOSED:
1554         case CONERROR: case READERR: case WRITEFAILED:
1555         case RANGEERR:
1556           /* Non-fatal errors continue executing the loop, which will
1557              bring them to "while" statement at the end, to judge
1558              whether the number of tries was exceeded.  */
1559           FREEHSTAT (hstat);
1560           printwhat (count, opt.ntry);
1561           continue;
1562           break;
1563         case HOSTERR: case CONREFUSED: case PROXERR: case AUTHFAILED:
1564         case SSLERRCTXCREATE: case CONTNOTSUPPORTED:
1565           /* Fatal errors just return from the function.  */
1566           FREEHSTAT (hstat);
1567           xfree (filename_plus_orig_suffix); /* must precede every return! */
1568           return err;
1569           break;
1570         case FWRITEERR: case FOPENERR:
1571           /* Another fatal error.  */
1572           logputs (LOG_VERBOSE, "\n");
1573           logprintf (LOG_NOTQUIET, _("Cannot write to `%s' (%s).\n"),
1574                      u->local, strerror (errno));
1575           FREEHSTAT (hstat);
1576           return err;
1577           break;
1578         case CONSSLERR:
1579           /* Another fatal error.  */
1580           logputs (LOG_VERBOSE, "\n");
1581           logprintf (LOG_NOTQUIET, _("Unable to establish SSL connection.\n"));
1582           FREEHSTAT (hstat);
1583           xfree (filename_plus_orig_suffix); /* must precede every return! */
1584           return err;
1585           break;
1586         case NEWLOCATION:
1587           /* Return the new location to the caller.  */
1588           if (!hstat.newloc)
1589             {
1590               logprintf (LOG_NOTQUIET,
1591                          _("ERROR: Redirection (%d) without location.\n"),
1592                          hstat.statcode);
1593               xfree (filename_plus_orig_suffix); /* must precede every return! */
1594               return WRONGCODE;
1595             }
1596           FREEHSTAT (hstat);
1597           xfree (filename_plus_orig_suffix); /* must precede every return! */
1598           return NEWLOCATION;
1599           break;
1600         case RETRFINISHED:
1601           /* Deal with you later.  */
1602           break;
1603         default:
1604           /* All possibilities should have been exhausted.  */
1605           abort ();
1606         }
1607       if (!(*dt & RETROKF))
1608         {
1609           if (!opt.verbose)
1610             {
1611               /* #### Ugly ugly ugly! */
1612               char *hurl = str_url (u->proxy ? u->proxy : u, 1);
1613               logprintf (LOG_NONVERBOSE, "%s:\n", hurl);
1614               xfree (hurl);
1615             }
1616           logprintf (LOG_NOTQUIET, _("%s ERROR %d: %s.\n"),
1617                      tms, hstat.statcode, hstat.error);
1618           logputs (LOG_VERBOSE, "\n");
1619           FREEHSTAT (hstat);
1620           xfree (filename_plus_orig_suffix); /* must precede every return! */
1621           return WRONGCODE;
1622         }
1623
1624       /* Did we get the time-stamp?  */
1625       if (!got_head)
1626         {
1627           if (opt.timestamping && !hstat.remote_time)
1628             {
1629               logputs (LOG_NOTQUIET, _("\
1630 Last-modified header missing -- time-stamps turned off.\n"));
1631             }
1632           else if (hstat.remote_time)
1633             {
1634               /* Convert the date-string into struct tm.  */
1635               tmr = http_atotm (hstat.remote_time);
1636               if (tmr == (time_t) (-1))
1637                 logputs (LOG_VERBOSE, _("\
1638 Last-modified header invalid -- time-stamp ignored.\n"));
1639             }
1640         }
1641
1642       /* The time-stamping section.  */
1643       if (use_ts)
1644         {
1645           got_head = 1;
1646           *dt &= ~HEAD_ONLY;
1647           use_ts = 0;           /* no more time-stamping */
1648           count = 0;            /* the retrieve count for HEAD is
1649                                    reset */
1650           if (hstat.remote_time && tmr != (time_t) (-1))
1651             {
1652               /* Now time-stamping can be used validly.  Time-stamping
1653                  means that if the sizes of the local and remote file
1654                  match, and local file is newer than the remote file,
1655                  it will not be retrieved.  Otherwise, the normal
1656                  download procedure is resumed.  */
1657               if (tml >= tmr &&
1658                   (hstat.contlen == -1 || local_size == hstat.contlen))
1659                 {
1660                   logprintf (LOG_VERBOSE, _("\
1661 Server file no newer than local file `%s' -- not retrieving.\n\n"),
1662                              local_filename);
1663                   FREEHSTAT (hstat);
1664                   xfree (filename_plus_orig_suffix); /*must precede every return!*/
1665                   return RETROK;
1666                 }
1667               else if (tml >= tmr)
1668                 logprintf (LOG_VERBOSE, _("\
1669 The sizes do not match (local %ld) -- retrieving.\n"), local_size);
1670               else
1671                 logputs (LOG_VERBOSE,
1672                          _("Remote file is newer, retrieving.\n"));
1673             }
1674           FREEHSTAT (hstat);
1675           continue;
1676         }
1677       if ((tmr != (time_t) (-1))
1678           && !opt.spider
1679           && ((hstat.len == hstat.contlen) ||
1680               ((hstat.res == 0) &&
1681                ((hstat.contlen == -1) ||
1682                 (hstat.len >= hstat.contlen && !opt.kill_longer)))))
1683         {
1684           /* #### This code repeats in http.c and ftp.c.  Move it to a
1685              function!  */
1686           const char *fl = NULL;
1687           if (opt.output_document)
1688             {
1689               if (opt.od_known_regular)
1690                 fl = opt.output_document;
1691             }
1692           else
1693             fl = u->local;
1694           if (fl)
1695             touch (fl, tmr);
1696         }
1697       /* End of time-stamping section.  */
1698
1699       if (opt.spider)
1700         {
1701           logprintf (LOG_NOTQUIET, "%d %s\n\n", hstat.statcode, hstat.error);
1702           xfree (filename_plus_orig_suffix); /* must precede every return! */
1703           return RETROK;
1704         }
1705
1706       /* It is now safe to free the remainder of hstat, since the
1707          strings within it will no longer be used.  */
1708       FREEHSTAT (hstat);
1709
1710       tmrate = rate (hstat.len - hstat.restval, hstat.dltime, 0);
1711
1712       if (hstat.len == hstat.contlen)
1713         {
1714           if (*dt & RETROKF)
1715             {
1716               logprintf (LOG_VERBOSE,
1717                          _("%s (%s) - `%s' saved [%ld/%ld]\n\n"),
1718                          tms, tmrate, locf, hstat.len, hstat.contlen);
1719               logprintf (LOG_NONVERBOSE,
1720                          "%s URL:%s [%ld/%ld] -> \"%s\" [%d]\n",
1721                          tms, u->url, hstat.len, hstat.contlen, locf, count);
1722             }
1723           ++opt.numurls;
1724           downloaded_increase (hstat.len);
1725
1726           /* Remember that we downloaded the file for later ".orig" code. */
1727           if (*dt & ADDED_HTML_EXTENSION)
1728             downloaded_file(FILE_DOWNLOADED_AND_HTML_EXTENSION_ADDED, locf);
1729           else
1730             downloaded_file(FILE_DOWNLOADED_NORMALLY, locf);
1731
1732           xfree(filename_plus_orig_suffix); /* must precede every return! */
1733           return RETROK;
1734         }
1735       else if (hstat.res == 0) /* No read error */
1736         {
1737           if (hstat.contlen == -1)  /* We don't know how much we were supposed
1738                                        to get, so assume we succeeded. */
1739             {
1740               if (*dt & RETROKF)
1741                 {
1742                   logprintf (LOG_VERBOSE,
1743                              _("%s (%s) - `%s' saved [%ld]\n\n"),
1744                              tms, tmrate, locf, hstat.len);
1745                   logprintf (LOG_NONVERBOSE,
1746                              "%s URL:%s [%ld] -> \"%s\" [%d]\n",
1747                              tms, u->url, hstat.len, locf, count);
1748                 }
1749               ++opt.numurls;
1750               downloaded_increase (hstat.len);
1751
1752               /* Remember that we downloaded the file for later ".orig" code. */
1753               if (*dt & ADDED_HTML_EXTENSION)
1754                 downloaded_file(FILE_DOWNLOADED_AND_HTML_EXTENSION_ADDED, locf);
1755               else
1756                 downloaded_file(FILE_DOWNLOADED_NORMALLY, locf);
1757
1758               xfree (filename_plus_orig_suffix); /* must precede every return! */
1759               return RETROK;
1760             }
1761           else if (hstat.len < hstat.contlen) /* meaning we lost the
1762                                                  connection too soon */
1763             {
1764               logprintf (LOG_VERBOSE,
1765                          _("%s (%s) - Connection closed at byte %ld. "),
1766                          tms, tmrate, hstat.len);
1767               printwhat (count, opt.ntry);
1768               continue;
1769             }
1770           else if (!opt.kill_longer) /* meaning we got more than expected */
1771             {
1772               logprintf (LOG_VERBOSE,
1773                          _("%s (%s) - `%s' saved [%ld/%ld])\n\n"),
1774                          tms, tmrate, locf, hstat.len, hstat.contlen);
1775               logprintf (LOG_NONVERBOSE,
1776                          "%s URL:%s [%ld/%ld] -> \"%s\" [%d]\n",
1777                          tms, u->url, hstat.len, hstat.contlen, locf, count);
1778               ++opt.numurls;
1779               downloaded_increase (hstat.len);
1780
1781               /* Remember that we downloaded the file for later ".orig" code. */
1782               if (*dt & ADDED_HTML_EXTENSION)
1783                 downloaded_file(FILE_DOWNLOADED_AND_HTML_EXTENSION_ADDED, locf);
1784               else
1785                 downloaded_file(FILE_DOWNLOADED_NORMALLY, locf);
1786
1787               xfree (filename_plus_orig_suffix); /* must precede every return! */
1788               return RETROK;
1789             }
1790           else                  /* the same, but not accepted */
1791             {
1792               logprintf (LOG_VERBOSE,
1793                          _("%s (%s) - Connection closed at byte %ld/%ld. "),
1794                          tms, tmrate, hstat.len, hstat.contlen);
1795               printwhat (count, opt.ntry);
1796               continue;
1797             }
1798         }
1799       else                      /* now hstat.res can only be -1 */
1800         {
1801           if (hstat.contlen == -1)
1802             {
1803               logprintf (LOG_VERBOSE,
1804                          _("%s (%s) - Read error at byte %ld (%s)."),
1805                          tms, tmrate, hstat.len, strerror (errno));
1806               printwhat (count, opt.ntry);
1807               continue;
1808             }
1809           else                  /* hstat.res == -1 and contlen is given */
1810             {
1811               logprintf (LOG_VERBOSE,
1812                          _("%s (%s) - Read error at byte %ld/%ld (%s). "),
1813                          tms, tmrate, hstat.len, hstat.contlen,
1814                          strerror (errno));
1815               printwhat (count, opt.ntry);
1816               continue;
1817             }
1818         }
1819       /* not reached */
1820       break;
1821     }
1822   while (!opt.ntry || (count < opt.ntry));
1823   xfree (filename_plus_orig_suffix); /* must precede every return! */
1824   return TRYLIMEXC;
1825 }
1826 \f
1827 /* Converts struct tm to time_t, assuming the data in tm is UTC rather
1828    than local timezone (mktime assumes the latter).
1829
1830    Contributed by Roger Beeman <beeman@cisco.com>, with the help of
1831    Mark Baushke <mdb@cisco.com> and the rest of the Gurus at CISCO.  */
1832 static time_t
1833 mktime_from_utc (struct tm *t)
1834 {
1835   time_t tl, tb;
1836
1837   tl = mktime (t);
1838   if (tl == -1)
1839     return -1;
1840   tb = mktime (gmtime (&tl));
1841   return (tl <= tb ? (tl + (tl - tb)) : (tl - (tb - tl)));
1842 }
1843
1844 /* Check whether the result of strptime() indicates success.
1845    strptime() returns the pointer to how far it got to in the string.
1846    The processing has been successful if the string is at `GMT' or
1847    `+X', or at the end of the string.
1848
1849    In extended regexp parlance, the function returns 1 if P matches
1850    "^ *(GMT|[+-][0-9]|$)", 0 otherwise.  P being NULL (a valid result of
1851    strptime()) is considered a failure and 0 is returned.  */
1852 static int
1853 check_end (const char *p)
1854 {
1855   if (!p)
1856     return 0;
1857   while (ISSPACE (*p))
1858     ++p;
1859   if (!*p
1860       || (p[0] == 'G' && p[1] == 'M' && p[2] == 'T')
1861       || ((p[0] == '+' || p[0] == '-') && ISDIGIT (p[1])))
1862     return 1;
1863   else
1864     return 0;
1865 }
1866
1867 /* Convert TIME_STRING time to time_t.  TIME_STRING can be in any of
1868    the three formats RFC2068 allows the HTTP servers to emit --
1869    RFC1123-date, RFC850-date or asctime-date.  Timezones are ignored,
1870    and should be GMT.
1871
1872    We use strptime() to recognize various dates, which makes it a
1873    little bit slacker than the RFC1123/RFC850/asctime (e.g. it always
1874    allows shortened dates and months, one-digit days, etc.).  It also
1875    allows more than one space anywhere where the specs require one SP.
1876    The routine should probably be even more forgiving (as recommended
1877    by RFC2068), but I do not have the time to write one.
1878
1879    Return the computed time_t representation, or -1 if all the
1880    schemes fail.
1881
1882    Needless to say, what we *really* need here is something like
1883    Marcus Hennecke's atotm(), which is forgiving, fast, to-the-point,
1884    and does not use strptime().  atotm() is to be found in the sources
1885    of `phttpd', a little-known HTTP server written by Peter Erikson.  */
1886 time_t
1887 http_atotm (char *time_string)
1888 {
1889   struct tm t;
1890
1891   /* Roger Beeman says: "This function dynamically allocates struct tm
1892      t, but does no initialization.  The only field that actually
1893      needs initialization is tm_isdst, since the others will be set by
1894      strptime.  Since strptime does not set tm_isdst, it will return
1895      the data structure with whatever data was in tm_isdst to begin
1896      with.  For those of us in timezones where DST can occur, there
1897      can be a one hour shift depending on the previous contents of the
1898      data area where the data structure is allocated."  */
1899   t.tm_isdst = -1;
1900
1901   /* Note that under foreign locales Solaris strptime() fails to
1902      recognize English dates, which renders this function useless.  I
1903      assume that other non-GNU strptime's are plagued by the same
1904      disease.  We solve this by setting only LC_MESSAGES in
1905      i18n_initialize(), instead of LC_ALL.
1906
1907      Another solution could be to temporarily set locale to C, invoke
1908      strptime(), and restore it back.  This is slow and dirty,
1909      however, and locale support other than LC_MESSAGES can mess other
1910      things, so I rather chose to stick with just setting LC_MESSAGES.
1911
1912      Also note that none of this is necessary under GNU strptime(),
1913      because it recognizes both international and local dates.  */
1914
1915   /* NOTE: We don't use `%n' for white space, as OSF's strptime uses
1916      it to eat all white space up to (and including) a newline, and
1917      the function fails if there is no newline (!).
1918
1919      Let's hope all strptime() implementations use ` ' to skip *all*
1920      whitespace instead of just one (it works that way on all the
1921      systems I've tested it on).  */
1922
1923   /* RFC1123: Thu, 29 Jan 1998 22:12:57 */
1924   if (check_end (strptime (time_string, "%a, %d %b %Y %T", &t)))
1925     return mktime_from_utc (&t);
1926   /* RFC850:  Thursday, 29-Jan-98 22:12:57 */
1927   if (check_end (strptime (time_string, "%A, %d-%b-%y %T", &t)))
1928     return mktime_from_utc (&t);
1929   /* pseudo-RFC850:  Thu, 29-Jan-1998 22:12:57
1930      (google.com uses this for their cookies.)*/
1931   if (check_end (strptime (time_string, "%a, %d-%b-%Y %T", &t)))
1932     return mktime_from_utc (&t);
1933   /* asctime: Thu Jan 29 22:12:57 1998 */
1934   if (check_end (strptime (time_string, "%a %b %d %T %Y", &t)))
1935     return mktime_from_utc (&t);
1936   /* Failure.  */
1937   return -1;
1938 }
1939 \f
1940 /* Authorization support: We support two authorization schemes:
1941
1942    * `Basic' scheme, consisting of base64-ing USER:PASSWORD string;
1943
1944    * `Digest' scheme, added by Junio Hamano <junio@twinsun.com>,
1945    consisting of answering to the server's challenge with the proper
1946    MD5 digests.  */
1947
1948 /* How many bytes it will take to store LEN bytes in base64.  */
1949 #define BASE64_LENGTH(len) (4 * (((len) + 2) / 3))
1950
1951 /* Encode the string S of length LENGTH to base64 format and place it
1952    to STORE.  STORE will be 0-terminated, and must point to a writable
1953    buffer of at least 1+BASE64_LENGTH(length) bytes.  */
1954 static void
1955 base64_encode (const char *s, char *store, int length)
1956 {
1957   /* Conversion table.  */
1958   static char tbl[64] = {
1959     'A','B','C','D','E','F','G','H',
1960     'I','J','K','L','M','N','O','P',
1961     'Q','R','S','T','U','V','W','X',
1962     'Y','Z','a','b','c','d','e','f',
1963     'g','h','i','j','k','l','m','n',
1964     'o','p','q','r','s','t','u','v',
1965     'w','x','y','z','0','1','2','3',
1966     '4','5','6','7','8','9','+','/'
1967   };
1968   int i;
1969   unsigned char *p = (unsigned char *)store;
1970
1971   /* Transform the 3x8 bits to 4x6 bits, as required by base64.  */
1972   for (i = 0; i < length; i += 3)
1973     {
1974       *p++ = tbl[s[0] >> 2];
1975       *p++ = tbl[((s[0] & 3) << 4) + (s[1] >> 4)];
1976       *p++ = tbl[((s[1] & 0xf) << 2) + (s[2] >> 6)];
1977       *p++ = tbl[s[2] & 0x3f];
1978       s += 3;
1979     }
1980   /* Pad the result if necessary...  */
1981   if (i == length + 1)
1982     *(p - 1) = '=';
1983   else if (i == length + 2)
1984     *(p - 1) = *(p - 2) = '=';
1985   /* ...and zero-terminate it.  */
1986   *p = '\0';
1987 }
1988
1989 /* Create the authentication header contents for the `Basic' scheme.
1990    This is done by encoding the string `USER:PASS' in base64 and
1991    prepending `HEADER: Basic ' to it.  */
1992 static char *
1993 basic_authentication_encode (const char *user, const char *passwd,
1994                              const char *header)
1995 {
1996   char *t1, *t2, *res;
1997   int len1 = strlen (user) + 1 + strlen (passwd);
1998   int len2 = BASE64_LENGTH (len1);
1999
2000   t1 = (char *)alloca (len1 + 1);
2001   sprintf (t1, "%s:%s", user, passwd);
2002   t2 = (char *)alloca (1 + len2);
2003   base64_encode (t1, t2, len1);
2004   res = (char *)xmalloc (len2 + 11 + strlen (header));
2005   sprintf (res, "%s: Basic %s\r\n", header, t2);
2006
2007   return res;
2008 }
2009
2010 #ifdef USE_DIGEST
2011 /* Parse HTTP `WWW-Authenticate:' header.  AU points to the beginning
2012    of a field in such a header.  If the field is the one specified by
2013    ATTR_NAME ("realm", "opaque", and "nonce" are used by the current
2014    digest authorization code), extract its value in the (char*)
2015    variable pointed by RET.  Returns negative on a malformed header,
2016    or number of bytes that have been parsed by this call.  */
2017 static int
2018 extract_header_attr (const char *au, const char *attr_name, char **ret)
2019 {
2020   const char *cp, *ep;
2021
2022   ep = cp = au;
2023
2024   if (strncmp (cp, attr_name, strlen (attr_name)) == 0)
2025     {
2026       cp += strlen (attr_name);
2027       if (!*cp)
2028         return -1;
2029       cp += skip_lws (cp);
2030       if (*cp != '=')
2031         return -1;
2032       if (!*++cp)
2033         return -1;
2034       cp += skip_lws (cp);
2035       if (*cp != '\"')
2036         return -1;
2037       if (!*++cp)
2038         return -1;
2039       for (ep = cp; *ep && *ep != '\"'; ep++)
2040         ;
2041       if (!*ep)
2042         return -1;
2043       FREE_MAYBE (*ret);
2044       *ret = strdupdelim (cp, ep);
2045       return ep - au + 1;
2046     }
2047   else
2048     return 0;
2049 }
2050
2051 /* Dump the hexadecimal representation of HASH to BUF.  HASH should be
2052    an array of 16 bytes containing the hash keys, and BUF should be a
2053    buffer of 33 writable characters (32 for hex digits plus one for
2054    zero termination).  */
2055 static void
2056 dump_hash (unsigned char *buf, const unsigned char *hash)
2057 {
2058   int i;
2059
2060   for (i = 0; i < MD5_HASHLEN; i++, hash++)
2061     {
2062       *buf++ = XDIGIT_TO_xchar (*hash >> 4);
2063       *buf++ = XDIGIT_TO_xchar (*hash & 0xf);
2064     }
2065   *buf = '\0';
2066 }
2067
2068 /* Take the line apart to find the challenge, and compose a digest
2069    authorization header.  See RFC2069 section 2.1.2.  */
2070 char *
2071 digest_authentication_encode (const char *au, const char *user,
2072                               const char *passwd, const char *method,
2073                               const char *path)
2074 {
2075   static char *realm, *opaque, *nonce;
2076   static struct {
2077     const char *name;
2078     char **variable;
2079   } options[] = {
2080     { "realm", &realm },
2081     { "opaque", &opaque },
2082     { "nonce", &nonce }
2083   };
2084   char *res;
2085
2086   realm = opaque = nonce = NULL;
2087
2088   au += 6;                      /* skip over `Digest' */
2089   while (*au)
2090     {
2091       int i;
2092
2093       au += skip_lws (au);
2094       for (i = 0; i < ARRAY_SIZE (options); i++)
2095         {
2096           int skip = extract_header_attr (au, options[i].name,
2097                                           options[i].variable);
2098           if (skip < 0)
2099             {
2100               FREE_MAYBE (realm);
2101               FREE_MAYBE (opaque);
2102               FREE_MAYBE (nonce);
2103               return NULL;
2104             }
2105           else if (skip)
2106             {
2107               au += skip;
2108               break;
2109             }
2110         }
2111       if (i == ARRAY_SIZE (options))
2112         {
2113           while (*au && *au != '=')
2114             au++;
2115           if (*au && *++au)
2116             {
2117               au += skip_lws (au);
2118               if (*au == '\"')
2119                 {
2120                   au++;
2121                   while (*au && *au != '\"')
2122                     au++;
2123                   if (*au)
2124                     au++;
2125                 }
2126             }
2127         }
2128       while (*au && *au != ',')
2129         au++;
2130       if (*au)
2131         au++;
2132     }
2133   if (!realm || !nonce || !user || !passwd || !path || !method)
2134     {
2135       FREE_MAYBE (realm);
2136       FREE_MAYBE (opaque);
2137       FREE_MAYBE (nonce);
2138       return NULL;
2139     }
2140
2141   /* Calculate the digest value.  */
2142   {
2143     struct md5_ctx ctx;
2144     unsigned char hash[MD5_HASHLEN];
2145     unsigned char a1buf[MD5_HASHLEN * 2 + 1], a2buf[MD5_HASHLEN * 2 + 1];
2146     unsigned char response_digest[MD5_HASHLEN * 2 + 1];
2147
2148     /* A1BUF = H(user ":" realm ":" password) */
2149     md5_init_ctx (&ctx);
2150     md5_process_bytes (user, strlen (user), &ctx);
2151     md5_process_bytes (":", 1, &ctx);
2152     md5_process_bytes (realm, strlen (realm), &ctx);
2153     md5_process_bytes (":", 1, &ctx);
2154     md5_process_bytes (passwd, strlen (passwd), &ctx);
2155     md5_finish_ctx (&ctx, hash);
2156     dump_hash (a1buf, hash);
2157
2158     /* A2BUF = H(method ":" path) */
2159     md5_init_ctx (&ctx);
2160     md5_process_bytes (method, strlen (method), &ctx);
2161     md5_process_bytes (":", 1, &ctx);
2162     md5_process_bytes (path, strlen (path), &ctx);
2163     md5_finish_ctx (&ctx, hash);
2164     dump_hash (a2buf, hash);
2165
2166     /* RESPONSE_DIGEST = H(A1BUF ":" nonce ":" A2BUF) */
2167     md5_init_ctx (&ctx);
2168     md5_process_bytes (a1buf, MD5_HASHLEN * 2, &ctx);
2169     md5_process_bytes (":", 1, &ctx);
2170     md5_process_bytes (nonce, strlen (nonce), &ctx);
2171     md5_process_bytes (":", 1, &ctx);
2172     md5_process_bytes (a2buf, MD5_HASHLEN * 2, &ctx);
2173     md5_finish_ctx (&ctx, hash);
2174     dump_hash (response_digest, hash);
2175
2176     res = (char*) xmalloc (strlen (user)
2177                            + strlen (user)
2178                            + strlen (realm)
2179                            + strlen (nonce)
2180                            + strlen (path)
2181                            + 2 * MD5_HASHLEN /*strlen (response_digest)*/
2182                            + (opaque ? strlen (opaque) : 0)
2183                            + 128);
2184     sprintf (res, "Authorization: Digest \
2185 username=\"%s\", realm=\"%s\", nonce=\"%s\", uri=\"%s\", response=\"%s\"",
2186              user, realm, nonce, path, response_digest);
2187     if (opaque)
2188       {
2189         char *p = res + strlen (res);
2190         strcat (p, ", opaque=\"");
2191         strcat (p, opaque);
2192         strcat (p, "\"");
2193       }
2194     strcat (res, "\r\n");
2195   }
2196   return res;
2197 }
2198 #endif /* USE_DIGEST */
2199
2200
2201 #define BEGINS_WITH(line, string_constant)                              \
2202   (!strncasecmp (line, string_constant, sizeof (string_constant) - 1)   \
2203    && (ISSPACE (line[sizeof (string_constant) - 1])                     \
2204        || !line[sizeof (string_constant) - 1]))
2205
2206 static int
2207 known_authentication_scheme_p (const char *au)
2208 {
2209   return BEGINS_WITH (au, "Basic")
2210     || BEGINS_WITH (au, "Digest")
2211     || BEGINS_WITH (au, "NTLM");
2212 }
2213
2214 #undef BEGINS_WITH
2215
2216 /* Create the HTTP authorization request header.  When the
2217    `WWW-Authenticate' response header is seen, according to the
2218    authorization scheme specified in that header (`Basic' and `Digest'
2219    are supported by the current implementation), produce an
2220    appropriate HTTP authorization request header.  */
2221 static char *
2222 create_authorization_line (const char *au, const char *user,
2223                            const char *passwd, const char *method,
2224                            const char *path)
2225 {
2226   char *wwwauth = NULL;
2227
2228   if (!strncasecmp (au, "Basic", 5))
2229     wwwauth = basic_authentication_encode (user, passwd, "Authorization");
2230   if (!strncasecmp (au, "NTLM", 4))
2231     wwwauth = basic_authentication_encode (user, passwd, "Authorization");
2232 #ifdef USE_DIGEST
2233   else if (!strncasecmp (au, "Digest", 6))
2234     wwwauth = digest_authentication_encode (au, user, passwd, method, path);
2235 #endif /* USE_DIGEST */
2236   return wwwauth;
2237 }