/* HTTP support.

   Copyright (C) 1996-2012, 2014-2015, 2018-2024 Free Software

   Foundation, Inc.

This file is part of GNU Wget.

GNU Wget is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation; either version 3 of the License, or

 (at your option) any later version.

GNU Wget is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with Wget.  If not, see <http://www.gnu.org/licenses/>.

Additional permission under GNU GPL version 3 section 7

If you modify this program, or any covered work, by linking or

combining it with the OpenSSL project's OpenSSL library (or a

modified version of that library), containing parts covered by the

terms of the OpenSSL or SSLeay licenses, the Free Software Foundation

grants you additional permission to convey the resulting work.

Corresponding Source for a non-source form of such a combination

shall include the source code for the parts of OpenSSL used as well

as that of the covered work.  */

#include "wget.h"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <assert.h>

#include <errno.h>

#include <time.h>

#include <locale.h>

#include <fcntl.h>

#include "hash.h"

#include "http.h"

#include "hsts.h"

#include "utils.h"

#include "url.h"

#include "host.h"

#include "retr.h"

#include "connect.h"

#include "netrc.h"

#ifdef HAVE_SSL

# include "ssl.h"

#endif

#ifdef ENABLE_NTLM

# include "http-ntlm.h"

#endif

#include "cookies.h"

#include "md5.h"

#include "convert.h"

#include "spider.h"

#include "warc.h"

#include "c-strcase.h"

#include "version.h"

#include "xstrndup.h"

#ifdef HAVE_METALINK

# include "metalink.h"

#endif

#ifdef ENABLE_XATTR

#include "xattr.h"

#endif

#ifdef TESTING

#include "../tests/unit-tests.h"

#endif

#ifdef __VMS

# include "vms.h"

#endif /* def __VMS */

/* Forward decls. */

struct http_stat;

static char *create_authorization_line (const char *, const char *,

                                        const char *, const char *,

                                        const char *, bool *, uerr_t *);

static char *basic_authentication_encode (const char *, const char *);

static bool known_authentication_scheme_p (const char *, const char *);

static void ensure_extension (struct http_stat *, const char *, int *);

static void load_cookies (void);

static bool cookies_loaded_p;

static struct cookie_jar *wget_cookie_jar;

#define TEXTHTML_S "text/html"

#define TEXTXHTML_S "application/xhtml+xml"

#define TEXTCSS_S "text/css"

/* Some status code validation macros: */

#define H_10X(x)        (((x) >= 100) && ((x) < 200))

#define H_20X(x)        (((x) >= 200) && ((x) < 300))

#define H_PARTIAL(x)    ((x) == HTTP_STATUS_PARTIAL_CONTENTS)

#define H_REDIRECTED(x) ((x) == HTTP_STATUS_MOVED_PERMANENTLY          \

                         || (x) == HTTP_STATUS_MOVED_TEMPORARILY       \

                         || (x) == HTTP_STATUS_SEE_OTHER               \

                         || (x) == HTTP_STATUS_TEMPORARY_REDIRECT      \

                         || (x) == HTTP_STATUS_PERMANENT_REDIRECT)

/* HTTP/1.0 status codes from RFC1945, provided for reference.  */

/* Successful 2xx.  */

#define HTTP_STATUS_OK                    200

#define HTTP_STATUS_CREATED               201

#define HTTP_STATUS_ACCEPTED              202

#define HTTP_STATUS_NO_CONTENT            204

#define HTTP_STATUS_PARTIAL_CONTENTS      206

/* Redirection 3xx.  */

#define HTTP_STATUS_MULTIPLE_CHOICES      300

#define HTTP_STATUS_MOVED_PERMANENTLY     301

#define HTTP_STATUS_MOVED_TEMPORARILY     302

#define HTTP_STATUS_SEE_OTHER             303 /* from HTTP/1.1 */

#define HTTP_STATUS_NOT_MODIFIED          304

#define HTTP_STATUS_TEMPORARY_REDIRECT    307 /* from HTTP/1.1 */

#define HTTP_STATUS_PERMANENT_REDIRECT    308 /* from HTTP/1.1 */

/* Client error 4xx.  */

#define HTTP_STATUS_BAD_REQUEST           400

#define HTTP_STATUS_UNAUTHORIZED          401

#define HTTP_STATUS_FORBIDDEN             403

#define HTTP_STATUS_NOT_FOUND             404

#define HTTP_STATUS_RANGE_NOT_SATISFIABLE 416

