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