home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2004 September / PCWELT_9_2004.ISO / pcwsoft / wgetwin-1_5_3_1-binary.z.exe / url.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-07-01  |  37.3 KB  |  1,501 lines
  1. /* URL handling.
  2.    Copyright (C) 1995, 1996, 1997 Free Software Foundation, Inc.
  3.  
  4. This file is part of Wget.
  5.  
  6. This program is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 2 of the License, or
  9. (at your option) any later version.
  10.  
  11. This program is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with this program; if not, write to the Free Software
  18. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20. #include <config.h>
  21.  
  22. #include <stdio.h>
  23. #include <stdlib.h>
  24. #ifdef HAVE_STRING_H
  25. # include <string.h>
  26. #else
  27. # include <strings.h>
  28. #endif
  29. #include <ctype.h>
  30. #include <sys/types.h>
  31. #ifdef HAVE_UNISTD_H
  32. # include <unistd.h>
  33. #endif
  34. #include <errno.h>
  35. #include <assert.h>
  36.  
  37. #include "wget.h"
  38. #include "utils.h"
  39. #include "url.h"
  40. #include "host.h"
  41. #include "html.h"
  42.  
  43. #ifndef errno
  44. extern int errno;
  45. #endif
  46.  
  47. /* Default port definitions */
  48. #define DEFAULT_HTTP_PORT 80
  49. #define DEFAULT_FTP_PORT 21
  50.  
  51. /* URL separator (for findurl) */
  52. #define URL_SEPARATOR "!\"#'(),>`{}|<>"
  53.  
  54. /* A list of unsafe characters for encoding, as per RFC1738.  '@' and
  55.    ':' (not listed in RFC) were added because of user/password
  56.    encoding, and \033 for safe printing.  */
  57.  
  58. #ifndef WINDOWS
  59. # define URL_UNSAFE " <>\"#%{}|\\^~[]`@:\033"
  60. #else  /* WINDOWS */
  61. # define URL_UNSAFE " :*<>\"%{}|\\^[]`\033"
  62. #endif /* WINDOWS */
  63.  
  64. /* If S contains unsafe characters, free it and replace it with a
  65.    version that doesn't.  */
  66. #define URL_CLEANSE(s) do            \
  67. {                        \
  68.   if (contains_unsafe (s))            \
  69.     {                        \
  70.       char *uc_tmp = encode_string (s);        \
  71.       free (s);                    \
  72.       (s) = uc_tmp;                \
  73.     }                        \
  74. } while (0)
  75.  
  76. /* Is a directory "."?  */
  77. #define DOTP(x) ((*(x) == '.') && (!*(x + 1)))
  78. /* Is a directory ".."?  */
  79. #define DDOTP(x) ((*(x) == '.') && (*(x + 1) == '.') && (!*(x + 2)))
  80.  
  81. /* NULL-terminated list of strings to be recognized as prototypes (URL
  82.    schemes).  Note that recognized doesn't mean supported -- only HTTP
  83.    and FTP are currently supported.
  84.  
  85.    However, a string that does not match anything in the list will be
  86.    considered a relative URL.  Thus it's important that this list has
  87.    anything anyone could think of being legal.
  88.  
  89.    There are wild things here.  :-) Take a look at
  90.    <URL:http://www.w3.org/pub/WWW/Addressing/schemes.html> for more
  91.    fun.  */
  92. static char *protostrings[] =
  93. {
  94.   "cid:",
  95.   "clsid:",
  96.   "file:",
  97.   "finger:",
  98.   "ftp:",
  99.   "gopher:",
  100.   "hdl:",
  101.   "http:",
  102.   "https:",
  103.   "ilu:",
  104.   "ior:",
  105.   "irc:",
  106.   "java:",
  107.   "javascript:",
  108.   "lifn:",
  109.   "mailto:",
  110.   "mid:",
  111.   "news:",
  112.   "nntp:",
  113.   "path:",
  114.   "prospero:",
  115.   "rlogin:",
  116.   "service:",
  117.   "shttp:",
  118.   "snews:",
  119.   "stanf:",
  120.   "telnet:",
  121.   "tn3270:",
  122.   "wais:",
  123.   "whois++:",
  124.   NULL
  125. };
  126.  
  127. struct proto
  128. {
  129.   char *name;
  130.   uerr_t ind;
  131.   unsigned short port;
  132. };
  133.  
  134. /* Similar to former, but for supported protocols: */
  135. static struct proto sup_protos[] =
  136. {
  137.   { "http://", URLHTTP, DEFAULT_HTTP_PORT },
  138.   { "ftp://", URLFTP, DEFAULT_FTP_PORT },
  139.   /*{ "file://", URLFILE, DEFAULT_FTP_PORT },*/
  140. };
  141.  
  142. static void parse_dir PARAMS ((const char *, char **, char **));
  143. static uerr_t parse_uname PARAMS ((const char *, char **, char **));
  144. static char *construct PARAMS ((const char *, const char *, int , int));
  145. static char *construct_relative PARAMS ((const char *, const char *));
  146. static char process_ftp_type PARAMS ((char *));
  147.  
  148.  
  149. /* Returns the number of characters to be skipped if the first thing
  150.    in a URL is URL: (which is 0 or 4+).  The optional spaces after
  151.    URL: are also skipped.  */
  152. int
  153. skip_url (const char *url)
  154. {
  155.   int i;
  156.  
  157.   if (toupper (url[0]) == 'U'
  158.       && toupper (url[1]) == 'R'
  159.       && toupper (url[2]) == 'L'
  160.       && url[3] == ':')
  161.     {
  162.       /* Skip blanks.  */
  163.       for (i = 4; url[i] && ISSPACE (url[i]); i++);
  164.       return i;
  165.     }
  166.   else
  167.     return 0;
  168. }
  169.  
  170. /* Returns 1 if the string contains unsafe characters, 0 otherwise.  */
  171. int
  172. contains_unsafe (const char *s)
  173. {
  174.   for (; *s; s++)
  175.     if (strchr (URL_UNSAFE, *s))
  176.       return 1;
  177.   return 0;
  178. }
  179.  
  180. /* Decodes the forms %xy in a URL to the character the hexadecimal
  181.    code of which is xy.  xy are hexadecimal digits from
  182.    [0123456789ABCDEF] (case-insensitive).  If x or y are not
  183.    hex-digits or `%' precedes `\0', the sequence is inserted
  184.    literally.  */
  185.  
  186. static void
  187. decode_string (char *s)
  188. {
  189.   char *p = s;
  190.  
  191.   for (; *s; s++, p++)
  192.     {
  193.       if (*s != '%')
  194.     *p = *s;
  195.       else
  196.     {
  197.       /* Do nothing if at the end of the string, or if the chars
  198.          are not hex-digits.  */
  199.       if (!*(s + 1) || !*(s + 2)
  200.           || !(ISXDIGIT (*(s + 1)) && ISXDIGIT (*(s + 2))))
  201.         {
  202.           *p = *s;
  203.           continue;
  204.         }
  205.       *p = (ASC2HEXD (*(s + 1)) << 4) + ASC2HEXD (*(s + 2));
  206.       s += 2;
  207.     }
  208.     }
  209.   *p = '\0';
  210. }
  211.  
  212. /* Encodes the unsafe characters (listed in URL_UNSAFE) in a given
  213.    string, returning a malloc-ed %XX encoded string.  */
  214. char *
  215. encode_string (const char *s)
  216. {
  217.   const char *b;
  218.   char *p, *res;
  219.   int i;
  220.  
  221.   b = s;
  222.   for (i = 0; *s; s++, i++)
  223.     if (strchr (URL_UNSAFE, *s))
  224.       i += 2; /* Two more characters (hex digits) */
  225.   res = (char *)xmalloc (i + 1);
  226.   s = b;
  227.   for (p = res; *s; s++)
  228.     if (strchr (URL_UNSAFE, *s))
  229.       {
  230.     const unsigned char c = *s;
  231.     *p++ = '%';
  232.     *p++ = HEXD2ASC (c >> 4);
  233.     *p++ = HEXD2ASC (c & 0xf);
  234.       }
  235.     else
  236.       *p++ = *s;
  237.   *p = '\0';
  238.   return res;
  239. }
  240.  
  241. /* Returns the proto-type if URL's protocol is supported, or
  242.    URLUNKNOWN if not.  */
  243. uerr_t
  244. urlproto (const char *url)
  245. {
  246.   int i;
  247.  
  248.   url += skip_url (url);
  249.   for (i = 0; i < ARRAY_SIZE (sup_protos); i++)
  250.     if (!strncasecmp (url, sup_protos[i].name, strlen (sup_protos[i].name)))
  251.       return sup_protos[i].ind;
  252.   for (i = 0; url[i] && url[i] != ':' && url[i] != '/'; i++);
  253.   if (url[i] == ':')
  254.     {
  255.       for (++i; url[i] && url[i] != '/'; i++)
  256.     if (!ISDIGIT (url[i]))
  257.       return URLBADPORT;
  258.       if (url[i - 1] == ':')
  259.     return URLFTP;
  260.       else
  261.     return URLHTTP;
  262.     }
  263.   else
  264.     return URLHTTP;
  265. }
  266.  
  267. /* Skip the protocol part of the URL, e.g. `http://'.  If no protocol
  268.    part is found, returns 0.  */
  269. int
  270. skip_proto (const char *url)
  271. {
  272.   char **s;
  273.   int l;
  274.  
  275.   for (s = protostrings; *s; s++)
  276.     if (!strncasecmp (*s, url, strlen (*s)))
  277.       break;
  278.   if (!*s)
  279.     return 0;
  280.   l = strlen (*s);
  281.   /* HTTP and FTP protocols are expected to yield exact host names
  282.      (i.e. the `//' part must be skipped, too).  */
  283.   if (!strcmp (*s, "http:") || !strcmp (*s, "ftp:"))
  284.     l += 2;
  285.   return l;
  286. }
  287.  
  288. /* Returns 1 if the URL begins with a protocol (supported or
  289.    unsupported), 0 otherwise.  */
  290. static int
  291. has_proto (const char *url)
  292. {
  293.   char **s;
  294.  
  295.   url += skip_url (url);
  296.   for (s = protostrings; *s; s++)
  297.     if (strncasecmp (url, *s, strlen (*s)) == 0)
  298.       return 1;
  299.   return 0;
  300. }
  301.  
  302. /* Skip the username and password, if present here.  The function
  303.    should be called *not* with the complete URL, but with the part
  304.    right after the protocol.
  305.  
  306.    If no username and password are found, return 0.  */
  307. int
  308. skip_uname (const char *url)
  309. {
  310.   const char *p;
  311.   for (p = url; *p && *p != '/'; p++)
  312.     if (*p == '@')
  313.       break;
  314.   /* If a `@' was found before the first occurrence of `/', skip
  315.      it.  */
  316.   if (*p == '@')
  317.     return p - url + 1;
  318.   else
  319.     return 0;
  320. }
  321.  
  322. /* Allocate a new urlinfo structure, fill it with default values and
  323.    return a pointer to it.  */
  324. struct urlinfo *
  325. newurl (void)
  326. {
  327.   struct urlinfo *u;
  328.  
  329.   u = (struct urlinfo *)xmalloc (sizeof (struct urlinfo));
  330.   memset (u, 0, sizeof (*u));
  331.   u->proto = URLUNKNOWN;
  332.   return u;
  333. }
  334.  
  335. /* Perform a "deep" free of the urlinfo structure.  The structure
  336.    should have been created with newurl, but need not have been used.
  337.    If free_pointer is non-0, free the pointer itself.  */
  338. void
  339. freeurl (struct urlinfo *u, int complete)
  340. {
  341.   assert (u != NULL);
  342.   FREE_MAYBE (u->url);
  343.   FREE_MAYBE (u->host);
  344.   FREE_MAYBE (u->path);
  345.   FREE_MAYBE (u->file);
  346.   FREE_MAYBE (u->dir);
  347.   FREE_MAYBE (u->user);
  348.   FREE_MAYBE (u->passwd);
  349.   FREE_MAYBE (u->local);
  350.   FREE_MAYBE (u->referer);
  351.   if (u->proxy)
  352.     freeurl (u->proxy, 1);
  353.   if (complete)
  354.     free (u);
  355.   return;
  356. }
  357.  
  358. /* Extract the given URL of the form
  359.    (http:|ftp:)// (user (:password)?@)?hostname (:port)? (/path)?
  360.    1. hostname (terminated with `/' or `:')
  361.    2. port number (terminated with `/'), or chosen for the protocol
  362.    3. dirname (everything after hostname)
  363.    Most errors are handled.  No allocation is done, you must supply
  364.    pointers to allocated memory.
  365.    ...and a host of other stuff :-)
  366.  
  367.    - Recognizes hostname:dir/file for FTP and
  368.      hostname (:portnum)?/dir/file for HTTP.
  369.    - Parses the path to yield directory and file
  370.    - Parses the URL to yield the username and passwd (if present)
  371.    - Decodes the strings, in case they contain "forbidden" characters
  372.    - Writes the result to struct urlinfo
  373.  
  374.    If the argument STRICT is set, it recognizes only the canonical
  375.    form.  */
  376. uerr_t
  377. parseurl (const char *url, struct urlinfo *u, int strict)
  378. {
  379.   int i, l, abs_ftp;
  380.   int recognizable;            /* Recognizable URL is the one where
  381.                   the protocol name was explicitly
  382.                   named, i.e. it wasn't deduced from
  383.                   the URL format.  */
  384.   uerr_t type;
  385.  
  386.   DEBUGP (("parseurl (\"%s\") -> ", url));
  387.   url += skip_url (url);
  388.   recognizable = has_proto (url);
  389.   if (strict && !recognizable)
  390.     return URLUNKNOWN;
  391.   for (i = 0, l = 0; i < ARRAY_SIZE (sup_protos); i++)
  392.     {
  393.       l = strlen (sup_protos[i].name);
  394.       if (!strncasecmp (sup_protos[i].name, url, l))
  395.     break;
  396.     }
  397.   /* If protocol is recognizable, but unsupported, bail out, else
  398.      suppose unknown.  */
  399.   if (recognizable && !sup_protos[i].name)
  400.     return URLUNKNOWN;
  401.   else if (i == ARRAY_SIZE (sup_protos))
  402.     type = URLUNKNOWN;
  403.   else
  404.     u->proto = type = sup_protos[i].ind;
  405.  
  406.   if (type == URLUNKNOWN)
  407.     l = 0;
  408.   /* Allow a username and password to be specified (i.e. just skip
  409.      them for now).  */
  410.   if (recognizable)
  411.     l += skip_uname (url + l);
  412.   for (i = l; url[i] && url[i] != ':' && url[i] != '/'; i++);
  413.   if (i == l)
  414.     return URLBADHOST;
  415.   /* Get the hostname.  */
  416.   u->host = strdupdelim (url + l, url + i);
  417.   DEBUGP (("host %s -> ", u->host));
  418.  
  419.   /* Assume no port has been given.  */
  420.   u->port = 0;
  421.   if (url[i] == ':')
  422.     {
  423.       /* We have a colon delimiting the hostname.  It could mean that
  424.      a port number is following it, or a directory.  */
  425.       if (ISDIGIT (url[++i]))    /* A port number */
  426.     {
  427.       if (type == URLUNKNOWN)
  428.         u->proto = type = URLHTTP;
  429.       for (; url[i] && url[i] != '/'; i++)
  430.         if (ISDIGIT (url[i]))
  431.           u->port = 10 * u->port + (url[i] - '0');
  432.         else
  433.           return URLBADPORT;
  434.       if (!u->port)
  435.         return URLBADPORT;
  436.       DEBUGP (("port %hu -> ", u->port));
  437.     }
  438.       else if (type == URLUNKNOWN) /* or a directory */
  439.     u->proto = type = URLFTP;
  440.       else                      /* or just a misformed port number */
  441.     return URLBADPORT;
  442.     }
  443.   else if (type == URLUNKNOWN)
  444.     u->proto = type = URLHTTP;
  445.   if (!u->port)
  446.     {
  447.       int i;
  448.       for (i = 0; i < ARRAY_SIZE (sup_protos); i++)
  449.     if (sup_protos[i].ind == type)
  450.       break;
  451.       if (i == ARRAY_SIZE (sup_protos))
  452.     return URLUNKNOWN;
  453.       u->port = sup_protos[i].port;
  454.     }
  455.   /* Some delimiter troubles...  */
  456.   if (url[i] == '/' && url[i - 1] != ':')
  457.     ++i;
  458.   if (type == URLHTTP)
  459.     while (url[i] && url[i] == '/')
  460.       ++i;
  461.   u->path = (char *)xmalloc (strlen (url + i) + 8);
  462.   strcpy (u->path, url + i);
  463.   if (type == URLFTP)
  464.     {
  465.       u->ftp_type = process_ftp_type (u->path);
  466.       /* #### We don't handle type `d' correctly yet.  */
  467.       if (!u->ftp_type || toupper (u->ftp_type) == 'D')
  468.     u->ftp_type = 'I';
  469.     }
  470.   DEBUGP (("opath %s -> ", u->path));
  471.   /* Parse the username and password (if existing).  */
  472.   parse_uname (url, &u->user, &u->passwd);
  473.   /* Decode the strings, as per RFC 1738.  */
  474.   decode_string (u->host);
  475.   decode_string (u->path);
  476.   if (u->user)
  477.     decode_string (u->user);
  478.   if (u->passwd)
  479.     decode_string (u->passwd);
  480.   /* Parse the directory.  */
  481.   parse_dir (u->path, &u->dir, &u->file);
  482.   DEBUGP (("dir %s -> file %s -> ", u->dir, u->file));
  483.   /* Simplify the directory.  */
  484.   path_simplify (u->dir);
  485.   /* Remove the leading `/' in HTTP.  */
  486.   if (type == URLHTTP && *u->dir == '/')
  487.     strcpy (u->dir, u->dir + 1);
  488.   DEBUGP (("ndir %s\n", u->dir));
  489.   /* Strip trailing `/'.  */
  490.   l = strlen (u->dir);
  491.   if (l && u->dir[l - 1] == '/')
  492.     u->dir[l - 1] = '\0';
  493.   /* Re-create the path: */
  494.   abs_ftp = (u->proto == URLFTP && *u->dir == '/');
  495.   /*  sprintf (u->path, "%s%s%s%s", abs_ftp ? "%2F": "/",
  496.       abs_ftp ? (u->dir + 1) : u->dir, *u->dir ? "/" : "", u->file); */
  497.   strcpy (u->path, abs_ftp ? "%2F" : "/");
  498.   strcat (u->path, abs_ftp ? (u->dir + 1) : u->dir);
  499.   strcat (u->path, *u->dir ? "/" : "");
  500.   strcat (u->path, u->file);
  501.   URL_CLEANSE (u->path);
  502.   /* Create the clean URL.  */
  503.   u->url = str_url (u, 0);
  504.   return URLOK;
  505. }
  506.  
  507. /* Build the directory and filename components of the path.  Both
  508.    components are *separately* malloc-ed strings!  It does not change
  509.    the contents of path.
  510.  
  511.    If the path ends with "." or "..", they are (correctly) counted as
  512.    directories.  */
  513. static void
  514. parse_dir (const char *path, char **dir, char **file)
  515. {
  516.   int i, l;
  517.  
  518.   for (i = l = strlen (path); i && path[i] != '/'; i--);
  519.   if (!i && *path != '/')   /* Just filename */
  520.     {
  521.       if (DOTP (path) || DDOTP (path))
  522.     {
  523.       *dir = xstrdup (path);
  524.       *file = xstrdup ("");
  525.     }
  526.       else
  527.     {
  528.       *dir = xstrdup ("");     /* This is required because of FTP */
  529.       *file = xstrdup (path);
  530.     }
  531.     }
  532.   else if (!i)                 /* /filename */
  533.     {
  534.       if (DOTP (path + 1) || DDOTP (path + 1))
  535.     {
  536.       *dir = xstrdup (path);
  537.       *file = xstrdup ("");
  538.     }
  539.       else
  540.     {
  541.       *dir = xstrdup ("/");
  542.       *file = xstrdup (path + 1);
  543.     }
  544.     }
  545.   else /* Nonempty directory with or without a filename */
  546.     {
  547.       if (DOTP (path + i + 1) || DDOTP (path + i + 1))
  548.     {
  549.       *dir = xstrdup (path);
  550.       *file = xstrdup ("");
  551.     }
  552.       else
  553.     {
  554.       *dir = strdupdelim (path, path + i);
  555.       *file = strdupdelim (path + i + 1, path + l + 1);
  556.     }
  557.     }
  558. }
  559.  
  560. /* Find the optional username and password within the URL, as per
  561.    RFC1738.  The returned user and passwd char pointers are
  562.    malloc-ed.  */
  563. static uerr_t
  564. parse_uname (const char *url, char **user, char **passwd)
  565. {
  566.   int l;
  567.   const char *p, *col;
  568.   char **where;
  569.  
  570.   *user = NULL;
  571.   *passwd = NULL;
  572.   url += skip_url (url);
  573.   /* Look for end of protocol string.  */
  574.   l = skip_proto (url);
  575.   if (!l)
  576.     return URLUNKNOWN;
  577.   /* Add protocol offset.  */
  578.   url += l;
  579.   /* Is there an `@' character?  */
  580.   for (p = url; *p && *p != '/'; p++)
  581.     if (*p == '@')
  582.       break;
  583.   /* If not, return.  */
  584.   if (*p != '@')
  585.     return URLOK;
  586.   /* Else find the username and password.  */
  587.   for (p = col = url; *p != '@'; p++)
  588.     {
  589.       if (*p == ':' && !*user)
  590.     {
  591.       *user = (char *)xmalloc (p - url + 1);
  592.       memcpy (*user, url, p - url);
  593.       (*user)[p - url] = '\0';
  594.       col = p + 1;
  595.     }
  596.     }
  597.   /* Decide whether you have only the username or both.  */
  598.   where = *user ? passwd : user;
  599.   *where = (char *)xmalloc (p - col + 1);
  600.   memcpy (*where, col, p - col);
  601.   (*where)[p - col] = '\0';
  602.   return URLOK;
  603. }
  604.  
  605. /* If PATH ends with `;type=X', return the character X.  */
  606. static char
  607. process_ftp_type (char *path)
  608. {
  609.   int len = strlen (path);
  610.  
  611.   if (len >= 7
  612.       && !memcmp (path + len - 7, ";type=", 6))
  613.     {
  614.       path[len - 7] = '\0';
  615.       return path[len - 1];
  616.     }
  617.   else
  618.     return '\0';
  619. }
  620.  
  621. /* Return the URL as fine-formed string, with a proper protocol, port
  622.    number, directory and optional user/password.  If HIDE is non-zero,
  623.    password will be hidden.  The forbidden characters in the URL will
  624.    be cleansed.  */
  625. char *
  626. str_url (const struct urlinfo *u, int hide)
  627. {
  628.   char *res, *host, *user, *passwd, *proto_name, *dir, *file;
  629.   int i, l, ln, lu, lh, lp, lf, ld;
  630.  
  631.   /* Look for the protocol name.  */
  632.   for (i = 0; i < ARRAY_SIZE (sup_protos); i++)
  633.     if (sup_protos[i].ind == u->proto)
  634.       break;
  635.   if (i == ARRAY_SIZE (sup_protos))
  636.     return NULL;
  637.   proto_name = sup_protos[i].name;
  638.   host = CLEANDUP (u->host);
  639.   dir = CLEANDUP (u->dir);
  640.   file = CLEANDUP (u->file);
  641.   user = passwd = NULL;
  642.   if (u->user)
  643.     user = CLEANDUP (u->user);
  644.   if (u->passwd)
  645.     {
  646.       int i;
  647.       passwd = CLEANDUP (u->passwd);
  648.       if (hide)
  649.     for (i = 0; passwd[i]; i++)
  650.       passwd[i] = 'x';
  651.     }
  652.   if (u->proto == URLFTP && *dir == '/')
  653.     {
  654.       char *tmp = (char *)xmalloc (strlen (dir) + 3);
  655.       /*sprintf (tmp, "%%2F%s", dir + 1);*/
  656.       *tmp = '%';
  657.       tmp[1] = '2';
  658.       tmp[2] = 'F';
  659.       strcpy (tmp + 3, dir + 1);
  660.       free (dir);
  661.       dir = tmp;
  662.     }
  663.  
  664.   ln = strlen (proto_name);
  665.   lu = user ? strlen (user) : 0;
  666.   lp = passwd ? strlen (passwd) : 0;
  667.   lh = strlen (host);
  668.   ld = strlen (dir);
  669.   lf = strlen (file);
  670.   res = (char *)xmalloc (ln + lu + lp + lh + ld + lf + 20); /* safe sex */
  671.   /* sprintf (res, "%s%s%s%s%s%s:%d/%s%s%s", proto_name,
  672.      (user ? user : ""), (passwd ? ":" : ""),
  673.      (passwd ? passwd : ""), (user ? "@" : ""),
  674.      host, u->port, dir, *dir ? "/" : "", file); */
  675.   l = 0;
  676.   memcpy (res, proto_name, ln);
  677.   l += ln;
  678.   if (user)
  679.     {
  680.       memcpy (res + l, user, lu);
  681.       l += lu;
  682.       if (passwd)
  683.     {
  684.       res[l++] = ':';
  685.       memcpy (res + l, passwd, lp);
  686.       l += lp;
  687.     }
  688.       res[l++] = '@';
  689.     }
  690.   memcpy (res + l, host, lh);
  691.   l += lh;
  692.   res[l++] = ':';
  693.   long_to_string (res + l, (long)u->port);
  694.   l += numdigit (u->port);
  695.   res[l++] = '/';
  696.   memcpy (res + l, dir, ld);
  697.   l += ld;
  698.   if (*dir)
  699.     res[l++] = '/';
  700.   strcpy (res + l, file);
  701.   free (host);
  702.   free (dir);
  703.   free (file);
  704.   FREE_MAYBE (user);
  705.   FREE_MAYBE (passwd);
  706.   return res;
  707. }
  708.  
  709. /* Check whether two URL-s are equivalent, i.e. pointing to the same
  710.    location.  Uses parseurl to parse them, and compares the canonical
  711.    forms.
  712.  
  713.    Returns 1 if the URL1 is equivalent to URL2, 0 otherwise.  Also
  714.    return 0 on error.  */
  715. int
  716. url_equal (const char *url1, const char *url2)
  717. {
  718.   struct urlinfo *u1, *u2;
  719.   uerr_t err;
  720.   int res;
  721.  
  722.   u1 = newurl ();
  723.   err = parseurl (url1, u1, 0);
  724.   if (err != URLOK)
  725.     {
  726.       freeurl (u1, 1);
  727.       return 0;
  728.     }
  729.   u2 = newurl ();
  730.   err = parseurl (url2, u2, 0);
  731.   if (err != URLOK)
  732.     {
  733.       freeurl (u2, 1);
  734.       return 0;
  735.     }
  736.   res = !strcmp (u1->url, u2->url);
  737.   freeurl (u1, 1);
  738.   freeurl (u2, 1);
  739.   return res;
  740. }
  741.  
  742. /* Find URL of format scheme:hostname[:port]/dir in a buffer.  The
  743.    buffer may contain pretty much anything; no errors are signaled.  */
  744. static const char *
  745. findurl (const char *buf, int howmuch, int *count)
  746. {
  747.   char **prot;
  748.   const char *s1, *s2;
  749.  
  750.   for (s1 = buf; howmuch; s1++, howmuch--)
  751.     for (prot = protostrings; *prot; prot++)
  752.       if (howmuch <= strlen (*prot))
  753.     continue;
  754.       else if (!strncasecmp (*prot, s1, strlen (*prot)))
  755.     {
  756.       for (s2 = s1, *count = 0;
  757.            howmuch && *s2 && *s2 >= 32 && *s2 < 127 && !ISSPACE (*s2) &&
  758.          !strchr (URL_SEPARATOR, *s2);
  759.            s2++, (*count)++, howmuch--);
  760.       return s1;
  761.     }
  762.   return NULL;
  763. }
  764.  
  765. /* Scans the file for signs of URL-s.  Returns a vector of pointers,
  766.    each pointer representing a URL string.  The file is *not* assumed
  767.    to be HTML.  */
  768. urlpos *
  769. get_urls_file (const char *file)
  770. {
  771.   long nread;
  772.   FILE *fp;
  773.   char *buf;
  774.   const char *pbuf;
  775.   int size;
  776.   urlpos *first, *current, *old;
  777.  
  778.   if (file && !HYPHENP (file))
  779.     {
  780.       fp = fopen (file, "rb");
  781.       if (!fp)
  782.     {
  783.       logprintf (LOG_NOTQUIET, "%s: %s\n", file, strerror (errno));
  784.       return NULL;
  785.     }
  786.     }
  787.   else
  788.     fp = stdin;
  789.   /* Load the file.  */
  790.   load_file (fp, &buf, &nread);
  791.   if (file && !HYPHENP (file))
  792.     fclose (fp);
  793.   DEBUGP (("Loaded %s (size %ld).\n", file, nread));
  794.   first = current = NULL;
  795.   /* Fill the linked list with URLs.  */
  796.   for (pbuf = buf; (pbuf = findurl (pbuf, nread - (pbuf - buf), &size));
  797.        pbuf += size)
  798.     {
  799.       /* Allocate the space.  */
  800.       old = current;
  801.       current = (urlpos *)xmalloc (sizeof (urlpos));
  802.       if (old)
  803.     old->next = current;
  804.       memset (current, 0, sizeof (*current));
  805.       current->next = NULL;
  806.       current->url = (char *)xmalloc (size + 1);
  807.       memcpy (current->url, pbuf, size);
  808.       current->url[size] = '\0';
  809.       if (!first)
  810.     first = current;
  811.     }
  812.   /* Free the buffer.  */
  813.   free (buf);
  814.  
  815.   return first;
  816. }
  817.  
  818. /* Similar to get_urls_file, but for HTML files.  FILE is scanned as
  819.    an HTML document using htmlfindurl(), which see.  get_urls_html()
  820.    constructs the HTML-s from the relative href-s.
  821.  
  822.    If SILENT is non-zero, do not barf on baseless relative links.  */
  823. urlpos *
  824. get_urls_html (const char *file, const char *this_url, int silent)
  825. {
  826.   long nread;
  827.   FILE *fp;
  828.   char *orig_buf;
  829.   const char *buf;
  830.   int step, first_time;
  831.   urlpos *first, *current, *old;
  832.  
  833.   if (file && !HYPHENP (file))
  834.     {
  835.       fp = fopen (file, "rb");
  836.       if (!fp)
  837.     {
  838.       logprintf (LOG_NOTQUIET, "%s: %s\n", file, strerror (errno));
  839.       return NULL;
  840.     }
  841.     }
  842.   else
  843.     fp = stdin;
  844.   /* Load the file.  */
  845.   load_file (fp, &orig_buf, &nread);
  846.   if (file && !HYPHENP (file))
  847.     fclose (fp);
  848.   DEBUGP (("Loaded HTML file %s (size %ld).\n", file, nread));
  849.   first = current = NULL;
  850.   first_time = 1;
  851.   /* Iterate over the URLs in BUF, picked by htmlfindurl().  */
  852.   for (buf = orig_buf;
  853.        (buf = htmlfindurl (buf, nread - (buf - orig_buf), &step, first_time));
  854.        buf += step)
  855.     {
  856.       int i, no_proto;
  857.       int size = step;
  858.       const char *pbuf = buf;
  859.       char *constr, *base;
  860.       const char *cbase;
  861.  
  862.       first_time = 0;
  863.  
  864.       /* A frequent phenomenon that needs to be handled are pages
  865.          generated by brain-damaged HTML generators, which refer to to
  866.          URI-s as <a href="<spaces>URI<spaces>">.  We simply ignore
  867.          any spaces at the beginning or at the end of the string.
  868.          This is probably not strictly correct, but that's what the
  869.          browsers do, so we may follow.  May the authors of "WYSIWYG"
  870.          HTML tools burn in hell for the damage they've inflicted!  */
  871.       while ((pbuf < buf + step) && ISSPACE (*pbuf))
  872.         {
  873.           ++pbuf;
  874.           --size;
  875.         }
  876.       while (size && ISSPACE (pbuf[size - 1]))
  877.     --size;
  878.       if (!size)
  879.     break;
  880.  
  881.       for (i = 0; protostrings[i]; i++)
  882.     {
  883.       if (!strncasecmp (protostrings[i], pbuf,
  884.                 MINVAL (strlen (protostrings[i]), size)))
  885.         break;
  886.     }
  887.       /* Check for http:RELATIVE_URI.  See below for details.  */
  888.       if (protostrings[i]
  889.       && !(strncasecmp (pbuf, "http:", 5) == 0
  890.            && strncasecmp (pbuf, "http://", 7) != 0))
  891.     {
  892.       no_proto = 0;
  893.     }
  894.       else
  895.     {
  896.       no_proto = 1;
  897.       /* This is for extremely brain-damaged pages that refer to
  898.          relative URI-s as <a href="http:URL">.  Just strip off the
  899.          silly leading "http:" (as well as any leading blanks
  900.          before it).  */
  901.       if ((size > 5) && !strncasecmp ("http:", pbuf, 5))
  902.         pbuf += 5, size -= 5;
  903.     }
  904.       if (!no_proto)
  905.     {
  906.       for (i = 0; i < ARRAY_SIZE (sup_protos); i++)
  907.         {
  908.           if (!strncasecmp (sup_protos[i].name, pbuf,
  909.                    MINVAL (strlen (sup_protos[i].name), size)))
  910.         break;
  911.         }
  912.       /* Do *not* accept a non-supported protocol.  */
  913.       if (i == ARRAY_SIZE (sup_protos))
  914.         continue;
  915.     }
  916.       if (no_proto)
  917.     {
  918.       /* First, construct the base, which can be relative itself.
  919.  
  920.          Criteria for creating the base are:
  921.          1) html_base created by <base href="...">
  922.          2) current URL
  923.          3) base provided from the command line */
  924.       cbase = html_base ();
  925.       if (!cbase)
  926.         cbase = this_url;
  927.       if (!cbase)
  928.         cbase = opt.base_href;
  929.       if (!cbase)             /* Error condition -- a baseless
  930.                      relative link.  */
  931.         {
  932.           if (!opt.quiet && !silent)
  933.         {
  934.           /* Use malloc, not alloca because this is called in
  935.                      a loop. */
  936.           char *temp = (char *)malloc (size + 1);
  937.           strncpy (temp, pbuf, size);
  938.           temp[size] = '\0';
  939.           logprintf (LOG_NOTQUIET,
  940.                  _("Error (%s): Link %s without a base provided.\n"),
  941.                  file, temp);
  942.           free (temp);
  943.         }
  944.           continue;
  945.         }
  946.       if (this_url)
  947.         base = construct (this_url, cbase, strlen (cbase),
  948.                   !has_proto (cbase));
  949.       else
  950.         {
  951.           /* Base must now be absolute, with host name and
  952.          protocol.  */
  953.           if (!has_proto (cbase))
  954.         {
  955.           logprintf (LOG_NOTQUIET, _("\
  956. Error (%s): Base %s relative, without referer URL.\n"),
  957.                  file, cbase);
  958.           continue;
  959.         }
  960.           base = xstrdup (cbase);
  961.         }
  962.       constr = construct (base, pbuf, size, no_proto);
  963.       free (base);
  964.     }
  965.       else /* has proto */
  966.     {
  967.       constr = (char *)xmalloc (size + 1);
  968.       strncpy (constr, pbuf, size);
  969.       constr[size] = '\0';
  970.     }
  971. #ifdef DEBUG
  972.       if (opt.debug)
  973.     {
  974.       char *tmp;
  975.       const char *tmp2;
  976.  
  977.       tmp2 = html_base ();
  978.       /* Use malloc, not alloca because this is called in a loop. */
  979.       tmp = (char *)xmalloc (size + 1);
  980.       strncpy (tmp, pbuf, size);
  981.       tmp[size] = '\0';
  982.       logprintf (LOG_ALWAYS,
  983.              "file %s; this_url %s; base %s\nlink: %s; constr: %s\n",
  984.              file, this_url ? this_url : "(null)",
  985.              tmp2 ? tmp2 : "(null)", tmp, constr);
  986.       free (tmp);
  987.     }
  988. #endif
  989.  
  990.       /* Allocate the space.  */
  991.       old = current;
  992.       current = (urlpos *)xmalloc (sizeof (urlpos));
  993.       if (old)
  994.     old->next = current;
  995.       if (!first)
  996.     first = current;
  997.       /* Fill the values.  */
  998.       memset (current, 0, sizeof (*current));
  999.       current->next = NULL;
  1000.       current->url = constr;
  1001.       current->size = size;
  1002.       current->pos = pbuf - orig_buf;
  1003.       /* A URL is relative if the host and protocol are not named,
  1004.      and the name does not start with `/'.  */
  1005.       if (no_proto && *pbuf != '/')
  1006.     current->flags |= (URELATIVE | UNOPROTO);
  1007.       else if (no_proto)
  1008.     current->flags |= UNOPROTO;
  1009.     }
  1010.   free (orig_buf);
  1011.  
  1012.   return first;
  1013. }
  1014.  
  1015. /* Free the linked list of urlpos.  */
  1016. void
  1017. free_urlpos (urlpos *l)
  1018. {
  1019.   while (l)
  1020.     {
  1021.       urlpos *next = l->next;
  1022.       free (l->url);
  1023.       FREE_MAYBE (l->local_name);
  1024.       free (l);
  1025.       l = next;
  1026.     }
  1027. }
  1028.  
  1029. /* Rotate FNAME opt.backups times */
  1030. void
  1031. rotate_backups(const char *fname)
  1032. {
  1033.   int maxlen = strlen (fname) + 1 + numdigit (opt.backups) + 1;
  1034.   char *from = (char *)alloca (maxlen);
  1035.   char *to = (char *)alloca (maxlen);
  1036.   struct stat sb;
  1037.   int i;
  1038.  
  1039.   if (stat (fname, &sb) == 0)
  1040.     if (S_ISREG (sb.st_mode) == 0)
  1041.       return;
  1042.  
  1043.   for (i = opt.backups; i > 1; i--)
  1044.     {
  1045.       sprintf (from, "%s.%d", fname, i - 1);
  1046.       sprintf (to, "%s.%d", fname, i);
  1047.       /* #### This will fail on machines without the rename() system
  1048.          call.  */
  1049.       rename (from, to);
  1050.     }
  1051.  
  1052.   sprintf (to, "%s.%d", fname, 1);
  1053.   rename(fname, to);
  1054. }
  1055.  
  1056. /* Create all the necessary directories for PATH (a file).  Calls
  1057.    mkdirhier() internally.  */
  1058. int
  1059. mkalldirs (const char *path)
  1060. {
  1061.   const char *p;
  1062.   char *t;
  1063.   struct stat st;
  1064.   int res;
  1065.  
  1066.   p = path + strlen (path);
  1067.   for (; *p != '/' && p != path; p--);
  1068.   /* Don't create if it's just a file.  */
  1069.   if ((p == path) && (*p != '/'))
  1070.     return 0;
  1071.   t = strdupdelim (path, p);
  1072.   /* Check whether the directory exists.  */
  1073.   if ((stat (t, &st) == 0))
  1074.     {
  1075.       if (S_ISDIR (st.st_mode))
  1076.     {
  1077.       free (t);
  1078.       return 0;
  1079.     }
  1080.       else
  1081.     {
  1082.       /* If the dir exists as a file name, remove it first.  This
  1083.          is *only* for Wget to work with buggy old CERN http
  1084.          servers.  Here is the scenario: When Wget tries to
  1085.          retrieve a directory without a slash, e.g.
  1086.          http://foo/bar (bar being a directory), CERN server will
  1087.          not redirect it too http://foo/bar/ -- it will generate a
  1088.          directory listing containing links to bar/file1,
  1089.          bar/file2, etc.  Wget will lose because it saves this
  1090.          HTML listing to a file `bar', so it cannot create the
  1091.          directory.  To work around this, if the file of the same
  1092.          name exists, we just remove it and create the directory
  1093.          anyway.  */
  1094.       DEBUGP (("Removing %s because of directory danger!\n", t));
  1095.       unlink (t);
  1096.     }
  1097.     }
  1098.   res = make_directory (t);
  1099.   if (res != 0)
  1100.     logprintf (LOG_NOTQUIET, "%s: %s", t, strerror (errno));
  1101.   free (t);
  1102.   return res;
  1103. }
  1104.  
  1105. static int
  1106. count_slashes (const char *s)
  1107. {
  1108.   int i = 0;
  1109.   while (*s)
  1110.     if (*s++ == '/')
  1111.       ++i;
  1112.   return i;
  1113. }
  1114.  
  1115. /* Return the path name of the URL-equivalent file name, with a
  1116.    remote-like structure of directories.  */
  1117. static char *
  1118. mkstruct (const struct urlinfo *u)
  1119. {
  1120.   char *host, *dir, *file, *res, *dirpref;
  1121.   int l;
  1122.  
  1123.   assert (u->dir != NULL);
  1124.   assert (u->host != NULL);
  1125.  
  1126.   if (opt.cut_dirs)
  1127.     {
  1128.       char *ptr = u->dir + (*u->dir == '/');
  1129.       int slash_count = 1 + count_slashes (ptr);
  1130.       int cut = MINVAL (opt.cut_dirs, slash_count);
  1131.       for (; cut && *ptr; ptr++)
  1132.     if (*ptr == '/')
  1133.       --cut;
  1134.       STRDUP_ALLOCA (dir, ptr);
  1135.     }
  1136.   else
  1137.     dir = u->dir + (*u->dir == '/');
  1138.  
  1139.   host = xstrdup (u->host);
  1140.   /* Check for the true name (or at least a consistent name for saving
  1141.      to directory) of HOST, reusing the hlist if possible.  */
  1142.   if (opt.add_hostdir && !opt.simple_check)
  1143.     {
  1144.       char *nhost = realhost (host);
  1145.       free (host);
  1146.       host = nhost;
  1147.     }
  1148.   /* Add dir_prefix and hostname (if required) to the beginning of
  1149.      dir.  */
  1150.   if (opt.add_hostdir)
  1151.     {
  1152.       if (!DOTP (opt.dir_prefix))
  1153.     {
  1154.       dirpref = (char *)alloca (strlen (opt.dir_prefix) + 1
  1155.                     + strlen (host) + 1);
  1156.       sprintf (dirpref, "%s/%s", opt.dir_prefix, host);
  1157.     }
  1158.       else
  1159.     STRDUP_ALLOCA (dirpref, host);
  1160.     }
  1161.   else                         /* not add_hostdir */
  1162.     {
  1163.       if (!DOTP (opt.dir_prefix))
  1164.     dirpref = opt.dir_prefix;
  1165.       else
  1166.     dirpref = "";
  1167.     }
  1168.   free (host);
  1169.  
  1170.   /* If there is a prefix, prepend it.  */
  1171.   if (*dirpref)
  1172.     {
  1173.       char *newdir = (char *)alloca (strlen (dirpref) + 1 + strlen (dir) + 2);
  1174.       sprintf (newdir, "%s%s%s", dirpref, *dir == '/' ? "" : "/", dir);
  1175.       dir = newdir;
  1176.     }
  1177.   dir = xstrdup (dir);
  1178.   URL_CLEANSE (dir);
  1179.   l = strlen (dir);
  1180.   if (l && dir[l - 1] == '/')
  1181.     dir[l - 1] = '\0';
  1182.  
  1183.   if (!*u->file)
  1184.     file = "index.html";
  1185.   else
  1186.     file = u->file;
  1187.  
  1188.   /* Finally, construct the full name.  */
  1189.   res = (char *)xmalloc (strlen (dir) + 1 + strlen (file) + 1);
  1190.   sprintf (res, "%s%s%s", dir, *dir ? "/" : "", file);
  1191.   free (dir);
  1192.   return res;
  1193. }
  1194.  
  1195. /* Create a unique filename, corresponding to a given URL.  Calls
  1196.    mkstruct if necessary.  Does *not* actually create any directories.  */
  1197. char *
  1198. url_filename (const struct urlinfo *u)
  1199. {
  1200.   char *file, *name;
  1201.   int have_prefix = 0;        /* whether we must prepend opt.dir_prefix */
  1202.  
  1203.   if (opt.dirstruct)
  1204.     {
  1205.       file = mkstruct (u);
  1206.       have_prefix = 1;
  1207.     }
  1208.   else
  1209.     {
  1210.       if (!*u->file)
  1211.     file = xstrdup ("index.html");
  1212.       else
  1213.     file = xstrdup (u->file);
  1214.     }
  1215.  
  1216.   if (!have_prefix)
  1217.     {
  1218.       /* Check whether the prefix directory is something other than "."
  1219.      before prepending it.  */
  1220.       if (!DOTP (opt.dir_prefix))
  1221.     {
  1222.       char *nfile = (char *)xmalloc (strlen (opt.dir_prefix)
  1223.                      + 1 + strlen (file) + 1);
  1224.       sprintf (nfile, "%s/%s", opt.dir_prefix, file);
  1225.       free (file);
  1226.       file = nfile;
  1227.     }
  1228.     }
  1229.   /* DOS-ish file systems don't like `%' signs in them; we change it
  1230.      to `@'.  */
  1231. #ifdef WINDOWS
  1232.   {
  1233.     char *p = file;
  1234.     for (p = file; *p; p++)
  1235.       if ( (*p == '%') || (*p == '?') || (*p == '*') )
  1236.     *p = '@';
  1237.   }
  1238. #endif /* WINDOWS */
  1239.  
  1240.   /* Check the cases in which the unique extensions are not used:
  1241.      1) Clobbering is turned off (-nc).
  1242.      2) Retrieval with regetting.
  1243.      3) Timestamping is used.
  1244.      4) Hierarchy is built.
  1245.  
  1246.      The exception is the case when file does exist and is a
  1247.      directory (actually support for bad httpd-s).  */
  1248.   if ((opt.noclobber || opt.always_rest || opt.timestamping || opt.dirstruct)
  1249.       && !(file_exists_p (file) && !file_non_directory_p (file)))
  1250.     return file;
  1251.  
  1252.   /* Find a unique name.  */
  1253.   name = unique_name (file);
  1254.   free (file);
  1255.   return name;
  1256. }
  1257.  
  1258. /* Construct an absolute URL, given a (possibly) relative one.  This
  1259.    is more tricky than it might seem, but it works.  */
  1260. static char *
  1261. construct (const char *url, const char *sub, int subsize, int no_proto)
  1262. {
  1263.   char *constr;
  1264.  
  1265.   if (no_proto)
  1266.     {
  1267.       int i;
  1268.  
  1269.       if (*sub != '/')
  1270.     {
  1271.       for (i = strlen (url); i && url[i] != '/'; i--);
  1272.       if (!i || (url[i] == url[i - 1]))
  1273.         {
  1274.           int l = strlen (url);
  1275.           char *t = (char *)alloca (l + 2);
  1276.           strcpy (t, url);
  1277.           t[l] = '/';
  1278.           t[l + 1] = '\0';
  1279.           url = t;
  1280.           i = l;
  1281.         }
  1282.       constr = (char *)xmalloc (i + 1 + subsize + 1);
  1283.       strncpy (constr, url, i + 1);
  1284.       constr[i + 1] = '\0';
  1285.       strncat (constr, sub, subsize);
  1286.     }
  1287.       else /* *sub == `/' */
  1288.     {
  1289.       int fl;
  1290.  
  1291.       i = 0;
  1292.       do
  1293.         {
  1294.           for (; url[i] && url[i] != '/'; i++);
  1295.           if (!url[i])
  1296.         break;
  1297.           fl = (url[i] == url[i + 1] && url[i + 1] == '/');
  1298.           if (fl)
  1299.         i += 2;
  1300.         }
  1301.       while (fl);
  1302.       if (!url[i])
  1303.         {
  1304.           int l = strlen (url);
  1305.           char *t = (char *)alloca (l + 2);
  1306.           strcpy (t, url);
  1307.           t[l] = '/';
  1308.           t[l + 1] = '\0';
  1309.           url = t;
  1310.         }
  1311.       constr = (char *)xmalloc (i + 1 + subsize + 1);
  1312.       strncpy (constr, url, i);
  1313.       constr[i] = '\0';
  1314.       strncat (constr + i, sub, subsize);
  1315.       constr[i + subsize] = '\0';
  1316.     } /* *sub == `/' */
  1317.     }
  1318.   else /* !no_proto */
  1319.     {
  1320.       constr = (char *)xmalloc (subsize + 1);
  1321.       strncpy (constr, sub, subsize);
  1322.       constr[subsize] = '\0';
  1323.     }
  1324.   return constr;
  1325. }
  1326.  
  1327. /* Optimize URL by host, destructively replacing u->host with realhost
  1328.    (u->host).  Do this regardless of opt.simple_check.  */
  1329. void
  1330. opt_url (struct urlinfo *u)
  1331. {
  1332.   /* Find the "true" host.  */
  1333.   char *host = realhost (u->host);
  1334.   free (u->host);
  1335.   u->host = host;
  1336.   assert (u->dir != NULL);      /* the URL must have been parsed */
  1337.   /* Refresh the printed representation.  */
  1338.   free (u->url);
  1339.   u->url = str_url (u, 0);
  1340. }
  1341.  
  1342. /* Returns proxy host address, in accordance with PROTO.  */
  1343. char *
  1344. getproxy (uerr_t proto)
  1345. {
  1346.   if (proto == URLHTTP)
  1347.     return opt.http_proxy ? opt.http_proxy : getenv ("http_proxy");
  1348.   else if (proto == URLFTP)
  1349.     return opt.ftp_proxy ? opt.ftp_proxy : getenv ("ftp_proxy");
  1350.   else
  1351.     return NULL;
  1352. }
  1353.  
  1354. /* Should a host be accessed through proxy, concerning no_proxy?  */
  1355. int
  1356. no_proxy_match (const char *host, const char **no_proxy)
  1357. {
  1358.   if (!no_proxy)
  1359.     return 1;
  1360.   else
  1361.     return !sufmatch (no_proxy, host);
  1362. }
  1363.  
  1364. /* Change the links in an HTML document.  Accepts a structure that
  1365.    defines the positions of all the links.  */
  1366. void
  1367. convert_links (const char *file, urlpos *l)
  1368. {
  1369.   FILE *fp;
  1370.   char *buf, *p, *p2;
  1371.   long size;
  1372.  
  1373.   logprintf (LOG_VERBOSE, _("Converting %s... "), file);
  1374.   /* Read from the file....  */
  1375.   fp = fopen (file, "rb");
  1376.   if (!fp)
  1377.     {
  1378.       logprintf (LOG_NOTQUIET, _("Cannot convert links in %s: %s\n"),
  1379.          file, strerror (errno));
  1380.       return;
  1381.     }
  1382.   /* ...to a buffer.  */
  1383.   load_file (fp, &buf, &size);
  1384.   fclose (fp);
  1385.   /* Now open the file for writing.  */
  1386.   fp = fopen (file, "wb");
  1387.   if (!fp)
  1388.     {
  1389.       logprintf (LOG_NOTQUIET, _("Cannot convert links in %s: %s\n"),
  1390.          file, strerror (errno));
  1391.       free (buf);
  1392.       return;
  1393.     }
  1394.   for (p = buf; l; l = l->next)
  1395.     {
  1396.       if (l->pos >= size)
  1397.     {
  1398.       DEBUGP (("Something strange is going on.  Please investigate."));
  1399.       break;
  1400.     }
  1401.       /* If the URL already is relative or it is not to be converted
  1402.      for some other reason (e.g. because of not having been
  1403.      downloaded in the first place), skip it.  */
  1404.       if ((l->flags & URELATIVE) || !(l->flags & UABS2REL))
  1405.     {
  1406.       DEBUGP (("Skipping %s at position %d (flags %d).\n", l->url,
  1407.            l->pos, l->flags));
  1408.       continue;
  1409.     }
  1410.       /* Else, reach the position of the offending URL, echoing
  1411.      everything up to it to the outfile.  */
  1412.       for (p2 = buf + l->pos; p < p2; p++)
  1413.     putc (*p, fp);
  1414.       if (l->flags & UABS2REL)
  1415.     {
  1416.       char *newname = construct_relative (file, l->local_name);
  1417.       fprintf (fp, "%s", newname);
  1418.       DEBUGP (("ABS2REL: %s to %s at position %d in %s.\n",
  1419.            l->url, newname, l->pos, file));
  1420.       free (newname);
  1421.     }
  1422.       p += l->size;
  1423.     }
  1424.   if (p - buf < size)
  1425.     {
  1426.       for (p2 = buf + size; p < p2; p++)
  1427.     putc (*p, fp);
  1428.     }
  1429.   fclose (fp);
  1430.   free (buf);
  1431.   logputs (LOG_VERBOSE, _("done.\n"));
  1432. }
  1433.  
  1434. /* Construct and return a malloced copy of the relative link from two
  1435.    pieces of information: local name S1 of the referring file and
  1436.    local name S2 of the referred file.
  1437.  
  1438.    So, if S1 is "jagor.srce.hr/index.html" and S2 is
  1439.    "jagor.srce.hr/images/news.gif", the function will return
  1440.    "images/news.gif".
  1441.  
  1442.    Alternately, if S1 is "fly.cc.fer.hr/ioccc/index.html", and S2 is
  1443.    "fly.cc.fer.hr/images/fly.gif", the function will return
  1444.    "../images/fly.gif".
  1445.  
  1446.    Caveats: S1 should not begin with `/', unless S2 also begins with
  1447.    '/'.  S1 should not contain things like ".." and such --
  1448.    construct_relative ("fly/ioccc/../index.html",
  1449.    "fly/images/fly.gif") will fail.  (A workaround is to call
  1450.    something like path_simplify() on S1).  */
  1451. static char *
  1452. construct_relative (const char *s1, const char *s2)
  1453. {
  1454.   int i, cnt, sepdirs1;
  1455.   char *res;
  1456.  
  1457.   if (*s2 == '/')
  1458.     return xstrdup (s2);
  1459.   /* S1 should *not* be absolute, if S2 wasn't.  */
  1460.   assert (*s1 != '/');
  1461.   i = cnt = 0;
  1462.   /* Skip the directories common to both strings.  */
  1463.   while (1)
  1464.     {
  1465.       while (s1[i] && s2[i]
  1466.          && (s1[i] == s2[i])
  1467.          && (s1[i] != '/')
  1468.          && (s2[i] != '/'))
  1469.     ++i;
  1470.       if (s1[i] == '/' && s2[i] == '/')
  1471.     cnt = ++i;
  1472.       else
  1473.     break;
  1474.     }
  1475.   for (sepdirs1 = 0; s1[i]; i++)
  1476.     if (s1[i] == '/')
  1477.       ++sepdirs1;
  1478.   /* Now, construct the file as of:
  1479.      - ../ repeated sepdirs1 time
  1480.      - all the non-mutual directories of S2.  */
  1481.   res = (char *)xmalloc (3 * sepdirs1 + strlen (s2 + cnt) + 1);
  1482.   for (i = 0; i < sepdirs1; i++)
  1483.     memcpy (res + 3 * i, "../", 3);
  1484.   strcpy (res + 3 * i, s2 + cnt);
  1485.   return res;
  1486. }
  1487.  
  1488. /* Add URL to the head of the list L.  */
  1489. urlpos *
  1490. add_url (urlpos *l, const char *url, const char *file)
  1491. {
  1492.   urlpos *t;
  1493.  
  1494.   t = (urlpos *)xmalloc (sizeof (urlpos));
  1495.   memset (t, 0, sizeof (*t));
  1496.   t->url = xstrdup (url);
  1497.   t->local_name = xstrdup (file);
  1498.   t->next = l;
  1499.   return t;
  1500. }
  1501.