/* Server errors 5xx.  */

#define HTTP_STATUS_INTERNAL              500

#define HTTP_STATUS_NOT_IMPLEMENTED       501

#define HTTP_STATUS_BAD_GATEWAY           502

#define HTTP_STATUS_UNAVAILABLE           503

#define HTTP_STATUS_GATEWAY_TIMEOUT       504

enum rp {

  rel_none, rel_name, rel_value, rel_both

};

struct request {

  const char *method;

  char *arg;

  struct request_header {

    char *name, *value;

    enum rp release_policy;

  } *headers;

  int hcount, hcapacity;

};

/* Create a new, empty request. Set the request's method and its

   arguments.  METHOD should be a literal string (or it should outlive

   the request) because it will not be freed.  ARG will be freed by

   request_free.  */

static struct request *

request_new (const char *method, char *arg)

{

  struct request *req = xnew0 (struct request);

  req->hcapacity = 8;

  req->headers = xnew_array (struct request_header, req->hcapacity);

  req->method = method;

  req->arg = arg;

  return req;

}

/* Return the method string passed with the last call to

   request_set_method.  */

static const char *

request_method (const struct request *req)

{

  return req->method;

}

/* Free one header according to the release policy specified with

   request_set_header.  */

static void

release_header (struct request_header *hdr)

{

  switch (hdr->release_policy)

    {

    case rel_none:

      break;

    case rel_name:

      xfree (hdr->name);

      break;

    case rel_value:

      xfree (hdr->value);

      break;

    case rel_both:

      xfree (hdr->name);

      xfree (hdr->value);

      break;

    }

}

/* Set the request named NAME to VALUE.  Specifically, this means that

   a "NAME: VALUE\r\n" header line will be used in the request.  If a

   header with the same name previously existed in the request, its

   value will be replaced by this one.  A NULL value means do nothing.

   RELEASE_POLICY determines whether NAME and VALUE should be released

   (freed) with request_free.  Allowed values are:

    - rel_none     - don't free NAME or VALUE

    - rel_name     - free NAME when done

    - rel_value    - free VALUE when done

    - rel_both     - free both NAME and VALUE when done

   Setting release policy is useful when arguments come from different

   sources.  For example:

     // Don't free literal strings!

     request_set_header (req, "Pragma", "no-cache", rel_none);

     // Don't free a global variable, we'll need it later.

     request_set_header (req, "Referer", opt.referer, rel_none);

     // Value freshly allocated, free it when done.

     request_set_header (req, "Range",

                         aprintf ("bytes=%s-", number_to_static_string (hs->restval)),

                         rel_value);

   */

static void

request_set_header (struct request *req, const char *name, const char *value,

                    enum rp release_policy)

{

  struct request_header *hdr;

  int i;

  if (!value)

    {

      /* A NULL value is a no-op; if freeing the name is requested,

         free it now to avoid leaks.  */

      if (release_policy == rel_name || release_policy == rel_both)

        xfree (name);

      return;

    }

  for (i = 0; i < req->hcount; i++)

    {

      hdr = &req->headers[i];

      if (0 == c_strcasecmp (name, hdr->name))

        {

          /* Replace existing header. */

          release_header (hdr);

          hdr->name = (void *)name;

          hdr->value = (void *)value;

          hdr->release_policy = release_policy;

          return;

        }

    }

  /* Install new header. */

  if (req->hcount >= req->hcapacity)

    {

      req->hcapacity <<= 1;

      req->headers = xrealloc (req->headers, req->hcapacity * sizeof (*hdr));

    }

  hdr = &req->headers[req->hcount++];

  hdr->name = (void *)name;

  hdr->value = (void *)value;

  hdr->release_policy = release_policy;

}

/* Like request_set_header, but sets the whole header line, as

   provided by the user using the `--header' option.  For example,

   request_set_user_header (req, "Foo: bar") works just like

   request_set_header (req, "Foo", "bar").  */

static void

request_set_user_header (struct request *req, const char *header)

{

  const char *name, *p;

  if (!(p = strchr (header, ':')))

    return;

  name = xstrndup(header, p - header);

  ++p;

  while (c_isspace (*p))

    ++p;

  request_set_header (req, name, p, rel_name);

}

/* Remove the header with specified name from REQ.  Returns true if

   the header was actually removed, false otherwise.  */

static bool

request_remove_header (struct request *req, const char *name)

