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