Rename --html-extension to --adjust-extension.
[wget] / src / http.c
1 /* HTTP support.
2    Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
3    2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
4
5 This file is part of GNU Wget.
6
7 GNU Wget is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10  (at your option) any later version.
11
12 GNU Wget is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with Wget.  If not, see <http://www.gnu.org/licenses/>.
19
20 Additional permission under GNU GPL version 3 section 7
21
22 If you modify this program, or any covered work, by linking or
23 combining it with the OpenSSL project's OpenSSL library (or a
24 modified version of that library), containing parts covered by the
25 terms of the OpenSSL or SSLeay licenses, the Free Software Foundation
26 grants you additional permission to convey the resulting work.
27 Corresponding Source for a non-source form of such a combination
28 shall include the source code for the parts of OpenSSL used as well
29 as that of the covered work.  */
30
31 #include "wget.h"
32
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <string.h>
36 #ifdef HAVE_UNISTD_H
37 # include <unistd.h>
38 #endif
39 #include <assert.h>
40 #include <errno.h>
41 #include <time.h>
42 #include <locale.h>
43
44 #include "hash.h"
45 #include "http.h"
46 #include "utils.h"
47 #include "url.h"
48 #include "host.h"
49 #include "retr.h"
50 #include "connect.h"
51 #include "netrc.h"
52 #ifdef HAVE_SSL
53 # include "ssl.h"
54 #endif
55 #ifdef ENABLE_NTLM
56 # include "http-ntlm.h"
57 #endif
58 #include "cookies.h"
59 #ifdef ENABLE_DIGEST
60 # include "gen-md5.h"
61 #endif
62 #include "convert.h"
63 #include "spider.h"
64
65 #ifdef TESTING
66 #include "test.h"
67 #endif
68
69 #ifdef __VMS
70 # include "vms.h"
71 #endif /* def __VMS */
72
73 extern char *version_string;
74
75 /* Forward decls. */
76 struct http_stat;
77 static char *create_authorization_line (const char *, const char *,
78                                         const char *, const char *,
79                                         const char *, bool *);
80 static char *basic_authentication_encode (const char *, const char *);
81 static bool known_authentication_scheme_p (const char *, const char *);
82 static void ensure_extension (struct http_stat *, const char *, int *);
83 static void load_cookies (void);
84
85 #ifndef MIN
86 # define MIN(x, y) ((x) > (y) ? (y) : (x))
87 #endif
88
89 \f
90 static bool cookies_loaded_p;
91 static struct cookie_jar *wget_cookie_jar;
92
93 #define TEXTHTML_S "text/html"
94 #define TEXTXHTML_S "application/xhtml+xml"
95 #define TEXTCSS_S "text/css"
96
97 /* Some status code validation macros: */
98 #define H_20X(x)        (((x) >= 200) && ((x) < 300))
99 #define H_PARTIAL(x)    ((x) == HTTP_STATUS_PARTIAL_CONTENTS)
100 #define H_REDIRECTED(x) ((x) == HTTP_STATUS_MOVED_PERMANENTLY          \
101                          || (x) == HTTP_STATUS_MOVED_TEMPORARILY       \
102                          || (x) == HTTP_STATUS_SEE_OTHER               \
103                          || (x) == HTTP_STATUS_TEMPORARY_REDIRECT)
104
105 /* HTTP/1.0 status codes from RFC1945, provided for reference.  */
106 /* Successful 2xx.  */
107 #define HTTP_STATUS_OK                    200
108 #define HTTP_STATUS_CREATED               201
109 #define HTTP_STATUS_ACCEPTED              202
110 #define HTTP_STATUS_NO_CONTENT            204
111 #define HTTP_STATUS_PARTIAL_CONTENTS      206
112
113 /* Redirection 3xx.  */
114 #define HTTP_STATUS_MULTIPLE_CHOICES      300
115 #define HTTP_STATUS_MOVED_PERMANENTLY     301
116 #define HTTP_STATUS_MOVED_TEMPORARILY     302
117 #define HTTP_STATUS_SEE_OTHER             303 /* from HTTP/1.1 */
118 #define HTTP_STATUS_NOT_MODIFIED          304
119 #define HTTP_STATUS_TEMPORARY_REDIRECT    307 /* from HTTP/1.1 */
120
121 /* Client error 4xx.  */
122 #define HTTP_STATUS_BAD_REQUEST           400
123 #define HTTP_STATUS_UNAUTHORIZED          401
124 #define HTTP_STATUS_FORBIDDEN             403
125 #define HTTP_STATUS_NOT_FOUND             404
126 #define HTTP_STATUS_RANGE_NOT_SATISFIABLE 416
127
128 /* Server errors 5xx.  */
129 #define HTTP_STATUS_INTERNAL              500
130 #define HTTP_STATUS_NOT_IMPLEMENTED       501
131 #define HTTP_STATUS_BAD_GATEWAY           502
132 #define HTTP_STATUS_UNAVAILABLE           503
133 \f
134 enum rp {
135   rel_none, rel_name, rel_value, rel_both
136 };
137
138 struct request {
139   const char *method;
140   char *arg;
141
142   struct request_header {
143     char *name, *value;
144     enum rp release_policy;
145   } *headers;
146   int hcount, hcapacity;
147 };
148
149 extern int numurls;
150
151 /* Create a new, empty request.  At least request_set_method must be
152    called before the request can be used.  */
153
154 static struct request *
155 request_new (void)
156 {
157   struct request *req = xnew0 (struct request);
158   req->hcapacity = 8;
159   req->headers = xnew_array (struct request_header, req->hcapacity);
160   return req;
161 }
162
163 /* Set the request's method and its arguments.  METH should be a
164    literal string (or it should outlive the request) because it will
165    not be freed.  ARG will be freed by request_free.  */
166
167 static void
168 request_set_method (struct request *req, const char *meth, char *arg)
169 {
170   req->method = meth;
171   req->arg = arg;
172 }
173
174 /* Return the method string passed with the last call to
175    request_set_method.  */
176
177 static const char *
178 request_method (const struct request *req)
179 {
180   return req->method;
181 }
182
183 /* Free one header according to the release policy specified with
184    request_set_header.  */
185
186 static void
187 release_header (struct request_header *hdr)
188 {
189   switch (hdr->release_policy)
190     {
191     case rel_none:
192       break;
193     case rel_name:
194       xfree (hdr->name);
195       break;
196     case rel_value:
197       xfree (hdr->value);
198       break;
199     case rel_both:
200       xfree (hdr->name);
201       xfree (hdr->value);
202       break;
203     }
204 }
205
206 /* Set the request named NAME to VALUE.  Specifically, this means that
207    a "NAME: VALUE\r\n" header line will be used in the request.  If a
208    header with the same name previously existed in the request, its
209    value will be replaced by this one.  A NULL value means do nothing.
210
211    RELEASE_POLICY determines whether NAME and VALUE should be released
212    (freed) with request_free.  Allowed values are:
213
214     - rel_none     - don't free NAME or VALUE
215     - rel_name     - free NAME when done
216     - rel_value    - free VALUE when done
217     - rel_both     - free both NAME and VALUE when done
218
219    Setting release policy is useful when arguments come from different
220    sources.  For example:
221
222      // Don't free literal strings!
223      request_set_header (req, "Pragma", "no-cache", rel_none);
224
225      // Don't free a global variable, we'll need it later.
226      request_set_header (req, "Referer", opt.referer, rel_none);
227
228      // Value freshly allocated, free it when done.
229      request_set_header (req, "Range",
230                          aprintf ("bytes=%s-", number_to_static_string (hs->restval)),
231                          rel_value);
232    */
233
234 static void
235 request_set_header (struct request *req, char *name, char *value,
236                     enum rp release_policy)
237 {
238   struct request_header *hdr;
239   int i;
240
241   if (!value)
242     {
243       /* A NULL value is a no-op; if freeing the name is requested,
244          free it now to avoid leaks.  */
245       if (release_policy == rel_name || release_policy == rel_both)
246         xfree (name);
247       return;
248     }
249
250   for (i = 0; i < req->hcount; i++)
251     {
252       hdr = &req->headers[i];
253       if (0 == strcasecmp (name, hdr->name))
254         {
255           /* Replace existing header. */
256           release_header (hdr);
257           hdr->name = name;
258           hdr->value = value;
259           hdr->release_policy = release_policy;
260           return;
261         }
262     }
263
264   /* Install new header. */
265
266   if (req->hcount >= req->hcapacity)
267     {
268       req->hcapacity <<= 1;
269       req->headers = xrealloc (req->headers, req->hcapacity * sizeof (*hdr));
270     }
271   hdr = &req->headers[req->hcount++];
272   hdr->name = name;
273   hdr->value = value;
274   hdr->release_policy = release_policy;
275 }
276
277 /* Like request_set_header, but sets the whole header line, as
278    provided by the user using the `--header' option.  For example,
279    request_set_user_header (req, "Foo: bar") works just like
280    request_set_header (req, "Foo", "bar").  */
281
282 static void
283 request_set_user_header (struct request *req, const char *header)
284 {
285   char *name;
286   const char *p = strchr (header, ':');
287   if (!p)
288     return;
289   BOUNDED_TO_ALLOCA (header, p, name);
290   ++p;
291   while (c_isspace (*p))
292     ++p;
293   request_set_header (req, xstrdup (name), (char *) p, rel_name);
294 }
295
296 /* Remove the header with specified name from REQ.  Returns true if
297    the header was actually removed, false otherwise.  */
298
299 static bool
300 request_remove_header (struct request *req, char *name)
301 {
302   int i;
303   for (i = 0; i < req->hcount; i++)
304     {
305       struct request_header *hdr = &req->headers[i];
306       if (0 == strcasecmp (name, hdr->name))
307         {
308           release_header (hdr);
309           /* Move the remaining headers by one. */
310           if (i < req->hcount - 1)
311             memmove (hdr, hdr + 1, (req->hcount - i - 1) * sizeof (*hdr));
312           --req->hcount;
313           return true;
314         }
315     }
316   return false;
317 }
318
319 #define APPEND(p, str) do {                     \
320   int A_len = strlen (str);                     \
321   memcpy (p, str, A_len);                       \
322   p += A_len;                                   \
323 } while (0)
324
325 /* Construct the request and write it to FD using fd_write.  */
326
327 static int
328 request_send (const struct request *req, int fd)
329 {
330   char *request_string, *p;
331   int i, size, write_error;
332
333   /* Count the request size. */
334   size = 0;
335
336   /* METHOD " " ARG " " "HTTP/1.0" "\r\n" */
337   size += strlen (req->method) + 1 + strlen (req->arg) + 1 + 8 + 2;
338
339   for (i = 0; i < req->hcount; i++)
340     {
341       struct request_header *hdr = &req->headers[i];
342       /* NAME ": " VALUE "\r\n" */
343       size += strlen (hdr->name) + 2 + strlen (hdr->value) + 2;
344     }
345
346   /* "\r\n\0" */
347   size += 3;
348
349   p = request_string = alloca_array (char, size);
350
351   /* Generate the request. */
352
353   APPEND (p, req->method); *p++ = ' ';
354   APPEND (p, req->arg);    *p++ = ' ';
355   memcpy (p, "HTTP/1.0\r\n", 10); p += 10;
356
357   for (i = 0; i < req->hcount; i++)
358     {
359       struct request_header *hdr = &req->headers[i];
360       APPEND (p, hdr->name);
361       *p++ = ':', *p++ = ' ';
362       APPEND (p, hdr->value);
363       *p++ = '\r', *p++ = '\n';
364     }
365
366   *p++ = '\r', *p++ = '\n', *p++ = '\0';
367   assert (p - request_string == size);
368
369 #undef APPEND
370
371   DEBUGP (("\n---request begin---\n%s---request end---\n", request_string));
372
373   /* Send the request to the server. */
374
375   write_error = fd_write (fd, request_string, size - 1, -1);
376   if (write_error < 0)
377     logprintf (LOG_VERBOSE, _("Failed writing HTTP request: %s.\n"),
378                fd_errstr (fd));
379   return write_error;
380 }
381
382 /* Release the resources used by REQ. */
383
384 static void
385 request_free (struct request *req)
386 {
387   int i;
388   xfree_null (req->arg);
389   for (i = 0; i < req->hcount; i++)
390     release_header (&req->headers[i]);
391   xfree_null (req->headers);
392   xfree (req);
393 }
394
395 static struct hash_table *basic_authed_hosts;
396
397 /* Find out if this host has issued a Basic challenge yet; if so, give
398  * it the username, password. A temporary measure until we can get
399  * proper authentication in place. */
400
401 static bool
402 maybe_send_basic_creds (const char *hostname, const char *user,
403                         const char *passwd, struct request *req)
404 {
405   bool do_challenge = false;
406
407   if (opt.auth_without_challenge)
408     {
409       DEBUGP(("Auth-without-challenge set, sending Basic credentials.\n"));
410       do_challenge = true;
411     }
412   else if (basic_authed_hosts
413       && hash_table_contains(basic_authed_hosts, hostname))
414     {
415       DEBUGP(("Found %s in basic_authed_hosts.\n", quote (hostname)));
416       do_challenge = true;
417     }
418   else
419     {
420       DEBUGP(("Host %s has not issued a general basic challenge.\n",
421               quote (hostname)));
422     }
423   if (do_challenge)
424     {
425       request_set_header (req, "Authorization",
426                           basic_authentication_encode (user, passwd),
427                           rel_value);
428     }
429   return do_challenge;
430 }
431
432 static void
433 register_basic_auth_host (const char *hostname)
434 {
435   if (!basic_authed_hosts)
436     {
437       basic_authed_hosts = make_nocase_string_hash_table (1);
438     }
439   if (!hash_table_contains(basic_authed_hosts, hostname))
440     {
441       hash_table_put (basic_authed_hosts, xstrdup(hostname), NULL);
442       DEBUGP(("Inserted %s into basic_authed_hosts\n", quote (hostname)));
443     }
444 }
445
446
447 /* Send the contents of FILE_NAME to SOCK.  Make sure that exactly
448    PROMISED_SIZE bytes are sent over the wire -- if the file is
449    longer, read only that much; if the file is shorter, report an error.  */
450
451 static int
452 post_file (int sock, const char *file_name, wgint promised_size)
453 {
454   static char chunk[8192];
455   wgint written = 0;
456   int write_error;
457   FILE *fp;
458
459   DEBUGP (("[writing POST file %s ... ", file_name));
460
461   fp = fopen (file_name, "rb");
462   if (!fp)
463     return -1;
464   while (!feof (fp) && written < promised_size)
465     {
466       int towrite;
467       int length = fread (chunk, 1, sizeof (chunk), fp);
468       if (length == 0)
469         break;
470       towrite = MIN (promised_size - written, length);
471       write_error = fd_write (sock, chunk, towrite, -1);
472       if (write_error < 0)
473         {
474           fclose (fp);
475           return -1;
476         }
477       written += towrite;
478     }
479   fclose (fp);
480
481   /* If we've written less than was promised, report a (probably
482      nonsensical) error rather than break the promise.  */
483   if (written < promised_size)
484     {
485       errno = EINVAL;
486       return -1;
487     }
488
489   assert (written == promised_size);
490   DEBUGP (("done]\n"));
491   return 0;
492 }
493 \f
494 /* Determine whether [START, PEEKED + PEEKLEN) contains an empty line.
495    If so, return the pointer to the position after the line, otherwise
496    return NULL.  This is used as callback to fd_read_hunk.  The data
497    between START and PEEKED has been read and cannot be "unread"; the
498    data after PEEKED has only been peeked.  */
499
500 static const char *
501 response_head_terminator (const char *start, const char *peeked, int peeklen)
502 {
503   const char *p, *end;
504
505   /* If at first peek, verify whether HUNK starts with "HTTP".  If
506      not, this is a HTTP/0.9 request and we must bail out without
507      reading anything.  */
508   if (start == peeked && 0 != memcmp (start, "HTTP", MIN (peeklen, 4)))
509     return start;
510
511   /* Look for "\n[\r]\n", and return the following position if found.
512      Start two chars before the current to cover the possibility that
513      part of the terminator (e.g. "\n\r") arrived in the previous
514      batch.  */
515   p = peeked - start < 2 ? start : peeked - 2;
516   end = peeked + peeklen;
517
518   /* Check for \n\r\n or \n\n anywhere in [p, end-2). */
519   for (; p < end - 2; p++)
520     if (*p == '\n')
521       {
522         if (p[1] == '\r' && p[2] == '\n')
523           return p + 3;
524         else if (p[1] == '\n')
525           return p + 2;
526       }
527   /* p==end-2: check for \n\n directly preceding END. */
528   if (p[0] == '\n' && p[1] == '\n')
529     return p + 2;
530
531   return NULL;
532 }
533
534 /* The maximum size of a single HTTP response we care to read.  Rather
535    than being a limit of the reader implementation, this limit
536    prevents Wget from slurping all available memory upon encountering
537    malicious or buggy server output, thus protecting the user.  Define
538    it to 0 to remove the limit.  */
539
540 #define HTTP_RESPONSE_MAX_SIZE 65536
541
542 /* Read the HTTP request head from FD and return it.  The error
543    conditions are the same as with fd_read_hunk.
544
545    To support HTTP/0.9 responses, this function tries to make sure
546    that the data begins with "HTTP".  If this is not the case, no data
547    is read and an empty request is returned, so that the remaining
548    data can be treated as body.  */
549
550 static char *
551 read_http_response_head (int fd)
552 {
553   return fd_read_hunk (fd, response_head_terminator, 512,
554                        HTTP_RESPONSE_MAX_SIZE);
555 }
556
557 struct response {
558   /* The response data. */
559   const char *data;
560
561   /* The array of pointers that indicate where each header starts.
562      For example, given this HTTP response:
563
564        HTTP/1.0 200 Ok
565        Description: some
566         text
567        Etag: x
568
569      The headers are located like this:
570
571      "HTTP/1.0 200 Ok\r\nDescription: some\r\n text\r\nEtag: x\r\n\r\n"
572      ^                   ^                             ^          ^
573      headers[0]          headers[1]                    headers[2] headers[3]
574
575      I.e. headers[0] points to the beginning of the request,
576      headers[1] points to the end of the first header and the
577      beginning of the second one, etc.  */
578
579   const char **headers;
580 };
581
582 /* Create a new response object from the text of the HTTP response,
583    available in HEAD.  That text is automatically split into
584    constituent header lines for fast retrieval using
585    resp_header_*.  */
586
587 static struct response *
588 resp_new (const char *head)
589 {
590   const char *hdr;
591   int count, size;
592
593   struct response *resp = xnew0 (struct response);
594   resp->data = head;
595
596   if (*head == '\0')
597     {
598       /* Empty head means that we're dealing with a headerless
599          (HTTP/0.9) response.  In that case, don't set HEADERS at
600          all.  */
601       return resp;
602     }
603
604   /* Split HEAD into header lines, so that resp_header_* functions
605      don't need to do this over and over again.  */
606
607   size = count = 0;
608   hdr = head;
609   while (1)
610     {
611       DO_REALLOC (resp->headers, size, count + 1, const char *);
612       resp->headers[count++] = hdr;
613
614       /* Break upon encountering an empty line. */
615       if (!hdr[0] || (hdr[0] == '\r' && hdr[1] == '\n') || hdr[0] == '\n')
616         break;
617
618       /* Find the end of HDR, including continuations. */
619       do
620         {
621           const char *end = strchr (hdr, '\n');
622           if (end)
623             hdr = end + 1;
624           else
625             hdr += strlen (hdr);
626         }
627       while (*hdr == ' ' || *hdr == '\t');
628     }
629   DO_REALLOC (resp->headers, size, count + 1, const char *);
630   resp->headers[count] = NULL;
631
632   return resp;
633 }
634
635 /* Locate the header named NAME in the request data, starting with
636    position START.  This allows the code to loop through the request
637    data, filtering for all requests of a given name.  Returns the
638    found position, or -1 for failure.  The code that uses this
639    function typically looks like this:
640
641      for (pos = 0; (pos = resp_header_locate (...)) != -1; pos++)
642        ... do something with header ...
643
644    If you only care about one header, use resp_header_get instead of
645    this function.  */
646
647 static int
648 resp_header_locate (const struct response *resp, const char *name, int start,
649                     const char **begptr, const char **endptr)
650 {
651   int i;
652   const char **headers = resp->headers;
653   int name_len;
654
655   if (!headers || !headers[1])
656     return -1;
657
658   name_len = strlen (name);
659   if (start > 0)
660     i = start;
661   else
662     i = 1;
663
664   for (; headers[i + 1]; i++)
665     {
666       const char *b = headers[i];
667       const char *e = headers[i + 1];
668       if (e - b > name_len
669           && b[name_len] == ':'
670           && 0 == strncasecmp (b, name, name_len))
671         {
672           b += name_len + 1;
673           while (b < e && c_isspace (*b))
674             ++b;
675           while (b < e && c_isspace (e[-1]))
676             --e;
677           *begptr = b;
678           *endptr = e;
679           return i;
680         }
681     }
682   return -1;
683 }
684
685 /* Find and retrieve the header named NAME in the request data.  If
686    found, set *BEGPTR to its starting, and *ENDPTR to its ending
687    position, and return true.  Otherwise return false.
688
689    This function is used as a building block for resp_header_copy
690    and resp_header_strdup.  */
691
692 static bool
693 resp_header_get (const struct response *resp, const char *name,
694                  const char **begptr, const char **endptr)
695 {
696   int pos = resp_header_locate (resp, name, 0, begptr, endptr);
697   return pos != -1;
698 }
699
700 /* Copy the response header named NAME to buffer BUF, no longer than
701    BUFSIZE (BUFSIZE includes the terminating 0).  If the header
702    exists, true is returned, false otherwise.  If there should be no
703    limit on the size of the header, use resp_header_strdup instead.
704
705    If BUFSIZE is 0, no data is copied, but the boolean indication of
706    whether the header is present is still returned.  */
707
708 static bool
709 resp_header_copy (const struct response *resp, const char *name,
710                   char *buf, int bufsize)
711 {
712   const char *b, *e;
713   if (!resp_header_get (resp, name, &b, &e))
714     return false;
715   if (bufsize)
716     {
717       int len = MIN (e - b, bufsize - 1);
718       memcpy (buf, b, len);
719       buf[len] = '\0';
720     }
721   return true;
722 }
723
724 /* Return the value of header named NAME in RESP, allocated with
725    malloc.  If such a header does not exist in RESP, return NULL.  */
726
727 static char *
728 resp_header_strdup (const struct response *resp, const char *name)
729 {
730   const char *b, *e;
731   if (!resp_header_get (resp, name, &b, &e))
732     return NULL;
733   return strdupdelim (b, e);
734 }
735
736 /* Parse the HTTP status line, which is of format:
737
738    HTTP-Version SP Status-Code SP Reason-Phrase
739
740    The function returns the status-code, or -1 if the status line
741    appears malformed.  The pointer to "reason-phrase" message is
742    returned in *MESSAGE.  */
743
744 static int
745 resp_status (const struct response *resp, char **message)
746 {
747   int status;
748   const char *p, *end;
749
750   if (!resp->headers)
751     {
752       /* For a HTTP/0.9 response, assume status 200. */
753       if (message)
754         *message = xstrdup (_("No headers, assuming HTTP/0.9"));
755       return 200;
756     }
757
758   p = resp->headers[0];
759   end = resp->headers[1];
760
761   if (!end)
762     return -1;
763
764   /* "HTTP" */
765   if (end - p < 4 || 0 != strncmp (p, "HTTP", 4))
766     return -1;
767   p += 4;
768
769   /* Match the HTTP version.  This is optional because Gnutella
770      servers have been reported to not specify HTTP version.  */
771   if (p < end && *p == '/')
772     {
773       ++p;
774       while (p < end && c_isdigit (*p))
775         ++p;
776       if (p < end && *p == '.')
777         ++p; 
778       while (p < end && c_isdigit (*p))
779         ++p;
780     }
781
782   while (p < end && c_isspace (*p))
783     ++p;
784   if (end - p < 3 || !c_isdigit (p[0]) || !c_isdigit (p[1]) || !c_isdigit (p[2]))
785     return -1;
786
787   status = 100 * (p[0] - '0') + 10 * (p[1] - '0') + (p[2] - '0');
788   p += 3;
789
790   if (message)
791     {
792       while (p < end && c_isspace (*p))
793         ++p;
794       while (p < end && c_isspace (end[-1]))
795         --end;
796       *message = strdupdelim (p, end);
797     }
798
799   return status;
800 }
801
802 /* Release the resources used by RESP.  */
803
804 static void
805 resp_free (struct response *resp)
806 {
807   xfree_null (resp->headers);
808   xfree (resp);
809 }
810
811 /* Print a single line of response, the characters [b, e).  We tried
812    getting away with
813       logprintf (LOG_VERBOSE, "%s%.*s\n", prefix, (int) (e - b), b);
814    but that failed to escape the non-printable characters and, in fact,
815    caused crashes in UTF-8 locales.  */
816
817 static void
818 print_response_line(const char *prefix, const char *b, const char *e)
819 {
820   char *copy;
821   BOUNDED_TO_ALLOCA(b, e, copy);
822   logprintf (LOG_ALWAYS, "%s%s\n", prefix, 
823              quotearg_style (escape_quoting_style, copy));
824 }
825
826 /* Print the server response, line by line, omitting the trailing CRLF
827    from individual header lines, and prefixed with PREFIX.  */
828
829 static void
830 print_server_response (const struct response *resp, const char *prefix)
831 {
832   int i;
833   if (!resp->headers)
834     return;
835   for (i = 0; resp->headers[i + 1]; i++)
836     {
837       const char *b = resp->headers[i];
838       const char *e = resp->headers[i + 1];
839       /* Skip CRLF */
840       if (b < e && e[-1] == '\n')
841         --e;
842       if (b < e && e[-1] == '\r')
843         --e;
844       print_response_line(prefix, b, e);
845     }
846 }
847
848 /* Parse the `Content-Range' header and extract the information it
849    contains.  Returns true if successful, false otherwise.  */
850 static bool
851 parse_content_range (const char *hdr, wgint *first_byte_ptr,
852                      wgint *last_byte_ptr, wgint *entity_length_ptr)
853 {
854   wgint num;
855
856   /* Ancient versions of Netscape proxy server, presumably predating
857      rfc2068, sent out `Content-Range' without the "bytes"
858      specifier.  */
859   if (0 == strncasecmp (hdr, "bytes", 5))
860     {
861       hdr += 5;
862       /* "JavaWebServer/1.1.1" sends "bytes: x-y/z", contrary to the
863          HTTP spec. */
864       if (*hdr == ':')
865         ++hdr;
866       while (c_isspace (*hdr))
867         ++hdr;
868       if (!*hdr)
869         return false;
870     }
871   if (!c_isdigit (*hdr))
872     return false;
873   for (num = 0; c_isdigit (*hdr); hdr++)
874     num = 10 * num + (*hdr - '0');
875   if (*hdr != '-' || !c_isdigit (*(hdr + 1)))
876     return false;
877   *first_byte_ptr = num;
878   ++hdr;
879   for (num = 0; c_isdigit (*hdr); hdr++)
880     num = 10 * num + (*hdr - '0');
881   if (*hdr != '/' || !c_isdigit (*(hdr + 1)))
882     return false;
883   *last_byte_ptr = num;
884   ++hdr;
885   if (*hdr == '*')
886     num = -1;
887   else
888     for (num = 0; c_isdigit (*hdr); hdr++)
889       num = 10 * num + (*hdr - '0');
890   *entity_length_ptr = num;
891   return true;
892 }
893
894 /* Read the body of the request, but don't store it anywhere and don't
895    display a progress gauge.  This is useful for reading the bodies of
896    administrative responses to which we will soon issue another
897    request.  The response is not useful to the user, but reading it
898    allows us to continue using the same connection to the server.
899
900    If reading fails, false is returned, true otherwise.  In debug
901    mode, the body is displayed for debugging purposes.  */
902
903 static bool
904 skip_short_body (int fd, wgint contlen)
905 {
906   enum {
907     SKIP_SIZE = 512,                /* size of the download buffer */
908     SKIP_THRESHOLD = 4096        /* the largest size we read */
909   };
910   char dlbuf[SKIP_SIZE + 1];
911   dlbuf[SKIP_SIZE] = '\0';        /* so DEBUGP can safely print it */
912
913   /* We shouldn't get here with unknown contlen.  (This will change
914      with HTTP/1.1, which supports "chunked" transfer.)  */
915   assert (contlen != -1);
916
917   /* If the body is too large, it makes more sense to simply close the
918      connection than to try to read the body.  */
919   if (contlen > SKIP_THRESHOLD)
920     return false;
921
922   DEBUGP (("Skipping %s bytes of body: [", number_to_static_string (contlen)));
923
924   while (contlen > 0)
925     {
926       int ret = fd_read (fd, dlbuf, MIN (contlen, SKIP_SIZE), -1);
927       if (ret <= 0)
928         {
929           /* Don't normally report the error since this is an
930              optimization that should be invisible to the user.  */
931           DEBUGP (("] aborting (%s).\n",
932                    ret < 0 ? fd_errstr (fd) : "EOF received"));
933           return false;
934         }
935       contlen -= ret;
936       /* Safe even if %.*s bogusly expects terminating \0 because
937          we've zero-terminated dlbuf above.  */
938       DEBUGP (("%.*s", ret, dlbuf));
939     }
940
941   DEBUGP (("] done.\n"));
942   return true;
943 }
944
945 /* Extract a parameter from the string (typically an HTTP header) at
946    **SOURCE and advance SOURCE to the next parameter.  Return false
947    when there are no more parameters to extract.  The name of the
948    parameter is returned in NAME, and the value in VALUE.  If the
949    parameter has no value, the token's value is zeroed out.
950
951    For example, if *SOURCE points to the string "attachment;
952    filename=\"foo bar\"", the first call to this function will return
953    the token named "attachment" and no value, and the second call will
954    return the token named "filename" and value "foo bar".  The third
955    call will return false, indicating no more valid tokens.  */
956
957 bool
958 extract_param (const char **source, param_token *name, param_token *value,
959                char separator)
960 {
961   const char *p = *source;
962
963   while (c_isspace (*p)) ++p;
964   if (!*p)
965     {
966       *source = p;
967       return false;             /* no error; nothing more to extract */
968     }
969
970   /* Extract name. */
971   name->b = p;
972   while (*p && !c_isspace (*p) && *p != '=' && *p != separator) ++p;
973   name->e = p;
974   if (name->b == name->e)
975     return false;               /* empty name: error */
976   while (c_isspace (*p)) ++p;
977   if (*p == separator || !*p)           /* no value */
978     {
979       xzero (*value);
980       if (*p == separator) ++p;
981       *source = p;
982       return true;
983     }
984   if (*p != '=')
985     return false;               /* error */
986
987   /* *p is '=', extract value */
988   ++p;
989   while (c_isspace (*p)) ++p;
990   if (*p == '"')                /* quoted */
991     {
992       value->b = ++p;
993       while (*p && *p != '"') ++p;
994       if (!*p)
995         return false;
996       value->e = p++;
997       /* Currently at closing quote; find the end of param. */
998       while (c_isspace (*p)) ++p;
999       while (*p && *p != separator) ++p;
1000       if (*p == separator)
1001         ++p;
1002       else if (*p)
1003         /* garbage after closed quote, e.g. foo="bar"baz */
1004         return false;
1005     }
1006   else                          /* unquoted */
1007     {
1008       value->b = p;
1009       while (*p && *p != separator) ++p;
1010       value->e = p;
1011       while (value->e != value->b && c_isspace (value->e[-1]))
1012         --value->e;
1013       if (*p == separator) ++p;
1014     }
1015   *source = p;
1016   return true;
1017 }
1018
1019 #undef MAX
1020 #define MAX(p, q) ((p) > (q) ? (p) : (q))
1021
1022 /* Parse the contents of the `Content-Disposition' header, extracting
1023    the information useful to Wget.  Content-Disposition is a header
1024    borrowed from MIME; when used in HTTP, it typically serves for
1025    specifying the desired file name of the resource.  For example:
1026
1027        Content-Disposition: attachment; filename="flora.jpg"
1028
1029    Wget will skip the tokens it doesn't care about, such as
1030    "attachment" in the previous example; it will also skip other
1031    unrecognized params.  If the header is syntactically correct and
1032    contains a file name, a copy of the file name is stored in
1033    *filename and true is returned.  Otherwise, the function returns
1034    false.
1035
1036    The file name is stripped of directory components and must not be
1037    empty.  */
1038
1039 static bool
1040 parse_content_disposition (const char *hdr, char **filename)
1041 {
1042   param_token name, value;
1043   while (extract_param (&hdr, &name, &value, ';'))
1044     if (BOUNDED_EQUAL_NO_CASE (name.b, name.e, "filename") && value.b != NULL)
1045       {
1046         /* Make the file name begin at the last slash or backslash. */
1047         const char *last_slash = memrchr (value.b, '/', value.e - value.b);
1048         const char *last_bs = memrchr (value.b, '\\', value.e - value.b);
1049         if (last_slash && last_bs)
1050           value.b = 1 + MAX (last_slash, last_bs);
1051         else if (last_slash || last_bs)
1052           value.b = 1 + (last_slash ? last_slash : last_bs);
1053         if (value.b == value.e)
1054           continue;
1055         /* Start with the directory prefix, if specified. */
1056         if (opt.dir_prefix)
1057           {
1058             int prefix_length = strlen (opt.dir_prefix);
1059             bool add_slash = (opt.dir_prefix[prefix_length - 1] != '/');
1060             int total_length;
1061
1062             if (add_slash) 
1063               ++prefix_length;
1064             total_length = prefix_length + (value.e - value.b);            
1065             *filename = xmalloc (total_length + 1);
1066             strcpy (*filename, opt.dir_prefix);
1067             if (add_slash) 
1068               (*filename)[prefix_length - 1] = '/';
1069             memcpy (*filename + prefix_length, value.b, (value.e - value.b));
1070             (*filename)[total_length] = '\0';
1071           }
1072         else
1073           *filename = strdupdelim (value.b, value.e);
1074         return true;
1075       }
1076   return false;
1077 }
1078 \f
1079 /* Persistent connections.  Currently, we cache the most recently used
1080    connection as persistent, provided that the HTTP server agrees to
1081    make it such.  The persistence data is stored in the variables
1082    below.  Ideally, it should be possible to cache an arbitrary fixed
1083    number of these connections.  */
1084
1085 /* Whether a persistent connection is active. */
1086 static bool pconn_active;
1087
1088 static struct {
1089   /* The socket of the connection.  */
1090   int socket;
1091
1092   /* Host and port of the currently active persistent connection. */
1093   char *host;
1094   int port;
1095
1096   /* Whether a ssl handshake has occoured on this connection.  */
1097   bool ssl;
1098
1099   /* Whether the connection was authorized.  This is only done by
1100      NTLM, which authorizes *connections* rather than individual
1101      requests.  (That practice is peculiar for HTTP, but it is a
1102      useful optimization.)  */
1103   bool authorized;
1104
1105 #ifdef ENABLE_NTLM
1106   /* NTLM data of the current connection.  */
1107   struct ntlmdata ntlm;
1108 #endif
1109 } pconn;
1110
1111 /* Mark the persistent connection as invalid and free the resources it
1112    uses.  This is used by the CLOSE_* macros after they forcefully
1113    close a registered persistent connection.  */
1114
1115 static void
1116 invalidate_persistent (void)
1117 {
1118   DEBUGP (("Disabling further reuse of socket %d.\n", pconn.socket));
1119   pconn_active = false;
1120   fd_close (pconn.socket);
1121   xfree (pconn.host);
1122   xzero (pconn);
1123 }
1124
1125 /* Register FD, which should be a TCP/IP connection to HOST:PORT, as
1126    persistent.  This will enable someone to use the same connection
1127    later.  In the context of HTTP, this must be called only AFTER the
1128    response has been received and the server has promised that the
1129    connection will remain alive.
1130
1131    If a previous connection was persistent, it is closed. */
1132
1133 static void
1134 register_persistent (const char *host, int port, int fd, bool ssl)
1135 {
1136   if (pconn_active)
1137     {
1138       if (pconn.socket == fd)
1139         {
1140           /* The connection FD is already registered. */
1141           return;
1142         }
1143       else
1144         {
1145           /* The old persistent connection is still active; close it
1146              first.  This situation arises whenever a persistent
1147              connection exists, but we then connect to a different
1148              host, and try to register a persistent connection to that
1149              one.  */
1150           invalidate_persistent ();
1151         }
1152     }
1153
1154   pconn_active = true;
1155   pconn.socket = fd;
1156   pconn.host = xstrdup (host);
1157   pconn.port = port;
1158   pconn.ssl = ssl;
1159   pconn.authorized = false;
1160
1161   DEBUGP (("Registered socket %d for persistent reuse.\n", fd));
1162 }
1163
1164 /* Return true if a persistent connection is available for connecting
1165    to HOST:PORT.  */
1166
1167 static bool
1168 persistent_available_p (const char *host, int port, bool ssl,
1169                         bool *host_lookup_failed)
1170 {
1171   /* First, check whether a persistent connection is active at all.  */
1172   if (!pconn_active)
1173     return false;
1174
1175   /* If we want SSL and the last connection wasn't or vice versa,
1176      don't use it.  Checking for host and port is not enough because
1177      HTTP and HTTPS can apparently coexist on the same port.  */
1178   if (ssl != pconn.ssl)
1179     return false;
1180
1181   /* If we're not connecting to the same port, we're not interested. */
1182   if (port != pconn.port)
1183     return false;
1184
1185   /* If the host is the same, we're in business.  If not, there is
1186      still hope -- read below.  */
1187   if (0 != strcasecmp (host, pconn.host))
1188     {
1189       /* Check if pconn.socket is talking to HOST under another name.
1190          This happens often when both sites are virtual hosts
1191          distinguished only by name and served by the same network
1192          interface, and hence the same web server (possibly set up by
1193          the ISP and serving many different web sites).  This
1194          admittedly unconventional optimization does not contradict
1195          HTTP and works well with popular server software.  */
1196
1197       bool found;
1198       ip_address ip;
1199       struct address_list *al;
1200
1201       if (ssl)
1202         /* Don't try to talk to two different SSL sites over the same
1203            secure connection!  (Besides, it's not clear that
1204            name-based virtual hosting is even possible with SSL.)  */
1205         return false;
1206
1207       /* If pconn.socket's peer is one of the IP addresses HOST
1208          resolves to, pconn.socket is for all intents and purposes
1209          already talking to HOST.  */
1210
1211       if (!socket_ip_address (pconn.socket, &ip, ENDPOINT_PEER))
1212         {
1213           /* Can't get the peer's address -- something must be very
1214              wrong with the connection.  */
1215           invalidate_persistent ();
1216           return false;
1217         }
1218       al = lookup_host (host, 0);
1219       if (!al)
1220         {
1221           *host_lookup_failed = true;
1222           return false;
1223         }
1224
1225       found = address_list_contains (al, &ip);
1226       address_list_release (al);
1227
1228       if (!found)
1229         return false;
1230
1231       /* The persistent connection's peer address was found among the
1232          addresses HOST resolved to; therefore, pconn.sock is in fact
1233          already talking to HOST -- no need to reconnect.  */
1234     }
1235
1236   /* Finally, check whether the connection is still open.  This is
1237      important because most servers implement liberal (short) timeout
1238      on persistent connections.  Wget can of course always reconnect
1239      if the connection doesn't work out, but it's nicer to know in
1240      advance.  This test is a logical followup of the first test, but
1241      is "expensive" and therefore placed at the end of the list.
1242
1243      (Current implementation of test_socket_open has a nice side
1244      effect that it treats sockets with pending data as "closed".
1245      This is exactly what we want: if a broken server sends message
1246      body in response to HEAD, or if it sends more than conent-length
1247      data, we won't reuse the corrupted connection.)  */
1248
1249   if (!test_socket_open (pconn.socket))
1250     {
1251       /* Oops, the socket is no longer open.  Now that we know that,
1252          let's invalidate the persistent connection before returning
1253          0.  */
1254       invalidate_persistent ();
1255       return false;
1256     }
1257
1258   return true;
1259 }
1260
1261 /* The idea behind these two CLOSE macros is to distinguish between
1262    two cases: one when the job we've been doing is finished, and we
1263    want to close the connection and leave, and two when something is
1264    seriously wrong and we're closing the connection as part of
1265    cleanup.
1266
1267    In case of keep_alive, CLOSE_FINISH should leave the connection
1268    open, while CLOSE_INVALIDATE should still close it.
1269
1270    Note that the semantics of the flag `keep_alive' is "this
1271    connection *will* be reused (the server has promised not to close
1272    the connection once we're done)", while the semantics of
1273    `pc_active_p && (fd) == pc_last_fd' is "we're *now* using an
1274    active, registered connection".  */
1275
1276 #define CLOSE_FINISH(fd) do {                   \
1277   if (!keep_alive)                              \
1278     {                                           \
1279       if (pconn_active && (fd) == pconn.socket) \
1280         invalidate_persistent ();               \
1281       else                                      \
1282         {                                       \
1283           fd_close (fd);                        \
1284           fd = -1;                              \
1285         }                                       \
1286     }                                           \
1287 } while (0)
1288
1289 #define CLOSE_INVALIDATE(fd) do {               \
1290   if (pconn_active && (fd) == pconn.socket)     \
1291     invalidate_persistent ();                   \
1292   else                                          \
1293     fd_close (fd);                              \
1294   fd = -1;                                      \
1295 } while (0)
1296 \f
1297 struct http_stat
1298 {
1299   wgint len;                    /* received length */
1300   wgint contlen;                /* expected length */
1301   wgint restval;                /* the restart value */
1302   int res;                      /* the result of last read */
1303   char *rderrmsg;               /* error message from read error */
1304   char *newloc;                 /* new location (redirection) */
1305   char *remote_time;            /* remote time-stamp string */
1306   char *error;                  /* textual HTTP error */
1307   int statcode;                 /* status code */
1308   char *message;                /* status message */
1309   wgint rd_size;                /* amount of data read from socket */
1310   double dltime;                /* time it took to download the data */
1311   const char *referer;          /* value of the referer header. */
1312   char *local_file;             /* local file name. */
1313   bool existence_checked;       /* true if we already checked for a file's
1314                                    existence after having begun to download
1315                                    (needed in gethttp for when connection is
1316                                    interrupted/restarted. */
1317   bool timestamp_checked;       /* true if pre-download time-stamping checks 
1318                                  * have already been performed */
1319   char *orig_file_name;         /* name of file to compare for time-stamping
1320                                  * (might be != local_file if -K is set) */
1321   wgint orig_file_size;         /* size of file to compare for time-stamping */
1322   time_t orig_file_tstamp;      /* time-stamp of file to compare for 
1323                                  * time-stamping */
1324 };
1325
1326 static void
1327 free_hstat (struct http_stat *hs)
1328 {
1329   xfree_null (hs->newloc);
1330   xfree_null (hs->remote_time);
1331   xfree_null (hs->error);
1332   xfree_null (hs->rderrmsg);
1333   xfree_null (hs->local_file);
1334   xfree_null (hs->orig_file_name);
1335   xfree_null (hs->message);
1336
1337   /* Guard against being called twice. */
1338   hs->newloc = NULL;
1339   hs->remote_time = NULL;
1340   hs->error = NULL;
1341 }
1342
1343 #define BEGINS_WITH(line, string_constant)                               \
1344   (!strncasecmp (line, string_constant, sizeof (string_constant) - 1)    \
1345    && (c_isspace (line[sizeof (string_constant) - 1])                      \
1346        || !line[sizeof (string_constant) - 1]))
1347
1348 #ifdef __VMS
1349 #define SET_USER_AGENT(req) do {                                         \
1350   if (!opt.useragent)                                                    \
1351     request_set_header (req, "User-Agent",                               \
1352                         aprintf ("Wget/%s (VMS %s %s)",                  \
1353                         version_string, vms_arch(), vms_vers()),         \
1354                         rel_value);                                      \
1355   else if (*opt.useragent)                                               \
1356     request_set_header (req, "User-Agent", opt.useragent, rel_none);     \
1357 } while (0)
1358 #else /* def __VMS */
1359 #define SET_USER_AGENT(req) do {                                         \
1360   if (!opt.useragent)                                                    \
1361     request_set_header (req, "User-Agent",                               \
1362                         aprintf ("Wget/%s (%s)",                         \
1363                         version_string, OS_TYPE),                        \
1364                         rel_value);                                      \
1365   else if (*opt.useragent)                                               \
1366     request_set_header (req, "User-Agent", opt.useragent, rel_none);     \
1367 } while (0)
1368 #endif /* def __VMS [else] */
1369
1370 /* The flags that allow clobbering the file (opening with "wb").
1371    Defined here to avoid repetition later.  #### This will require
1372    rework.  */
1373 #define ALLOW_CLOBBER (opt.noclobber || opt.always_rest || opt.timestamping \
1374                        || opt.dirstruct || opt.output_document)
1375
1376 /* Retrieve a document through HTTP protocol.  It recognizes status
1377    code, and correctly handles redirections.  It closes the network
1378    socket.  If it receives an error from the functions below it, it
1379    will print it if there is enough information to do so (almost
1380    always), returning the error to the caller (i.e. http_loop).
1381
1382    Various HTTP parameters are stored to hs.
1383
1384    If PROXY is non-NULL, the connection will be made to the proxy
1385    server, and u->url will be requested.  */
1386 static uerr_t
1387 gethttp (struct url *u, struct http_stat *hs, int *dt, struct url *proxy,
1388          struct iri *iri)
1389 {
1390   struct request *req;
1391
1392   char *type;
1393   char *user, *passwd;
1394   char *proxyauth;
1395   int statcode;
1396   int write_error;
1397   wgint contlen, contrange;
1398   struct url *conn;
1399   FILE *fp;
1400
1401   int sock = -1;
1402   int flags;
1403
1404   /* Set to 1 when the authorization has already been sent and should
1405      not be tried again. */
1406   bool auth_finished = false;
1407
1408   /* Set to 1 when just globally-set Basic authorization has been sent;
1409    * should prevent further Basic negotiations, but not other
1410    * mechanisms. */
1411   bool basic_auth_finished = false;
1412
1413   /* Whether NTLM authentication is used for this request. */
1414   bool ntlm_seen = false;
1415
1416   /* Whether our connection to the remote host is through SSL.  */
1417   bool using_ssl = false;
1418
1419   /* Whether a HEAD request will be issued (as opposed to GET or
1420      POST). */
1421   bool head_only = !!(*dt & HEAD_ONLY);
1422
1423   char *head;
1424   struct response *resp;
1425   char hdrval[256];
1426   char *message;
1427
1428   /* Whether this connection will be kept alive after the HTTP request
1429      is done. */
1430   bool keep_alive;
1431
1432   /* Whether keep-alive should be inhibited.
1433
1434      RFC 2068 requests that 1.0 clients not send keep-alive requests
1435      to proxies.  This is because many 1.0 proxies do not interpret
1436      the Connection header and transfer it to the remote server,
1437      causing it to not close the connection and leave both the proxy
1438      and the client hanging.  */
1439   bool inhibit_keep_alive =
1440     !opt.http_keep_alive || opt.ignore_length || proxy != NULL;
1441
1442   /* Headers sent when using POST. */
1443   wgint post_data_size = 0;
1444
1445   bool host_lookup_failed = false;
1446
1447 #ifdef HAVE_SSL
1448   if (u->scheme == SCHEME_HTTPS)
1449     {
1450       /* Initialize the SSL context.  After this has once been done,
1451          it becomes a no-op.  */
1452       if (!ssl_init ())
1453         {
1454           scheme_disable (SCHEME_HTTPS);
1455           logprintf (LOG_NOTQUIET,
1456                      _("Disabling SSL due to encountered errors.\n"));
1457           return SSLINITFAILED;
1458         }
1459     }
1460 #endif /* HAVE_SSL */
1461
1462   /* Initialize certain elements of struct http_stat.  */
1463   hs->len = 0;
1464   hs->contlen = -1;
1465   hs->res = -1;
1466   hs->rderrmsg = NULL;
1467   hs->newloc = NULL;
1468   hs->remote_time = NULL;
1469   hs->error = NULL;
1470   hs->message = NULL;
1471
1472   conn = u;
1473
1474   /* Prepare the request to send. */
1475
1476   req = request_new ();
1477   {
1478     char *meth_arg;
1479     const char *meth = "GET";
1480     if (head_only)
1481       meth = "HEAD";
1482     else if (opt.post_file_name || opt.post_data)
1483       meth = "POST";
1484     /* Use the full path, i.e. one that includes the leading slash and
1485        the query string.  E.g. if u->path is "foo/bar" and u->query is
1486        "param=value", full_path will be "/foo/bar?param=value".  */
1487     if (proxy
1488 #ifdef HAVE_SSL
1489         /* When using SSL over proxy, CONNECT establishes a direct
1490            connection to the HTTPS server.  Therefore use the same
1491            argument as when talking to the server directly. */
1492         && u->scheme != SCHEME_HTTPS
1493 #endif
1494         )
1495       meth_arg = xstrdup (u->url);
1496     else
1497       meth_arg = url_full_path (u);
1498     request_set_method (req, meth, meth_arg);
1499   }
1500
1501   request_set_header (req, "Referer", (char *) hs->referer, rel_none);
1502   if (*dt & SEND_NOCACHE)
1503     request_set_header (req, "Pragma", "no-cache", rel_none);
1504   if (hs->restval)
1505     request_set_header (req, "Range",
1506                         aprintf ("bytes=%s-",
1507                                  number_to_static_string (hs->restval)),
1508                         rel_value);
1509   SET_USER_AGENT (req);
1510   request_set_header (req, "Accept", "*/*", rel_none);
1511
1512   /* Find the username and password for authentication. */
1513   user = u->user;
1514   passwd = u->passwd;
1515   search_netrc (u->host, (const char **)&user, (const char **)&passwd, 0);
1516   user = user ? user : (opt.http_user ? opt.http_user : opt.user);
1517   passwd = passwd ? passwd : (opt.http_passwd ? opt.http_passwd : opt.passwd);
1518
1519   /* We only do "site-wide" authentication with "global" user/password
1520    * values unless --auth-no-challange has been requested; URL user/password
1521    * info overrides. */
1522   if (user && passwd && (!u->user || opt.auth_without_challenge))
1523     {
1524       /* If this is a host for which we've already received a Basic
1525        * challenge, we'll go ahead and send Basic authentication creds. */
1526       basic_auth_finished = maybe_send_basic_creds(u->host, user, passwd, req);
1527     }
1528
1529   /* Generate the Host header, HOST:PORT.  Take into account that:
1530
1531      - Broken server-side software often doesn't recognize the PORT
1532        argument, so we must generate "Host: www.server.com" instead of
1533        "Host: www.server.com:80" (and likewise for https port).
1534
1535      - IPv6 addresses contain ":", so "Host: 3ffe:8100:200:2::2:1234"
1536        becomes ambiguous and needs to be rewritten as "Host:
1537        [3ffe:8100:200:2::2]:1234".  */
1538   {
1539     /* Formats arranged for hfmt[add_port][add_squares].  */
1540     static const char *hfmt[][2] = {
1541       { "%s", "[%s]" }, { "%s:%d", "[%s]:%d" }
1542     };
1543     int add_port = u->port != scheme_default_port (u->scheme);
1544     int add_squares = strchr (u->host, ':') != NULL;
1545     request_set_header (req, "Host",
1546                         aprintf (hfmt[add_port][add_squares], u->host, u->port),
1547                         rel_value);
1548   }
1549
1550   if (!inhibit_keep_alive)
1551     request_set_header (req, "Connection", "Keep-Alive", rel_none);
1552
1553   if (opt.cookies)
1554     request_set_header (req, "Cookie",
1555                         cookie_header (wget_cookie_jar,
1556                                        u->host, u->port, u->path,
1557 #ifdef HAVE_SSL
1558                                        u->scheme == SCHEME_HTTPS
1559 #else
1560                                        0
1561 #endif
1562                                        ),
1563                         rel_value);
1564
1565   if (opt.post_data || opt.post_file_name)
1566     {
1567       request_set_header (req, "Content-Type",
1568                           "application/x-www-form-urlencoded", rel_none);
1569       if (opt.post_data)
1570         post_data_size = strlen (opt.post_data);
1571       else
1572         {
1573           post_data_size = file_size (opt.post_file_name);
1574           if (post_data_size == -1)
1575             {
1576               logprintf (LOG_NOTQUIET, _("POST data file %s missing: %s\n"),
1577                          quote (opt.post_file_name), strerror (errno));
1578               post_data_size = 0;
1579             }
1580         }
1581       request_set_header (req, "Content-Length",
1582                           xstrdup (number_to_static_string (post_data_size)),
1583                           rel_value);
1584     }
1585
1586   /* Add the user headers. */
1587   if (opt.user_headers)
1588     {
1589       int i;
1590       for (i = 0; opt.user_headers[i]; i++)
1591         request_set_user_header (req, opt.user_headers[i]);
1592     }
1593
1594  retry_with_auth:
1595   /* We need to come back here when the initial attempt to retrieve
1596      without authorization header fails.  (Expected to happen at least
1597      for the Digest authorization scheme.)  */
1598
1599   proxyauth = NULL;
1600   if (proxy)
1601     {
1602       char *proxy_user, *proxy_passwd;
1603       /* For normal username and password, URL components override
1604          command-line/wgetrc parameters.  With proxy
1605          authentication, it's the reverse, because proxy URLs are
1606          normally the "permanent" ones, so command-line args
1607          should take precedence.  */
1608       if (opt.proxy_user && opt.proxy_passwd)
1609         {
1610           proxy_user = opt.proxy_user;
1611           proxy_passwd = opt.proxy_passwd;
1612         }
1613       else
1614         {
1615           proxy_user = proxy->user;
1616           proxy_passwd = proxy->passwd;
1617         }
1618       /* #### This does not appear right.  Can't the proxy request,
1619          say, `Digest' authentication?  */
1620       if (proxy_user && proxy_passwd)
1621         proxyauth = basic_authentication_encode (proxy_user, proxy_passwd);
1622
1623       /* If we're using a proxy, we will be connecting to the proxy
1624          server.  */
1625       conn = proxy;
1626
1627       /* Proxy authorization over SSL is handled below. */
1628 #ifdef HAVE_SSL
1629       if (u->scheme != SCHEME_HTTPS)
1630 #endif
1631         request_set_header (req, "Proxy-Authorization", proxyauth, rel_value);
1632     }
1633
1634   keep_alive = false;
1635
1636   /* Establish the connection.  */
1637
1638   if (!inhibit_keep_alive)
1639     {
1640       /* Look for a persistent connection to target host, unless a
1641          proxy is used.  The exception is when SSL is in use, in which
1642          case the proxy is nothing but a passthrough to the target
1643          host, registered as a connection to the latter.  */
1644       struct url *relevant = conn;
1645 #ifdef HAVE_SSL
1646       if (u->scheme == SCHEME_HTTPS)
1647         relevant = u;
1648 #endif
1649
1650       if (persistent_available_p (relevant->host, relevant->port,
1651 #ifdef HAVE_SSL
1652                                   relevant->scheme == SCHEME_HTTPS,
1653 #else
1654                                   0,
1655 #endif
1656                                   &host_lookup_failed))
1657         {
1658           sock = pconn.socket;
1659           using_ssl = pconn.ssl;
1660           logprintf (LOG_VERBOSE, _("Reusing existing connection to %s:%d.\n"),
1661                      quotearg_style (escape_quoting_style, pconn.host), 
1662                      pconn.port);
1663           DEBUGP (("Reusing fd %d.\n", sock));
1664           if (pconn.authorized)
1665             /* If the connection is already authorized, the "Basic"
1666                authorization added by code above is unnecessary and
1667                only hurts us.  */
1668             request_remove_header (req, "Authorization");
1669         }
1670       else if (host_lookup_failed)
1671         {
1672           request_free (req);
1673           logprintf(LOG_NOTQUIET,
1674                     _("%s: unable to resolve host address %s\n"),
1675                     exec_name, quote (relevant->host));
1676           return HOSTERR;
1677         }
1678     }
1679
1680   if (sock < 0)
1681     {
1682       sock = connect_to_host (conn->host, conn->port);
1683       if (sock == E_HOST)
1684         {
1685           request_free (req);
1686           return HOSTERR;
1687         }
1688       else if (sock < 0)
1689         {
1690           request_free (req);
1691           return (retryable_socket_connect_error (errno)
1692                   ? CONERROR : CONIMPOSSIBLE);
1693         }
1694
1695 #ifdef HAVE_SSL
1696       if (proxy && u->scheme == SCHEME_HTTPS)
1697         {
1698           /* When requesting SSL URLs through proxies, use the
1699              CONNECT method to request passthrough.  */
1700           struct request *connreq = request_new ();
1701           request_set_method (connreq, "CONNECT",
1702                               aprintf ("%s:%d", u->host, u->port));
1703           SET_USER_AGENT (connreq);
1704           if (proxyauth)
1705             {
1706               request_set_header (connreq, "Proxy-Authorization",
1707                                   proxyauth, rel_value);
1708               /* Now that PROXYAUTH is part of the CONNECT request,
1709                  zero it out so we don't send proxy authorization with
1710                  the regular request below.  */
1711               proxyauth = NULL;
1712             }
1713           /* Examples in rfc2817 use the Host header in CONNECT
1714              requests.  I don't see how that gains anything, given
1715              that the contents of Host would be exactly the same as
1716              the contents of CONNECT.  */
1717
1718           write_error = request_send (connreq, sock);
1719           request_free (connreq);
1720           if (write_error < 0)
1721             {
1722               CLOSE_INVALIDATE (sock);
1723               return WRITEFAILED;
1724             }
1725
1726           head = read_http_response_head (sock);
1727           if (!head)
1728             {
1729               logprintf (LOG_VERBOSE, _("Failed reading proxy response: %s\n"),
1730                          fd_errstr (sock));
1731               CLOSE_INVALIDATE (sock);
1732               return HERR;
1733             }
1734           message = NULL;
1735           if (!*head)
1736             {
1737               xfree (head);
1738               goto failed_tunnel;
1739             }
1740           DEBUGP (("proxy responded with: [%s]\n", head));
1741
1742           resp = resp_new (head);
1743           statcode = resp_status (resp, &message);
1744           hs->message = xstrdup (message);
1745           resp_free (resp);
1746           xfree (head);
1747           if (statcode != 200)
1748             {
1749             failed_tunnel:
1750               logprintf (LOG_NOTQUIET, _("Proxy tunneling failed: %s"),
1751                          message ? quotearg_style (escape_quoting_style, message) : "?");
1752               xfree_null (message);
1753               return CONSSLERR;
1754             }
1755           xfree_null (message);
1756
1757           /* SOCK is now *really* connected to u->host, so update CONN
1758              to reflect this.  That way register_persistent will
1759              register SOCK as being connected to u->host:u->port.  */
1760           conn = u;
1761         }
1762
1763       if (conn->scheme == SCHEME_HTTPS)
1764         {
1765           if (!ssl_connect_wget (sock) || !ssl_check_certificate (sock, u->host))
1766             {
1767               fd_close (sock);
1768               return CONSSLERR;
1769             }
1770           using_ssl = true;
1771         }
1772 #endif /* HAVE_SSL */
1773     }
1774
1775   /* Send the request to server.  */
1776   write_error = request_send (req, sock);
1777
1778   if (write_error >= 0)
1779     {
1780       if (opt.post_data)
1781         {
1782           DEBUGP (("[POST data: %s]\n", opt.post_data));
1783           write_error = fd_write (sock, opt.post_data, post_data_size, -1);
1784         }
1785       else if (opt.post_file_name && post_data_size != 0)
1786         write_error = post_file (sock, opt.post_file_name, post_data_size);
1787     }
1788
1789   if (write_error < 0)
1790     {
1791       CLOSE_INVALIDATE (sock);
1792       request_free (req);
1793       return WRITEFAILED;
1794     }
1795   logprintf (LOG_VERBOSE, _("%s request sent, awaiting response... "),
1796              proxy ? "Proxy" : "HTTP");
1797   contlen = -1;
1798   contrange = 0;
1799   *dt &= ~RETROKF;
1800
1801   head = read_http_response_head (sock);
1802   if (!head)
1803     {
1804       if (errno == 0)
1805         {
1806           logputs (LOG_NOTQUIET, _("No data received.\n"));
1807           CLOSE_INVALIDATE (sock);
1808           request_free (req);
1809           return HEOF;
1810         }
1811       else
1812         {
1813           logprintf (LOG_NOTQUIET, _("Read error (%s) in headers.\n"),
1814                      fd_errstr (sock));
1815           CLOSE_INVALIDATE (sock);
1816           request_free (req);
1817           return HERR;
1818         }
1819     }
1820   DEBUGP (("\n---response begin---\n%s---response end---\n", head));
1821
1822   resp = resp_new (head);
1823
1824   /* Check for status line.  */
1825   message = NULL;
1826   statcode = resp_status (resp, &message);
1827   hs->message = xstrdup (message);
1828   if (!opt.server_response)
1829     logprintf (LOG_VERBOSE, "%2d %s\n", statcode,
1830                message ? quotearg_style (escape_quoting_style, message) : "");
1831   else
1832     {
1833       logprintf (LOG_VERBOSE, "\n");
1834       print_server_response (resp, "  ");
1835     }
1836
1837   /* Check for keep-alive related responses. */
1838   if (!inhibit_keep_alive && contlen != -1)
1839     {
1840       if (resp_header_copy (resp, "Keep-Alive", NULL, 0))
1841         keep_alive = true;
1842       else if (resp_header_copy (resp, "Connection", hdrval, sizeof (hdrval)))
1843         {
1844           if (0 == strcasecmp (hdrval, "Keep-Alive"))
1845             keep_alive = true;
1846         }
1847     }
1848
1849   if (keep_alive)
1850     /* The server has promised that it will not close the connection
1851        when we're done.  This means that we can register it.  */
1852     register_persistent (conn->host, conn->port, sock, using_ssl);
1853
1854   if (statcode == HTTP_STATUS_UNAUTHORIZED)
1855     {
1856       /* Authorization is required.  */
1857       if (keep_alive && !head_only && skip_short_body (sock, contlen))
1858         CLOSE_FINISH (sock);
1859       else
1860         CLOSE_INVALIDATE (sock);
1861       pconn.authorized = false;
1862       if (!auth_finished && (user && passwd))
1863         {
1864           /* IIS sends multiple copies of WWW-Authenticate, one with
1865              the value "negotiate", and other(s) with data.  Loop over
1866              all the occurrences and pick the one we recognize.  */
1867           int wapos;
1868           const char *wabeg, *waend;
1869           char *www_authenticate = NULL;
1870           for (wapos = 0;
1871                (wapos = resp_header_locate (resp, "WWW-Authenticate", wapos,
1872                                             &wabeg, &waend)) != -1;
1873                ++wapos)
1874             if (known_authentication_scheme_p (wabeg, waend))
1875               {
1876                 BOUNDED_TO_ALLOCA (wabeg, waend, www_authenticate);
1877                 break;
1878               }
1879
1880           if (!www_authenticate)
1881             {
1882               /* If the authentication header is missing or
1883                  unrecognized, there's no sense in retrying.  */
1884               logputs (LOG_NOTQUIET, _("Unknown authentication scheme.\n"));
1885             }
1886           else if (!basic_auth_finished
1887                    || !BEGINS_WITH (www_authenticate, "Basic"))
1888             {
1889               char *pth;
1890               pth = url_full_path (u);
1891               request_set_header (req, "Authorization",
1892                                   create_authorization_line (www_authenticate,
1893                                                              user, passwd,
1894                                                              request_method (req),
1895                                                              pth,
1896                                                              &auth_finished),
1897                                   rel_value);
1898               if (BEGINS_WITH (www_authenticate, "NTLM"))
1899                 ntlm_seen = true;
1900               else if (!u->user && BEGINS_WITH (www_authenticate, "Basic"))
1901                 {
1902                   /* Need to register this host as using basic auth,
1903                    * so we automatically send creds next time. */
1904                   register_basic_auth_host (u->host);
1905                 }
1906               xfree (pth);
1907               xfree_null (message);
1908               resp_free (resp);
1909               xfree (head);
1910               goto retry_with_auth;
1911             }
1912           else
1913             {
1914               /* We already did Basic auth, and it failed. Gotta
1915                * give up. */
1916             }
1917         }
1918       logputs (LOG_NOTQUIET, _("Authorization failed.\n"));
1919       request_free (req);
1920       xfree_null (message);
1921       resp_free (resp);
1922       xfree (head);
1923       return AUTHFAILED;
1924     }
1925   else /* statcode != HTTP_STATUS_UNAUTHORIZED */
1926     {
1927       /* Kludge: if NTLM is used, mark the TCP connection as authorized. */
1928       if (ntlm_seen)
1929         pconn.authorized = true;
1930     }
1931
1932   /* Determine the local filename if needed. Notice that if -O is used 
1933    * hstat.local_file is set by http_loop to the argument of -O. */
1934   if (!hs->local_file)
1935     {
1936       /* Honor Content-Disposition whether possible. */
1937       if (!opt.content_disposition
1938           || !resp_header_copy (resp, "Content-Disposition", 
1939                                 hdrval, sizeof (hdrval))
1940           || !parse_content_disposition (hdrval, &hs->local_file))
1941         {
1942           /* The Content-Disposition header is missing or broken. 
1943            * Choose unique file name according to given URL. */
1944           hs->local_file = url_file_name (u);
1945         }
1946     }
1947
1948   /* TODO: perform this check only once. */
1949   if (!hs->existence_checked && file_exists_p (hs->local_file))
1950     {
1951       if (opt.noclobber && !opt.output_document)
1952         {
1953           /* If opt.noclobber is turned on and file already exists, do not
1954              retrieve the file. But if the output_document was given, then this
1955              test was already done and the file didn't exist. Hence the !opt.output_document */
1956           logprintf (LOG_VERBOSE, _("\
1957 File %s already there; not retrieving.\n\n"), quote (hs->local_file));
1958           /* If the file is there, we suppose it's retrieved OK.  */
1959           *dt |= RETROKF;
1960
1961           /* #### Bogusness alert.  */
1962           /* If its suffix is "html" or "htm" or similar, assume text/html.  */
1963           if (has_html_suffix_p (hs->local_file))
1964             *dt |= TEXTHTML;
1965
1966           xfree (head);
1967           xfree_null (message);
1968           return RETRUNNEEDED;
1969         }
1970       else if (!ALLOW_CLOBBER)
1971         {
1972           char *unique = unique_name (hs->local_file, true);
1973           if (unique != hs->local_file)
1974             xfree (hs->local_file);
1975           hs->local_file = unique;
1976         }
1977     }
1978   hs->existence_checked = true;
1979
1980   /* Support timestamping */
1981   /* TODO: move this code out of gethttp. */
1982   if (opt.timestamping && !hs->timestamp_checked)
1983     {
1984       size_t filename_len = strlen (hs->local_file);
1985       char *filename_plus_orig_suffix = alloca (filename_len + sizeof (ORIG_SFX));
1986       bool local_dot_orig_file_exists = false;
1987       char *local_filename = NULL;
1988       struct_stat st;
1989
1990       if (opt.backup_converted)
1991         /* If -K is specified, we'll act on the assumption that it was specified
1992            last time these files were downloaded as well, and instead of just
1993            comparing local file X against server file X, we'll compare local
1994            file X.orig (if extant, else X) against server file X.  If -K
1995            _wasn't_ specified last time, or the server contains files called
1996            *.orig, -N will be back to not operating correctly with -k. */
1997         {
1998           /* Would a single s[n]printf() call be faster?  --dan
1999
2000              Definitely not.  sprintf() is horribly slow.  It's a
2001              different question whether the difference between the two
2002              affects a program.  Usually I'd say "no", but at one
2003              point I profiled Wget, and found that a measurable and
2004              non-negligible amount of time was lost calling sprintf()
2005              in url.c.  Replacing sprintf with inline calls to
2006              strcpy() and number_to_string() made a difference.
2007              --hniksic */
2008           memcpy (filename_plus_orig_suffix, hs->local_file, filename_len);
2009           memcpy (filename_plus_orig_suffix + filename_len,
2010                   ORIG_SFX, sizeof (ORIG_SFX));
2011
2012           /* Try to stat() the .orig file. */
2013           if (stat (filename_plus_orig_suffix, &st) == 0)
2014             {
2015               local_dot_orig_file_exists = true;
2016               local_filename = filename_plus_orig_suffix;
2017             }
2018         }
2019
2020       if (!local_dot_orig_file_exists)
2021         /* Couldn't stat() <file>.orig, so try to stat() <file>. */
2022         if (stat (hs->local_file, &st) == 0)
2023           local_filename = hs->local_file;
2024
2025       if (local_filename != NULL)
2026         /* There was a local file, so we'll check later to see if the version
2027            the server has is the same version we already have, allowing us to
2028            skip a download. */
2029         {
2030           hs->orig_file_name = xstrdup (local_filename);
2031           hs->orig_file_size = st.st_size;
2032           hs->orig_file_tstamp = st.st_mtime;
2033 #ifdef WINDOWS
2034           /* Modification time granularity is 2 seconds for Windows, so
2035              increase local time by 1 second for later comparison. */
2036           ++hs->orig_file_tstamp;
2037 #endif
2038         }
2039     }
2040
2041   if (!opt.ignore_length
2042       && resp_header_copy (resp, "Content-Length", hdrval, sizeof (hdrval)))
2043     {
2044       wgint parsed;
2045       errno = 0;
2046       parsed = str_to_wgint (hdrval, NULL, 10);
2047       if (parsed == WGINT_MAX && errno == ERANGE)
2048         {
2049           /* Out of range.
2050              #### If Content-Length is out of range, it most likely
2051              means that the file is larger than 2G and that we're
2052              compiled without LFS.  In that case we should probably
2053              refuse to even attempt to download the file.  */
2054           contlen = -1;
2055         }
2056       else if (parsed < 0)
2057         {
2058           /* Negative Content-Length; nonsensical, so we can't
2059              assume any information about the content to receive. */
2060           contlen = -1;
2061         }
2062       else
2063         contlen = parsed;
2064     }
2065
2066   request_free (req);
2067
2068   hs->statcode = statcode;
2069   if (statcode == -1)
2070     hs->error = xstrdup (_("Malformed status line"));
2071   else if (!*message)
2072     hs->error = xstrdup (_("(no description)"));
2073   else
2074     hs->error = xstrdup (message);
2075   xfree_null (message);
2076
2077   type = resp_header_strdup (resp, "Content-Type");
2078   if (type)
2079     {
2080       char *tmp = strchr (type, ';');
2081       if (tmp)
2082         {
2083           /* sXXXav: only needed if IRI support is enabled */
2084           char *tmp2 = tmp + 1;
2085
2086           while (tmp > type && c_isspace (tmp[-1]))
2087             --tmp;
2088           *tmp = '\0';
2089
2090           /* Try to get remote encoding if needed */
2091           if (opt.enable_iri && !opt.encoding_remote)
2092             {
2093               tmp = parse_charset (tmp2);
2094               if (tmp)
2095                 set_content_encoding (iri, tmp);
2096             }
2097         }
2098     }
2099   hs->newloc = resp_header_strdup (resp, "Location");
2100   hs->remote_time = resp_header_strdup (resp, "Last-Modified");
2101
2102   /* Handle (possibly multiple instances of) the Set-Cookie header. */
2103   if (opt.cookies)
2104     {
2105       int scpos;
2106       const char *scbeg, *scend;
2107       /* The jar should have been created by now. */
2108       assert (wget_cookie_jar != NULL);
2109       for (scpos = 0;
2110            (scpos = resp_header_locate (resp, "Set-Cookie", scpos,
2111                                         &scbeg, &scend)) != -1;
2112            ++scpos)
2113         {
2114           char *set_cookie; BOUNDED_TO_ALLOCA (scbeg, scend, set_cookie);
2115           cookie_handle_set_cookie (wget_cookie_jar, u->host, u->port,
2116                                     u->path, set_cookie);
2117         }
2118     }
2119
2120   if (resp_header_copy (resp, "Content-Range", hdrval, sizeof (hdrval)))
2121     {
2122       wgint first_byte_pos, last_byte_pos, entity_length;
2123       if (parse_content_range (hdrval, &first_byte_pos, &last_byte_pos,
2124                                &entity_length))
2125         {
2126           contrange = first_byte_pos;
2127           contlen = last_byte_pos - first_byte_pos + 1;
2128         }
2129     }
2130   resp_free (resp);
2131
2132   /* 20x responses are counted among successful by default.  */
2133   if (H_20X (statcode))
2134     *dt |= RETROKF;
2135
2136   /* Return if redirected.  */
2137   if (H_REDIRECTED (statcode) || statcode == HTTP_STATUS_MULTIPLE_CHOICES)
2138     {
2139       /* RFC2068 says that in case of the 300 (multiple choices)
2140          response, the server can output a preferred URL through
2141          `Location' header; otherwise, the request should be treated
2142          like GET.  So, if the location is set, it will be a
2143          redirection; otherwise, just proceed normally.  */
2144       if (statcode == HTTP_STATUS_MULTIPLE_CHOICES && !hs->newloc)
2145         *dt |= RETROKF;
2146       else
2147         {
2148           logprintf (LOG_VERBOSE,
2149                      _("Location: %s%s\n"),
2150                      hs->newloc ? escnonprint_uri (hs->newloc) : _("unspecified"),
2151                      hs->newloc ? _(" [following]") : "");
2152           if (keep_alive && !head_only && skip_short_body (sock, contlen))
2153             CLOSE_FINISH (sock);
2154           else
2155             CLOSE_INVALIDATE (sock);
2156           xfree_null (type);
2157           xfree (head);
2158           return NEWLOCATION;
2159         }
2160     }
2161
2162   /* If content-type is not given, assume text/html.  This is because
2163      of the multitude of broken CGI's that "forget" to generate the
2164      content-type.  */
2165   if (!type ||
2166         0 == strncasecmp (type, TEXTHTML_S, strlen (TEXTHTML_S)) ||
2167         0 == strncasecmp (type, TEXTXHTML_S, strlen (TEXTXHTML_S)))    
2168     *dt |= TEXTHTML;
2169   else
2170     *dt &= ~TEXTHTML;
2171
2172   if (type &&
2173       0 == strncasecmp (type, TEXTCSS_S, strlen (TEXTCSS_S)))
2174     *dt |= TEXTCSS;
2175   else
2176     *dt &= ~TEXTCSS;
2177
2178   if (opt.adjust_extension)
2179     {
2180       if (*dt & TEXTHTML)
2181         /* -E / --adjust-extension / adjust_extension = on was specified,
2182            and this is a text/html file.  If some case-insensitive
2183            variation on ".htm[l]" isn't already the file's suffix,
2184            tack on ".html". */
2185         {
2186           ensure_extension (hs, ".html", dt);
2187         }
2188       else if (*dt & TEXTCSS)
2189         {
2190           ensure_extension (hs, ".css", dt);
2191         }
2192     }
2193
2194   if (statcode == HTTP_STATUS_RANGE_NOT_SATISFIABLE
2195       || (hs->restval > 0 && statcode == HTTP_STATUS_OK
2196           && contrange == 0 && hs->restval >= contlen)
2197      )
2198     {
2199       /* If `-c' is in use and the file has been fully downloaded (or
2200          the remote file has shrunk), Wget effectively requests bytes
2201          after the end of file and the server response with 416
2202          (or 200 with a <= Content-Length.  */
2203       logputs (LOG_VERBOSE, _("\
2204 \n    The file is already fully retrieved; nothing to do.\n\n"));
2205       /* In case the caller inspects. */
2206       hs->len = contlen;
2207       hs->res = 0;
2208       /* Mark as successfully retrieved. */
2209       *dt |= RETROKF;
2210       xfree_null (type);
2211       CLOSE_INVALIDATE (sock);        /* would be CLOSE_FINISH, but there
2212                                    might be more bytes in the body. */
2213       xfree (head);
2214       return RETRUNNEEDED;
2215     }
2216   if ((contrange != 0 && contrange != hs->restval)
2217       || (H_PARTIAL (statcode) && !contrange))
2218     {
2219       /* The Range request was somehow misunderstood by the server.
2220          Bail out.  */
2221       xfree_null (type);
2222       CLOSE_INVALIDATE (sock);
2223       xfree (head);
2224       return RANGEERR;
2225     }
2226   if (contlen == -1)
2227     hs->contlen = -1;
2228   else
2229     hs->contlen = contlen + contrange;
2230
2231   if (opt.verbose)
2232     {
2233       if (*dt & RETROKF)
2234         {
2235           /* No need to print this output if the body won't be
2236              downloaded at all, or if the original server response is
2237              printed.  */
2238           logputs (LOG_VERBOSE, _("Length: "));
2239           if (contlen != -1)
2240             {
2241               logputs (LOG_VERBOSE, number_to_static_string (contlen + contrange));
2242               if (contlen + contrange >= 1024)
2243                 logprintf (LOG_VERBOSE, " (%s)",
2244                            human_readable (contlen + contrange));
2245               if (contrange)
2246                 {
2247                   if (contlen >= 1024)
2248                     logprintf (LOG_VERBOSE, _(", %s (%s) remaining"),
2249                                number_to_static_string (contlen),
2250                                human_readable (contlen));
2251                   else
2252                     logprintf (LOG_VERBOSE, _(", %s remaining"),
2253                                number_to_static_string (contlen));
2254                 }
2255             }
2256           else
2257             logputs (LOG_VERBOSE,
2258                      opt.ignore_length ? _("ignored") : _("unspecified"));
2259           if (type)
2260             logprintf (LOG_VERBOSE, " [%s]\n", quotearg_style (escape_quoting_style, type));
2261           else
2262             logputs (LOG_VERBOSE, "\n");
2263         }
2264     }
2265   xfree_null (type);
2266   type = NULL;                        /* We don't need it any more.  */
2267
2268   /* Return if we have no intention of further downloading.  */
2269   if (!(*dt & RETROKF) || head_only)
2270     {
2271       /* In case the caller cares to look...  */
2272       hs->len = 0;
2273       hs->res = 0;
2274       xfree_null (type);
2275       if (head_only)
2276         /* Pre-1.10 Wget used CLOSE_INVALIDATE here.  Now we trust the
2277            servers not to send body in response to a HEAD request, and
2278            those that do will likely be caught by test_socket_open.
2279            If not, they can be worked around using
2280            `--no-http-keep-alive'.  */
2281         CLOSE_FINISH (sock);
2282       else if (keep_alive && skip_short_body (sock, contlen))
2283         /* Successfully skipped the body; also keep using the socket. */
2284         CLOSE_FINISH (sock);
2285       else
2286         CLOSE_INVALIDATE (sock);
2287       xfree (head);
2288       return RETRFINISHED;
2289     }
2290
2291 /* 2005-06-17 SMS.
2292    For VMS, define common fopen() optional arguments.
2293 */
2294 #ifdef __VMS
2295 # define FOPEN_OPT_ARGS "fop=sqo", "acc", acc_cb, &open_id
2296 # define FOPEN_BIN_FLAG 3
2297 #else /* def __VMS */
2298 # define FOPEN_BIN_FLAG 1
2299 #endif /* def __VMS [else] */
2300
2301   /* Open the local file.  */
2302   if (!output_stream)
2303     {
2304       mkalldirs (hs->local_file);
2305       if (opt.backups)
2306         rotate_backups (hs->local_file);
2307       if (hs->restval)
2308         {
2309 #ifdef __VMS
2310           int open_id;
2311
2312           open_id = 21;
2313           fp = fopen (hs->local_file, "ab", FOPEN_OPT_ARGS);
2314 #else /* def __VMS */
2315           fp = fopen (hs->local_file, "ab");
2316 #endif /* def __VMS [else] */
2317         }
2318       else if (ALLOW_CLOBBER)
2319         {
2320 #ifdef __VMS
2321           int open_id;
2322
2323           open_id = 22;
2324           fp = fopen (hs->local_file, "wb", FOPEN_OPT_ARGS);
2325 #else /* def __VMS */
2326           fp = fopen (hs->local_file, "wb");
2327 #endif /* def __VMS [else] */
2328         }
2329       else
2330         {
2331           fp = fopen_excl (hs->local_file, true);
2332           if (!fp && errno == EEXIST)
2333             {
2334               /* We cannot just invent a new name and use it (which is
2335                  what functions like unique_create typically do)
2336                  because we told the user we'd use this name.
2337                  Instead, return and retry the download.  */
2338               logprintf (LOG_NOTQUIET,
2339                          _("%s has sprung into existence.\n"),
2340                          hs->local_file);
2341               CLOSE_INVALIDATE (sock);
2342               xfree (head);
2343               return FOPEN_EXCL_ERR;
2344             }
2345         }
2346       if (!fp)
2347         {
2348           logprintf (LOG_NOTQUIET, "%s: %s\n", hs->local_file, strerror (errno));
2349           CLOSE_INVALIDATE (sock);
2350           xfree (head);
2351           return FOPENERR;
2352         }
2353     }
2354   else
2355     fp = output_stream;
2356
2357   /* Print fetch message, if opt.verbose.  */
2358   if (opt.verbose)
2359     {
2360       logprintf (LOG_NOTQUIET, _("Saving to: %s\n"), 
2361                  HYPHENP (hs->local_file) ? quote ("STDOUT") : quote (hs->local_file));
2362     }
2363     
2364   /* This confuses the timestamping code that checks for file size.
2365      #### The timestamping code should be smarter about file size.  */
2366   if (opt.save_headers && hs->restval == 0)
2367     fwrite (head, 1, strlen (head), fp);
2368
2369   /* Now we no longer need to store the response header. */
2370   xfree (head);
2371
2372   /* Download the request body.  */
2373   flags = 0;
2374   if (contlen != -1)
2375     /* If content-length is present, read that much; otherwise, read
2376        until EOF.  The HTTP spec doesn't require the server to
2377        actually close the connection when it's done sending data. */
2378     flags |= rb_read_exactly;
2379   if (hs->restval > 0 && contrange == 0)
2380     /* If the server ignored our range request, instruct fd_read_body
2381        to skip the first RESTVAL bytes of body.  */
2382     flags |= rb_skip_startpos;
2383   hs->len = hs->restval;
2384   hs->rd_size = 0;
2385   hs->res = fd_read_body (sock, fp, contlen != -1 ? contlen : 0,
2386                           hs->restval, &hs->rd_size, &hs->len, &hs->dltime,
2387                           flags);
2388
2389   if (hs->res >= 0)
2390     CLOSE_FINISH (sock);
2391   else
2392     {
2393       if (hs->res < 0)
2394         hs->rderrmsg = xstrdup (fd_errstr (sock));
2395       CLOSE_INVALIDATE (sock);
2396     }
2397
2398   if (!output_stream)
2399     fclose (fp);
2400   if (hs->res == -2)
2401     return FWRITEERR;
2402   return RETRFINISHED;
2403 }
2404
2405 /* The genuine HTTP loop!  This is the part where the retrieval is
2406    retried, and retried, and retried, and...  */
2407 uerr_t
2408 http_loop (struct url *u, char **newloc, char **local_file, const char *referer,
2409            int *dt, struct url *proxy, struct iri *iri)
2410 {
2411   int count;
2412   bool got_head = false;         /* used for time-stamping and filename detection */
2413   bool time_came_from_head = false;
2414   bool got_name = false;
2415   char *tms;
2416   const char *tmrate;
2417   uerr_t err, ret = TRYLIMEXC;
2418   time_t tmr = -1;               /* remote time-stamp */
2419   struct http_stat hstat;        /* HTTP status */
2420   struct_stat st;
2421   bool send_head_first = true;
2422   char *file_name;
2423
2424   /* Assert that no value for *LOCAL_FILE was passed. */
2425   assert (local_file == NULL || *local_file == NULL);
2426
2427   /* Set LOCAL_FILE parameter. */
2428   if (local_file && opt.output_document)
2429     *local_file = HYPHENP (opt.output_document) ? NULL : xstrdup (opt.output_document);
2430
2431   /* Reset NEWLOC parameter. */
2432   *newloc = NULL;
2433
2434   /* This used to be done in main(), but it's a better idea to do it
2435      here so that we don't go through the hoops if we're just using
2436      FTP or whatever. */
2437   if (opt.cookies)
2438     load_cookies();
2439
2440   /* Warn on (likely bogus) wildcard usage in HTTP. */
2441   if (opt.ftp_glob && has_wildcards_p (u->path))
2442     logputs (LOG_VERBOSE, _("Warning: wildcards not supported in HTTP.\n"));
2443
2444   /* Setup hstat struct. */
2445   xzero (hstat);
2446   hstat.referer = referer;
2447
2448   if (opt.output_document)
2449     {
2450       hstat.local_file = xstrdup (opt.output_document);
2451       got_name = true;
2452     }
2453   else if (!opt.content_disposition)
2454     {
2455       hstat.local_file = url_file_name (u);
2456       got_name = true;
2457     }
2458
2459   /* TODO: Ick! This code is now in both gethttp and http_loop, and is
2460    * screaming for some refactoring. */
2461   if (got_name && file_exists_p (hstat.local_file) && opt.noclobber && !opt.output_document)
2462     {
2463       /* If opt.noclobber is turned on and file already exists, do not
2464          retrieve the file. But if the output_document was given, then this
2465          test was already done and the file didn't exist. Hence the !opt.output_document */
2466       logprintf (LOG_VERBOSE, _("\
2467 File %s already there; not retrieving.\n\n"),
2468                  quote (hstat.local_file));
2469       /* If the file is there, we suppose it's retrieved OK.  */
2470       *dt |= RETROKF;
2471
2472       /* #### Bogusness alert.  */
2473       /* If its suffix is "html" or "htm" or similar, assume text/html.  */
2474       if (has_html_suffix_p (hstat.local_file))
2475         *dt |= TEXTHTML;
2476
2477       ret = RETROK;
2478       goto exit;
2479     }
2480
2481   /* Reset the counter. */
2482   count = 0;
2483
2484   /* Reset the document type. */
2485   *dt = 0;
2486
2487   /* Skip preliminary HEAD request if we're not in spider mode AND
2488    * if -O was given or HTTP Content-Disposition support is disabled. */
2489   if (!opt.spider
2490       && (got_name || !opt.content_disposition))
2491     send_head_first = false;
2492
2493   /* Send preliminary HEAD request if -N is given and we have an existing 
2494    * destination file. */
2495   file_name = url_file_name (u);
2496   if (opt.timestamping
2497       && !opt.content_disposition
2498       && file_exists_p (file_name))
2499     send_head_first = true;
2500   xfree (file_name);
2501   
2502   /* THE loop */
2503   do
2504     {
2505       /* Increment the pass counter.  */
2506       ++count;
2507       sleep_between_retrievals (count);
2508
2509       /* Get the current time string.  */
2510       tms = datetime_str (time (NULL));
2511
2512       if (opt.spider && !got_head)
2513         logprintf (LOG_VERBOSE, _("\
2514 Spider mode enabled. Check if remote file exists.\n"));
2515
2516       /* Print fetch message, if opt.verbose.  */
2517       if (opt.verbose)
2518         {
2519           char *hurl = url_string (u, URL_AUTH_HIDE_PASSWD);
2520
2521           if (count > 1)
2522             {
2523               char tmp[256];
2524               sprintf (tmp, _("(try:%2d)"), count);
2525               logprintf (LOG_NOTQUIET, "--%s--  %s  %s\n",
2526                          tms, tmp, hurl);
2527             }
2528           else
2529             {
2530               logprintf (LOG_NOTQUIET, "--%s--  %s\n",
2531                          tms, hurl);
2532             }
2533
2534 #ifdef WINDOWS
2535           ws_changetitle (hurl);
2536 #endif
2537           xfree (hurl);
2538         }
2539
2540       /* Default document type is empty.  However, if spider mode is
2541          on or time-stamping is employed, HEAD_ONLY commands is
2542          encoded within *dt.  */
2543       if (send_head_first && !got_head)
2544         *dt |= HEAD_ONLY;
2545       else
2546         *dt &= ~HEAD_ONLY;
2547
2548       /* Decide whether or not to restart.  */
2549       if (opt.always_rest
2550           && got_name
2551           && stat (hstat.local_file, &st) == 0
2552           && S_ISREG (st.st_mode))
2553         /* When -c is used, continue from on-disk size.  (Can't use
2554            hstat.len even if count>1 because we don't want a failed
2555            first attempt to clobber existing data.)  */
2556         hstat.restval = st.st_size;
2557       else if (count > 1)
2558         /* otherwise, continue where the previous try left off */
2559         hstat.restval = hstat.len;
2560       else
2561         hstat.restval = 0;
2562
2563       /* Decide whether to send the no-cache directive.  We send it in
2564          two cases:
2565            a) we're using a proxy, and we're past our first retrieval.
2566               Some proxies are notorious for caching incomplete data, so
2567               we require a fresh get.
2568            b) caching is explicitly inhibited. */
2569       if ((proxy && count > 1)        /* a */
2570           || !opt.allow_cache)        /* b */
2571         *dt |= SEND_NOCACHE;
2572       else
2573         *dt &= ~SEND_NOCACHE;
2574
2575       /* Try fetching the document, or at least its head.  */
2576       err = gethttp (u, &hstat, dt, proxy, iri);
2577
2578       /* Time?  */
2579       tms = datetime_str (time (NULL));
2580
2581       /* Get the new location (with or without the redirection).  */
2582       if (hstat.newloc)
2583         *newloc = xstrdup (hstat.newloc);
2584
2585       switch (err)
2586         {
2587         case HERR: case HEOF: case CONSOCKERR: case CONCLOSED:
2588         case CONERROR: case READERR: case WRITEFAILED:
2589         case RANGEERR: case FOPEN_EXCL_ERR:
2590           /* Non-fatal errors continue executing the loop, which will
2591              bring them to "while" statement at the end, to judge
2592              whether the number of tries was exceeded.  */
2593           printwhat (count, opt.ntry);
2594           continue;
2595         case FWRITEERR: case FOPENERR:
2596           /* Another fatal error.  */
2597           logputs (LOG_VERBOSE, "\n");
2598           logprintf (LOG_NOTQUIET, _("Cannot write to %s (%s).\n"),
2599                      quote (hstat.local_file), strerror (errno));
2600         case HOSTERR: case CONIMPOSSIBLE: case PROXERR: case AUTHFAILED: 
2601         case SSLINITFAILED: case CONTNOTSUPPORTED:
2602           /* Fatal errors just return from the function.  */
2603           ret = err;
2604           goto exit;
2605         case CONSSLERR:
2606           /* Another fatal error.  */
2607           logprintf (LOG_NOTQUIET, _("Unable to establish SSL connection.\n"));
2608           ret = err;
2609           goto exit;
2610         case NEWLOCATION:
2611           /* Return the new location to the caller.  */
2612           if (!*newloc)
2613             {
2614               logprintf (LOG_NOTQUIET,
2615                          _("ERROR: Redirection (%d) without location.\n"),
2616                          hstat.statcode);
2617               ret = WRONGCODE;
2618             }
2619           else
2620             {
2621               ret = NEWLOCATION;
2622             }
2623           goto exit;
2624         case RETRUNNEEDED:
2625           /* The file was already fully retrieved. */
2626           ret = RETROK;
2627           goto exit;
2628         case RETRFINISHED:
2629           /* Deal with you later.  */
2630           break;
2631         default:
2632           /* All possibilities should have been exhausted.  */
2633           abort ();
2634         }
2635
2636       if (!(*dt & RETROKF))
2637         {
2638           char *hurl = NULL;
2639           if (!opt.verbose)
2640             {
2641               /* #### Ugly ugly ugly! */
2642               hurl = url_string (u, URL_AUTH_HIDE_PASSWD);
2643               logprintf (LOG_NONVERBOSE, "%s:\n", hurl);
2644             }
2645
2646           /* Fall back to GET if HEAD fails with a 500 or 501 error code. */
2647           if (*dt & HEAD_ONLY
2648               && (hstat.statcode == 500 || hstat.statcode == 501))
2649             {
2650               got_head = true;
2651               continue;
2652             }
2653           /* Maybe we should always keep track of broken links, not just in
2654            * spider mode.
2655            * Don't log error if it was UTF-8 encoded because we will try
2656            * once unencoded. */
2657           else if (opt.spider && !iri->utf8_encode)
2658             {
2659               /* #### Again: ugly ugly ugly! */
2660               if (!hurl)
2661                 hurl = url_string (u, URL_AUTH_HIDE_PASSWD);
2662               nonexisting_url (hurl);
2663               logprintf (LOG_NOTQUIET, _("\
2664 Remote file does not exist -- broken link!!!\n"));
2665             }
2666           else
2667             {
2668               logprintf (LOG_NOTQUIET, _("%s ERROR %d: %s.\n"),
2669                          tms, hstat.statcode,
2670                          quotearg_style (escape_quoting_style, hstat.error));
2671             }
2672           logputs (LOG_VERBOSE, "\n");
2673           ret = WRONGCODE;
2674           xfree_null (hurl);
2675           goto exit;
2676         }
2677
2678       /* Did we get the time-stamp? */
2679       if (!got_head)
2680         {
2681           got_head = true;    /* no more time-stamping */
2682
2683           if (opt.timestamping && !hstat.remote_time)
2684             {
2685               logputs (LOG_NOTQUIET, _("\
2686 Last-modified header missing -- time-stamps turned off.\n"));
2687             }
2688           else if (hstat.remote_time)
2689             {
2690               /* Convert the date-string into struct tm.  */
2691               tmr = http_atotm (hstat.remote_time);
2692               if (tmr == (time_t) (-1))
2693                 logputs (LOG_VERBOSE, _("\
2694 Last-modified header invalid -- time-stamp ignored.\n"));
2695               if (*dt & HEAD_ONLY)
2696                 time_came_from_head = true;
2697             }
2698       
2699           if (send_head_first)
2700             {
2701               /* The time-stamping section.  */
2702               if (opt.timestamping)
2703                 {
2704                   if (hstat.orig_file_name) /* Perform the following
2705                                                checks only if the file
2706                                                we're supposed to
2707                                                download already exists.  */
2708                     {
2709                       if (hstat.remote_time && 
2710                           tmr != (time_t) (-1))
2711                         {
2712                           /* Now time-stamping can be used validly.
2713                              Time-stamping means that if the sizes of
2714                              the local and remote file match, and local
2715                              file is newer than the remote file, it will
2716                              not be retrieved.  Otherwise, the normal
2717                              download procedure is resumed.  */
2718                           if (hstat.orig_file_tstamp >= tmr)
2719                             {
2720                               if (hstat.contlen == -1 
2721                                   || hstat.orig_file_size == hstat.contlen)
2722                                 {
2723                                   logprintf (LOG_VERBOSE, _("\
2724 Server file no newer than local file %s -- not retrieving.\n\n"),
2725                                              quote (hstat.orig_file_name));
2726                                   ret = RETROK;
2727                                   goto exit;
2728                                 }
2729                               else
2730                                 {
2731                                   logprintf (LOG_VERBOSE, _("\
2732 The sizes do not match (local %s) -- retrieving.\n"),
2733                                              number_to_static_string (hstat.orig_file_size));
2734                                 }
2735                             }
2736                           else
2737                             logputs (LOG_VERBOSE,
2738                                      _("Remote file is newer, retrieving.\n"));
2739
2740                           logputs (LOG_VERBOSE, "\n");
2741                         }
2742                     }
2743                   
2744                   /* free_hstat (&hstat); */
2745                   hstat.timestamp_checked = true;
2746                 }
2747               
2748               if (opt.spider)
2749                 {
2750                   bool finished = true;
2751                   if (opt.recursive)
2752                     {
2753                       if (*dt & TEXTHTML)
2754                         {
2755                           logputs (LOG_VERBOSE, _("\
2756 Remote file exists and could contain links to other resources -- retrieving.\n\n"));
2757                           finished = false;
2758                         }
2759                       else 
2760                         {
2761                           logprintf (LOG_VERBOSE, _("\
2762 Remote file exists but does not contain any link -- not retrieving.\n\n"));
2763                           ret = RETROK; /* RETRUNNEEDED is not for caller. */
2764                         }
2765                     }
2766                   else
2767                     {
2768                       if (*dt & TEXTHTML)
2769                         {
2770                           logprintf (LOG_VERBOSE, _("\
2771 Remote file exists and could contain further links,\n\
2772 but recursion is disabled -- not retrieving.\n\n"));
2773                         }
2774                       else 
2775                         {
2776                           logprintf (LOG_VERBOSE, _("\
2777 Remote file exists.\n\n"));
2778                         }
2779                       ret = RETROK; /* RETRUNNEEDED is not for caller. */
2780                     }
2781                   
2782                   if (finished)
2783                     {
2784                       logprintf (LOG_NONVERBOSE, 
2785                                  _("%s URL: %s %2d %s\n"), 
2786                                  tms, u->url, hstat.statcode,
2787                                  hstat.message ? quotearg_style (escape_quoting_style, hstat.message) : "");
2788                       goto exit;
2789                     }
2790                 }
2791
2792               got_name = true;
2793               *dt &= ~HEAD_ONLY;
2794               count = 0;          /* the retrieve count for HEAD is reset */
2795               continue;
2796             } /* send_head_first */
2797         } /* !got_head */
2798           
2799       if ((tmr != (time_t) (-1))
2800           && ((hstat.len == hstat.contlen) ||
2801               ((hstat.res == 0) && (hstat.contlen == -1))))
2802         {
2803           const char *fl = NULL;
2804           set_local_file (&fl, hstat.local_file);
2805           if (fl)
2806             {
2807               time_t newtmr = -1;
2808               /* Reparse time header, in case it's changed. */
2809               if (time_came_from_head
2810                   && hstat.remote_time && hstat.remote_time[0])
2811                 {
2812                   newtmr = http_atotm (hstat.remote_time);
2813                   if (newtmr != (time_t)-1)
2814                     tmr = newtmr;
2815                 }
2816               touch (fl, tmr);
2817             }
2818         }
2819       /* End of time-stamping section. */
2820
2821       tmrate = retr_rate (hstat.rd_size, hstat.dltime);
2822       total_download_time += hstat.dltime;
2823
2824       if (hstat.len == hstat.contlen)
2825         {
2826           if (*dt & RETROKF)
2827             {
2828               bool write_to_stdout = (opt.output_document && HYPHENP (opt.output_document));
2829
2830               logprintf (LOG_VERBOSE,
2831                          write_to_stdout 
2832                          ? _("%s (%s) - written to stdout %s[%s/%s]\n\n")
2833                          : _("%s (%s) - %s saved [%s/%s]\n\n"),
2834                          tms, tmrate,
2835                          write_to_stdout ? "" : quote (hstat.local_file),
2836                          number_to_static_string (hstat.len),
2837                          number_to_static_string (hstat.contlen));
2838               logprintf (LOG_NONVERBOSE,
2839                          "%s URL:%s [%s/%s] -> \"%s\" [%d]\n",
2840                          tms, u->url,
2841                          number_to_static_string (hstat.len),
2842                          number_to_static_string (hstat.contlen),
2843                          hstat.local_file, count);
2844             }
2845           ++numurls;
2846           total_downloaded_bytes += hstat.len;
2847
2848           /* Remember that we downloaded the file for later ".orig" code. */
2849           if (*dt & ADDED_HTML_EXTENSION)
2850             downloaded_file(FILE_DOWNLOADED_AND_HTML_EXTENSION_ADDED, hstat.local_file);
2851           else
2852             downloaded_file(FILE_DOWNLOADED_NORMALLY, hstat.local_file);
2853
2854           ret = RETROK;
2855           goto exit;
2856         }
2857       else if (hstat.res == 0) /* No read error */
2858         {
2859           if (hstat.contlen == -1)  /* We don't know how much we were supposed
2860                                        to get, so assume we succeeded. */ 
2861             {
2862               if (*dt & RETROKF)
2863                 {
2864                   bool write_to_stdout = (opt.output_document && HYPHENP (opt.output_document));
2865
2866                   logprintf (LOG_VERBOSE,
2867                              write_to_stdout
2868                              ? _("%s (%s) - written to stdout %s[%s]\n\n")
2869                              : _("%s (%s) - %s saved [%s]\n\n"),
2870                              tms, tmrate, 
2871                              write_to_stdout ? "" : quote (hstat.local_file),
2872                              number_to_static_string (hstat.len));
2873                   logprintf (LOG_NONVERBOSE,
2874                              "%s URL:%s [%s] -> \"%s\" [%d]\n",
2875                              tms, u->url, number_to_static_string (hstat.len),
2876                              hstat.local_file, count);
2877                 }
2878               ++numurls;
2879               total_downloaded_bytes += hstat.len;
2880
2881               /* Remember that we downloaded the file for later ".orig" code. */
2882               if (*dt & ADDED_HTML_EXTENSION)
2883                 downloaded_file(FILE_DOWNLOADED_AND_HTML_EXTENSION_ADDED, hstat.local_file);
2884               else
2885                 downloaded_file(FILE_DOWNLOADED_NORMALLY, hstat.local_file);
2886               
2887               ret = RETROK;
2888               goto exit;
2889             }
2890           else if (hstat.len < hstat.contlen) /* meaning we lost the
2891                                                  connection too soon */
2892             {
2893               logprintf (LOG_VERBOSE,
2894                          _("%s (%s) - Connection closed at byte %s. "),
2895                          tms, tmrate, number_to_static_string (hstat.len));
2896               printwhat (count, opt.ntry);
2897               continue;
2898             }
2899           else if (hstat.len != hstat.restval)
2900             /* Getting here would mean reading more data than
2901                requested with content-length, which we never do.  */
2902             abort ();
2903           else
2904             {
2905               /* Getting here probably means that the content-length was
2906                * _less_ than the original, local size. We should probably
2907                * truncate or re-read, or something. FIXME */
2908               ret = RETROK;
2909               goto exit;
2910             }
2911         }
2912       else /* from now on hstat.res can only be -1 */
2913         {
2914           if (hstat.contlen == -1)
2915             {
2916               logprintf (LOG_VERBOSE,
2917                          _("%s (%s) - Read error at byte %s (%s)."),
2918                          tms, tmrate, number_to_static_string (hstat.len),
2919                          hstat.rderrmsg);
2920               printwhat (count, opt.ntry);
2921               continue;
2922             }
2923           else /* hstat.res == -1 and contlen is given */
2924             {
2925               logprintf (LOG_VERBOSE,
2926                          _("%s (%s) - Read error at byte %s/%s (%s). "),
2927                          tms, tmrate,
2928                          number_to_static_string (hstat.len),
2929                          number_to_static_string (hstat.contlen),
2930                          hstat.rderrmsg);
2931               printwhat (count, opt.ntry);
2932               continue;
2933             }
2934         }
2935       /* not reached */
2936     }
2937   while (!opt.ntry || (count < opt.ntry));
2938
2939 exit:
2940   if (ret == RETROK) 
2941     *local_file = xstrdup (hstat.local_file);
2942   free_hstat (&hstat);
2943   
2944   return ret;
2945 }
2946 \f
2947 /* Check whether the result of strptime() indicates success.
2948    strptime() returns the pointer to how far it got to in the string.
2949    The processing has been successful if the string is at `GMT' or
2950    `+X', or at the end of the string.
2951
2952    In extended regexp parlance, the function returns 1 if P matches
2953    "^ *(GMT|[+-][0-9]|$)", 0 otherwise.  P being NULL (which strptime
2954    can return) is considered a failure and 0 is returned.  */
2955 static bool
2956 check_end (const char *p)
2957 {
2958   if (!p)
2959     return false;
2960   while (c_isspace (*p))
2961     ++p;
2962   if (!*p
2963       || (p[0] == 'G' && p[1] == 'M' && p[2] == 'T')
2964       || ((p[0] == '+' || p[0] == '-') && c_isdigit (p[1])))
2965     return true;
2966   else
2967     return false;
2968 }
2969
2970 /* Convert the textual specification of time in TIME_STRING to the
2971    number of seconds since the Epoch.
2972
2973    TIME_STRING can be in any of the three formats RFC2616 allows the
2974    HTTP servers to emit -- RFC1123-date, RFC850-date or asctime-date,
2975    as well as the time format used in the Set-Cookie header.
2976    Timezones are ignored, and should be GMT.
2977
2978    Return the computed time_t representation, or -1 if the conversion
2979    fails.
2980
2981    This function uses strptime with various string formats for parsing
2982    TIME_STRING.  This results in a parser that is not as lenient in
2983    interpreting TIME_STRING as I would like it to be.  Being based on
2984    strptime, it always allows shortened months, one-digit days, etc.,
2985    but due to the multitude of formats in which time can be
2986    represented, an ideal HTTP time parser would be even more
2987    forgiving.  It should completely ignore things like week days and
2988    concentrate only on the various forms of representing years,
2989    months, days, hours, minutes, and seconds.  For example, it would
2990    be nice if it accepted ISO 8601 out of the box.
2991
2992    I've investigated free and PD code for this purpose, but none was
2993    usable.  getdate was big and unwieldy, and had potential copyright
2994    issues, or so I was informed.  Dr. Marcus Hennecke's atotm(),
2995    distributed with phttpd, is excellent, but we cannot use it because
2996    it is not assigned to the FSF.  So I stuck it with strptime.  */
2997
2998 time_t
2999 http_atotm (const char *time_string)
3000 {
3001   /* NOTE: Solaris strptime man page claims that %n and %t match white
3002      space, but that's not universally available.  Instead, we simply
3003      use ` ' to mean "skip all WS", which works under all strptime
3004      implementations I've tested.  */
3005
3006   static const char *time_formats[] = {
3007     "%a, %d %b %Y %T",          /* rfc1123: Thu, 29 Jan 1998 22:12:57 */
3008     "%A, %d-%b-%y %T",          /* rfc850:  Thursday, 29-Jan-98 22:12:57 */
3009     "%a %b %d %T %Y",           /* asctime: Thu Jan 29 22:12:57 1998 */
3010     "%a, %d-%b-%Y %T"           /* cookies: Thu, 29-Jan-1998 22:12:57
3011                                    (used in Set-Cookie, defined in the
3012                                    Netscape cookie specification.) */
3013   };
3014   const char *oldlocale;
3015   char savedlocale[256];
3016   size_t i;
3017   time_t ret = (time_t) -1;
3018
3019   /* Solaris strptime fails to recognize English month names in
3020      non-English locales, which we work around by temporarily setting
3021      locale to C before invoking strptime.  */
3022   oldlocale = setlocale (LC_TIME, NULL);
3023   if (oldlocale)
3024     {
3025       size_t l = strlen (oldlocale);
3026       if (l >= sizeof savedlocale)
3027         savedlocale[0] = '\0';
3028       else
3029         memcpy (savedlocale, oldlocale, l);
3030     }
3031   else savedlocale[0] = '\0';
3032
3033   setlocale (LC_TIME, "C");
3034
3035   for (i = 0; i < countof (time_formats); i++)
3036     {
3037       struct tm t;
3038
3039       /* Some versions of strptime use the existing contents of struct
3040          tm to recalculate the date according to format.  Zero it out
3041          to prevent stack garbage from influencing strptime.  */
3042       xzero (t);
3043
3044       if (check_end (strptime (time_string, time_formats[i], &t)))
3045         {
3046           ret = timegm (&t);
3047           break;
3048         }
3049     }
3050
3051   /* Restore the previous locale. */
3052   if (savedlocale[0])
3053     setlocale (LC_TIME, savedlocale);
3054
3055   return ret;
3056 }
3057 \f
3058 /* Authorization support: We support three authorization schemes:
3059
3060    * `Basic' scheme, consisting of base64-ing USER:PASSWORD string;
3061
3062    * `Digest' scheme, added by Junio Hamano <junio@twinsun.com>,
3063    consisting of answering to the server's challenge with the proper
3064    MD5 digests.
3065
3066    * `NTLM' ("NT Lan Manager") scheme, based on code written by Daniel
3067    Stenberg for libcurl.  Like digest, NTLM is based on a
3068    challenge-response mechanism, but unlike digest, it is non-standard
3069    (authenticates TCP connections rather than requests), undocumented
3070    and Microsoft-specific.  */
3071
3072 /* Create the authentication header contents for the `Basic' scheme.
3073    This is done by encoding the string "USER:PASS" to base64 and
3074    prepending the string "Basic " in front of it.  */
3075
3076 static char *
3077 basic_authentication_encode (const char *user, const char *passwd)
3078 {
3079   char *t1, *t2;
3080   int len1 = strlen (user) + 1 + strlen (passwd);
3081
3082   t1 = (char *)alloca (len1 + 1);
3083   sprintf (t1, "%s:%s", user, passwd);
3084
3085   t2 = (char *)alloca (BASE64_LENGTH (len1) + 1);
3086   base64_encode (t1, len1, t2);
3087
3088   return concat_strings ("Basic ", t2, (char *) 0);
3089 }
3090
3091 #define SKIP_WS(x) do {                         \
3092   while (c_isspace (*(x)))                        \
3093     ++(x);                                      \
3094 } while (0)
3095
3096 #ifdef ENABLE_DIGEST
3097 /* Dump the hexadecimal representation of HASH to BUF.  HASH should be
3098    an array of 16 bytes containing the hash keys, and BUF should be a
3099    buffer of 33 writable characters (32 for hex digits plus one for
3100    zero termination).  */
3101 static void
3102 dump_hash (char *buf, const unsigned char *hash)
3103 {
3104   int i;
3105
3106   for (i = 0; i < MD5_HASHLEN; i++, hash++)
3107     {
3108       *buf++ = XNUM_TO_digit (*hash >> 4);
3109       *buf++ = XNUM_TO_digit (*hash & 0xf);
3110     }
3111   *buf = '\0';
3112 }
3113
3114 /* Take the line apart to find the challenge, and compose a digest
3115    authorization header.  See RFC2069 section 2.1.2.  */
3116 static char *
3117 digest_authentication_encode (const char *au, const char *user,
3118                               const char *passwd, const char *method,
3119                               const char *path)
3120 {
3121   static char *realm, *opaque, *nonce;
3122   static struct {
3123     const char *name;
3124     char **variable;
3125   } options[] = {
3126     { "realm", &realm },
3127     { "opaque", &opaque },
3128     { "nonce", &nonce }
3129   };
3130   char *res;
3131   param_token name, value;
3132
3133   realm = opaque = nonce = NULL;
3134
3135   au += 6;                      /* skip over `Digest' */
3136   while (extract_param (&au, &name, &value, ','))
3137     {
3138       size_t i;
3139       size_t namelen = name.e - name.b;
3140       for (i = 0; i < countof (options); i++)
3141         if (namelen == strlen (options[i].name)
3142             && 0 == strncmp (name.b, options[i].name,
3143                              namelen))
3144           {
3145             *options[i].variable = strdupdelim (value.b, value.e);
3146             break;
3147           }
3148     }
3149   if (!realm || !nonce || !user || !passwd || !path || !method)
3150     {
3151       xfree_null (realm);
3152       xfree_null (opaque);
3153       xfree_null (nonce);
3154       return NULL;
3155     }
3156
3157   /* Calculate the digest value.  */
3158   {
3159     ALLOCA_MD5_CONTEXT (ctx);
3160     unsigned char hash[MD5_HASHLEN];
3161     char a1buf[MD5_HASHLEN * 2 + 1], a2buf[MD5_HASHLEN * 2 + 1];
3162     char response_digest[MD5_HASHLEN * 2 + 1];
3163
3164     /* A1BUF = H(user ":" realm ":" password) */
3165     gen_md5_init (ctx);
3166     gen_md5_update ((unsigned char *)user, strlen (user), ctx);
3167     gen_md5_update ((unsigned char *)":", 1, ctx);
3168     gen_md5_update ((unsigned char *)realm, strlen (realm), ctx);
3169     gen_md5_update ((unsigned char *)":", 1, ctx);
3170     gen_md5_update ((unsigned char *)passwd, strlen (passwd), ctx);
3171     gen_md5_finish (ctx, hash);
3172     dump_hash (a1buf, hash);
3173
3174     /* A2BUF = H(method ":" path) */
3175     gen_md5_init (ctx);
3176     gen_md5_update ((unsigned char *)method, strlen (method), ctx);
3177     gen_md5_update ((unsigned char *)":", 1, ctx);
3178     gen_md5_update ((unsigned char *)path, strlen (path), ctx);
3179     gen_md5_finish (ctx, hash);
3180     dump_hash (a2buf, hash);
3181
3182     /* RESPONSE_DIGEST = H(A1BUF ":" nonce ":" A2BUF) */
3183     gen_md5_init (ctx);
3184     gen_md5_update ((unsigned char *)a1buf, MD5_HASHLEN * 2, ctx);
3185     gen_md5_update ((unsigned char *)":", 1, ctx);
3186     gen_md5_update ((unsigned char *)nonce, strlen (nonce), ctx);
3187     gen_md5_update ((unsigned char *)":", 1, ctx);
3188     gen_md5_update ((unsigned char *)a2buf, MD5_HASHLEN * 2, ctx);
3189     gen_md5_finish (ctx, hash);
3190     dump_hash (response_digest, hash);
3191
3192     res = xmalloc (strlen (user)
3193                    + strlen (user)
3194                    + strlen (realm)
3195                    + strlen (nonce)
3196                    + strlen (path)
3197                    + 2 * MD5_HASHLEN /*strlen (response_digest)*/
3198                    + (opaque ? strlen (opaque) : 0)
3199                    + 128);
3200     sprintf (res, "Digest \
3201 username=\"%s\", realm=\"%s\", nonce=\"%s\", uri=\"%s\", response=\"%s\"",
3202              user, realm, nonce, path, response_digest);
3203     if (opaque)
3204       {
3205         char *p = res + strlen (res);
3206         strcat (p, ", opaque=\"");
3207         strcat (p, opaque);
3208         strcat (p, "\"");
3209       }
3210   }
3211   return res;
3212 }
3213 #endif /* ENABLE_DIGEST */
3214
3215 /* Computing the size of a string literal must take into account that
3216    value returned by sizeof includes the terminating \0.  */
3217 #define STRSIZE(literal) (sizeof (literal) - 1)
3218
3219 /* Whether chars in [b, e) begin with the literal string provided as
3220    first argument and are followed by whitespace or terminating \0.
3221    The comparison is case-insensitive.  */
3222 #define STARTS(literal, b, e)                           \
3223   ((e > b) \
3224    && ((size_t) ((e) - (b))) >= STRSIZE (literal)   \
3225    && 0 == strncasecmp (b, literal, STRSIZE (literal))  \
3226    && ((size_t) ((e) - (b)) == STRSIZE (literal)          \
3227        || c_isspace (b[STRSIZE (literal)])))
3228
3229 static bool
3230 known_authentication_scheme_p (const char *hdrbeg, const char *hdrend)
3231 {
3232   return STARTS ("Basic", hdrbeg, hdrend)
3233 #ifdef ENABLE_DIGEST
3234     || STARTS ("Digest", hdrbeg, hdrend)
3235 #endif
3236 #ifdef ENABLE_NTLM
3237     || STARTS ("NTLM", hdrbeg, hdrend)
3238 #endif
3239     ;
3240 }
3241
3242 #undef STARTS
3243
3244 /* Create the HTTP authorization request header.  When the
3245    `WWW-Authenticate' response header is seen, according to the
3246    authorization scheme specified in that header (`Basic' and `Digest'
3247    are supported by the current implementation), produce an
3248    appropriate HTTP authorization request header.  */
3249 static char *
3250 create_authorization_line (const char *au, const char *user,
3251                            const char *passwd, const char *method,
3252                            const char *path, bool *finished)
3253 {
3254   /* We are called only with known schemes, so we can dispatch on the
3255      first letter. */
3256   switch (c_toupper (*au))
3257     {
3258     case 'B':                   /* Basic */
3259       *finished = true;
3260       return basic_authentication_encode (user, passwd);
3261 #ifdef ENABLE_DIGEST
3262     case 'D':                   /* Digest */
3263       *finished = true;
3264       return digest_authentication_encode (au, user, passwd, method, path);
3265 #endif
3266 #ifdef ENABLE_NTLM
3267     case 'N':                   /* NTLM */
3268       if (!ntlm_input (&pconn.ntlm, au))
3269         {
3270           *finished = true;
3271           return NULL;
3272         }
3273       return ntlm_output (&pconn.ntlm, user, passwd, finished);
3274 #endif
3275     default:
3276       /* We shouldn't get here -- this function should be only called
3277          with values approved by known_authentication_scheme_p.  */
3278       abort ();
3279     }
3280 }
3281 \f
3282 static void
3283 load_cookies (void)
3284 {
3285   if (!wget_cookie_jar)
3286     wget_cookie_jar = cookie_jar_new ();
3287   if (opt.cookies_input && !cookies_loaded_p)
3288     {
3289       cookie_jar_load (wget_cookie_jar, opt.cookies_input);
3290       cookies_loaded_p = true;
3291     }
3292 }
3293
3294 void
3295 save_cookies (void)
3296 {
3297   if (wget_cookie_jar)
3298     cookie_jar_save (wget_cookie_jar, opt.cookies_output);
3299 }
3300
3301 void
3302 http_cleanup (void)
3303 {
3304   xfree_null (pconn.host);
3305   if (wget_cookie_jar)
3306     cookie_jar_delete (wget_cookie_jar);
3307 }
3308
3309 void
3310 ensure_extension (struct http_stat *hs, const char *ext, int *dt)
3311 {
3312   char *last_period_in_local_filename = strrchr (hs->local_file, '.');
3313   char shortext[8];
3314   int len = strlen (ext);
3315   if (len == 5)
3316     {
3317       strncpy (shortext, ext, len - 1);
3318       shortext[len - 2] = '\0';
3319     }
3320
3321   if (last_period_in_local_filename == NULL
3322       || !(0 == strcasecmp (last_period_in_local_filename, shortext)
3323            || 0 == strcasecmp (last_period_in_local_filename, ext)))
3324     {
3325       int local_filename_len = strlen (hs->local_file);
3326       /* Resize the local file, allowing for ".html" preceded by
3327          optional ".NUMBER".  */
3328       hs->local_file = xrealloc (hs->local_file,
3329                                  local_filename_len + 24 + len);
3330       strcpy (hs->local_file + local_filename_len, ext);
3331       /* If clobbering is not allowed and the file, as named,
3332          exists, tack on ".NUMBER.html" instead. */
3333       if (!ALLOW_CLOBBER && file_exists_p (hs->local_file))
3334         {
3335           int ext_num = 1;
3336           do
3337             sprintf (hs->local_file + local_filename_len,
3338                      ".%d%s", ext_num++, ext);
3339           while (file_exists_p (hs->local_file));
3340         }
3341       *dt |= ADDED_HTML_EXTENSION;
3342     }
3343 }
3344
3345
3346 #ifdef TESTING
3347
3348 const char *
3349 test_parse_content_disposition()
3350 {
3351   int i;
3352   struct {
3353     char *hdrval;    
3354     char *opt_dir_prefix;
3355     char *filename;
3356     bool result;
3357   } test_array[] = {
3358     { "filename=\"file.ext\"", NULL, "file.ext", true },
3359     { "filename=\"file.ext\"", "somedir", "somedir/file.ext", true },
3360     { "attachment; filename=\"file.ext\"", NULL, "file.ext", true },
3361     { "attachment; filename=\"file.ext\"", "somedir", "somedir/file.ext", true },
3362     { "attachment; filename=\"file.ext\"; dummy", NULL, "file.ext", true },
3363     { "attachment; filename=\"file.ext\"; dummy", "somedir", "somedir/file.ext", true },
3364     { "attachment", NULL, NULL, false },
3365     { "attachment", "somedir", NULL, false },
3366   };
3367   
3368   for (i = 0; i < sizeof(test_array)/sizeof(test_array[0]); ++i) 
3369     {
3370       char *filename;
3371       bool res;
3372
3373       opt.dir_prefix = test_array[i].opt_dir_prefix;
3374       res = parse_content_disposition (test_array[i].hdrval, &filename);
3375
3376       mu_assert ("test_parse_content_disposition: wrong result", 
3377                  res == test_array[i].result
3378                  && (res == false 
3379                      || 0 == strcmp (test_array[i].filename, filename)));
3380     }
3381
3382   return NULL;
3383 }
3384
3385 #endif /* TESTING */
3386
3387 /*
3388  * vim: et sts=2 sw=2 cino+={s
3389  */
3390