{

  int i;

  for (i = 0; i < req->hcount; i++)

    {

      struct request_header *hdr = &req->headers[i];

      if (0 == c_strcasecmp (name, hdr->name))

        {

          release_header (hdr);

          /* Move the remaining headers by one. */

          if (i < req->hcount - 1)

            memmove (hdr, hdr + 1, (req->hcount - i - 1) * sizeof (*hdr));

          --req->hcount;

          return true;

        }

    }

  return false;

}

#define APPEND(p, str) do {                     \

  int A_len = strlen (str);                     \

  memcpy (p, str, A_len);                       \

  p += A_len;                                   \

} while (0)

/* Construct the request and write it to FD using fd_write.

   If warc_tmp is set to a file pointer, the request string will

   also be written to that file. */

static int

request_send (const struct request *req, int fd, FILE *warc_tmp)

{

  char *request_string, *p;

  int i, size, write_error;

  /* Count the request size. */

  size = 0;

  /* METHOD " " ARG " " "HTTP/1.0" "\r\n" */

  size += strlen (req->method) + 1 + strlen (req->arg) + 1 + 8 + 2;

  for (i = 0; i < req->hcount; i++)

    {

      struct request_header *hdr = &req->headers[i];

      /* NAME ": " VALUE "\r\n" */

      size += strlen (hdr->name) + 2 + strlen (hdr->value) + 2;

    }

  /* "\r\n\0" */

  size += 3;

  p = request_string = xmalloc (size);

  /* Generate the request. */

  APPEND (p, req->method); *p++ = ' ';

  APPEND (p, req->arg);    *p++ = ' ';

  memcpy (p, "HTTP/1.1\r\n", 10); p += 10;

  for (i = 0; i < req->hcount; i++)

    {

      struct request_header *hdr = &req->headers[i];

      APPEND (p, hdr->name);

      *p++ = ':', *p++ = ' ';

      APPEND (p, hdr->value);

      *p++ = '\r', *p++ = '\n';

    }

  *p++ = '\r', *p++ = '\n', *p++ = '\0';

  assert (p - request_string == size);

#undef APPEND

  DEBUGP (("\n---request begin---\n%s---request end---\n", request_string));

  /* Send the request to the server. */

  write_error = fd_write (fd, request_string, size - 1, -1);

  if (write_error < 0)

    logprintf (LOG_VERBOSE, _("Failed writing HTTP request: %s.\n"),

               fd_errstr (fd));

  else if (warc_tmp != NULL)

    {

      /* Write a copy of the data to the WARC record. */

      int warc_tmp_written = fwrite (request_string, 1, size - 1, warc_tmp);

      if (warc_tmp_written != size - 1)

        write_error = -2;

    }

  xfree (request_string);

  return write_error;

}

/* Release the resources used by REQ.

   It is safe to call it with a valid pointer to a NULL pointer.

   It is not safe to call it with an invalid or NULL pointer.  */

static void

request_free (struct request **req_ref)

{

  int i;

  struct request *req = *req_ref;

  if (!req)

    return;

  xfree (req->arg);

  for (i = 0; i < req->hcount; i++)

    release_header (&req->headers[i]);

  xfree (req->headers);

  xfree (req);

  *req_ref = NULL;

}

static struct hash_table *basic_authed_hosts;

/* Find out if this host has issued a Basic challenge yet; if so, give

 * it the username, password. A temporary measure until we can get

 * proper authentication in place. */

static bool

maybe_send_basic_creds (const char *hostname, const char *user,

                        const char *passwd, struct request *req)

{

  bool do_challenge = false;

  if (opt.auth_without_challenge)

    {

      DEBUGP (("Auth-without-challenge set, sending Basic credentials.\n"));

      do_challenge = true;

    }

  else if (basic_authed_hosts

      && hash_table_contains (basic_authed_hosts, hostname))

    {

      DEBUGP (("Found %s in basic_authed_hosts.\n", quote (hostname)));

      do_challenge = true;

    }

  else

    {

      DEBUGP (("Host %s has not issued a general basic challenge.\n",

              quote (hostname)));

    }

  if (do_challenge)

    {

      request_set_header (req, "Authorization",

                          basic_authentication_encode (user, passwd),

                          rel_value);

    }

  return do_challenge;

}

static void

register_basic_auth_host (const char *hostname)

