sjero.net Git - wget/blob - src/http.c

   1 /* HTTP support.
   2    Copyright (C) 1995, 1996, 1997, 1998 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 \f
 258 struct http_stat
 259 {
 260   long len;                     /* received length */
 261   long contlen;                 /* expected length */
 262   long restval;                 /* the restart value */
 263   int res;                      /* the result of last read */
 264   char *newloc;                 /* new location (redirection) */
 265   char *remote_time;            /* remote time-stamp string */
 266   char *error;                  /* textual HTTP error */
 267   int statcode;                 /* status code */
 268   long dltime;                  /* time of the download */
 269 };
 270
 271 /* Free the elements of hstat X.  */
 272 #define FREEHSTAT(x) do                                 \
 273 {                                                       \
 274   FREE_MAYBE ((x).newloc);                              \
 275   FREE_MAYBE ((x).remote_time);                         \
 276   FREE_MAYBE ((x).error);                               \
 277   (x).newloc = (x).remote_time = (x).error = NULL;      \
 278 } while (0)
 279
 280 static char *create_authorization_line PARAMS ((const char *, const char *,
 281                                                 const char *, const char *,
 282                                                 const char *));
 283 static char *basic_authentication_encode PARAMS ((const char *, const char *,
 284                                                   const char *));
 285 static int known_authentication_scheme_p PARAMS ((const char *));
 286
 287 static time_t http_atotm PARAMS ((char *));
 288
 289 /* Retrieve a document through HTTP protocol.  It recognizes status
 290    code, and correctly handles redirections.  It closes the network
 291    socket.  If it receives an error from the functions below it, it
 292    will print it if there is enough information to do so (almost
 293    always), returning the error to the caller (i.e. http_loop).
 294
 295    Various HTTP parameters are stored to hs.  Although it parses the
 296    response code correctly, it is not used in a sane way.  The caller
 297    can do that, though.
 298
 299    If u->proxy is non-NULL, the URL u will be taken as a proxy URL,
 300    and u->proxy->url will be given to the proxy server (bad naming,
 301    I'm afraid).  */
 302 static uerr_t
 303 gethttp (struct urlinfo *u, struct http_stat *hs, int *dt)
 304 {
 305   char *request, *type, *command, *path;
 306   char *user, *passwd;
 307   char *pragma_h, *referer, *useragent, *range, *wwwauth, *remhost;
 308   char *authenticate_h;
 309   char *proxyauth;
 310   char *all_headers;
 311   char *host_port;
 312   int host_port_len;
 313   int sock, hcount, num_written, all_length, remport, statcode;
 314   long contlen, contrange;
 315   struct urlinfo *ou;
 316   uerr_t err;
 317   FILE *fp;
 318   int auth_tried_already;
 319   struct rbuf rbuf;
 320
 321   /* Let the others worry about local filename...  */
 322   if (!(*dt & HEAD_ONLY))
 323     assert (u->local != NULL);
 324
 325   authenticate_h = 0;
 326   auth_tried_already = 0;
 327
 328  again:
 329   /* We need to come back here when the initial attempt to retrieve
 330      without authorization header fails.  */
 331
 332   /* Initialize certain elements of struct hstat.  */
 333   hs->len = 0L;
 334   hs->contlen = -1;
 335   hs->res = -1;
 336   hs->newloc = NULL;
 337   hs->remote_time = NULL;
 338   hs->error = NULL;
 339
 340   /* Which structure to use to retrieve the original URL data.  */
 341   if (u->proxy)
 342     ou = u->proxy;
 343   else
 344     ou = u;
 345
 346   /* First: establish the connection.  */
 347   logprintf (LOG_VERBOSE, _("Connecting to %s:%hu... "), u->host, u->port);
 348   err = make_connection (&sock, u->host, u->port);
 349   switch (err)
 350     {
 351     case HOSTERR:
 352       logputs (LOG_VERBOSE, "\n");
 353       logprintf (LOG_NOTQUIET, "%s: %s.\n", u->host, herrmsg (h_errno));
 354       return HOSTERR;
 355       break;
 356     case CONSOCKERR:
 357       logputs (LOG_VERBOSE, "\n");
 358       logprintf (LOG_NOTQUIET, "socket: %s\n", strerror (errno));
 359       return CONSOCKERR;
 360       break;
 361     case CONREFUSED:
 362       logputs (LOG_VERBOSE, "\n");
 363       logprintf (LOG_NOTQUIET,
 364                  _("Connection to %s:%hu refused.\n"), u->host, u->port);
 365       CLOSE (sock);
 366       return CONREFUSED;
 367     case CONERROR:
 368       logputs (LOG_VERBOSE, "\n");
 369       logprintf (LOG_NOTQUIET, "connect: %s\n", strerror (errno));
 370       CLOSE (sock);
 371       return CONERROR;
 372       break;
 373     case NOCONERROR:
 374       /* Everything is fine!  */
 375       logputs (LOG_VERBOSE, _("connected!\n"));
 376       break;
 377     default:
 378       abort ();
 379       break;
 380     } /* switch */
 381
 382   if (u->proxy)
 383     path = u->proxy->url;
 384   else
 385     path = u->path;
 386
 387   command = (*dt & HEAD_ONLY) ? "HEAD" : "GET";
 388   referer = NULL;
 389   if (ou->referer)
 390     {
 391       referer = (char *)alloca (9 + strlen (ou->referer) + 3);
 392       sprintf (referer, "Referer: %s\r\n", ou->referer);
 393     }
 394   if (*dt & SEND_NOCACHE)
 395     pragma_h = "Pragma: no-cache\r\n";
 396   else
 397     pragma_h = "";
 398   if (hs->restval)
 399     {
 400       range = (char *)alloca (13 + numdigit (hs->restval) + 4);
 401       /* #### Gag me!  Some servers (e.g. WebSitePro) have been known
 402          to misinterpret the following `Range' format, and return the
 403          document as multipart/x-byte-ranges MIME type!
 404
 405          #### TODO: Interpret MIME types, recognize bullshits similar
 406          the one described above, and deal with them!  */
 407       sprintf (range, "Range: bytes=%ld-\r\n", hs->restval);
 408     }
 409   else
 410     range = NULL;
 411   if (opt.useragent)
 412     STRDUP_ALLOCA (useragent, opt.useragent);
 413   else
 414     {
 415       useragent = (char *)alloca (10 + strlen (version_string));
 416       sprintf (useragent, "Wget/%s", version_string);
 417     }
 418   /* Construct the authentication, if userid is present.  */
 419   user = ou->user;
 420   passwd = ou->passwd;
 421   search_netrc (u->host, (const char **)&user, (const char **)&passwd, 0);
 422   user = user ? user : opt.http_user;
 423   passwd = passwd ? passwd : opt.http_passwd;
 424
 425   wwwauth = NULL;
 426   if (authenticate_h && user && passwd)
 427     {
 428       wwwauth = create_authorization_line (authenticate_h, user, passwd,
 429                                            command, ou->path);
 430     }
 431
 432   proxyauth = NULL;
 433   if (u->proxy)
 434     {
 435       char *proxy_user, *proxy_passwd;
 436       /* For normal username and password, URL components override
 437          command-line/wgetrc parameters.  With proxy authentication,
 438          it's the reverse, because proxy URLs are normally the
 439          "permanent" ones, so command-line args should take
 440          precedence.  */
 441       if (opt.proxy_user && opt.proxy_passwd)
 442         {
 443           proxy_user = opt.proxy_user;
 444           proxy_passwd = opt.proxy_passwd;
 445         }
 446       else
 447         {
 448           proxy_user = u->user;
 449           proxy_passwd = u->passwd;
 450         }
 451       /* #### This is junky.  Can't the proxy request, say, `Digest'
 452          authentication?  */
 453       if (proxy_user && proxy_passwd)
 454         proxyauth = basic_authentication_encode (proxy_user, proxy_passwd,
 455                                                  "Proxy-Authorization");
 456     }
 457   remhost = ou->host;
 458   remport = ou->port;
 459
 460   if (remport == 80)
 461     {
 462       host_port = NULL;
 463       host_port_len = 0;
 464     }
 465   else
 466     {
 467       host_port = (char *)alloca (numdigit (remport) + 2);
 468       host_port_len = sprintf (host_port, ":%d", remport);
 469     }
 470
 471   /* Allocate the memory for the request.  */
 472   request = (char *)alloca (strlen (command) + strlen (path)
 473                             + strlen (useragent)
 474                             + strlen (remhost) + host_port_len
 475                             + strlen (HTTP_ACCEPT)
 476                             + (referer ? strlen (referer) : 0)
 477                             + (wwwauth ? strlen (wwwauth) : 0)
 478                             + (proxyauth ? strlen (proxyauth) : 0)
 479                             + (range ? strlen (range) : 0)
 480                             + strlen (pragma_h)
 481                             + (opt.user_header ? strlen (opt.user_header) : 0)
 482                             + 64);
 483   /* Construct the request.  */
 484   sprintf (request, "\
 485 %s %s HTTP/1.0\r\n\
 486 User-Agent: %s\r\n\
 487 Host: %s%s\r\n\
 488 Accept: %s\r\n\
 489 %s%s%s%s%s%s\r\n",
 490            command, path, useragent, remhost,
 491            host_port ? host_port : "",
 492            HTTP_ACCEPT, referer ? referer : "",
 493            wwwauth ? wwwauth : "",
 494            proxyauth ? proxyauth : "",
 495            range ? range : "",
 496            pragma_h,
 497            opt.user_header ? opt.user_header : "");
 498   DEBUGP (("---request begin---\n%s---request end---\n", request));
 499    /* Free the temporary memory.  */
 500   FREE_MAYBE (wwwauth);
 501   FREE_MAYBE (proxyauth);
 502
 503   /* Send the request to server.  */
 504   num_written = iwrite (sock, request, strlen (request));
 505   if (num_written < 0)
 506     {
 507       logputs (LOG_VERBOSE, _("Failed writing HTTP request.\n"));
 508       free (request);
 509       CLOSE (sock);
 510       return WRITEFAILED;
 511     }
 512   logprintf (LOG_VERBOSE, _("%s request sent, awaiting response... "),
 513              u->proxy ? "Proxy" : "HTTP");
 514   contlen = contrange = -1;
 515   type = NULL;
 516   statcode = -1;
 517   *dt &= ~RETROKF;
 518
 519   /* Before reading anything, initialize the rbuf.  */
 520   rbuf_initialize (&rbuf, sock);
 521
 522   all_headers = NULL;
 523   all_length = 0;
 524   /* Header-fetching loop.  */
 525   hcount = 0;
 526   while (1)
 527     {
 528       char *hdr;
 529       int status;
 530
 531       ++hcount;
 532       /* Get the header.  */
 533       status = header_get (&rbuf, &hdr,
 534                            /* Disallow continuations for status line.  */
 535                            (hcount == 1 ? HG_NO_CONTINUATIONS : HG_NONE));
 536
 537       /* Check for errors.  */
 538       if (status == HG_EOF && *hdr)
 539         {
 540           /* This used to be an unconditional error, but that was
 541              somewhat controversial, because of a large number of
 542              broken CGI's that happily "forget" to send the second EOL
 543              before closing the connection of a HEAD request.
 544
 545              So, the deal is to check whether the header is empty
 546              (*hdr is zero if it is); if yes, it means that the
 547              previous header was fully retrieved, and that -- most
 548              probably -- the request is complete.  "...be liberal in
 549              what you accept."  Oh boy.  */
 550           logputs (LOG_VERBOSE, "\n");
 551           logputs (LOG_NOTQUIET, _("End of file while parsing headers.\n"));
 552           free (hdr);
 553           FREE_MAYBE (type);
 554           FREE_MAYBE (hs->newloc);
 555           FREE_MAYBE (all_headers);
 556           CLOSE (sock);
 557           return HEOF;
 558         }
 559       else if (status == HG_ERROR)
 560         {
 561           logputs (LOG_VERBOSE, "\n");
 562           logprintf (LOG_NOTQUIET, _("Read error (%s) in headers.\n"),
 563                      strerror (errno));
 564           free (hdr);
 565           FREE_MAYBE (type);
 566           FREE_MAYBE (hs->newloc);
 567           FREE_MAYBE (all_headers);
 568           CLOSE (sock);
 569           return HERR;
 570         }
 571
 572       /* If the headers are to be saved to a file later, save them to
 573          memory now.  */
 574       if (opt.save_headers)
 575         {
 576           int lh = strlen (hdr);
 577           all_headers = (char *)xrealloc (all_headers, all_length + lh + 2);
 578           memcpy (all_headers + all_length, hdr, lh);
 579           all_length += lh;
 580           all_headers[all_length++] = '\n';
 581           all_headers[all_length] = '\0';
 582         }
 583
 584       /* Print the header if requested.  */
 585       if (opt.server_response && hcount != 1)
 586         logprintf (LOG_VERBOSE, "\n%d %s", hcount, hdr);
 587
 588       /* Check for status line.  */
 589       if (hcount == 1)
 590         {
 591           const char *error;
 592           /* Parse the first line of server response.  */
 593           statcode = parse_http_status_line (hdr, &error);
 594           hs->statcode = statcode;
 595           /* Store the descriptive response.  */
 596           if (statcode == -1) /* malformed response */
 597             {
 598               /* A common reason for "malformed response" error is the
 599                  case when no data was actually received.  Handle this
 600                  special case.  */
 601               if (!*hdr)
 602                 hs->error = xstrdup (_("No data received"));
 603               else
 604                 hs->error = xstrdup (_("Malformed status line"));
 605               free (hdr);
 606               break;
 607             }
 608           else if (!*error)
 609             hs->error = xstrdup (_("(no description)"));
 610           else
 611             hs->error = xstrdup (error);
 612
 613           if ((statcode != -1)
 614 #ifdef DEBUG
 615               && !opt.debug
 616 #endif
 617               )
 618             logprintf (LOG_VERBOSE, "%d %s", statcode, error);
 619
 620           goto done_header;
 621         }
 622
 623       /* Exit on empty header.  */
 624       if (!*hdr)
 625         {
 626           free (hdr);
 627           break;
 628         }
 629
 630       /* Try getting content-length.  */
 631       if (contlen == -1 && !opt.ignore_length)
 632         if (header_process (hdr, "Content-Length", header_extract_number,
 633                             &contlen))
 634           goto done_header;
 635       /* Try getting content-type.  */
 636       if (!type)
 637         if (header_process (hdr, "Content-Type", http_process_type, &type))
 638           goto done_header;
 639       /* Try getting location.  */
 640       if (!hs->newloc)
 641         if (header_process (hdr, "Location", header_strdup, &hs->newloc))
 642           goto done_header;
 643       /* Try getting last-modified.  */
 644       if (!hs->remote_time)
 645         if (header_process (hdr, "Last-Modified", header_strdup,
 646                             &hs->remote_time))
 647           goto done_header;
 648       /* Try getting www-authentication.  */
 649       if (!authenticate_h)
 650         if (header_process (hdr, "WWW-Authenticate", header_strdup,
 651                             &authenticate_h))
 652           goto done_header;
 653       /* Check for accept-ranges header.  If it contains the word
 654          `none', disable the ranges.  */
 655       if (*dt & ACCEPTRANGES)
 656         {
 657           int nonep;
 658           if (header_process (hdr, "Accept-Ranges", http_process_none, &nonep))
 659             {
 660               if (nonep)
 661                 *dt &= ~ACCEPTRANGES;
 662               goto done_header;
 663             }
 664         }
 665       /* Try getting content-range.  */
 666       if (contrange == -1)
 667         {
 668           struct http_process_range_closure closure;
 669           if (header_process (hdr, "Content-Range", http_process_range, &closure))
 670             {
 671               contrange = closure.first_byte_pos;
 672               goto done_header;
 673             }
 674         }
 675     done_header:
 676       free (hdr);
 677     }
 678
 679   logputs (LOG_VERBOSE, "\n");
 680
 681   if ((statcode == HTTP_STATUS_UNAUTHORIZED)
 682       && authenticate_h)
 683     {
 684       /* Authorization is required.  */
 685       FREE_MAYBE (type);
 686       type = NULL;
 687       FREEHSTAT (*hs);
 688       CLOSE (sock);
 689       if (auth_tried_already)
 690         {
 691           /* If we have tried it already, then there is not point
 692              retrying it.  */
 693           logputs (LOG_NOTQUIET, _("Authorization failed.\n"));
 694           free (authenticate_h);
 695           return AUTHFAILED;
 696         }
 697       else if (!known_authentication_scheme_p (authenticate_h))
 698         {
 699           free (authenticate_h);
 700           logputs (LOG_NOTQUIET, _("Unknown authentication scheme.\n"));
 701           return AUTHFAILED;
 702         }
 703       else
 704         {
 705           auth_tried_already = 1;
 706           goto again;
 707         }
 708     }
 709   /* We do not need this anymore.  */
 710   if (authenticate_h)
 711     {
 712       free (authenticate_h);
 713       authenticate_h = NULL;
 714     }
 715
 716   /* 20x responses are counted among successful by default.  */
 717   if (H_20X (statcode))
 718     *dt |= RETROKF;
 719
 720   if (type && !strncasecmp (type, TEXTHTML_S, strlen (TEXTHTML_S)))
 721     *dt |= TEXTHTML;
 722   else
 723     /* We don't assume text/html by default.  */
 724     *dt &= ~TEXTHTML;
 725
 726   if (contrange == -1)
 727     hs->restval = 0;
 728   else if (contrange != hs->restval ||
 729            (H_PARTIAL (statcode) && contrange == -1))
 730     {
 731       /* This means the whole request was somehow misunderstood by the
 732          server.  Bail out.  */
 733       FREE_MAYBE (type);
 734       FREE_MAYBE (hs->newloc);
 735       FREE_MAYBE (all_headers);
 736       CLOSE (sock);
 737       return RANGEERR;
 738     }
 739
 740   if (hs->restval)
 741     {
 742       if (contlen != -1)
 743         contlen += contrange;
 744       else
 745         contrange = -1;        /* If conent-length was not sent,
 746                                   content-range will be ignored.  */
 747     }
 748   hs->contlen = contlen;
 749
 750   /* Return if redirected.  */
 751   if (H_REDIRECTED (statcode) || statcode == HTTP_STATUS_MULTIPLE_CHOICES)
 752     {
 753       /* RFC2068 says that in case of the 300 (multiple choices)
 754          response, the server can output a preferred URL through
 755          `Location' header; otherwise, the request should be treated
 756          like GET.  So, if the location is set, it will be a
 757          redirection; otherwise, just proceed normally.  */
 758       if (statcode == HTTP_STATUS_MULTIPLE_CHOICES && !hs->newloc)
 759         *dt |= RETROKF;
 760       else
 761         {
 762           logprintf (LOG_VERBOSE,
 763                      _("Location: %s%s\n"),
 764                      hs->newloc ? hs->newloc : _("unspecified"),
 765                      hs->newloc ? _(" [following]") : "");
 766           CLOSE (sock);
 767           FREE_MAYBE (type);
 768           FREE_MAYBE (all_headers);
 769           return NEWLOCATION;
 770         }
 771     }
 772   if (opt.verbose)
 773     {
 774       if ((*dt & RETROKF) && !opt.server_response)
 775         {
 776           /* No need to print this output if the body won't be
 777              downloaded at all, or if the original server response is
 778              printed.  */
 779           logputs (LOG_VERBOSE, _("Length: "));
 780           if (contlen != -1)
 781             {
 782               logputs (LOG_VERBOSE, legible (contlen));
 783               if (contrange != -1)
 784                 logprintf (LOG_VERBOSE, _(" (%s to go)"),
 785                            legible (contlen - contrange));
 786             }
 787           else
 788             logputs (LOG_VERBOSE,
 789                      opt.ignore_length ? _("ignored") : _("unspecified"));
 790           if (type)
 791             logprintf (LOG_VERBOSE, " [%s]\n", type);
 792           else
 793             logputs (LOG_VERBOSE, "\n");
 794         }
 795     }
 796   FREE_MAYBE (type);
 797   type = NULL;                  /* We don't need it any more.  */
 798
 799   /* Return if we have no intention of further downloading.  */
 800   if (!(*dt & RETROKF) || (*dt & HEAD_ONLY))
 801     {
 802       /* In case someone cares to look...  */
 803       hs->len = 0L;
 804       hs->res = 0;
 805       FREE_MAYBE (type);
 806       FREE_MAYBE (all_headers);
 807       CLOSE (sock);
 808       return RETRFINISHED;
 809     }
 810
 811   /* Open the local file.  */
 812   if (!opt.dfp)
 813     {
 814       mkalldirs (u->local);
 815       if (opt.backups)
 816         rotate_backups (u->local);
 817       fp = fopen (u->local, hs->restval ? "ab" : "wb");
 818       if (!fp)
 819         {
 820           logprintf (LOG_NOTQUIET, "%s: %s\n", u->local, strerror (errno));
 821           CLOSE (sock);
 822           FREE_MAYBE (all_headers);
 823           return FOPENERR;
 824         }
 825     }
 826   else                      /* opt.dfp */
 827     fp = opt.dfp;
 828
 829   /* #### This confuses the code that checks for file size.  There
 830      should be some overhead information.  */
 831   if (opt.save_headers)
 832     fwrite (all_headers, 1, all_length, fp);
 833   reset_timer ();
 834   /* Get the contents of the document.  */
 835   hs->res = get_contents (sock, fp, &hs->len, hs->restval,
 836                           (contlen != -1 ? contlen : 0),
 837                           &rbuf);
 838   hs->dltime = elapsed_time ();
 839   if (!opt.dfp)
 840     fclose (fp);
 841   else
 842     fflush (fp);
 843   FREE_MAYBE (all_headers);
 844   CLOSE (sock);
 845   if (hs->res == -2)
 846     return FWRITEERR;
 847   return RETRFINISHED;
 848 }
 849
 850 /* The genuine HTTP loop!  This is the part where the retrieval is
 851    retried, and retried, and retried, and...  */
 852 uerr_t
 853 http_loop (struct urlinfo *u, char **newloc, int *dt)
 854 {
 855   static int first_retrieval = 1;
 856
 857   int count;
 858   int local_dot_orig_file_exists = FALSE;
 859   int use_ts, got_head = 0;     /* time-stamping info */
 860   char *tms, *suf, *locf, *tmrate;
 861   uerr_t err;
 862   time_t tml = -1, tmr = -1;    /* local and remote time-stamps */
 863   long local_size = 0;          /* the size of the local file */
 864   struct http_stat hstat;       /* HTTP status */
 865   struct stat st;
 866
 867   *newloc = NULL;
 868
 869   /* Warn on (likely bogus) wildcard usage in HTTP.  Don't use
 870      has_wildcards_p because it would also warn on `?', and we know that
 871      shows up in CGI paths a *lot*.  */
 872   if (strchr (u->url, '*'))
 873     logputs (LOG_VERBOSE, _("Warning: wildcards not supported in HTTP.\n"));
 874
 875   /* Determine the local filename.  */
 876   if (!u->local)
 877     u->local = url_filename (u->proxy ? u->proxy : u);
 878
 879   if (!opt.output_document)
 880     locf = u->local;
 881   else
 882     locf = opt.output_document;
 883
 884   if (opt.noclobber && file_exists_p (u->local))
 885     {
 886       /* If opt.noclobber is turned on and file already exists, do not
 887          retrieve the file */
 888       logprintf (LOG_VERBOSE, _("\
 889 File `%s' already there, will not retrieve.\n"), u->local);
 890       /* If the file is there, we suppose it's retrieved OK.  */
 891       *dt |= RETROKF;
 892
 893       /* #### Bogusness alert.  */
 894       /* If its suffix is "html" or (yuck!) "htm", we suppose it's
 895          text/html, a harmless lie.  */
 896       if (((suf = suffix (u->local)) != NULL)
 897           && (!strcmp (suf, "html") || !strcmp (suf, "htm")))
 898         *dt |= TEXTHTML;
 899       free (suf);
 900       /* Another harmless lie: */
 901       return RETROK;
 902     }
 903
 904   use_ts = 0;
 905   if (opt.timestamping)
 906     {
 907       boolean  local_file_exists = FALSE;
 908
 909       if (opt.backup_converted)
 910         /* If -K is specified, we'll act on the assumption that it was specified
 911            last time these files were downloaded as well, and instead of just
 912            comparing local file X against server file X, we'll compare local
 913            file X.orig (if extant, else X) against server file X.  If -K
 914            _wasn't_ specified last time, or the server contains files called
 915            *.orig, -N will be back to not operating correctly with -k. */
 916         {
 917           size_t filename_len = strlen(u->local);
 918           char*  filename_plus_orig_suffix = malloc(filename_len +
 919                                                     sizeof(".orig"));
 920
 921           /* Would a single s[n]printf() call be faster? */
 922           strcpy(filename_plus_orig_suffix, u->local);
 923           strcpy(filename_plus_orig_suffix + filename_len, ".orig");
 924
 925           /* Try to stat() the .orig file. */
 926           if (stat(filename_plus_orig_suffix, &st) == 0)
 927             {
 928               local_file_exists = TRUE;
 929               local_dot_orig_file_exists = TRUE;
 930             }
 931
 932           free(filename_plus_orig_suffix);
 933         }
 934
 935       if (!local_dot_orig_file_exists)
 936         /* Couldn't stat() <file>.orig, so try to stat() <file>. */
 937         if (stat (u->local, &st) == 0)
 938           local_file_exists = TRUE;
 939
 940       if (local_file_exists)
 941         /* There was a local file, so we'll check later to see if the version
 942            the server has is the same version we already have, allowing us to
 943            skip a download. */
 944         {
 945           use_ts = 1;
 946           tml = st.st_mtime;
 947           local_size = st.st_size;
 948           got_head = 0;
 949         }
 950     }
 951   /* Reset the counter.  */
 952   count = 0;
 953   *dt = 0 | ACCEPTRANGES;
 954   /* THE loop */
 955   do
 956     {
 957       /* Increment the pass counter.  */
 958       ++count;
 959       /* Wait before the retrieval (unless this is the very first
 960          retrieval).
 961          Check if we are retrying or not, wait accordingly - HEH */
 962       if (!first_retrieval && (opt.wait || (count && opt.waitretry)))
 963         {
 964           if (count)
 965             {
 966               if (count<opt.waitretry)
 967                 sleep(count);
 968               else
 969                 sleep(opt.waitretry);
 970             }
 971           else
 972             sleep (opt.wait);
 973         }
 974       if (first_retrieval)
 975         first_retrieval = 0;
 976       /* Get the current time string.  */
 977       tms = time_str (NULL);
 978       /* Print fetch message, if opt.verbose.  */
 979       if (opt.verbose)
 980         {
 981           char *hurl = str_url (u->proxy ? u->proxy : u, 1);
 982           char tmp[15];
 983           strcpy (tmp, "        ");
 984           if (count > 1)
 985             sprintf (tmp, _("(try:%2d)"), count);
 986           logprintf (LOG_VERBOSE, "--%s--  %s\n  %s => `%s'\n",
 987                      tms, hurl, tmp, locf);
 988 #ifdef WINDOWS
 989           ws_changetitle (hurl, 1);
 990 #endif
 991           free (hurl);
 992         }
 993
 994       /* Default document type is empty.  However, if spider mode is
 995          on or time-stamping is employed, HEAD_ONLY commands is
 996          encoded within *dt.  */
 997       if (opt.spider || (use_ts && !got_head))
 998         *dt |= HEAD_ONLY;
 999       else
1000         *dt &= ~HEAD_ONLY;
1001       /* Assume no restarting.  */
1002       hstat.restval = 0L;
1003       /* Decide whether or not to restart.  */
1004       if (((count > 1 && (*dt & ACCEPTRANGES)) || opt.always_rest)
1005           && file_exists_p (u->local))
1006         if (stat (u->local, &st) == 0)
1007           hstat.restval = st.st_size;
1008       /* Decide whether to send the no-cache directive.  */
1009       if (u->proxy && (count > 1 || (opt.proxy_cache == 0)))
1010         *dt |= SEND_NOCACHE;
1011       else
1012         *dt &= ~SEND_NOCACHE;
1013
1014       /* Try fetching the document, or at least its head.  :-) */
1015       err = gethttp (u, &hstat, dt);
1016       /* Time?  */
1017       tms = time_str (NULL);
1018       /* Get the new location (with or without the redirection).  */
1019       if (hstat.newloc)
1020         *newloc = xstrdup (hstat.newloc);
1021       switch (err)
1022         {
1023         case HERR: case HEOF: case CONSOCKERR: case CONCLOSED:
1024         case CONERROR: case READERR: case WRITEFAILED:
1025         case RANGEERR:
1026           /* Non-fatal errors continue executing the loop, which will
1027              bring them to "while" statement at the end, to judge
1028              whether the number of tries was exceeded.  */
1029           FREEHSTAT (hstat);
1030           printwhat (count, opt.ntry);
1031           continue;
1032           break;
1033         case HOSTERR: case CONREFUSED: case PROXERR: case AUTHFAILED:
1034           /* Fatal errors just return from the function.  */
1035           FREEHSTAT (hstat);
1036           return err;
1037           break;
1038         case FWRITEERR: case FOPENERR:
1039           /* Another fatal error.  */
1040           logputs (LOG_VERBOSE, "\n");
1041           logprintf (LOG_NOTQUIET, _("Cannot write to `%s' (%s).\n"),
1042                      u->local, strerror (errno));
1043           FREEHSTAT (hstat);
1044           return err;
1045           break;
1046         case NEWLOCATION:
1047           /* Return the new location to the caller.  */
1048           if (!hstat.newloc)
1049             {
1050               logprintf (LOG_NOTQUIET,
1051                          _("ERROR: Redirection (%d) without location.\n"),
1052                          hstat.statcode);
1053               return WRONGCODE;
1054             }
1055           FREEHSTAT (hstat);
1056           return NEWLOCATION;
1057           break;
1058         case RETRFINISHED:
1059           /* Deal with you later.  */
1060           break;
1061         default:
1062           /* All possibilities should have been exhausted.  */
1063           abort ();
1064         }
1065       if (!(*dt & RETROKF))
1066         {
1067           if (!opt.verbose)
1068             {
1069               /* #### Ugly ugly ugly! */
1070               char *hurl = str_url (u->proxy ? u->proxy : u, 1);
1071               logprintf (LOG_NONVERBOSE, "%s:\n", hurl);
1072               free (hurl);
1073             }
1074           logprintf (LOG_NOTQUIET, _("%s ERROR %d: %s.\n"),
1075                      tms, hstat.statcode, hstat.error);
1076           logputs (LOG_VERBOSE, "\n");
1077           FREEHSTAT (hstat);
1078           return WRONGCODE;
1079         }
1080
1081       /* Did we get the time-stamp?  */
1082       if (!got_head)
1083         {
1084           if (opt.timestamping && !hstat.remote_time)
1085             {
1086               logputs (LOG_NOTQUIET, _("\
1087 Last-modified header missing -- time-stamps turned off.\n"));
1088             }
1089           else if (hstat.remote_time)
1090             {
1091               /* Convert the date-string into struct tm.  */
1092               tmr = http_atotm (hstat.remote_time);
1093               if (tmr == (time_t) (-1))
1094                 logputs (LOG_VERBOSE, _("\
1095 Last-modified header invalid -- time-stamp ignored.\n"));
1096             }
1097         }
1098
1099       /* The time-stamping section.  */
1100       if (use_ts)
1101         {
1102           got_head = 1;
1103           *dt &= ~HEAD_ONLY;
1104           use_ts = 0;           /* no more time-stamping */
1105           count = 0;            /* the retrieve count for HEAD is
1106                                    reset */
1107           if (hstat.remote_time && tmr != (time_t) (-1))
1108             {
1109               /* Now time-stamping can be used validly.  Time-stamping
1110                  means that if the sizes of the local and remote file
1111                  match, and local file is newer than the remote file,
1112                  it will not be retrieved.  Otherwise, the normal
1113                  download procedure is resumed.  */
1114               if (tml >= tmr &&
1115                   (hstat.contlen == -1 || local_size == hstat.contlen))
1116                 {
1117                   if (local_dot_orig_file_exists)
1118                     /* We can't collapse this down into just one logprintf()
1119                        call with a variable set to u->local or the .orig
1120                        filename because we have to malloc() space for the
1121                        latter, and because there are multiple returns above (a
1122                        coding style no-no by many measures, for reasons such as
1123                        this) we'd have to remember to free() the string at each
1124                        one to avoid a memory leak. */
1125                     logprintf (LOG_VERBOSE, _("\
1126 Server file no newer than local file `%s.orig' -- not retrieving.\n\n"),
1127                                u->local);
1128                   else
1129                     logprintf (LOG_VERBOSE, _("\
1130 Server file no newer than local file `%s' -- not retrieving.\n\n"), u->local);
1131                   FREEHSTAT (hstat);
1132                   return RETROK;
1133                 }
1134               else if (tml >= tmr)
1135                 logprintf (LOG_VERBOSE, _("\
1136 The sizes do not match (local %ld) -- retrieving.\n"), local_size);
1137               else
1138                 logputs (LOG_VERBOSE,
1139                          _("Remote file is newer, retrieving.\n"));
1140             }
1141           FREEHSTAT (hstat);
1142           continue;
1143         }
1144       if (!opt.dfp
1145           && (tmr != (time_t) (-1))
1146           && !opt.spider
1147           && ((hstat.len == hstat.contlen) ||
1148               ((hstat.res == 0) &&
1149                ((hstat.contlen == -1) ||
1150                 (hstat.len >= hstat.contlen && !opt.kill_longer)))))
1151         {
1152           touch (u->local, tmr);
1153         }
1154       /* End of time-stamping section.  */
1155
1156       if (opt.spider)
1157         {
1158           logprintf (LOG_NOTQUIET, "%d %s\n\n", hstat.statcode, hstat.error);
1159           return RETROK;
1160         }
1161
1162       /* It is now safe to free the remainder of hstat, since the
1163          strings within it will no longer be used.  */
1164       FREEHSTAT (hstat);
1165
1166       tmrate = rate (hstat.len - hstat.restval, hstat.dltime);
1167
1168       if (hstat.len == hstat.contlen)
1169         {
1170           if (*dt & RETROKF)
1171             {
1172               logprintf (LOG_VERBOSE,
1173                          _("%s (%s) - `%s' saved [%ld/%ld]\n\n"),
1174                          tms, tmrate, locf, hstat.len, hstat.contlen);
1175               logprintf (LOG_NONVERBOSE,
1176                          "%s URL:%s [%ld/%ld] -> \"%s\" [%d]\n",
1177                          tms, u->url, hstat.len, hstat.contlen, locf, count);
1178             }
1179           ++opt.numurls;
1180           opt.downloaded += hstat.len;
1181           downloaded_file(ADD_FILE, locf);
1182           return RETROK;
1183         }
1184       else if (hstat.res == 0) /* No read error */
1185         {
1186           if (hstat.contlen == -1)  /* We don't know how much we were supposed
1187                                        to get, so assume we succeeded. */
1188             {
1189               if (*dt & RETROKF)
1190                 {
1191                   logprintf (LOG_VERBOSE,
1192                              _("%s (%s) - `%s' saved [%ld]\n\n"),
1193                              tms, tmrate, locf, hstat.len);
1194                   logprintf (LOG_NONVERBOSE,
1195                              "%s URL:%s [%ld] -> \"%s\" [%d]\n",
1196                              tms, u->url, hstat.len, locf, count);
1197                 }
1198               ++opt.numurls;
1199               opt.downloaded += hstat.len;
1200               downloaded_file(ADD_FILE, locf);
1201               return RETROK;
1202             }
1203           else if (hstat.len < hstat.contlen) /* meaning we lost the
1204                                                  connection too soon */
1205             {
1206               logprintf (LOG_VERBOSE,
1207                          _("%s (%s) - Connection closed at byte %ld. "),
1208                          tms, tmrate, hstat.len);
1209               printwhat (count, opt.ntry);
1210               continue;
1211             }
1212           else if (!opt.kill_longer) /* meaning we got more than expected */
1213             {
1214               logprintf (LOG_VERBOSE,
1215                          _("%s (%s) - `%s' saved [%ld/%ld])\n\n"),
1216                          tms, tmrate, locf, hstat.len, hstat.contlen);
1217               logprintf (LOG_NONVERBOSE,
1218                          "%s URL:%s [%ld/%ld] -> \"%s\" [%d]\n",
1219                          tms, u->url, hstat.len, hstat.contlen, locf, count);
1220               ++opt.numurls;
1221               opt.downloaded += hstat.len;
1222               downloaded_file(ADD_FILE, locf);
1223               return RETROK;
1224             }
1225           else                  /* the same, but not accepted */
1226             {
1227               logprintf (LOG_VERBOSE,
1228                          _("%s (%s) - Connection closed at byte %ld/%ld. "),
1229                          tms, tmrate, hstat.len, hstat.contlen);
1230               printwhat (count, opt.ntry);
1231               continue;
1232             }
1233         }
1234       else                      /* now hstat.res can only be -1 */
1235         {
1236           if (hstat.contlen == -1)
1237             {
1238               logprintf (LOG_VERBOSE,
1239                          _("%s (%s) - Read error at byte %ld (%s)."),
1240                          tms, tmrate, hstat.len, strerror (errno));
1241               printwhat (count, opt.ntry);
1242               continue;
1243             }
1244           else                  /* hstat.res == -1 and contlen is given */
1245             {
1246               logprintf (LOG_VERBOSE,
1247                          _("%s (%s) - Read error at byte %ld/%ld (%s). "),
1248                          tms, tmrate, hstat.len, hstat.contlen,
1249                          strerror (errno));
1250               printwhat (count, opt.ntry);
1251               continue;
1252             }
1253         }
1254       /* not reached */
1255       break;
1256     }
1257   while (!opt.ntry || (count < opt.ntry));
1258   return TRYLIMEXC;
1259 }
1260 \f
1261 /* Converts struct tm to time_t, assuming the data in tm is UTC rather
1262    than local timezone (mktime assumes the latter).
1263
1264    Contributed by Roger Beeman <beeman@cisco.com>, with the help of
1265    Mark Baushke <mdb@cisco.com> and the rest of the Gurus at CISCO.  */
1266 static time_t
1267 mktime_from_utc (struct tm *t)
1268 {
1269   time_t tl, tb;
1270
1271   tl = mktime (t);
1272   if (tl == -1)
1273     return -1;
1274   tb = mktime (gmtime (&tl));
1275   return (tl <= tb ? (tl + (tl - tb)) : (tl - (tb - tl)));
1276 }
1277
1278 /* Check whether the result of strptime() indicates success.
1279    strptime() returns the pointer to how far it got to in the string.
1280    The processing has been successful if the string is at `GMT' or
1281    `+X', or at the end of the string.
1282
1283    In extended regexp parlance, the function returns 1 if P matches
1284    "^ *(GMT|[+-][0-9]|$)", 0 otherwise.  P being NULL (a valid result of
1285    strptime()) is considered a failure and 0 is returned.  */
1286 static int
1287 check_end (char *p)
1288 {
1289   if (!p)
1290     return 0;
1291   while (ISSPACE (*p))
1292     ++p;
1293   if (!*p
1294       || (p[0] == 'G' && p[1] == 'M' && p[2] == 'T')
1295       || ((p[0] == '+' || p[1] == '-') && ISDIGIT (p[1])))
1296     return 1;
1297   else
1298     return 0;
1299 }
1300
1301 /* Convert TIME_STRING time to time_t.  TIME_STRING can be in any of
1302    the three formats RFC2068 allows the HTTP servers to emit --
1303    RFC1123-date, RFC850-date or asctime-date.  Timezones are ignored,
1304    and should be GMT.
1305
1306    We use strptime() to recognize various dates, which makes it a
1307    little bit slacker than the RFC1123/RFC850/asctime (e.g. it always
1308    allows shortened dates and months, one-digit days, etc.).  It also
1309    allows more than one space anywhere where the specs require one SP.
1310    The routine should probably be even more forgiving (as recommended
1311    by RFC2068), but I do not have the time to write one.
1312
1313    Return the computed time_t representation, or -1 if all the
1314    schemes fail.
1315
1316    Needless to say, what we *really* need here is something like
1317    Marcus Hennecke's atotm(), which is forgiving, fast, to-the-point,
1318    and does not use strptime().  atotm() is to be found in the sources
1319    of `phttpd', a little-known HTTP server written by Peter Erikson.  */
1320 static time_t
1321 http_atotm (char *time_string)
1322 {
1323   struct tm t;
1324
1325   /* Roger Beeman says: "This function dynamically allocates struct tm
1326      t, but does no initialization.  The only field that actually
1327      needs initialization is tm_isdst, since the others will be set by
1328      strptime.  Since strptime does not set tm_isdst, it will return
1329      the data structure with whatever data was in tm_isdst to begin
1330      with.  For those of us in timezones where DST can occur, there
1331      can be a one hour shift depending on the previous contents of the
1332      data area where the data structure is allocated."  */
1333   t.tm_isdst = -1;
1334
1335   /* Note that under foreign locales Solaris strptime() fails to
1336      recognize English dates, which renders this function useless.  I
1337      assume that other non-GNU strptime's are plagued by the same
1338      disease.  We solve this by setting only LC_MESSAGES in
1339      i18n_initialize(), instead of LC_ALL.
1340
1341      Another solution could be to temporarily set locale to C, invoke
1342      strptime(), and restore it back.  This is slow and dirty,
1343      however, and locale support other than LC_MESSAGES can mess other
1344      things, so I rather chose to stick with just setting LC_MESSAGES.
1345
1346      Also note that none of this is necessary under GNU strptime(),
1347      because it recognizes both international and local dates.  */
1348
1349   /* NOTE: We don't use `%n' for white space, as OSF's strptime uses
1350      it to eat all white space up to (and including) a newline, and
1351      the function fails if there is no newline (!).
1352
1353      Let's hope all strptime() implementations use ` ' to skip *all*
1354      whitespace instead of just one (it works that way on all the
1355      systems I've tested it on).  */
1356
1357   /* RFC1123: Thu, 29 Jan 1998 22:12:57 */
1358   if (check_end (strptime (time_string, "%a, %d %b %Y %T", &t)))
1359     return mktime_from_utc (&t);
1360   /* RFC850:  Thu, 29-Jan-98 22:12:57 */
1361   if (check_end (strptime (time_string, "%a, %d-%b-%y %T", &t)))
1362     return mktime_from_utc (&t);
1363   /* asctime: Thu Jan 29 22:12:57 1998 */
1364   if (check_end (strptime (time_string, "%a %b %d %T %Y", &t)))
1365     return mktime_from_utc (&t);
1366   /* Failure.  */
1367   return -1;
1368 }
1369 \f
1370 /* Authorization support: We support two authorization schemes:
1371
1372    * `Basic' scheme, consisting of base64-ing USER:PASSWORD string;
1373
1374    * `Digest' scheme, added by Junio Hamano <junio@twinsun.com>,
1375    consisting of answering to the server's challenge with the proper
1376    MD5 digests.  */
1377
1378 /* How many bytes it will take to store LEN bytes in base64.  */
1379 #define BASE64_LENGTH(len) (4 * (((len) + 2) / 3))
1380
1381 /* Encode the string S of length LENGTH to base64 format and place it
1382    to STORE.  STORE will be 0-terminated, and must point to a writable
1383    buffer of at least 1+BASE64_LENGTH(length) bytes.  */
1384 static void
1385 base64_encode (const char *s, char *store, int length)
1386 {
1387   /* Conversion table.  */
1388   static char tbl[64] = {
1389     'A','B','C','D','E','F','G','H',
1390     'I','J','K','L','M','N','O','P',
1391     'Q','R','S','T','U','V','W','X',
1392     'Y','Z','a','b','c','d','e','f',
1393     'g','h','i','j','k','l','m','n',
1394     'o','p','q','r','s','t','u','v',
1395     'w','x','y','z','0','1','2','3',
1396     '4','5','6','7','8','9','+','/'
1397   };
1398   int i;
1399   unsigned char *p = (unsigned char *)store;
1400
1401   /* Transform the 3x8 bits to 4x6 bits, as required by base64.  */
1402   for (i = 0; i < length; i += 3)
1403     {
1404       *p++ = tbl[s[0] >> 2];
1405       *p++ = tbl[((s[0] & 3) << 4) + (s[1] >> 4)];
1406       *p++ = tbl[((s[1] & 0xf) << 2) + (s[2] >> 6)];
1407       *p++ = tbl[s[2] & 0x3f];
1408       s += 3;
1409     }
1410   /* Pad the result if necessary...  */
1411   if (i == length + 1)
1412     *(p - 1) = '=';
1413   else if (i == length + 2)
1414     *(p - 1) = *(p - 2) = '=';
1415   /* ...and zero-terminate it.  */
1416   *p = '\0';
1417 }
1418
1419 /* Create the authentication header contents for the `Basic' scheme.
1420    This is done by encoding the string `USER:PASS' in base64 and
1421    prepending `HEADER: Basic ' to it.  */
1422 static char *
1423 basic_authentication_encode (const char *user, const char *passwd,
1424                              const char *header)
1425 {
1426   char *t1, *t2, *res;
1427   int len1 = strlen (user) + 1 + strlen (passwd);
1428   int len2 = BASE64_LENGTH (len1);
1429
1430   t1 = (char *)alloca (len1 + 1);
1431   sprintf (t1, "%s:%s", user, passwd);
1432   t2 = (char *)alloca (1 + len2);
1433   base64_encode (t1, t2, len1);
1434   res = (char *)malloc (len2 + 11 + strlen (header));
1435   sprintf (res, "%s: Basic %s\r\n", header, t2);
1436
1437   return res;
1438 }
1439
1440 #ifdef USE_DIGEST
1441 /* Parse HTTP `WWW-Authenticate:' header.  AU points to the beginning
1442    of a field in such a header.  If the field is the one specified by
1443    ATTR_NAME ("realm", "opaque", and "nonce" are used by the current
1444    digest authorization code), extract its value in the (char*)
1445    variable pointed by RET.  Returns negative on a malformed header,
1446    or number of bytes that have been parsed by this call.  */
1447 static int
1448 extract_header_attr (const char *au, const char *attr_name, char **ret)
1449 {
1450   const char *cp, *ep;
1451
1452   ep = cp = au;
1453
1454   if (strncmp (cp, attr_name, strlen (attr_name)) == 0)
1455     {
1456       cp += strlen (attr_name);
1457       if (!*cp)
1458         return -1;
1459       cp += skip_lws (cp);
1460       if (*cp != '=')
1461         return -1;
1462       if (!*++cp)
1463         return -1;
1464       cp += skip_lws (cp);
1465       if (*cp != '\"')
1466         return -1;
1467       if (!*++cp)
1468         return -1;
1469       for (ep = cp; *ep && *ep != '\"'; ep++)
1470         ;
1471       if (!*ep)
1472         return -1;
1473       FREE_MAYBE (*ret);
1474       *ret = strdupdelim (cp, ep);
1475       return ep - au + 1;
1476     }
1477   else
1478     return 0;
1479 }
1480
1481 /* Response value needs to be in lowercase, so we cannot use HEXD2ASC
1482    from url.h.  See RFC 2069 2.1.2 for the syntax of response-digest.  */
1483 #define HEXD2asc(x) (((x) < 10) ? ((x) + '0') : ((x) - 10 + 'a'))
1484
1485 /* Dump the hexadecimal representation of HASH to BUF.  HASH should be
1486    an array of 16 bytes containing the hash keys, and BUF should be a
1487    buffer of 33 writable characters (32 for hex digits plus one for
1488    zero termination).  */
1489 static void
1490 dump_hash (unsigned char *buf, const unsigned char *hash)
1491 {
1492   int i;
1493
1494   for (i = 0; i < MD5_HASHLEN; i++, hash++)
1495     {
1496       *buf++ = HEXD2asc (*hash >> 4);
1497       *buf++ = HEXD2asc (*hash & 0xf);
1498     }
1499   *buf = '\0';
1500 }
1501
1502 /* Take the line apart to find the challenge, and compose a digest
1503    authorization header.  See RFC2069 section 2.1.2.  */
1504 char *
1505 digest_authentication_encode (const char *au, const char *user,
1506                               const char *passwd, const char *method,
1507                               const char *path)
1508 {
1509   static char *realm, *opaque, *nonce;
1510   static struct {
1511     const char *name;
1512     char **variable;
1513   } options[] = {
1514     { "realm", &realm },
1515     { "opaque", &opaque },
1516     { "nonce", &nonce }
1517   };
1518   char *res;
1519
1520   realm = opaque = nonce = NULL;
1521
1522   au += 6;                      /* skip over `Digest' */
1523   while (*au)
1524     {
1525       int i;
1526
1527       au += skip_lws (au);
1528       for (i = 0; i < ARRAY_SIZE (options); i++)
1529         {
1530           int skip = extract_header_attr (au, options[i].name,
1531                                           options[i].variable);
1532           if (skip < 0)
1533             {
1534               FREE_MAYBE (realm);
1535               FREE_MAYBE (opaque);
1536               FREE_MAYBE (nonce);
1537               return NULL;
1538             }
1539           else if (skip)
1540             {
1541               au += skip;
1542               break;
1543             }
1544         }
1545       if (i == ARRAY_SIZE (options))
1546         {
1547           while (*au && *au != '=')
1548             au++;
1549           if (*au && *++au)
1550             {
1551               au += skip_lws (au);
1552               if (*au == '\"')
1553                 {
1554                   au++;
1555                   while (*au && *au != '\"')
1556                     au++;
1557                   if (*au)
1558                     au++;
1559                 }
1560             }
1561         }
1562       while (*au && *au != ',')
1563         au++;
1564       if (*au)
1565         au++;
1566     }
1567   if (!realm || !nonce || !user || !passwd || !path || !method)
1568     {
1569       FREE_MAYBE (realm);
1570       FREE_MAYBE (opaque);
1571       FREE_MAYBE (nonce);
1572       return NULL;
1573     }
1574
1575   /* Calculate the digest value.  */
1576   {
1577     struct md5_ctx ctx;
1578     unsigned char hash[MD5_HASHLEN];
1579     unsigned char a1buf[MD5_HASHLEN * 2 + 1], a2buf[MD5_HASHLEN * 2 + 1];
1580     unsigned char response_digest[MD5_HASHLEN * 2 + 1];
1581
1582     /* A1BUF = H(user ":" realm ":" password) */
1583     md5_init_ctx (&ctx);
1584     md5_process_bytes (user, strlen (user), &ctx);
1585     md5_process_bytes (":", 1, &ctx);
1586     md5_process_bytes (realm, strlen (realm), &ctx);
1587     md5_process_bytes (":", 1, &ctx);
1588     md5_process_bytes (passwd, strlen (passwd), &ctx);
1589     md5_finish_ctx (&ctx, hash);
1590     dump_hash (a1buf, hash);
1591
1592     /* A2BUF = H(method ":" path) */
1593     md5_init_ctx (&ctx);
1594     md5_process_bytes (method, strlen (method), &ctx);
1595     md5_process_bytes (":", 1, &ctx);
1596     md5_process_bytes (path, strlen (path), &ctx);
1597     md5_finish_ctx (&ctx, hash);
1598     dump_hash (a2buf, hash);
1599
1600     /* RESPONSE_DIGEST = H(A1BUF ":" nonce ":" A2BUF) */
1601     md5_init_ctx (&ctx);
1602     md5_process_bytes (a1buf, MD5_HASHLEN * 2, &ctx);
1603     md5_process_bytes (":", 1, &ctx);
1604     md5_process_bytes (nonce, strlen (nonce), &ctx);
1605     md5_process_bytes (":", 1, &ctx);
1606     md5_process_bytes (a2buf, MD5_HASHLEN * 2, &ctx);
1607     md5_finish_ctx (&ctx, hash);
1608     dump_hash (response_digest, hash);
1609
1610     res = (char*) xmalloc (strlen (user)
1611                            + strlen (user)
1612                            + strlen (realm)
1613                            + strlen (nonce)
1614                            + strlen (path)
1615                            + 2 * MD5_HASHLEN /*strlen (response_digest)*/
1616                            + (opaque ? strlen (opaque) : 0)
1617                            + 128);
1618     sprintf (res, "Authorization: Digest \
1619 username=\"%s\", realm=\"%s\", nonce=\"%s\", uri=\"%s\", response=\"%s\"",
1620              user, realm, nonce, path, response_digest);
1621     if (opaque)
1622       {
1623         char *p = res + strlen (res);
1624         strcat (p, ", opaque=\"");
1625         strcat (p, opaque);
1626         strcat (p, "\"");
1627       }
1628     strcat (res, "\r\n");
1629   }
1630   return res;
1631 }
1632 #endif /* USE_DIGEST */
1633
1634
1635 #define HACK_O_MATIC(line, string_constant)                             \
1636   (!strncasecmp (line, string_constant, sizeof (string_constant) - 1)   \
1637    && (ISSPACE (line[sizeof (string_constant) - 1])                     \
1638        || !line[sizeof (string_constant) - 1]))
1639
1640 static int
1641 known_authentication_scheme_p (const char *au)
1642 {
1643   return HACK_O_MATIC (au, "Basic") || HACK_O_MATIC (au, "Digest");
1644 }
1645
1646 #undef HACK_O_MATIC
1647
1648 /* Create the HTTP authorization request header.  When the
1649    `WWW-Authenticate' response header is seen, according to the
1650    authorization scheme specified in that header (`Basic' and `Digest'
1651    are supported by the current implementation), produce an
1652    appropriate HTTP authorization request header.  */
1653 static char *
1654 create_authorization_line (const char *au, const char *user,
1655                            const char *passwd, const char *method,
1656                            const char *path)
1657 {
1658   char *wwwauth = NULL;
1659
1660   if (!strncasecmp (au, "Basic", 5))
1661     wwwauth = basic_authentication_encode (user, passwd, "Authorization");
1662 #ifdef USE_DIGEST
1663   else if (!strncasecmp (au, "Digest", 6))
1664     wwwauth = digest_authentication_encode (au, user, passwd, method, path);
1665 #endif /* USE_DIGEST */
1666   return wwwauth;
1667 }