X-Git-Url: http://sjero.net/git/?p=wget;a=blobdiff_plain;f=src%2Fhost.c;h=11de5944352d91d6b805b8bc00ad832ee8097ca3;hp=1ff8150f60c07fa63209fb5867222adcf781c536;hb=4d7c5e087b2bc82c9f503dff003916d1047903ce;hpb=094481c386cac4dc30a9f6685060873dbe6ca363

diff --git a/src/host.c b/src/host.c
index 1ff8150f..11de5944 100644
--- a/src/host.c
+++ b/src/host.c
@@ -1,389 +1,836 @@
-/* Dealing with host names.
-   Copyright (C) 1995, 1996, 1997 Free Software Foundation, Inc.
+/* Host name resolution and matching.
+   Copyright (C) 1996-2006 Free Software Foundation, Inc.
 
-This file is part of Wget.
+This file is part of GNU Wget.
 
-This program is free software; you can redistribute it and/or modify
+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 2 of the License, or
-(at your option) any later version.
+the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
 
-This program is distributed in the hope that it will be useful,
+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 this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+along with Wget.  If not, see <http://www.gnu.org/licenses/>.
+
+In addition, as a special exception, the Free Software Foundation
+gives permission to link the code of its release of Wget with the
+OpenSSL project's "OpenSSL" library (or with modified versions of it
+that use the same license as the "OpenSSL" library), and distribute
+the linked executables.  You must obey the GNU General Public License
+in all respects for all of the code used other than "OpenSSL".  If you
+modify this file, you may extend this exception to your version of the
+file, but you are not obligated to do so.  If you do not wish to do
+so, delete this exception statement from your version.  */
 
 #include <config.h>
 
 #include <stdio.h>
 #include <stdlib.h>
-#include <ctype.h>
-#ifdef HAVE_STRING_H
-# include <string.h>
-#else
-# include <strings.h>
-#endif
+#include <string.h>
 #include <assert.h>
-#include <sys/types.h>
 
-#ifdef WINDOWS
-# include <winsock.h>
-#else
+#ifndef WINDOWS
 # include <sys/socket.h>
 # include <netinet/in.h>
-# include <arpa/inet.h>
+# ifndef __BEOS__
+#  include <arpa/inet.h>
+# endif
 # include <netdb.h>
+# define SET_H_ERRNO(err) ((void)(h_errno = (err)))
+#else  /* WINDOWS */
+# define SET_H_ERRNO(err) WSASetLastError (err)
 #endif /* WINDOWS */
 
-#ifdef HAVE_SYS_UTSNAME_H
-# include <sys/utsname.h>
-#endif
 #include <errno.h>
 
 #include "wget.h"
 #include "utils.h"
 #include "host.h"
 #include "url.h"
+#include "hash.h"
 
-#ifndef errno
-extern int errno;
+#ifndef NO_ADDRESS
+# define NO_ADDRESS NO_DATA
 #endif
 
-/* Host list entry */
-struct host
-{
-  /* Host's symbolical name, as encountered at the time of first
-     inclusion, e.g. "fly.cc.fer.hr".  */
-  char *hostname;
-  /* Host's "real" name, i.e. its IP address, written out in ASCII
-     form of N.N.N.N, e.g. "161.53.70.130".  */
-  char *realname;
-  /* More than one HOSTNAME can correspond to the same REALNAME.  For
-     our purposes, the canonical name of the host is its HOSTNAME when
-     it was first encountered.  This entry is said to have QUALITY.  */
-  int quality;
-  /* Next entry in the list.  */
-  struct host *next;
-};
+/* Lists of IP addresses that result from running DNS queries.  See
+   lookup_host for details.  */
 