{

  if (!basic_authed_hosts)

    {

      basic_authed_hosts = make_nocase_string_hash_table (1);

    }

  if (!hash_table_contains (basic_authed_hosts, hostname))

    {

      hash_table_put (basic_authed_hosts, xstrdup (hostname), NULL);

      DEBUGP (("Inserted %s into basic_authed_hosts\n", quote (hostname)));

    }

}

/* Send the contents of FILE_NAME to SOCK.  Make sure that exactly

   PROMISED_SIZE bytes are sent over the wire -- if the file is

   longer, read only that much; if the file is shorter, report an error.

   If warc_tmp is set to a file pointer, the post data will

   also be written to that file.  */

static int

body_file_send (int sock, const char *file_name, wgint promised_size, FILE *warc_tmp)

{

  static char chunk[8192];

  wgint written = 0;

  int write_error;

  FILE *fp;

  DEBUGP (("[writing BODY file %s ... ", file_name));

  fp = fopen (file_name, "rb");

  if (!fp)

    return -1;

  while (!feof (fp) && written < promised_size)

    {

      int towrite;

      int length = fread (chunk, 1, sizeof (chunk), fp);

      if (length == 0)

        break;

      towrite = MIN (promised_size - written, length);

      write_error = fd_write (sock, chunk, towrite, -1);

      if (write_error < 0)

        {

          fclose (fp);

          return -1;

        }

      if (warc_tmp != NULL)

        {

          /* Write a copy of the data to the WARC record. */

          int warc_tmp_written = fwrite (chunk, 1, towrite, warc_tmp);

          if (warc_tmp_written != towrite)

            {

              fclose (fp);

              return -2;

            }

        }

      written += towrite;

    }

  fclose (fp);

  /* If we've written less than was promised, report a (probably

     nonsensical) error rather than break the promise.  */

  if (written < promised_size)

    {

      errno = EINVAL;

      return -1;

    }

  assert (written == promised_size);

  DEBUGP (("done]\n"));

  return 0;

}

/* Determine whether [START, PEEKED + PEEKLEN) contains an empty line.

   If so, return the pointer to the position after the line, otherwise

   return NULL.  This is used as callback to fd_read_hunk.  The data

   between START and PEEKED has been read and cannot be "unread"; the

   data after PEEKED has only been peeked.  */

static const char *

response_head_terminator (const char *start, const char *peeked, int peeklen)

{

  const char *p, *end;

  /* If at first peek, verify whether HUNK starts with "HTTP".  If

     not, this is a HTTP/0.9 request and we must bail out without

     reading anything.  */

  if (start == peeked && 0 != memcmp (start, "HTTP", MIN (peeklen, 4)))

    return start;

  /* Look for "\n[\r]\n", and return the following position if found.

     Start two chars before the current to cover the possibility that

     part of the terminator (e.g. "\n\r") arrived in the previous

     batch.  */

  p = peeked - start < 2 ? start : peeked - 2;

  end = peeked + peeklen;

  /* Check for \n\r\n or \n\n anywhere in [p, end-2). */

  for (; p < end - 2; p++)

    if (*p == '\n')

      {

        if (p[1] == '\r' && p[2] == '\n')

          return p + 3;

        else if (p[1] == '\n')

          return p + 2;

      }

  /* p==end-2: check for \n\n directly preceding END. */

  if (peeklen >= 2 && p[0] == '\n' && p[1] == '\n')

    return p + 2;

  return NULL;

}

/* The maximum size of a single HTTP response we care to read.  Rather

   than being a limit of the reader implementation, this limit

   prevents Wget from slurping all available memory upon encountering

   malicious or buggy server output, thus protecting the user.  Define

   it to 0 to remove the limit.  */

#define HTTP_RESPONSE_MAX_SIZE 65536

/* Read the HTTP request head from FD and return it.  The error

   conditions are the same as with fd_read_hunk.

   To support HTTP/0.9 responses, this function tries to make sure

   that the data begins with "HTTP".  If this is not the case, no data

   is read and an empty request is returned, so that the remaining

   data can be treated as body.  */

static char *

read_http_response_head (int fd)

{

  return fd_read_hunk (fd, response_head_terminator, 512,

                       HTTP_RESPONSE_MAX_SIZE);

}

struct response {

  /* The response data. */

  const char *data;

  /* The array of pointers that indicate where each header starts.

     For example, given this HTTP response:

       HTTP/1.0 200 Ok

       Description: some

        text

       Etag: x

     The headers are located like this:

     "HTTP/1.0 200 Ok\r\nDescription: some\r\n text\r\nEtag: x\r\n\r\n"

     ^                   ^                             ^          ^

     headers[0]          headers[1]                    headers[2] headers[3]

     I.e. headers[0] points to the beginning of the request,

     headers[1] points to the end of the first header and the

     beginning of the second one, etc.  */

