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