-static struct host *hlist;
+struct address_list {
+  int count;			/* number of adrresses */
+  ip_address *addresses;	/* pointer to the string of addresses */
 
-static struct host *add_hlist PARAMS ((struct host *, const char *,
-				       const char *, int));
+  int faulty;			/* number of addresses known not to work. */
+  bool connected;		/* whether we were able to connect to
+				   one of the addresses in the list,
+				   at least once. */
 
-/* The same as gethostbyname, but supports internet addresses of the
-   form `N.N.N.N'.  */
-struct hostent *
-ngethostbyname (const char *name)
-{
-  struct hostent *hp;
-  unsigned long addr;
+  int refcount;			/* reference count; when it drops to
+				   0, the entry is freed. */
+};
 
-  addr = (unsigned long)inet_addr (name);
-  if ((int)addr != -1)
-    hp = gethostbyaddr ((char *)&addr, sizeof (addr), AF_INET);
-  else
-    hp = gethostbyname (name);
-  return hp;
+/* Get the bounds of the address list.  */
+
+void
+address_list_get_bounds (const struct address_list *al, int *start, int *end)
+{
+  *start = al->faulty;
+  *end   = al->count;
 }
 
-/* Search for HOST in the linked list L, by hostname.  Return the
-   entry, if found, or NULL.  The search is case-insensitive.  */
-static struct host *
-search_host (struct host *l, const char *host)
+/* Return a pointer to the address at position POS.  */
+
+const ip_address *
+address_list_address_at (const struct address_list *al, int pos)
 {
-  for (; l; l = l->next)
-    if (strcasecmp (l->hostname, host) == 0)
-      return l;
-  return NULL;
+  assert (pos >= al->faulty && pos < al->count);
+  return al->addresses + pos;
 }
 
-/* Like search_host, but searches by address.  */
-static struct host *
-search_address (struct host *l, const char *address)
+/* Return true if AL contains IP, false otherwise.  */
+
+bool
+address_list_contains (const struct address_list *al, const ip_address *ip)
 {
-  for (; l; l = l->next)
+  int i;
+  switch (ip->family)
     {
-      int cmp = strcmp (l->realname, address);
-      if (cmp == 0)
-	return l;
-      else if (cmp > 0)
-	return NULL;
+    case AF_INET:
+      for (i = 0; i < al->count; i++)
+	{
+	  ip_address *cur = al->addresses + i;
+	  if (cur->family == AF_INET
+	      && (cur->data.d4.s_addr == ip->data.d4.s_addr))
+	    return true;
+	}
+      return false;
+#ifdef ENABLE_IPV6
+    case AF_INET6:
+      for (i = 0; i < al->count; i++)
+	{
+	  ip_address *cur = al->addresses + i;
+	  if (cur->family == AF_INET6
+#ifdef HAVE_SOCKADDR_IN6_SCOPE_ID
+	      && cur->ipv6_scope == ip->ipv6_scope
+#endif
+	      && IN6_ARE_ADDR_EQUAL (&cur->data.d6, &ip->data.d6))
+	    return true;
+	}
+      return false;
+#endif /* ENABLE_IPV6 */
+    default:
+      abort ();
     }
-  return NULL;
 }
 
-/* Store the address of HOSTNAME, internet-style, to WHERE.  First
-   check for it in the host list, and (if not found), use
-   ngethostbyname to get it.
+/* Mark the INDEXth element of AL as faulty, so that the next time
+   this address list is used, the faulty element will be skipped.  */
 
-   Return 1 on successful finding of the hostname, 0 otherwise.  */
-int
-store_hostaddress (unsigned char *where, const char *hostname)
+void
+address_list_set_faulty (struct address_list *al, int index)
 {
-  struct host *t;
-  unsigned long addr;
-  struct hostent *hptr;
-  struct in_addr in;
-  char *inet_s;
+  /* We assume that the address list is traversed in order, so that a
+     "faulty" attempt is always preceded with all-faulty addresses,
+     and this is how Wget uses it.  */
+  assert (index == al->faulty);
+
+  ++al->faulty;
+  if (al->faulty >= al->count)
+    /* All addresses have been proven faulty.  Since there's not much
+       sense in returning the user an empty address list the next
+       time, we'll rather make them all clean, so that they can be
+       retried anew.  */
+    al->faulty = 0;
+}
+
+/* Set the "connected" flag to true.  This flag used by connect.c to
+   see if the host perhaps needs to be resolved again.  */
+
+void
+address_list_set_connected (struct address_list *al)
+{
+  al->connected = true;
+}
+
+/* Return the value of the "connected" flag. */
+
+bool
+address_list_connected_p (const struct address_list *al)
+{
+  return al->connected;
+}
+
+#ifdef ENABLE_IPV6
+
+/* Create an address_list from the addresses in the given struct
+   addrinfo.  */
+
+static struct address_list *
+address_list_from_addrinfo (const struct addrinfo *ai)
+{
+  struct address_list *al;
+  const struct addrinfo *ptr;
+  int cnt;
+  ip_address *ip;
+
+  cnt = 0;
+  for (ptr = ai; ptr != NULL ; ptr = ptr->ai_next)
+    if (ptr->ai_family == AF_INET || ptr->ai_family == AF_INET6)
+      ++cnt;
+  if (cnt == 0)
+    return NULL;
+
+  al = xnew0 (struct address_list);
+  al->addresses = xnew_array (ip_address, cnt);
+  al->count     = cnt;
+  al->refcount  = 1;
+
+  ip = al->addresses;
+  for (ptr = ai; ptr != NULL; ptr = ptr->ai_next)
+    if (ptr->ai_family == AF_INET6) 
+      {
+	const struct sockaddr_in6 *sin6 =
+	  (const struct sockaddr_in6 *)ptr->ai_addr;
+	ip->family = AF_INET6;
+	ip->data.d6 = sin6->sin6_addr;
+#ifdef HAVE_SOCKADDR_IN6_SCOPE_ID
+	ip->ipv6_scope = sin6->sin6_scope_id;
+#endif
+	++ip;
+      } 
+    else if (ptr->ai_family == AF_INET)
+      {
+	const struct sockaddr_in *sin =
+	  (const struct sockaddr_in *)ptr->ai_addr;
+	ip->family = AF_INET;
+	ip->data.d4 = sin->sin_addr;
+	++ip;
+      }
+  assert (ip - al->addresses == cnt);
+  return al;
+}
+
+#define IS_IPV4(addr) (((const ip_address *) addr)->family == AF_INET)
+
+/* Compare two IP addresses by family, giving preference to the IPv4
+   address (sorting it first).  In other words, return -1 if ADDR1 is
+   IPv4 and ADDR2 is IPv6, +1 if ADDR1 is IPv6 and ADDR2 is IPv4, and
+   0 otherwise.
+
+   This is intended to be used as the comparator arg to a qsort-like
+   sorting function, which is why it accepts generic pointers.  */
+
+static int
+cmp_prefer_ipv4 (const void *addr1, const void *addr2)
+{
+  return !IS_IPV4 (addr1) - !IS_IPV4 (addr2);
+}
+
+#define IS_IPV6(addr) (((const ip_address *) addr)->family == AF_INET6)
+
+/* Like the above, but give preference to the IPv6 address.  */
+
+static int
+cmp_prefer_ipv6 (const void *addr1, const void *addr2)
+{
+  return !IS_IPV6 (addr1) - !IS_IPV6 (addr2);
+}
+
+#else  /* not ENABLE_IPV6 */
+
+/* Create an address_list from a NULL-terminated vector of IPv4
+   addresses.  This kind of vector is returned by gethostbyname.  */
 
-  /* If the address is of the form d.d.d.d, there will be no trouble
-     with it.  */
-  addr = (unsigned long)inet_addr (hostname);
-  if ((int)addr == -1)
+static struct address_list *
+address_list_from_ipv4_addresses (char **vec)
+{
+  int count, i;
+  struct address_list *al = xnew0 (struct address_list);
+
+  count = 0;
+  while (vec[count])
+    ++count;
+  assert (count > 0);
+
+  al->addresses = xnew_array (ip_address, count);
+  al->count     = count;
+  al->refcount  = 1;
+
+  for (i = 0; i < count; i++)
     {
-      /* If it is not of that form, try to find it in the cache.  */
-      t = search_host (hlist, hostname);
-      if (t)
-	addr = (unsigned long)inet_addr (t->realname);
+      ip_address *ip = &al->addresses[i];
+      ip->family = AF_INET;
+      memcpy (IP_INADDR_DATA (ip), vec[i], 4);
     }
-  /* If we have the numeric address, just store it.  */
-  if ((int)addr != -1)
+
+  return al;
+}
+
+#endif /* not ENABLE_IPV6 */
+
+static void
+address_list_delete (struct address_list *al)
+{
+  xfree (al->addresses);
+  xfree (al);
+}
+
+/* Mark the address list as being no longer in use.  This will reduce
+   its reference count which will cause the list to be freed when the
+   count reaches 0.  */
+
+void
+address_list_release (struct address_list *al)
+{
+  --al->refcount;
+  DEBUGP (("Releasing 0x%0*lx (new refcount %d).\n", PTR_FORMAT (al),
+	   al->refcount));
+  if (al->refcount <= 0)
     {
-      /* ADDR is in network byte order, meaning the code works on
-         little and big endian 32-bit architectures without change.
-         On big endian 64-bit architectures we need to be careful to
-         copy the correct four bytes.  */
-      int offset = 0;
-#ifdef WORDS_BIGENDIAN
-      offset = sizeof (unsigned long) - 4;
-#endif
-      memcpy (where, (char *)&addr + offset, 4);
-      return 1;
+      DEBUGP (("Deleting unused 0x%0*lx.\n", PTR_FORMAT (al)));
+      address_list_delete (al);
     }
-  /* Since all else has failed, let's try gethostbyname().  Note that
-     we use gethostbyname() rather than ngethostbyname(), because we
-     *know* the address is not numerical.  */
-  hptr = gethostbyname (hostname);
-  if (!hptr)
-    return 0;
-  /* Copy the address of the host to socket description.  */
-  memcpy (where, hptr->h_addr_list[0], hptr->h_length);
-  /* Now that we're here, we could as well cache the hostname for
-     future use, as in realhost().  First, we have to look for it by
-     address to know if it's already in the cache by another name.  */
-
-  /* Originally, we copied to in.s_addr, but it appears to be missing
-     on some systems.  */
-  memcpy (&in, *hptr->h_addr_list, sizeof (in));
-  STRDUP_ALLOCA (inet_s, inet_ntoa (in));
-  t = search_address (hlist, inet_s);
-  if (t) /* Found in the list, as realname.  */
+}
+
+/* Versions of gethostbyname and getaddrinfo that support timeout. */
+
+#ifndef ENABLE_IPV6
+
+struct ghbnwt_context {
+  const char *host_name;
+  struct hostent *hptr;
+};
+
+static void
+gethostbyname_with_timeout_callback (void *arg)
+{
+  struct ghbnwt_context *ctx = (struct ghbnwt_context *)arg;
+  ctx->hptr = gethostbyname (ctx->host_name);
+}
+
+/* Just like gethostbyname, except it times out after TIMEOUT seconds.
+   In case of timeout, NULL is returned and errno is set to ETIMEDOUT.
+   The function makes sure that when NULL is returned for reasons
+   other than timeout, errno is reset.  */
+
+static struct hostent *
+gethostbyname_with_timeout (const char *host_name, double timeout)
+{
+  struct ghbnwt_context ctx;
+  ctx.host_name = host_name;
+  if (run_with_timeout (timeout, gethostbyname_with_timeout_callback, &ctx))
     {
-      /* Set the default, 0 quality.  */
-      hlist = add_hlist (hlist, hostname, inet_s, 0);
-      return 1;
+      SET_H_ERRNO (HOST_NOT_FOUND);
+      errno = ETIMEDOUT;
+      return NULL;
     }
-  /* Since this is really the first time this host is encountered,
-     set quality to 1.  */
-  hlist = add_hlist (hlist, hostname, inet_s, 1);
-  return 1;
+  if (!ctx.hptr)
+    errno = 0;
+  return ctx.hptr;
 }
 
-/* Add a host to the host list.  The list is sorted by addresses.  For
-   equal addresses, the entries with quality should bubble towards the
-   beginning of the list.  */
-static struct host *
-add_hlist (struct host *l, const char *nhost, const char *nreal, int quality)
+/* Print error messages for host errors.  */
+static char *
+host_errstr (int error)
 {
-  struct host *t, *old, *beg;
+  /* Can't use switch since some of these constants can be equal,
+     which makes the compiler complain about duplicate case
+     values.  */
+  if (error == HOST_NOT_FOUND
+      || error == NO_RECOVERY
+      || error == NO_DATA
+      || error == NO_ADDRESS)
+    return _("Unknown host");
+  else if (error == TRY_AGAIN)
+    /* Message modeled after what gai_strerror returns in similar
+       circumstances.  */
+    return _("Temporary failure in name resolution");
+  else
+    return _("Unknown error");
+}
+
+#else  /* ENABLE_IPV6 */
+
+struct gaiwt_context {
+  const char *node;
+  const char *service;
+  const struct addrinfo *hints;
+  struct addrinfo **res;
+  int exit_code;
+};
+
+static void
+getaddrinfo_with_timeout_callback (void *arg)
+{
+  struct gaiwt_context *ctx = (struct gaiwt_context *)arg;
+  ctx->exit_code = getaddrinfo (ctx->node, ctx->service, ctx->hints, ctx->res);
+}
+
+/* Just like getaddrinfo, except it times out after TIMEOUT seconds.
+   In case of timeout, the EAI_SYSTEM error code is returned and errno
+   is set to ETIMEDOUT.  */
+
+static int
+getaddrinfo_with_timeout (const char *node, const char *service,
+			  const struct addrinfo *hints, struct addrinfo **res,
+			  double timeout)
+{
+  struct gaiwt_context ctx;
+  ctx.node = node;
+  ctx.service = service;
+  ctx.hints = hints;
+  ctx.res = res;
 
-  /* The entry goes to the beginning of the list if the list is empty
-     or the order requires it.  */
-  if (!l || (strcmp (nreal, l->realname) < 0))
+  if (run_with_timeout (timeout, getaddrinfo_with_timeout_callback, &ctx))
     {
-      t = (struct host *)xmalloc (sizeof (struct host));
-      t->hostname = xstrdup (nhost);
-      t->realname = xstrdup (nreal);
-      t->quality = quality;
-      t->next = l;
-      return t;
+      errno = ETIMEDOUT;
+      return EAI_SYSTEM;
     }
+  return ctx.exit_code;
+}
+
+#endif /* ENABLE_IPV6 */
+
+/* Return a textual representation of ADDR, i.e. the dotted quad for
+   IPv4 addresses, and the colon-separated list of hex words (with all
+   zeros omitted, etc.) for IPv6 addresses.  */
+
+const char *
+print_address (const ip_address *addr)
+{
+#ifdef ENABLE_IPV6
+  static char buf[64];
+  if (!inet_ntop (addr->family, IP_INADDR_DATA (addr), buf, sizeof buf))
+    snprintf (buf, sizeof buf, "<error: %s>", strerror (errno));
+  return buf;
+#else
+  return inet_ntoa (addr->data.d4);
+#endif
+}
 
-  beg = l;
-  /* Second two one-before-the-last element.  */
-  while (l->next)
+/* The following two functions were adapted from glibc's
+   implementation of inet_pton, written by Paul Vixie. */
+
+static bool
+is_valid_ipv4_address (const char *str, const char *end)
+{
+  bool saw_digit = false;
+  int octets = 0;
+  int val = 0;
+
+  while (str < end)
     {
-      int cmp;
-      old = l;
-      l = l->next;
-      cmp = strcmp (nreal, l->realname);
-      if (cmp >= 0)
-	continue;
-      /* If the next list element is greater than s, put s between the
-	 current and the next list element.  */
-      t = (struct host *)xmalloc (sizeof (struct host));
-      old->next = t;
-      t->next = l;
-      t->hostname = xstrdup (nhost);
-      t->realname = xstrdup (nreal);
-      t->quality = quality;
-      return beg;
+      int ch = *str++;
+
+      if (ch >= '0' && ch <= '9')
+	{
+	  val = val * 10 + (ch - '0');
+
+	  if (val > 255)
+	    return false;
+	  if (!saw_digit)
+	    {
+	      if (++octets > 4)
+		return false;
+	      saw_digit = true;
+	    }
+	}
+      else if (ch == '.' && saw_digit)
+	{
+	  if (octets == 4)
+	    return false;
+	  val = 0;
+	  saw_digit = false;
+	}
+      else
+	return false;
     }
-  t = (struct host *)xmalloc (sizeof (struct host));
-  t->hostname = xstrdup (nhost);
-  t->realname = xstrdup (nreal);
-  t->quality = quality;
-  /* Insert the new element after the last element.  */
-  l->next = t;
-  t->next = NULL;
-  return beg;
+  if (octets < 4)
+    return false;
+  
+  return true;
 }
 
-/* Determine the "real" name of HOST, as perceived by Wget.  If HOST
-   is referenced by more than one name, "real" name is considered to
-   be the first one encountered in the past.
-
-   If the host cannot be found in the list of already dealt-with
-   hosts, try with its INET address.  If this fails too, add it to the
-   list.  The routine does not call gethostbyname twice for the same
-   host if it can possibly avoid it.  */
-char *
-realhost (const char *host)
+bool
+is_valid_ipv6_address (const char *str, const char *end)
 {
-  struct host *l;
-  struct in_addr in;
-  struct hostent *hptr;
-  char *inet_s;
+  /* Use lower-case for these to avoid clash with system headers.  */
+  enum {
+    ns_inaddrsz  = 4,
+    ns_in6addrsz = 16,
+    ns_int16sz   = 2
+  };
+
+  const char *curtok;
+  int tp;
+  const char *colonp;
+  bool saw_xdigit;
+  unsigned int val;
+
+  tp = 0;
+  colonp = NULL;
+
+  if (str == end)
+    return false;
+  
+  /* Leading :: requires some special handling. */
+  if (*str == ':')
+    {
+      ++str;
+      if (str == end || *str != ':')
+	return false;
+    }
+
+  curtok = str;
+  saw_xdigit = false;
+  val = 0;
 
-  DEBUGP (("Checking for %s.\n", host));
-  /* Look for the host, looking by the host name.  */
-  l = search_host (hlist, host);
-  if (l && l->quality)              /* Found it with quality */
+  while (str < end)
     {
-      DEBUGP (("%s was already used, by that name.\n", host));
-      /* Here we return l->hostname, not host, because of the possible
-         case differences (e.g. jaGOR.srce.hr and jagor.srce.hr are
-         the same, but we want the one that was first.  */
-      return xstrdup (l->hostname);
+      int ch = *str++;
+
+      /* if ch is a number, add it to val. */
+      if (ISXDIGIT (ch))
+	{
+	  val <<= 4;
+	  val |= XDIGIT_TO_NUM (ch);
+	  if (val > 0xffff)
+	    return false;
+	  saw_xdigit = true;
+	  continue;
+	}
+
+      /* if ch is a colon ... */
+      if (ch == ':')
+	{
+	  curtok = str;
+	  if (!saw_xdigit)
+	    {
+	      if (colonp != NULL)
+		return false;
+	      colonp = str + tp;
+	      continue;
+	    }
+	  else if (str == end)
+	    return false;
+	  if (tp > ns_in6addrsz - ns_int16sz)
+	    return false;
+	  tp += ns_int16sz;
+	  saw_xdigit = false;
+	  val = 0;
+	  continue;
+	}
+
+      /* if ch is a dot ... */
+      if (ch == '.' && (tp <= ns_in6addrsz - ns_inaddrsz)
+	  && is_valid_ipv4_address (curtok, end) == 1)
+	{
+	  tp += ns_inaddrsz;
+	  saw_xdigit = false;
+	  break;
+	}
+    
+      return false;
     }
-  else if (!l)                      /* Not found, with or without quality */
+
+  if (saw_xdigit)
     {
-      /* The fact that gethostbyname will get called makes it
-	 necessary to store it to the list, to ensure that
-	 gethostbyname will not be called twice for the same string.
-	 However, the quality argument must be set appropriately.
-
-	 Note that add_hlist must be called *after* the realname
-	 search, or the quality would be always set to 0 */
-      DEBUGP (("This is the first time I hear about host %s by that name.\n",
-	       host));
-      hptr = ngethostbyname (host);
-      if (!hptr)
-	return xstrdup (host);
-      /* Originally, we copied to in.s_addr, but it appears to be
-         missing on some systems.  */
-      memcpy (&in, *hptr->h_addr_list, sizeof (in));
-      STRDUP_ALLOCA (inet_s, inet_ntoa (in));
+      if (tp > ns_in6addrsz - ns_int16sz) 
+	return false;
+      tp += ns_int16sz;
     }
-  else /* Found, without quality */
+
+  if (colonp != NULL)
     {
-      /* This case happens when host is on the list,
-	 but not as first entry (the one with quality).
-	 Then we just get its INET address and pick
-	 up the first entry with quality.  */
-      DEBUGP (("We've dealt with host %s, but under the name %s.\n",
-	       host, l->realname));
-      STRDUP_ALLOCA (inet_s, l->realname);
+      if (tp == ns_in6addrsz) 
+	return false;
+      tp = ns_in6addrsz;
     }
 
-  /* Now we certainly have the INET address.  The following loop is
-     guaranteed to pick either an entry with quality (because it is
-     the first one), or none at all.  */
-  l = search_address (hlist, inet_s);
-  if (l) /* Found in the list, as realname.  */
+  if (tp != ns_in6addrsz)
+    return false;
+
+  return true;
+}
+
+/* Simple host cache, used by lookup_host to speed up resolving.  The
+   cache doesn't handle TTL because Wget is a fairly short-lived
+   application.  Refreshing is attempted when connect fails, though --
+   see connect_to_host.  */
+
+/* Mapping between known hosts and to lists of their addresses. */
+static struct hash_table *host_name_addresses_map;
+
+
+/* Return the host's resolved addresses from the cache, if
+   available.  */
+
+static struct address_list *
+cache_query (const char *host)
+{
+  struct address_list *al;
+  if (!host_name_addresses_map)
+    return NULL;
+  al = hash_table_get (host_name_addresses_map, host);
+  if (al)
     {
-      /* Set the default, 0 quality.  */
-      hlist = add_hlist (hlist, host, inet_s, 0);
-      return xstrdup (l->hostname);
+      DEBUGP (("Found %s in host_name_addresses_map (%p)\n", host, al));
+      ++al->refcount;
+      return al;
     }
-  /* Since this is really the first time this host is encountered,
-     set quality to 1.  */
-  hlist = add_hlist (hlist, host, inet_s, 1);
-  return xstrdup (host);
+  return NULL;
 }
 
-/* Compare two hostnames (out of URL-s if the arguments are URL-s),
-   taking care of aliases.  It uses realhost() to determine a unique
-   hostname for each of two hosts.  If simple_check is non-zero, only
-   strcmp() is used for comparison.  */
-int
-same_host (const char *u1, const char *u2)
+/* Cache the DNS lookup of HOST.  Subsequent invocations of
+   lookup_host will return the cached value.  */
+
+static void
+cache_store (const char *host, struct address_list *al)
 {
-  const char *s;
-  char *p1, *p2;
-  char *real1, *real2;
-
-  /* Skip protocol, if present.  */
-  u1 += skip_url (u1);
-  u2 += skip_url (u2);
-  u1 += skip_proto (u1);
-  u2 += skip_proto (u2);
-
-  /* Skip username ans password, if present.  */
-  u1 += skip_uname (u1);
-  u2 += skip_uname (u2);
-
-  for (s = u1; *u1 && *u1 != '/' && *u1 != ':'; u1++);
-  p1 = strdupdelim (s, u1);
-  for (s = u2; *u2 && *u2 != '/' && *u2 != ':'; u2++);
-  p2 = strdupdelim (s, u2);
-  DEBUGP (("Comparing hosts %s and %s...\n", p1, p2));
-  if (strcasecmp (p1, p2) == 0)
+  if (!host_name_addresses_map)
+    host_name_addresses_map = make_nocase_string_hash_table (0);
+
+  ++al->refcount;
+  hash_table_put (host_name_addresses_map, xstrdup_lower (host), al);
+
+  IF_DEBUG
     {
-      free (p1);
-      free (p2);
-      DEBUGP (("They are quite alike.\n"));
-      return 1;
+      int i;
+      debug_logprintf ("Caching %s =>", host);
+      for (i = 0; i < al->count; i++)
+	debug_logprintf (" %s", print_address (al->addresses + i));
+      debug_logprintf ("\n");
     }
-  else if (opt.simple_check)
+}
+
+/* Remove HOST from the DNS cache.  Does nothing is HOST is not in
+   the cache.  */
+
+static void
+cache_remove (const char *host)
+{
+  struct address_list *al;
+  if (!host_name_addresses_map)
+    return;
+  al = hash_table_get (host_name_addresses_map, host);
+  if (al)
     {
-      free (p1);
-      free (p2);
-      DEBUGP (("Since checking is simple, I'd say they are not the same.\n"));
-      return 0;
+      address_list_release (al);
+      hash_table_remove (host_name_addresses_map, host);
     }
-  real1 = realhost (p1);
-  real2 = realhost (p2);
-  free (p1);
-  free (p2);
-  if (strcasecmp (real1, real2) == 0)
+}
+
+/* Look up HOST in DNS and return a list of IP addresses.
+
+   This function caches its result so that, if the same host is passed
+   the second time, the addresses are returned without DNS lookup.
+   (Use LH_REFRESH to force lookup, or set opt.dns_cache to 0 to
+   globally disable caching.)
+
+   The order of the returned addresses is affected by the setting of
+   opt.prefer_family: if it is set to prefer_ipv4, IPv4 addresses are
+   placed at the beginning; if it is prefer_ipv6, IPv6 ones are placed
+   at the beginning; otherwise, the order is left intact.  The
+   relative order of addresses with the same family is left
+   undisturbed in either case.
+
+   FLAGS can be a combination of:
+     LH_SILENT  - don't print the "resolving ... done" messages.
+     LH_BIND    - resolve addresses for use with bind, which under
+                  IPv6 means to use AI_PASSIVE flag to getaddrinfo.
+		  Passive lookups are not cached under IPv6.
+     LH_REFRESH - if HOST is cached, remove the entry from the cache
+                  and resolve it anew.  */
+
+struct address_list *
+lookup_host (const char *host, int flags)
+{
+  struct address_list *al;
+  bool silent = !!(flags & LH_SILENT);
+  bool use_cache;
+  bool numeric_address = false;
+  double timeout = opt.dns_timeout;
+
+#ifndef ENABLE_IPV6
+  /* If we're not using getaddrinfo, first check if HOST specifies a
+     numeric IPv4 address.  Some implementations of gethostbyname
+     (e.g. the Ultrix one and possibly Winsock) don't accept
+     dotted-decimal IPv4 addresses.  */
+  {
+    uint32_t addr_ipv4 = (uint32_t)inet_addr (host);
+    if (addr_ipv4 != (uint32_t) -1)
+      {
+	/* No need to cache host->addr relation, just return the
+	   address.  */
+	char *vec[2];
+	vec[0] = (char *)&addr_ipv4;
+	vec[1] = NULL;
+	return address_list_from_ipv4_addresses (vec);
+      }
+  }
+#else  /* ENABLE_IPV6 */
+  /* If we're using getaddrinfo, at least check whether the address is
+     already numeric, in which case there is no need to print the
+     "Resolving..." output.  (This comes at no additional cost since
+     the is_valid_ipv*_address are already required for
+     url_parse.)  */
+  {
+    const char *end = host + strlen (host);
+    if (is_valid_ipv4_address (host, end) || is_valid_ipv6_address (host, end))
+      numeric_address = true;
+  }
+#endif
+
+  /* Cache is normally on, but can be turned off with --no-dns-cache.
+     Don't cache passive lookups under IPv6.  */
+  use_cache = opt.dns_cache;
+#ifdef ENABLE_IPV6
+  if ((flags & LH_BIND) || numeric_address)
+    use_cache = false;
+#endif
+
+  /* Try to find the host in the cache so we don't need to talk to the
+     resolver.  If LH_REFRESH is requested, remove HOST from the cache
+     instead.  */
+  if (use_cache)
     {
-      DEBUGP (("They are alike, after realhost()->%s.\n", real1));
-      free (real1);
-      free (real2);
-      return 1;
+      if (!(flags & LH_REFRESH))
+	{
+	  al = cache_query (host);
+	  if (al)
+	    return al;
+	}
+      else
+	cache_remove (host);
     }
-  else
+
+  /* No luck with the cache; resolve HOST. */
+
+  if (!silent && !numeric_address)
+    logprintf (LOG_VERBOSE, _("Resolving %s... "), escnonprint (host));
+
+#ifdef ENABLE_IPV6
+  {
+    int err;
+    struct addrinfo hints, *res;
+
+    xzero (hints);
+    hints.ai_socktype = SOCK_STREAM;
+    if (opt.ipv4_only)
+      hints.ai_family = AF_INET;
+    else if (opt.ipv6_only)
+      hints.ai_family = AF_INET6;
+    else
+      /* We tried using AI_ADDRCONFIG, but removed it because: it
+	 misinterprets IPv6 loopbacks, it is broken on AIX 5.1, and
+	 it's unneeded since we sort the addresses anyway.  */
+	hints.ai_family = AF_UNSPEC;
+
+    if (flags & LH_BIND)
+      hints.ai_flags |= AI_PASSIVE;
+
+#ifdef AI_NUMERICHOST
+    if (numeric_address)
+      {
+	/* Where available, the AI_NUMERICHOST hint can prevent costly
+	   access to DNS servers.  */
+	hints.ai_flags |= AI_NUMERICHOST;
+	timeout = 0;		/* no timeout needed when "resolving"
+				   numeric hosts -- avoid setting up
+				   signal handlers and such. */
+      }
+#endif
+
+    err = getaddrinfo_with_timeout (host, NULL, &hints, &res, timeout);
+    if (err != 0 || res == NULL)
+      {
+	if (!silent)
+	  logprintf (LOG_VERBOSE, _("failed: %s.\n"),
+		     err != EAI_SYSTEM ? gai_strerror (err) : strerror (errno));
+	return NULL;
+      }
+    al = address_list_from_addrinfo (res);
+    freeaddrinfo (res);
+    if (!al)
+      {
+	logprintf (LOG_VERBOSE,
+		   _("failed: No IPv4/IPv6 addresses for host.\n"));
+	return NULL;
+      }
+
+    /* Reorder addresses so that IPv4 ones (or IPv6 ones, as per
+       --prefer-family) come first.  Sorting is stable so the order of
+       the addresses with the same family is undisturbed.  */
+    if (al->count > 1 && opt.prefer_family != prefer_none)
+      stable_sort (al->addresses, al->count, sizeof (ip_address),
+		   opt.prefer_family == prefer_ipv4
+		   ? cmp_prefer_ipv4 : cmp_prefer_ipv6);
+  }
+#else  /* not ENABLE_IPV6 */
+  {
+    struct hostent *hptr = gethostbyname_with_timeout (host, timeout);
+    if (!hptr)
+      {
+	if (!silent)
+	  {
+	    if (errno != ETIMEDOUT)
+	      logprintf (LOG_VERBOSE, _("failed: %s.\n"),
+			 host_errstr (h_errno));
+	    else
+	      logputs (LOG_VERBOSE, _("failed: timed out.\n"));
+	  }
+	return NULL;
+      }
+    /* Do older systems have h_addr_list?  */
+    al = address_list_from_ipv4_addresses (hptr->h_addr_list);
+  }
+#endif /* not ENABLE_IPV6 */
+
+  /* Print the addresses determined by DNS lookup, but no more than
+     three.  */
+  if (!silent && !numeric_address)
     {
-      DEBUGP (("They are not the same (%s, %s).\n", real1, real2));
-      free (real1);
-      free (real2);
-      return 0;
+      int i;
+      int printmax = al->count <= 3 ? al->count : 3;
+      for (i = 0; i < printmax; i++)
+	{
+	  logputs (LOG_VERBOSE, print_address (al->addresses + i));
+	  if (i < printmax - 1)
+	    logputs (LOG_VERBOSE, ", ");
+	}
+      if (printmax != al->count)
+	logputs (LOG_VERBOSE, ", ...");
+      logputs (LOG_VERBOSE, "\n");
     }
-}
 
+  /* Cache the lookup information. */
+  if (use_cache)
+    cache_store (host, al);
+
+  return al;
+}
+
 /* Determine whether a URL is acceptable to be followed, according to
    a list of domains to accept.  */
