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
1174     The server does not support continued download;
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       fp = opt.dfp;
1289       if (!hs->restval)
1290         {
1291           /* This will silently fail for streams that don't correspond
1292              to regular files, but that's OK.  */
1293           rewind (fp);
1294           clearerr (fp);
1295         }
1296     }
1297
1298   /* #### This confuses the code that checks for file size.  There
1299      should be some overhead information.  */
1300   if (opt.save_headers)
1301     fwrite (all_headers, 1, all_length, fp);
1302   reset_timer ();
1303   /* Get the contents of the document.  */
1304   hs->res = get_contents (sock, fp, &hs->len, hs->restval,
1305                           (contlen != -1 ? contlen : 0),
1306                           &rbuf, keep_alive);
1307   hs->dltime = elapsed_time ();
1308   {
1309     /* Close or flush the file.  We have to be careful to check for
1310        error here.  Checking the result of fwrite() is not enough --
1311        errors could go unnoticed!  */
1312     int flush_res;
1313     if (!opt.dfp)
1314       flush_res = fclose (fp);
1315     else
1316       flush_res = fflush (fp);
1317     if (flush_res == EOF)
1318       hs->res = -2;
1319   }
1320   FREE_MAYBE (all_headers);
1321   CLOSE_FINISH (sock);
1322   if (hs->res == -2)
1323     return FWRITEERR;
1324   return RETRFINISHED;
1325 }
1326
1327 /* The genuine HTTP loop!  This is the part where the retrieval is
1328    retried, and retried, and retried, and...  */
1329 uerr_t
1330 http_loop (struct urlinfo *u, char **newloc, int *dt)
1331 {
1332   int count;
1333   int use_ts, got_head = 0;     /* time-stamping info */
1334   char *filename_plus_orig_suffix;
1335   char *local_filename = NULL;
1336   char *tms, *suf, *locf, *tmrate;
1337   uerr_t err;
1338   time_t tml = -1, tmr = -1;    /* local and remote time-stamps */
1339   long local_size = 0;          /* the size of the local file */
1340   size_t filename_len;
1341   struct http_stat hstat;       /* HTTP status */
1342   struct stat st;
1343
1344   *newloc = NULL;
1345
1346   /* Warn on (likely bogus) wildcard usage in HTTP.  Don't use
1347      has_wildcards_p because it would also warn on `?', and we know that
1348      shows up in CGI paths a *lot*.  */
1349   if (strchr (u->url, '*'))
1350     logputs (LOG_VERBOSE, _("Warning: wildcards not supported in HTTP.\n"));
1351
1352   /* Determine the local filename.  */
1353   if (!u->local)
1354     u->local = url_filename (u->proxy ? u->proxy : u);
1355
1356   if (!opt.output_document)
1357     locf = u->local;
1358   else
1359     locf = opt.output_document;
1360
1361   /* Yuck.  Multiple returns suck.  We need to remember to free() the space we
1362      xmalloc() here before EACH return.  This is one reason it's better to set
1363      flags that influence flow control and then return once at the end. */
1364   filename_len = strlen(u->local);
1365   filename_plus_orig_suffix = xmalloc(filename_len + sizeof(".orig"));
1366
1367   if (opt.noclobber && file_exists_p (u->local))
1368     {
1369       /* If opt.noclobber is turned on and file already exists, do not
1370          retrieve the file */
1371       logprintf (LOG_VERBOSE, _("\
1372 File `%s' already there, will not retrieve.\n"), u->local);
1373       /* If the file is there, we suppose it's retrieved OK.  */
1374       *dt |= RETROKF;
1375
1376       /* #### Bogusness alert.  */
1377       /* If its suffix is "html" or (yuck!) "htm", we suppose it's
1378          text/html, a harmless lie.  */
1379       if (((suf = suffix (u->local)) != NULL)
1380           && (!strcmp (suf, "html") || !strcmp (suf, "htm")))
1381         *dt |= TEXTHTML;
1382       xfree (suf);
1383       xfree (filename_plus_orig_suffix); /* must precede every return! */
1384       /* Another harmless lie: */
1385       return RETROK;
1386     }
1387
1388   use_ts = 0;
1389   if (opt.timestamping)
1390     {
1391       boolean  local_dot_orig_file_exists = FALSE;
1392
1393       if (opt.backup_converted)
1394         /* If -K is specified, we'll act on the assumption that it was specified
1395            last time these files were downloaded as well, and instead of just
1396            comparing local file X against server file X, we'll compare local
1397            file X.orig (if extant, else X) against server file X.  If -K
1398            _wasn't_ specified last time, or the server contains files called
1399            *.orig, -N will be back to not operating correctly with -k. */
1400         {
1401           /* Would a single s[n]printf() call be faster?  --dan
1402
1403              Definitely not.  sprintf() is horribly slow.  It's a
1404              different question whether the difference between the two
1405              affects a program.  Usually I'd say "no", but at one
1406              point I profiled Wget, and found that a measurable and
1407              non-negligible amount of time was lost calling sprintf()
1408              in url.c.  Replacing sprintf with inline calls to
1409              strcpy() and long_to_string() made a difference.
1410              --hniksic */
1411           strcpy(filename_plus_orig_suffix, u->local);
1412           strcpy(filename_plus_orig_suffix + filename_len, ".orig");
1413
1414           /* Try to stat() the .orig file. */
1415           if (stat(filename_plus_orig_suffix, &st) == 0)
1416             {
1417               local_dot_orig_file_exists = TRUE;
1418               local_filename = filename_plus_orig_suffix;
1419             }
1420         }
1421
1422       if (!local_dot_orig_file_exists)
1423         /* Couldn't stat() <file>.orig, so try to stat() <file>. */
1424         if (stat (u->local, &st) == 0)
1425           local_filename = u->local;
1426
1427       if (local_filename != NULL)
1428         /* There was a local file, so we'll check later to see if the version
1429            the server has is the same version we already have, allowing us to
1430            skip a download. */
1431         {
1432           use_ts = 1;
1433           tml = st.st_mtime;
1434           local_size = st.st_size;
1435           got_head = 0;
1436         }
1437     }
1438   /* Reset the counter.  */
1439   count = 0;
1440   *dt = 0 | ACCEPTRANGES;
1441   /* THE loop */
1442   do
1443     {
1444       /* Increment the pass counter.  */
1445       ++count;
1446       sleep_between_retrievals (count);
1447       /* Get the current time string.  */
1448       tms = time_str (NULL);
1449       /* Print fetch message, if opt.verbose.  */
1450       if (opt.verbose)
1451         {
1452           char *hurl = str_url (u->proxy ? u->proxy : u, 1);
1453           char tmp[15];
1454           strcpy (tmp, "        ");
1455           if (count > 1)
1456             sprintf (tmp, _("(try:%2d)"), count);
1457           logprintf (LOG_VERBOSE, "--%s--  %s\n  %s => `%s'\n",
1458                      tms, hurl, tmp, locf);
1459 #ifdef WINDOWS
1460           ws_changetitle (hurl, 1);
1461 #endif
1462           xfree (hurl);
1463         }
1464
1465       /* Default document type is empty.  However, if spider mode is
1466          on or time-stamping is employed, HEAD_ONLY commands is
1467          encoded within *dt.  */
1468       if (opt.spider || (use_ts && !got_head))
1469         *dt |= HEAD_ONLY;
1470       else
1471         *dt &= ~HEAD_ONLY;
1472       /* Assume no restarting.  */
1473       hstat.restval = 0L;
1474       /* Decide whether or not to restart.  */
1475       if (((count > 1 && (*dt & ACCEPTRANGES)) || opt.always_rest)
1476           && file_exists_p (u->local))
1477         if (stat (u->local, &st) == 0)
1478           hstat.restval = st.st_size;
1479       /* Decide whether to send the no-cache directive.  */
1480       if (u->proxy && (count > 1 || (opt.proxy_cache == 0)))
1481         *dt |= SEND_NOCACHE;
1482       else
1483         *dt &= ~SEND_NOCACHE;
1484
1485       /* Try fetching the document, or at least its head.  :-) */
1486       err = gethttp (u, &hstat, dt);
1487
1488       /* It's unfortunate that wget determines the local filename before finding
1489          out the Content-Type of the file.  Barring a major restructuring of the
1490          code, we need to re-set locf here, since gethttp() may have xrealloc()d
1491          u->local to tack on ".html". */
1492       if (!opt.output_document)
1493         locf = u->local;
1494       else
1495         locf = opt.output_document;
1496
1497       /* In `-c' is used, check whether the file we're writing to
1498          exists before we've done anything.  If so, we'll refuse to
1499          truncate it if the server doesn't support continued
1500          downloads.  */
1501       if (opt.always_rest)
1502         hstat.no_truncate = file_exists_p (locf);
1503
1504       /* Time?  */
1505       tms = time_str (NULL);
1506       /* Get the new location (with or without the redirection).  */
1507       if (hstat.newloc)
1508         *newloc = xstrdup (hstat.newloc);
1509       switch (err)
1510         {
1511         case HERR: case HEOF: case CONSOCKERR: case CONCLOSED:
1512         case CONERROR: case READERR: case WRITEFAILED:
1513         case RANGEERR:
1514           /* Non-fatal errors continue executing the loop, which will
1515              bring them to "while" statement at the end, to judge
1516              whether the number of tries was exceeded.  */
1517           FREEHSTAT (hstat);
1518           printwhat (count, opt.ntry);
1519           continue;
1520           break;
1521         case HOSTERR: case CONREFUSED: case PROXERR: case AUTHFAILED:
1522         case SSLERRCTXCREATE: case CONTNOTSUPPORTED:
1523           /* Fatal errors just return from the function.  */
1524           FREEHSTAT (hstat);
1525           xfree (filename_plus_orig_suffix); /* must precede every return! */
1526           return err;
1527           break;
1528         case FWRITEERR: case FOPENERR:
1529           /* Another fatal error.  */
1530           logputs (LOG_VERBOSE, "\n");
1531           logprintf (LOG_NOTQUIET, _("Cannot write to `%s' (%s).\n"),
1532                      u->local, strerror (errno));
1533           FREEHSTAT (hstat);
1534           return err;
1535           break;
1536         case CONSSLERR:
1537           /* Another fatal error.  */
1538           logputs (LOG_VERBOSE, "\n");
1539           logprintf (LOG_NOTQUIET, _("Unable to establish SSL connection.\n"));
1540           FREEHSTAT (hstat);
1541           xfree (filename_plus_orig_suffix); /* must precede every return! */
1542           return err;
1543           break;
1544         case NEWLOCATION:
1545           /* Return the new location to the caller.  */
1546           if (!hstat.newloc)
1547             {
1548               logprintf (LOG_NOTQUIET,
1549                          _("ERROR: Redirection (%d) without location.\n"),
1550                          hstat.statcode);
1551               xfree (filename_plus_orig_suffix); /* must precede every return! */
1552               return WRONGCODE;
1553             }
1554           FREEHSTAT (hstat);
1555           xfree (filename_plus_orig_suffix); /* must precede every return! */
1556           return NEWLOCATION;
1557           break;
1558         case RETRFINISHED:
1559           /* Deal with you later.  */
1560           break;
1561         default:
1562           /* All possibilities should have been exhausted.  */
1563           abort ();
1564         }
1565       if (!(*dt & RETROKF))
1566         {
1567           if (!opt.verbose)
1568             {
1569               /* #### Ugly ugly ugly! */
1570               char *hurl = str_url (u->proxy ? u->proxy : u, 1);
1571               logprintf (LOG_NONVERBOSE, "%s:\n", hurl);
1572               xfree (hurl);
1573             }
1574           logprintf (LOG_NOTQUIET, _("%s ERROR %d: %s.\n"),
1575                      tms, hstat.statcode, hstat.error);
1576           logputs (LOG_VERBOSE, "\n");
1577           FREEHSTAT (hstat);
1578           xfree (filename_plus_orig_suffix); /* must precede every return! */
1579           return WRONGCODE;
1580         }
1581
1582       /* Did we get the time-stamp?  */
1583       if (!got_head)
1584         {
1585           if (opt.timestamping && !hstat.remote_time)
1586             {
1587               logputs (LOG_NOTQUIET, _("\
1588 Last-modified header missing -- time-stamps turned off.\n"));
1589             }
1590           else if (hstat.remote_time)
1591             {
1592               /* Convert the date-string into struct tm.  */
1593               tmr = http_atotm (hstat.remote_time);
1594               if (tmr == (time_t) (-1))
1595                 logputs (LOG_VERBOSE, _("\
1596 Last-modified header invalid -- time-stamp ignored.\n"));
1597             }
1598         }
1599
1600       /* The time-stamping section.  */
1601       if (use_ts)
1602         {
1603           got_head = 1;
1604           *dt &= ~HEAD_ONLY;
1605           use_ts = 0;           /* no more time-stamping */
1606           count = 0;            /* the retrieve count for HEAD is
1607                                    reset */
1608           if (hstat.remote_time && tmr != (time_t) (-1))
1609             {
1610               /* Now time-stamping can be used validly.  Time-stamping
1611                  means that if the sizes of the local and remote file
1612                  match, and local file is newer than the remote file,
1613                  it will not be retrieved.  Otherwise, the normal
1614                  download procedure is resumed.  */
1615               if (tml >= tmr &&
1616                   (hstat.contlen == -1 || local_size == hstat.contlen))
1617                 {
1618                   logprintf (LOG_VERBOSE, _("\
1619 Server file no newer than local file `%s' -- not retrieving.\n\n"),
1620                              local_filename);
1621                   FREEHSTAT (hstat);
1622                   xfree (filename_plus_orig_suffix); /*must precede every return!*/
1623                   return RETROK;
1624                 }
1625               else if (tml >= tmr)
1626                 logprintf (LOG_VERBOSE, _("\
1627 The sizes do not match (local %ld) -- retrieving.\n"), local_size);
1628               else
1629                 logputs (LOG_VERBOSE,
1630                          _("Remote file is newer, retrieving.\n"));
1631             }
1632           FREEHSTAT (hstat);
1633           continue;
1634         }
1635       if ((tmr != (time_t) (-1))
1636           && !opt.spider
1637           && ((hstat.len == hstat.contlen) ||
1638               ((hstat.res == 0) &&
1639                ((hstat.contlen == -1) ||
1640                 (hstat.len >= hstat.contlen && !opt.kill_longer)))))
1641         {
1642           /* #### This code repeats in http.c and ftp.c.  Move it to a
1643              function!  */
1644           const char *fl = NULL;
1645           if (opt.output_document)
1646             {
1647               if (opt.od_known_regular)
1648                 fl = opt.output_document;
1649             }
1650           else
1651             fl = u->local;
1652           if (fl)
1653             touch (fl, tmr);
1654         }
1655       /* End of time-stamping section.  */
1656
1657       if (opt.spider)
1658         {
1659           logprintf (LOG_NOTQUIET, "%d %s\n\n", hstat.statcode, hstat.error);
1660           xfree (filename_plus_orig_suffix); /* must precede every return! */
1661           return RETROK;
1662         }
1663
1664       /* It is now safe to free the remainder of hstat, since the
1665          strings within it will no longer be used.  */
1666       FREEHSTAT (hstat);
1667
1668       tmrate = rate (hstat.len - hstat.restval, hstat.dltime, 0);
1669
1670       if (hstat.len == hstat.contlen)
1671         {
1672           if (*dt & RETROKF)
1673             {
1674               logprintf (LOG_VERBOSE,
1675                          _("%s (%s) - `%s' saved [%ld/%ld]\n\n"),
1676                          tms, tmrate, locf, hstat.len, hstat.contlen);
1677               logprintf (LOG_NONVERBOSE,
1678                          "%s URL:%s [%ld/%ld] -> \"%s\" [%d]\n",
1679                          tms, u->url, hstat.len, hstat.contlen, locf, count);
1680             }
1681           ++opt.numurls;
1682           downloaded_increase (hstat.len);
1683
1684           /* Remember that we downloaded the file for later ".orig" code. */
1685           if (*dt & ADDED_HTML_EXTENSION)
1686             downloaded_file(FILE_DOWNLOADED_AND_HTML_EXTENSION_ADDED, locf);
1687           else
1688             downloaded_file(FILE_DOWNLOADED_NORMALLY, locf);
1689
1690           xfree(filename_plus_orig_suffix); /* must precede every return! */
1691           return RETROK;
1692         }
1693       else if (hstat.res == 0) /* No read error */
1694         {
1695           if (hstat.contlen == -1)  /* We don't know how much we were supposed
1696                                        to get, so assume we succeeded. */
1697             {
1698               if (*dt & RETROKF)
1699                 {
1700                   logprintf (LOG_VERBOSE,
1701                              _("%s (%s) - `%s' saved [%ld]\n\n"),
1702                              tms, tmrate, locf, hstat.len);
1703                   logprintf (LOG_NONVERBOSE,
1704                              "%s URL:%s [%ld] -> \"%s\" [%d]\n",
1705                              tms, u->url, hstat.len, locf, count);
1706                 }
1707               ++opt.numurls;
1708               downloaded_increase (hstat.len);
1709
1710               /* Remember that we downloaded the file for later ".orig" code. */
1711               if (*dt & ADDED_HTML_EXTENSION)
1712                 downloaded_file(FILE_DOWNLOADED_AND_HTML_EXTENSION_ADDED, locf);
1713               else
1714                 downloaded_file(FILE_DOWNLOADED_NORMALLY, locf);
1715
1716               xfree (filename_plus_orig_suffix); /* must precede every return! */
1717               return RETROK;
1718             }
1719           else if (hstat.len < hstat.contlen) /* meaning we lost the
1720                                                  connection too soon */
1721             {
1722               logprintf (LOG_VERBOSE,
1723                          _("%s (%s) - Connection closed at byte %ld. "),
1724                          tms, tmrate, hstat.len);
1725               printwhat (count, opt.ntry);
1726               continue;
1727             }
1728           else if (!opt.kill_longer) /* meaning we got more than expected */
1729             {
1730               logprintf (LOG_VERBOSE,
1731                          _("%s (%s) - `%s' saved [%ld/%ld])\n\n"),
1732                          tms, tmrate, locf, hstat.len, hstat.contlen);
1733               logprintf (LOG_NONVERBOSE,
1734                          "%s URL:%s [%ld/%ld] -> \"%s\" [%d]\n",
1735                          tms, u->url, hstat.len, hstat.contlen, locf, count);
1736               ++opt.numurls;
1737               downloaded_increase (hstat.len);
1738
1739               /* Remember that we downloaded the file for later ".orig" code. */
1740               if (*dt & ADDED_HTML_EXTENSION)
1741                 downloaded_file(FILE_DOWNLOADED_AND_HTML_EXTENSION_ADDED, locf);
1742               else
1743                 downloaded_file(FILE_DOWNLOADED_NORMALLY, locf);
1744
1745               xfree (filename_plus_orig_suffix); /* must precede every return! */
1746               return RETROK;
1747             }
1748           else                  /* the same, but not accepted */
1749             {
1750               logprintf (LOG_VERBOSE,
1751                          _("%s (%s) - Connection closed at byte %ld/%ld. "),
1752                          tms, tmrate, hstat.len, hstat.contlen);
1753               printwhat (count, opt.ntry);
1754               continue;
1755             }
1756         }
1757       else                      /* now hstat.res can only be -1 */
1758         {
1759           if (hstat.contlen == -1)
1760             {
1761               logprintf (LOG_VERBOSE,
1762                          _("%s (%s) - Read error at byte %ld (%s)."),
1763                          tms, tmrate, hstat.len, strerror (errno));
1764               printwhat (count, opt.ntry);
1765               continue;
1766             }
1767           else                  /* hstat.res == -1 and contlen is given */
1768             {
1769               logprintf (LOG_VERBOSE,
1770                          _("%s (%s) - Read error at byte %ld/%ld (%s). "),
1771                          tms, tmrate, hstat.len, hstat.contlen,
1772                          strerror (errno));
1773               printwhat (count, opt.ntry);
1774               continue;
1775             }
1776         }
1777       /* not reached */
1778       break;
1779     }
1780   while (!opt.ntry || (count < opt.ntry));
1781   xfree (filename_plus_orig_suffix); /* must precede every return! */
1782   return TRYLIMEXC;
1783 }
1784 \f
1785 /* Converts struct tm to time_t, assuming the data in tm is UTC rather
1786    than local timezone (mktime assumes the latter).
1787
1788    Contributed by Roger Beeman <beeman@cisco.com>, with the help of
1789    Mark Baushke <mdb@cisco.com> and the rest of the Gurus at CISCO.  */
1790 static time_t
1791 mktime_from_utc (struct tm *t)
1792 {
1793   time_t tl, tb;
1794
1795   tl = mktime (t);
1796   if (tl == -1)
1797     return -1;
1798   tb = mktime (gmtime (&tl));
1799   return (tl <= tb ? (tl + (tl - tb)) : (tl - (tb - tl)));
1800 }
1801
1802 /* Check whether the result of strptime() indicates success.
1803    strptime() returns the pointer to how far it got to in the string.
1804    The processing has been successful if the string is at `GMT' or
1805    `+X', or at the end of the string.
1806
1807    In extended regexp parlance, the function returns 1 if P matches
1808    "^ *(GMT|[+-][0-9]|$)", 0 otherwise.  P being NULL (a valid result of
1809    strptime()) is considered a failure and 0 is returned.  */
1810 static int
1811 check_end (const char *p)
1812 {
1813   if (!p)
1814     return 0;
1815   while (ISSPACE (*p))
1816     ++p;
1817   if (!*p
1818       || (p[0] == 'G' && p[1] == 'M' && p[2] == 'T')
1819       || ((p[0] == '+' || p[0] == '-') && ISDIGIT (p[1])))
1820     return 1;
1821   else
1822     return 0;
1823 }
1824
1825 /* Convert TIME_STRING time to time_t.  TIME_STRING can be in any of
1826    the three formats RFC2068 allows the HTTP servers to emit --
1827    RFC1123-date, RFC850-date or asctime-date.  Timezones are ignored,
1828    and should be GMT.
1829
1830    We use strptime() to recognize various dates, which makes it a
1831    little bit slacker than the RFC1123/RFC850/asctime (e.g. it always
1832    allows shortened dates and months, one-digit days, etc.).  It also
1833    allows more than one space anywhere where the specs require one SP.
1834    The routine should probably be even more forgiving (as recommended
1835    by RFC2068), but I do not have the time to write one.
1836
1837    Return the computed time_t representation, or -1 if all the
1838    schemes fail.
1839
1840    Needless to say, what we *really* need here is something like
1841    Marcus Hennecke's atotm(), which is forgiving, fast, to-the-point,
1842    and does not use strptime().  atotm() is to be found in the sources
1843    of `phttpd', a little-known HTTP server written by Peter Erikson.  */
1844 static time_t
1845 http_atotm (char *time_string)
1846 {
1847   struct tm t;
1848
1849   /* Roger Beeman says: "This function dynamically allocates struct tm
1850      t, but does no initialization.  The only field that actually
1851      needs initialization is tm_isdst, since the others will be set by
1852      strptime.  Since strptime does not set tm_isdst, it will return
1853      the data structure with whatever data was in tm_isdst to begin
1854      with.  For those of us in timezones where DST can occur, there
1855      can be a one hour shift depending on the previous contents of the
1856      data area where the data structure is allocated."  */
1857   t.tm_isdst = -1;
1858
1859   /* Note that under foreign locales Solaris strptime() fails to
1860      recognize English dates, which renders this function useless.  I
1861      assume that other non-GNU strptime's are plagued by the same
1862      disease.  We solve this by setting only LC_MESSAGES in
1863      i18n_initialize(), instead of LC_ALL.
1864
1865      Another solution could be to temporarily set locale to C, invoke
1866      strptime(), and restore it back.  This is slow and dirty,
1867      however, and locale support other than LC_MESSAGES can mess other
1868      things, so I rather chose to stick with just setting LC_MESSAGES.
1869
1870      Also note that none of this is necessary under GNU strptime(),
1871      because it recognizes both international and local dates.  */
1872
1873   /* NOTE: We don't use `%n' for white space, as OSF's strptime uses
1874      it to eat all white space up to (and including) a newline, and
1875      the function fails if there is no newline (!).
1876
1877      Let's hope all strptime() implementations use ` ' to skip *all*
1878      whitespace instead of just one (it works that way on all the
1879      systems I've tested it on).  */
1880
1881   /* RFC1123: Thu, 29 Jan 1998 22:12:57 */
1882   if (check_end (strptime (time_string, "%a, %d %b %Y %T", &t)))
1883     return mktime_from_utc (&t);
1884   /* RFC850:  Thu, 29-Jan-98 22:12:57 */
1885   if (check_end (strptime (time_string, "%a, %d-%b-%y %T", &t)))
1886     return mktime_from_utc (&t);
1887   /* asctime: Thu Jan 29 22:12:57 1998 */
1888   if (check_end (strptime (time_string, "%a %b %d %T %Y", &t)))
1889     return mktime_from_utc (&t);
1890   /* Failure.  */
1891   return -1;
1892 }
1893 \f
1894 /* Authorization support: We support two authorization schemes:
1895
1896    * `Basic' scheme, consisting of base64-ing USER:PASSWORD string;
1897
1898    * `Digest' scheme, added by Junio Hamano <junio@twinsun.com>,
1899    consisting of answering to the server's challenge with the proper
1900    MD5 digests.  */
1901
1902 /* How many bytes it will take to store LEN bytes in base64.  */
1903 #define BASE64_LENGTH(len) (4 * (((len) + 2) / 3))
1904
1905 /* Encode the string S of length LENGTH to base64 format and place it
1906    to STORE.  STORE will be 0-terminated, and must point to a writable
1907    buffer of at least 1+BASE64_LENGTH(length) bytes.  */
1908 static void
1909 base64_encode (const char *s, char *store, int length)
1910 {
1911   /* Conversion table.  */
1912   static char tbl[64] = {
1913     'A','B','C','D','E','F','G','H',
1914     'I','J','K','L','M','N','O','P',
1915     'Q','R','S','T','U','V','W','X',
1916     'Y','Z','a','b','c','d','e','f',
1917     'g','h','i','j','k','l','m','n',
1918     'o','p','q','r','s','t','u','v',
1919     'w','x','y','z','0','1','2','3',
1920     '4','5','6','7','8','9','+','/'
1921   };
1922   int i;
1923   unsigned char *p = (unsigned char *)store;
1924
1925   /* Transform the 3x8 bits to 4x6 bits, as required by base64.  */
1926   for (i = 0; i < length; i += 3)
1927     {
1928       *p++ = tbl[s[0] >> 2];
1929       *p++ = tbl[((s[0] & 3) << 4) + (s[1] >> 4)];
1930       *p++ = tbl[((s[1] & 0xf) << 2) + (s[2] >> 6)];
1931       *p++ = tbl[s[2] & 0x3f];
1932       s += 3;
1933     }
1934   /* Pad the result if necessary...  */
1935   if (i == length + 1)
1936     *(p - 1) = '=';
1937   else if (i == length + 2)
1938     *(p - 1) = *(p - 2) = '=';
1939   /* ...and zero-terminate it.  */
1940   *p = '\0';
1941 }
1942
1943 /* Create the authentication header contents for the `Basic' scheme.
1944    This is done by encoding the string `USER:PASS' in base64 and
1945    prepending `HEADER: Basic ' to it.  */
1946 static char *
1947 basic_authentication_encode (const char *user, const char *passwd,
1948                              const char *header)
1949 {
1950   char *t1, *t2, *res;
1951   int len1 = strlen (user) + 1 + strlen (passwd);
1952   int len2 = BASE64_LENGTH (len1);
1953
1954   t1 = (char *)alloca (len1 + 1);
1955   sprintf (t1, "%s:%s", user, passwd);
1956   t2 = (char *)alloca (1 + len2);
1957   base64_encode (t1, t2, len1);
1958   res = (char *)xmalloc (len2 + 11 + strlen (header));
1959   sprintf (res, "%s: Basic %s\r\n", header, t2);
1960
1961   return res;
1962 }
1963
1964 #ifdef USE_DIGEST
1965 /* Parse HTTP `WWW-Authenticate:' header.  AU points to the beginning
1966    of a field in such a header.  If the field is the one specified by
1967    ATTR_NAME ("realm", "opaque", and "nonce" are used by the current
1968    digest authorization code), extract its value in the (char*)
1969    variable pointed by RET.  Returns negative on a malformed header,
1970    or number of bytes that have been parsed by this call.  */
1971 static int
1972 extract_header_attr (const char *au, const char *attr_name, char **ret)
1973 {
1974   const char *cp, *ep;
1975
1976   ep = cp = au;
1977
1978   if (strncmp (cp, attr_name, strlen (attr_name)) == 0)
1979     {
1980       cp += strlen (attr_name);
1981       if (!*cp)
1982         return -1;
1983       cp += skip_lws (cp);
1984       if (*cp != '=')
1985         return -1;
1986       if (!*++cp)
1987         return -1;
1988       cp += skip_lws (cp);
1989       if (*cp != '\"')
1990         return -1;
1991       if (!*++cp)
1992         return -1;
1993       for (ep = cp; *ep && *ep != '\"'; ep++)
1994         ;
1995       if (!*ep)
1996         return -1;
1997       FREE_MAYBE (*ret);
1998       *ret = strdupdelim (cp, ep);
1999       return ep - au + 1;
2000     }
2001   else
2002     return 0;
2003 }
2004
2005 /* Response value needs to be in lowercase, so we cannot use HEXD2ASC
2006    from url.h.  See RFC 2069 2.1.2 for the syntax of response-digest.  */
2007 #define HEXD2asc(x) (((x) < 10) ? ((x) + '0') : ((x) - 10 + 'a'))
2008
2009 /* Dump the hexadecimal representation of HASH to BUF.  HASH should be
2010    an array of 16 bytes containing the hash keys, and BUF should be a
2011    buffer of 33 writable characters (32 for hex digits plus one for
2012    zero termination).  */
2013 static void
2014 dump_hash (unsigned char *buf, const unsigned char *hash)
2015 {
2016   int i;
2017
2018   for (i = 0; i < MD5_HASHLEN; i++, hash++)
2019     {
2020       *buf++ = HEXD2asc (*hash >> 4);
2021       *buf++ = HEXD2asc (*hash & 0xf);
2022     }
2023   *buf = '\0';
2024 }
2025
2026 /* Take the line apart to find the challenge, and compose a digest
2027    authorization header.  See RFC2069 section 2.1.2.  */
2028 char *
2029 digest_authentication_encode (const char *au, const char *user,
2030                               const char *passwd, const char *method,
2031                               const char *path)
2032 {
2033   static char *realm, *opaque, *nonce;
2034   static struct {
2035     const char *name;
2036     char **variable;
2037   } options[] = {
2038     { "realm", &realm },
2039     { "opaque", &opaque },
2040     { "nonce", &nonce }
2041   };
2042   char *res;
2043
2044   realm = opaque = nonce = NULL;
2045
2046   au += 6;                      /* skip over `Digest' */
2047   while (*au)
2048     {
2049       int i;
2050
2051       au += skip_lws (au);
2052       for (i = 0; i < ARRAY_SIZE (options); i++)
2053         {
2054           int skip = extract_header_attr (au, options[i].name,
2055                                           options[i].variable);
2056           if (skip < 0)
2057             {
2058               FREE_MAYBE (realm);
2059               FREE_MAYBE (opaque);
2060               FREE_MAYBE (nonce);
2061               return NULL;
2062             }
2063           else if (skip)
2064             {
2065               au += skip;
2066               break;
2067             }
2068         }
2069       if (i == ARRAY_SIZE (options))
2070         {
2071           while (*au && *au != '=')
2072             au++;
2073           if (*au && *++au)
2074             {
2075               au += skip_lws (au);
2076               if (*au == '\"')
2077                 {
2078                   au++;
2079                   while (*au && *au != '\"')
2080                     au++;
2081                   if (*au)
2082                     au++;
2083                 }
2084             }
2085         }
2086       while (*au && *au != ',')
2087         au++;
2088       if (*au)
2089         au++;
2090     }
2091   if (!realm || !nonce || !user || !passwd || !path || !method)
2092     {
2093       FREE_MAYBE (realm);
2094       FREE_MAYBE (opaque);
2095       FREE_MAYBE (nonce);
2096       return NULL;
2097     }
2098
2099   /* Calculate the digest value.  */
2100   {
2101     struct md5_ctx ctx;
2102     unsigned char hash[MD5_HASHLEN];
2103     unsigned char a1buf[MD5_HASHLEN * 2 + 1], a2buf[MD5_HASHLEN * 2 + 1];
2104     unsigned char response_digest[MD5_HASHLEN * 2 + 1];
2105
2106     /* A1BUF = H(user ":" realm ":" password) */
2107     md5_init_ctx (&ctx);
2108     md5_process_bytes (user, strlen (user), &ctx);
2109     md5_process_bytes (":", 1, &ctx);
2110     md5_process_bytes (realm, strlen (realm), &ctx);
2111     md5_process_bytes (":", 1, &ctx);
2112     md5_process_bytes (passwd, strlen (passwd), &ctx);
2113     md5_finish_ctx (&ctx, hash);
2114     dump_hash (a1buf, hash);
2115
2116     /* A2BUF = H(method ":" path) */
2117     md5_init_ctx (&ctx);
2118     md5_process_bytes (method, strlen (method), &ctx);
2119     md5_process_bytes (":", 1, &ctx);
2120     md5_process_bytes (path, strlen (path), &ctx);
2121     md5_finish_ctx (&ctx, hash);
2122     dump_hash (a2buf, hash);
2123
2124     /* RESPONSE_DIGEST = H(A1BUF ":" nonce ":" A2BUF) */
2125     md5_init_ctx (&ctx);
2126     md5_process_bytes (a1buf, MD5_HASHLEN * 2, &ctx);
2127     md5_process_bytes (":", 1, &ctx);
2128     md5_process_bytes (nonce, strlen (nonce), &ctx);
2129     md5_process_bytes (":", 1, &ctx);
2130     md5_process_bytes (a2buf, MD5_HASHLEN * 2, &ctx);
2131     md5_finish_ctx (&ctx, hash);
2132     dump_hash (response_digest, hash);
2133
2134     res = (char*) xmalloc (strlen (user)
2135                            + strlen (user)
2136                            + strlen (realm)
2137                            + strlen (nonce)
2138                            + strlen (path)
2139                            + 2 * MD5_HASHLEN /*strlen (response_digest)*/
2140                            + (opaque ? strlen (opaque) : 0)
2141                            + 128);
2142     sprintf (res, "Authorization: Digest \
2143 username=\"%s\", realm=\"%s\", nonce=\"%s\", uri=\"%s\", response=\"%s\"",
2144              user, realm, nonce, path, response_digest);
2145     if (opaque)
2146       {
2147         char *p = res + strlen (res);
2148         strcat (p, ", opaque=\"");
2149         strcat (p, opaque);
2150         strcat (p, "\"");
2151       }
2152     strcat (res, "\r\n");
2153   }
2154   return res;
2155 }
2156 #endif /* USE_DIGEST */
2157
2158
2159 #define BEGINS_WITH(line, string_constant)                              \
2160   (!strncasecmp (line, string_constant, sizeof (string_constant) - 1)   \
2161    && (ISSPACE (line[sizeof (string_constant) - 1])                     \
2162        || !line[sizeof (string_constant) - 1]))
2163
2164 static int
2165 known_authentication_scheme_p (const char *au)
2166 {
2167   return BEGINS_WITH (au, "Basic")
2168     || BEGINS_WITH (au, "Digest")
2169     || BEGINS_WITH (au, "NTLM");
2170 }
2171
2172 #undef BEGINS_WITH
2173
2174 /* Create the HTTP authorization request header.  When the
2175    `WWW-Authenticate' response header is seen, according to the
2176    authorization scheme specified in that header (`Basic' and `Digest'
2177    are supported by the current implementation), produce an
2178    appropriate HTTP authorization request header.  */
2179 static char *
2180 create_authorization_line (const char *au, const char *user,
2181                            const char *passwd, const char *method,
2182                            const char *path)
2183 {
2184   char *wwwauth = NULL;
2185
2186   if (!strncasecmp (au, "Basic", 5))
2187     wwwauth = basic_authentication_encode (user, passwd, "Authorization");
2188   if (!strncasecmp (au, "NTLM", 4))
2189     wwwauth = basic_authentication_encode (user, passwd, "Authorization");
2190 #ifdef USE_DIGEST
2191   else if (!strncasecmp (au, "Digest", 6))
2192     wwwauth = digest_authentication_encode (au, user, passwd, method, path);
2193 #endif /* USE_DIGEST */
2194   return wwwauth;
2195 }