  const char **headers;

};

/* Create a new response object from the text of the HTTP response,

   available in HEAD.  That text is automatically split into

   constituent header lines for fast retrieval using

   resp_header_*.  */

static struct response *

resp_new (char *head)

{

  char *hdr;

  int count, size;

  struct response *resp = xnew0 (struct response);

  resp->data = head;

  if (*head == '\0')

    {

      /* Empty head means that we're dealing with a headerless

         (HTTP/0.9) response.  In that case, don't set HEADERS at

         all.  */

      return resp;

    }

  /* Split HEAD into header lines, so that resp_header_* functions

     don't need to do this over and over again.  */

  size = count = 0;

  hdr = head;

  while (1)

    {

      DO_REALLOC (resp->headers, size, count + 1, const char *);

      resp->headers[count++] = hdr;

      /* Break upon encountering an empty line. */

      if (!hdr[0] || (hdr[0] == '\r' && hdr[1] == '\n') || hdr[0] == '\n')

        break;

      /* Find the end of HDR, including continuations. */

      for (;;)

        {

          char *end = strchr (hdr, '\n');

          if (!end)

            {

              hdr += strlen (hdr);

              break;

            }

          hdr = end + 1;

          if (*hdr != ' ' && *hdr != '\t')

            break;

          // continuation, transform \r and \n into spaces

          *end = ' ';

          if (end > head && end[-1] == '\r')

            end[-1] = ' ';

        }

    }

  DO_REALLOC (resp->headers, size, count + 1, const char *);

  resp->headers[count] = NULL;

  return resp;

}

/* Locate the header named NAME in the request data, starting with

   position START.  This allows the code to loop through the request

   data, filtering for all requests of a given name.  Returns the

   found position, or -1 for failure.  The code that uses this

   function typically looks like this:

     for (pos = 0; (pos = resp_header_locate (...)) != -1; pos++)

       ... do something with header ...

   If you only care about one header, use resp_header_get instead of

   this function.  */

static int

resp_header_locate (const struct response *resp, const char *name, int start,

                    const char **begptr, const char **endptr)

{

  int i;

  const char **headers = resp->headers;

  int name_len;

  if (!headers || !headers[1])

    return -1;

  name_len = strlen (name);

  if (start > 0)

    i = start;

  else

    i = 1;

  for (; headers[i + 1]; i++)

    {

      const char *b = headers[i];

      const char *e = headers[i + 1];

      if (e - b > name_len

          && b[name_len] == ':'

          && 0 == c_strncasecmp (b, name, name_len))

        {

          b += name_len + 1;

          while (b < e && c_isspace (*b))

            ++b;

          while (b < e && c_isspace (e[-1]))

            --e;

          *begptr = b;

          *endptr = e;

          return i;

        }

    }

  return -1;

}

/* Find and retrieve the header named NAME in the request data.  If

   found, set *BEGPTR to its starting, and *ENDPTR to its ending

   position, and return true.  Otherwise return false.

   This function is used as a building block for resp_header_copy

   and resp_header_strdup.  */

static bool

resp_header_get (const struct response *resp, const char *name,

                 const char **begptr, const char **endptr)

{

  int pos = resp_header_locate (resp, name, 0, begptr, endptr);

  return pos != -1;

}

/* Copy the response header named NAME to buffer BUF, no longer than

   BUFSIZE (BUFSIZE includes the terminating 0).  If the header

   exists, true is returned, false otherwise.  If there should be no

   limit on the size of the header, use resp_header_strdup instead.

   If BUFSIZE is 0, no data is copied, but the boolean indication of

   whether the header is present is still returned.  */

static bool

resp_header_copy (const struct response *resp, const char *name,

                  char *buf, int bufsize)

{

  const char *b, *e;

  if (!resp_header_get (resp, name, &b, &e))

    return false;

  if (bufsize)

    {

      int len = MIN (e - b, bufsize - 1);

      memcpy (buf, b, len);

      buf[len] = '\0';

    }

  return true;

}

/* Return the value of header named NAME in RESP, allocated with

   malloc.  If such a header does not exist in RESP, return NULL.  */

static char *

resp_header_strdup (const struct response *resp, const char *name)