-int
-accept_domain (struct urlinfo *u)
+bool
+accept_domain (struct url *u)
 {
   assert (u->host != NULL);
   if (opt.domains)
     {
       if (!sufmatch ((const char **)opt.domains, u->host))
-	return 0;
+	return false;
     }
   if (opt.exclude_domains)
     {
       if (sufmatch ((const char **)opt.exclude_domains, u->host))
-	return 0;
+	return false;
     }
-  return 1;
+  return true;
 }
 
 /* Check whether WHAT is matched in LIST, each element of LIST being a
@@ -391,7 +838,7 @@ accept_domain (struct urlinfo *u)
    match_backwards() in utils.c).
 
    If an element of LIST matched, 1 is returned, 0 otherwise.  */
-int
+bool
 sufmatch (const char **list, const char *what)
 {
   int i, j, k, lw;
@@ -404,162 +851,28 @@ sufmatch (const char **list, const char *what)
 	  break;
       /* The domain must be first to reach to beginning.  */
       if (j == -1)
-	return 1;
+	return true;
     }
-  return 0;
+  return false;
 }
 
-/* Return email address of the form username@FQDN suitable for
-   anonymous FTP passwords.  This process is error-prone, and the
-   escape hatch is the MY_HOST preprocessor constant, which can be
-   used to hard-code either your hostname or FQDN at compile-time.
-
-   If the FQDN cannot be determined, a warning is printed, and the
-   function returns a short `username@' form, accepted by most
-   anonymous servers.
-
-   If not even the username cannot be divined, it means things are
-   seriously fucked up, and Wget exits.  */
-char *
-ftp_getaddress (void)
+void
+host_cleanup (void)
 {
-  static char *address;
-
-  /* Do the drill only the first time, as it won't change.  */
-  if (!address)
+  if (host_name_addresses_map)
     {
-      char userid[32];		/* 9 should be enough for Unix, but
-				   I'd rather be on the safe side.  */
-      char *host, *fqdn;
-
-      if (!pwd_cuserid (userid))
+      hash_table_iterator iter;
+      for (hash_table_iterate (host_name_addresses_map, &iter);
+	   hash_table_iter_next (&iter);
+	   )
 	{
-	  logprintf (LOG_ALWAYS, _("%s: Cannot determine user-id.\n"),
-		     exec_name);
-	  exit (1);
+	  char *host = iter.key;
+	  struct address_list *al = iter.value;
+	  xfree (host);
+	  assert (al->refcount == 1);
+	  address_list_delete (al);
 	}
-#ifdef MY_HOST
-      STRDUP_ALLOCA (host, MY_HOST);
-#else /* not MY_HOST */
-#ifdef HAVE_UNAME
-      {
-	struct utsname ubuf;
-	if (uname (&ubuf) < 0)
-	  {
-	    logprintf (LOG_ALWAYS, _("%s: Warning: uname failed: %s\n"),
-		       exec_name, strerror (errno));
-	    fqdn = "";
-	    goto giveup;
-	  }
-	STRDUP_ALLOCA (host, ubuf.nodename);
-      }
-#else /* not HAVE_UNAME */
-#ifdef HAVE_GETHOSTNAME
-      host = alloca (256);
-      if (gethostname (host, 256) < 0)
-	{
-	  logprintf (LOG_ALWAYS, _("%s: Warning: gethostname failed\n"),
-		     exec_name);
-	  fqdn = "";
-	  goto giveup;
-	}
-#else /* not HAVE_GETHOSTNAME */
- #error Cannot determine host name.
-#endif /* not HAVE_GETHOSTNAME */
-#endif /* not HAVE_UNAME */
-#endif /* not MY_HOST */
-      /* If the address we got so far contains a period, don't bother
-         anymore.  */
-      if (strchr (host, '.'))
-	fqdn = host;
-      else
-	{
-	  /* #### I've seen the following scheme fail on at least one
-	     system!  Do we care?  */
-	  char *tmpstore;
-	  /* According to Richard Stevens, the correct way to find the
-	     FQDN is to (1) find the host name, (2) find its IP
-	     address using gethostbyname(), and (3) get the FQDN using
-	     gethostbyaddr().  So that's what we'll do.  Step one has
-	     been done above.  */
-	  /* (2) */
-	  struct hostent *hp = gethostbyname (host);
-	  if (!hp || !hp->h_addr_list)
-	    {
-	      logprintf (LOG_ALWAYS, _("\
-%s: Warning: cannot determine local IP address.\n"),
-			 exec_name);
-	      fqdn = "";
-	      goto giveup;
-	    }
-	  /* Copy the argument, so the call to gethostbyaddr doesn't
-	     clobber it -- just in case.  */
-	  tmpstore = (char *)alloca (hp->h_length);
-	  memcpy (tmpstore, *hp->h_addr_list, hp->h_length);
-	  /* (3) */
-	  hp = gethostbyaddr (tmpstore, hp->h_length, hp->h_addrtype);
-	  if (!hp || !hp->h_name)
-	    {
-	      logprintf (LOG_ALWAYS, _("\
-%s: Warning: cannot reverse-lookup local IP address.\n"),
-			 exec_name);
-	      fqdn = "";
-	      goto giveup;
-	    }
-	  if (!strchr (hp->h_name, '.'))
-	    {
-#if 0
-	      /* This gets ticked pretty often.  Karl Berry reports
-                 that there can be valid reasons for the local host
-                 name not to be an FQDN, so I've decided to remove the
-                 annoying warning.  */
- 	      logprintf (LOG_ALWAYS, _("\
-%s: Warning: reverse-lookup of local address did not yield FQDN!\n"),
-		       exec_name);
-#endif
-	      fqdn = "";
-	      goto giveup;
-	    }
-	  /* Once we're here, hp->h_name contains the correct FQDN.  */
-	  STRDUP_ALLOCA (fqdn, hp->h_name);
-	}
-    giveup:
-      address = (char *)xmalloc (strlen (userid) + 1 + strlen (fqdn) + 1);
-      sprintf (address, "%s@%s", userid, fqdn);
-    }
-  return address;
-}
-
-/* Print error messages for host errors.  */
-char *
-herrmsg (int error)
-{
-  /* Can't use switch since some constants are equal (at least on my
-     system), and the compiler signals "duplicate case value".  */
-  if (error == HOST_NOT_FOUND
-      || error == NO_RECOVERY
-      || error == NO_DATA
-      || error == NO_ADDRESS
-      || error == TRY_AGAIN)
-    return _("Host not found");
-  else
-    return _("Unknown error");
-}
-
-/* Clean the host list.  This is a separate function, so we needn't
-   export HLIST and its implementation.  Ha!  */
-void
-clean_hosts (void)
-{
-  struct host *l = hlist;
-
-  while (l)
-    {
-      struct host *p = l->next;
-      free (l->hostname);
-      free (l->realname);
-      free (l);
-      l = p;
+      hash_table_destroy (host_name_addresses_map);
+      host_name_addresses_map = NULL;
     }
-  hlist = NULL;
 }