{

  const char *b, *e;

  if (!resp_header_get (resp, name, &b, &e))

    return NULL;

  return strdupdelim (b, e);

}

/* Parse the HTTP status line, which is of format:

   HTTP-Version SP Status-Code SP Reason-Phrase

   The function returns the status-code, or -1 if the status line

   appears malformed.  The pointer to "reason-phrase" message is

   returned in *MESSAGE.  */

static int

resp_status (const struct response *resp, char **message)

{

  int status;

  const char *p, *end;

  if (!resp->headers)

    {

      /* For a HTTP/0.9 response, assume status 200. */

      if (message)

        *message = xstrdup (_("No headers, assuming HTTP/0.9"));

      return 200;

    }

  p = resp->headers[0];

  end = resp->headers[1];

  if (!end)

    return -1;

  /* "HTTP" */

  if (end - p < 4 || 0 != strncmp (p, "HTTP", 4))

    return -1;

  p += 4;

  /* Match the HTTP version.  This is optional because Gnutella

     servers have been reported to not specify HTTP version.  */

  if (p < end && *p == '/')

    {

      ++p;

      while (p < end && c_isdigit (*p))

        ++p;

      if (p < end && *p == '.')

        ++p;

      while (p < end && c_isdigit (*p))

        ++p;

    }

  while (p < end && c_isspace (*p))

    ++p;

  if (end - p < 3 || !c_isdigit (p[0]) || !c_isdigit (p[1]) || !c_isdigit (p[2]))

    return -1;

  status = 100 * (p[0] - '0') + 10 * (p[1] - '0') + (p[2] - '0');

  p += 3;

  if (message)

    {

      while (p < end && c_isspace (*p))

        ++p;

      while (p < end && c_isspace (end[-1]))

        --end;

      *message = strdupdelim (p, end);

    }

  return status;

}

/* Release the resources used by RESP.

   It is safe to call it with a valid pointer to a NULL pointer.

   It is not safe to call it with a invalid or NULL pointer.  */

static void

resp_free (struct response **resp_ref)

{

  struct response *resp = *resp_ref;

  if (!resp)

    return;

  xfree (resp->headers);

  xfree (resp);

  *resp_ref = NULL;

}

/* Print a single line of response, the characters [b, e).  We tried

   getting away with

      logprintf (LOG_VERBOSE, "%s%.*s\n", prefix, (int) (e - b), b);

   but that failed to escape the non-printable characters and, in fact,

   caused crashes in UTF-8 locales.  */

static void

print_response_line (const char *prefix, const char *b, const char *e)

{

  char buf[1024], *copy;

  size_t len = e - b;

  if (len < sizeof (buf))

    copy = buf;

  else

    copy = xmalloc(len + 1);

  memcpy(copy, b, len);

  copy[len] = 0;

  logprintf (LOG_ALWAYS, "%s%s\n", prefix,

             quotearg_style (escape_quoting_style, copy));

  if (copy != buf)

    xfree (copy);

}

/* Print the server response, line by line, omitting the trailing CRLF

   from individual header lines, and prefixed with PREFIX.  */

static void

print_server_response (const struct response *resp, const char *prefix)

{

  int i;

  if (!resp->headers)

    return;

  for (i = 0; resp->headers[i + 1]; i++)

    {

      const char *b = resp->headers[i];

      const char *e = resp->headers[i + 1];

      /* Skip CRLF */

      if (b < e && e[-1] == '\n')

        --e;

      if (b < e && e[-1] == '\r')

        --e;

      print_response_line (prefix, b, e);

    }

}

/* Parse the `Content-Range' header and extract the information it

   contains.  Returns true if successful, false otherwise.  */

static bool

parse_content_range (const char *hdr, wgint *first_byte_ptr,

                     wgint *last_byte_ptr, wgint *entity_length_ptr)

{

  wgint num;

  /* Ancient versions of Netscape proxy server, presumably predating

     rfc2068, sent out `Content-Range' without the "bytes"

     specifier.  */

  if (0 == strncasecmp (hdr, "bytes", 5))

    {

      hdr += 5;

      /* "JavaWebServer/1.1.1" sends "bytes: x-y/z", contrary to the

         HTTP spec. */

      if (*hdr == ':')

        ++hdr;

      while (c_isspace (*hdr))

        ++hdr;

      if (!*hdr)

        return false;

    }

  if (!c_isdigit (*hdr))

    return false;

  for (num = 0; c_isdigit (*hdr); hdr++)