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.
+ (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
#include <stdio.h>
#include <stdlib.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>
-# define SET_H_ERRNO(err) WSASetLastError (err)
-#else
+#ifndef WINDOWS
# include <sys/socket.h>
# include <netinet/in.h>
# ifndef __BEOS__
# endif
# include <netdb.h>
# define SET_H_ERRNO(err) ((void)(h_errno = (err)))
+#else /* WINDOWS */
+# define SET_H_ERRNO(err) WSASetLastError (err)
#endif /* WINDOWS */
-#ifndef NO_ADDRESS
-#define NO_ADDRESS NO_DATA
-#endif
-
-#ifdef HAVE_SYS_UTSNAME_H
-# include <sys/utsname.h>
-#endif
#include <errno.h>
#include "wget.h"
#include "host.h"
#include "url.h"
#include "hash.h"
+#include "connect.h" /* for socket_has_inet6 */
-#ifndef errno
-extern int errno;
-#endif
-
-#ifndef h_errno
-# ifndef __CYGWIN__
-extern int h_errno;
-# endif
-#endif
-
-#ifdef ENABLE_IPV6
-int ip_default_family = AF_UNSPEC;
-#else
-int ip_default_family = AF_INET;
+#ifndef NO_ADDRESS
+# define NO_ADDRESS NO_DATA
#endif
-/* Mapping between known hosts and to lists of their addresses. */
-
-static struct hash_table *host_name_addresses_map;
-\f
-/* Lists of addresses. This should eventually be extended to handle
- IPv6. */
+/* Lists of IP addresses that result from running DNS queries. See
+ lookup_host for details. */
struct address_list {
int count; /* number of adrresses */
ip_address *addresses; /* pointer to the string of addresses */
int faulty; /* number of addresses known not to work. */
- int refcount; /* so we know whether to free it or not. */
+ int connected; /* whether we were able to connect to
+ one of the addresses in the list,
+ at least once. */
+
+ int refcount; /* reference count; when it drops to
+ 0, the entry is freed. */
};
/* Get the bounds of the address list. */
*end = al->count;
}
-/* Copy address number INDEX to IP_STORE. */
+/* Return a pointer to the address at position POS. */
-void
-address_list_copy_one (const struct address_list *al, int index, ip_address *ip_store)
+const ip_address *
+address_list_address_at (const struct address_list *al, int pos)
{
- assert (index >= al->faulty && index < al->count);
- memcpy (ip_store, al->addresses + index, sizeof (ip_address));
+ assert (pos >= al->faulty && pos < al->count);
+ return al->addresses + pos;
}
-/* Check whether two address lists have all their IPs in common. */
+/* Return non-zero if AL contains IP, zero otherwise. */
int
-address_list_match_all (const struct address_list *al1, const struct address_list *al2)
+address_list_contains (const struct address_list *al, const ip_address *ip)
{
int i;
- if (al1 == al2)
- return 1;
- if (al1->count != al2->count)
- return 0;
- for (i = 0; i < al1->count; ++i)
+ switch (ip->type)
{
-#ifdef ENABLE_IPv6
- if (al1->addresses[i].type != al2->addresses[i].type)
- return 0;
- if (al1->addresses[i].type == IPv6_ADDRESS)
+ case IPV4_ADDRESS:
+ for (i = 0; i < al->count; i++)
{
- const struct in6_addr *addr1 = &al1->addresses[i].addr.ipv6.addr;
- const struct in6_addr *addr2 = &al2->addresses[i].addr.ipv6.addr;
-
-#ifdef HAVE_SOCKADDR_IN6_SCOPE_ID
- if ((al1->addresses[i].address.scope_id
- != al2->addresses[i].address.scope_id)
- || !IN6_ARE_ADDR_EQUAL (addr1, addr2))
-#else
- if (!IN6_ARE_ADDR_EQUAL (addr1, addr2))
-#endif
- return 0;
+ ip_address *cur = al->addresses + i;
+ if (cur->type == IPV4_ADDRESS
+ && (ADDRESS_IPV4_IN_ADDR (cur).s_addr
+ ==
+ ADDRESS_IPV4_IN_ADDR (ip).s_addr))
+ return 1;
}
- else
-#endif
+ return 0;
+#ifdef ENABLE_IPV6
+ case IPV6_ADDRESS:
+ for (i = 0; i < al->count; i++)
{
- const struct in_addr *addr1 = (const struct in_addr *)&al1->addresses[i].addr.ipv4.addr;
- const struct in_addr *addr2 = (const struct in_addr *)&al2->addresses[i].addr.ipv4.addr;
-
- if (addr1->s_addr != addr2->s_addr)
- return 0;
+ ip_address *cur = al->addresses + i;
+ if (cur->type == IPV6_ADDRESS
+#ifdef HAVE_SOCKADDR_IN6_SCOPE_ID
+ && ADDRESS_IPV6_SCOPE (cur) == ADDRESS_IPV6_SCOPE (ip)
+#endif
+ && IN6_ARE_ADDR_EQUAL (&ADDRESS_IPV6_IN6_ADDR (cur),
+ &ADDRESS_IPV6_IN6_ADDR (ip)))
+ return 1;
}
+ return 0;
+#endif /* ENABLE_IPV6 */
+ default:
+ abort ();
}
- return 1;
}
/* Mark the INDEXth element of AL as faulty, so that the next time
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 = 1;
+}
+
+/* Return the value of the "connected" flag. */
+
+int
+address_list_connected_p (const struct address_list *al)
+{
+ return al->connected;
+}
+
#ifdef ENABLE_IPV6
-/**
- * address_list_from_addrinfo
- *
- * This function transform an addrinfo links list in and address_list.
- *
- * Input:
- * addrinfo* Linkt list of addrinfo
- *
- * Output:
- * address_list* New allocated address_list
- */
+
+/* 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 = 0;
- int i;
+ 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 = xmalloc (sizeof (struct address_list));
- al->addresses = xmalloc (cnt * sizeof (ip_address));
+ al = xnew0 (struct address_list);
+ al->addresses = xnew_array (ip_address, cnt);
al->count = cnt;
- al->faulty = 0;
al->refcount = 1;
- for (i = 0, ptr = ai; ptr != NULL; ptr = ptr->ai_next)
+ 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;
- al->addresses[i].addr.ipv6.addr = sin6->sin6_addr;
- al->addresses[i].type = IPv6_ADDRESS;
+ ip->type = IPV6_ADDRESS;
+ ADDRESS_IPV6_IN6_ADDR (ip) = sin6->sin6_addr;
#ifdef HAVE_SOCKADDR_IN6_SCOPE_ID
- al->addresses[i].addr.ipv6.scope_id = sin6->sin6_scope_id;
+ ADDRESS_IPV6_SCOPE (ip) = sin6->sin6_scope_id;
#endif
- ++i;
+ ++ip;
}
else if (ptr->ai_family == AF_INET)
{
const struct sockaddr_in *sin =
(const struct sockaddr_in *)ptr->ai_addr;
- al->addresses[i].addr.ipv4.addr = sin->sin_addr;
- al->addresses[i].type = IPv4_ADDRESS;
- ++i;
+ ip->type = IPV4_ADDRESS;
+ ADDRESS_IPV4_IN_ADDR (ip) = sin->sin_addr;
+ ++ip;
}
- assert (i == cnt);
+ assert (ip - al->addresses == cnt);
return al;
}
-#else
-/* Create an address_list out of a NULL-terminated vector of
- addresses, as returned by gethostbyname. */
-static struct address_list *
-address_list_from_vector (char **h_addr_list)
-{
- int count = 0, i;
- struct address_list *al = xmalloc (sizeof (struct address_list));
+#define IS_IPV4(addr) (((const ip_address *) addr)->type == IPV4_ADDRESS)
- while (h_addr_list[count])
- ++count;
- assert (count > 0);
- al->count = count;
- al->faulty = 0;
- al->addresses = xmalloc (count * sizeof (ip_address));
- al->refcount = 1;
+/* Compare two IP addresses by type, 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.
- for (i = 0; i < count; i++) {
- /* Mauro Tortonesi: is this safe? */
- memcpy (&((al->addresses + i)->addr.ipv4.addr.s_addr), h_addr_list[i], 4);
- (al->addresses + i)->type = IPv4_ADDRESS;
- }
+ This is intended to be used as the comparator arg to a qsort-like
+ sorting function, which is why it accepts generic pointers. */
- return al;
+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)->type == IPV6_ADDRESS)
+
+/* 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);
}
-/* Like address_list_from_vector, but initialized with a single
- address. */
+#else /* not ENABLE_IPV6 */
+
+/* Create an address_list from a NULL-terminated vector of IPv4
+ addresses. This kind of vector is returned by gethostbyname. */
static struct address_list *
-address_list_from_single (const ip_address *addr)
+address_list_from_ipv4_addresses (char **vec)
{
- struct address_list *al = xmalloc (sizeof (struct address_list));
- al->count = 1;
- al->faulty = 0;
- al->addresses = xmalloc (sizeof (ip_address));
+ 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;
- memcpy (al->addresses, addr, sizeof (ip_address));
+
+ for (i = 0; i < count; i++)
+ {
+ ip_address *ip = &al->addresses[i];
+ ip->type = IPV4_ADDRESS;
+ memcpy (ADDRESS_IPV4_DATA (ip), vec[i], 4);
+ }
return al;
}
-#endif
+
+#endif /* not ENABLE_IPV6 */
static void
address_list_delete (struct address_list *al)
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 %p (new refcount %d).\n", al, al->refcount));
+ DEBUGP (("Releasing 0x%0*lx (new refcount %d).\n", PTR_FORMAT (al),
+ al->refcount));
if (al->refcount <= 0)
{
- DEBUGP (("Deleting unused %p.\n", al));
+ DEBUGP (("Deleting unused 0x%0*lx.\n", PTR_FORMAT (al)));
address_list_delete (al);
}
}
\f
-/**
- * sockaddr_set_address
- *
- * This function takes a sockaddr struct and fills in the protocol type,
- * the port number and the address. If ENABLE_IPV6 is defined, the sa
- * parameter should point to a sockaddr_storage structure; if not, it
- * should point to a sockaddr_in structure.
- * If the address parameter is NULL, the function will use the unspecified
- * address (0.0.0.0 for IPv4 and :: for IPv6).
- * Unsupported address family will abort the whole programm.
- *
- * Input:
- * struct sockaddr* The space to be filled
- * unsigned short The port
- * const ip_address The IP address
- *
- * Return:
- * - Only modifies 1st parameter.
- */
-void
-sockaddr_set_address (struct sockaddr *sa, unsigned short port,
- const ip_address *addr)
-{
- if (addr->type == IPv4_ADDRESS)
- {
- struct sockaddr_in *sin = (struct sockaddr_in *)sa;
-
- sin->sin_family = AF_INET;
- sin->sin_port = htons (port);
- if (addr == NULL)
- sin->sin_addr.s_addr = INADDR_ANY;
- else
- sin->sin_addr = addr->addr.ipv4.addr;
- }
-#ifdef ENABLE_IPV6
- else if (addr->type == IPv6_ADDRESS)
- {
- struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa;
-
- sin6->sin6_family = AF_INET6;
- sin6->sin6_port = htons (port);
- if (addr == NULL)
- sin6->sin6_addr = in6addr_any;
- else
- sin6->sin6_addr = addr->addr.ipv6.addr;
-#ifdef HAVE_SOCKADDR_IN6_SCOPE_ID
- sin6->sin6_scope_id = addr->addr.ipv6.scope_id;
-#endif /* HAVE_SOCKADDR_IN6_SCOPE_ID */
- }
-#endif /* ENABLE_IPV6 */
- else
- abort ();
-}
-
-void
-sockaddr_get_address (const struct sockaddr *sa, unsigned short *port,
- ip_address *addr)
-{
- if (sa->sa_family == AF_INET)
- {
- struct sockaddr_in *sin = (struct sockaddr_in *)sa;
-
- addr->type = IPv4_ADDRESS;
- addr->addr.ipv4.addr = sin->sin_addr;
- if (port != NULL)
- *port = ntohs (sin->sin_port);
- }
-#ifdef ENABLE_IPV6
- else if (sa->sa_family == AF_INET6)
- {
- struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa;
-
- addr->type = IPv6_ADDRESS;
- addr->addr.ipv6.addr = sin6->sin6_addr;
-#ifdef HAVE_SOCKADDR_IN6_SCOPE_ID
- addr->addr.ipv6.scope_id = sin6->sin6_scope_id;
-#endif
- if (port != NULL)
- *port = ntohs (sin6->sin6_port);
- }
-#endif
- else
- abort ();
-}
-
-#if 0 /* currently unused */
-/**
- * sockaddr_set_port
- *
- * This funtion only fill the port of the socket information.
- * If the protocol is not supported nothing is done.
- * Unsuported adress family will abort the whole programm.
- *
- * Require:
- * that the IP-Protocol already is set.
- *
- * Input:
- * wget_sockaddr* The space there port should be entered
- * unsigned int The port that should be entered in host order
- *
- * Return:
- * - Only modify 1. param
- */
-void
-sockaddr_set_port (struct sockaddr *sa, unsigned short port)
-{
- if (sa->sa_family == AF_INET)
- {
- struct sockaddr_in *sin = (struct sockaddr_in *)sa;
- sin->sin_port = htons (port);
- }
-#ifdef ENABLE_IPV6
- else if (sa->sa_family == AF_INET6)
- {
- struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa;
- sin6->sin6_port = htons (port);
- }
-#endif
- else
- abort ();
-}
-#endif
-
-/**
- * sockaddr_get_port
- *
- * This function only return the port from the input structure
- * Unsuported adress family will abort the whole programm.
- *
- * Require:
- * that the IP-Protocol already is set.
- *
- * Input:
- * wget_sockaddr* Information where to get the port
- *
- * Output:
- * unsigned short Port Number in host order.
- */
-unsigned short
-sockaddr_get_port (const struct sockaddr *sa)
-{
- if (sa->sa_family == AF_INET) {
- const struct sockaddr_in *sin = (const struct sockaddr_in *)sa;
- return htons (sin->sin_port);
-#ifdef ENABLE_IPV6
- } else if (sa->sa_family == AF_INET6) {
- const struct sockaddr_in6 *sin6 = (const struct sockaddr_in6 *)sa;
- return htons (sin6->sin6_port);
-#endif
- } else
- abort ();
- /* do not complain about return nothing */
- return -1;
-}
-
-/**
- * sockaddr_len
- *
- * This function return the length of the sockaddr corresponding to
- * the acutall prefered protocol for (bind, connect etc...)
- * Unsuported adress family will abort the whole programm.
- *
- * Require:
- * that the IP-Protocol already is set.
- *
- * Input:
- * - Public IP-Family Information
- *
- * Output:
- * int structure length for socket options
- */
-socklen_t
-sockaddr_len (const struct sockaddr *sa)
-{
- if (sa->sa_family == AF_INET)
- {
- return sizeof (struct sockaddr_in);
- }
-#ifdef ENABLE_IPV6
- else if (sa->sa_family == AF_INET6)
- {
- return sizeof (struct sockaddr_in6);
- }
-#endif
- else
- abort ();
- /* do not complain about return nothing */
- return 0;
-}
-\f
/* Versions of gethostbyname and getaddrinfo that support timeout. */
#ifndef ENABLE_IPV6
return ctx.hptr;
}
+/* Print error messages for host errors. */
+static char *
+host_errstr (int error)
+{
+ /* 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 {
{
switch (addr->type)
{
- case IPv4_ADDRESS:
- return inet_ntoa (addr->addr.ipv4.addr);
+ case IPV4_ADDRESS:
+ return inet_ntoa (ADDRESS_IPV4_IN_ADDR (addr));
#ifdef ENABLE_IPV6
- case IPv6_ADDRESS:
+ case IPV6_ADDRESS:
{
- int len;
static char buf[128];
- inet_ntop (AF_INET6, &addr->addr.ipv6.addr, buf, sizeof (buf));
+ inet_ntop (AF_INET6, &ADDRESS_IPV6_IN6_ADDR (addr), buf, sizeof (buf));
#if 0
#ifdef HAVE_SOCKADDR_IN6_SCOPE_ID
- /* print also scope_id for all ?non-global? addresses */
- snprintf (buf + len, sizeof (buf) - len, "%%%d", addr->addr.ipv6.scope_id);
+ {
+ /* append "%SCOPE_ID" for all ?non-global? addresses */
+ char *p = buf + strlen (buf);
+ *p++ = '%';
+ number_to_string (p, ADDRESS_IPV6_SCOPE (addr));
+ }
#endif
#endif
- len = strlen (buf);
buf[sizeof (buf) - 1] = '\0';
return buf;
}
#endif
}
abort ();
+}
+
+/* The following two functions were adapted from glibc. */
+
+static int
+is_valid_ipv4_address (const char *str, const char *end)
+{
+ int saw_digit = 0;
+ int octets = 0;
+ int val = 0;
+
+ while (str < end)
+ {
+ int ch = *str++;
+
+ if (ch >= '0' && ch <= '9')
+ {
+ val = val * 10 + (ch - '0');
+
+ if (val > 255)
+ return 0;
+ if (saw_digit == 0)
+ {
+ if (++octets > 4)
+ return 0;
+ saw_digit = 1;
+ }
+ }
+ else if (ch == '.' && saw_digit == 1)
+ {
+ if (octets == 4)
+ return 0;
+ val = 0;
+ saw_digit = 0;
+ }
+ else
+ return 0;
+ }
+ if (octets < 4)
+ return 0;
+
+ return 1;
+}
+
+int
+is_valid_ipv6_address (const char *str, const char *end)
+{
+ /* 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;
+ int saw_xdigit;
+ unsigned int val;
+
+ tp = 0;
+ colonp = NULL;
+
+ if (str == end)
+ return 0;
+
+ /* Leading :: requires some special handling. */
+ if (*str == ':')
+ {
+ ++str;
+ if (str == end || *str != ':')
+ return 0;
+ }
+
+ curtok = str;
+ saw_xdigit = 0;
+ val = 0;
+
+ while (str < end)
+ {
+ 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 0;
+ saw_xdigit = 1;
+ continue;
+ }
+
+ /* if ch is a colon ... */
+ if (ch == ':')
+ {
+ curtok = str;
+ if (saw_xdigit == 0)
+ {
+ if (colonp != NULL)
+ return 0;
+ colonp = str + tp;
+ continue;
+ }
+ else if (str == end)
+ return 0;
+ if (tp > ns_in6addrsz - ns_int16sz)
+ return 0;
+ tp += ns_int16sz;
+ saw_xdigit = 0;
+ 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 = 0;
+ break;
+ }
+
+ return 0;
+ }
+
+ if (saw_xdigit == 1)
+ {
+ if (tp > ns_in6addrsz - ns_int16sz)
+ return 0;
+ tp += ns_int16sz;
+ }
+
+ if (colonp != NULL)
+ {
+ if (tp == ns_in6addrsz)
+ return 0;
+ tp = ns_in6addrsz;
+ }
+
+ if (tp != ns_in6addrsz)
+ return 0;
+
+ return 1;
+}
+\f
+/* 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)
+ {
+ DEBUGP (("Found %s in host_name_addresses_map (%p)\n", host, al));
+ ++al->refcount;
+ return al;
+ }
return NULL;
}
-/* Add host name HOST with the address ADDR_TEXT to the cache.
- ADDR_LIST is a NULL-terminated list of addresses, as in struct
- hostent. */
+/* Cache the DNS lookup of HOST. Subsequent invocations of
+ lookup_host will return the cached value. */
static void
-cache_host_lookup (const char *host, struct address_list *al)
+cache_store (const char *host, struct address_list *al)
{
if (!host_name_addresses_map)
host_name_addresses_map = make_nocase_string_hash_table (0);
#endif
}
+/* 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)
+ {
+ address_list_release (al);
+ hash_table_remove (host_name_addresses_map, host);
+ }
+}
+\f
+/* 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 = NULL;
-
-#ifdef ENABLE_IPV6
- int err, family;
- struct addrinfo hints, *res;
-
- /* This ip_default_family+flags business looks like bad design to
- me. This function should rather accept a FAMILY argument. */
- if (flags & LH_IPv4_ONLY)
- family = AF_INET;
- else if (flags & LH_IPv6_ONLY)
- family = AF_INET6;
- else
- family = ip_default_family;
-#endif
-
- /* First, try to check whether the address is already a numeric
- address. Where getaddrinfo is available, we do it using the
- AI_NUMERICHOST flag. Without IPv6, we check whether inet_addr
- succeeds. */
+ struct address_list *al;
+ int silent = flags & LH_SILENT;
+ int use_cache;
+ int numeric_address = 0;
+ double timeout = opt.dns_timeout;
-#ifdef ENABLE_IPV6
- memset (&hints, 0, sizeof (hints));
- hints.ai_family = family;
- hints.ai_socktype = SOCK_STREAM;
- hints.ai_flags = AI_NUMERICHOST;
- if (flags & LH_PASSIVE)
- hints.ai_flags = AI_PASSIVE;
-
- /* no need to call getaddrinfo_with_timeout here, as we're not
- * relying on the DNS, but we're only doing an address translation
- * from presentation (ASCII) to network format */
- err = getaddrinfo (host, NULL, &hints, &res);
- if (err == 0 && res != NULL)
- {
- al = address_list_from_addrinfo (res);
- freeaddrinfo (res);
- return al;
- }
-#else
+#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)
{
- /* The return value of inet_addr is in network byte order, so
- we can just copy it to ADDR. */
- ip_address addr;
- /* This has a huge number of dereferences because C doesn't
- support anonymous unions and because struct in_addr adds a
- cast. */
- addr.addr.ipv4.addr.s_addr = addr_ipv4;
- addr.type = IPv4_ADDRESS;
- return address_list_from_single (&addr);
+ /* 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 = 1;
+ }
#endif
- /* Then, try to find the host in the cache. */
+ /* 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 = 0;
+#endif
- if (host_name_addresses_map)
+ /* 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)
{
- al = hash_table_get (host_name_addresses_map, host);
- if (al)
+ if (!(flags & LH_REFRESH))
{
- DEBUGP (("Found %s in host_name_addresses_map (%p)\n", host, al));
- ++al->refcount;
- return al;
+ al = cache_query (host);
+ if (al)
+ return al;
}
+ else
+ cache_remove (host);
}
- if (!(flags & LH_SILENT))
- logprintf (LOG_VERBOSE, _("Resolving %s... "), host);
+ /* No luck with the cache; resolve HOST. */
- /* Host name lookup goes on below. */
+ if (!silent && !numeric_address)
+ logprintf (LOG_VERBOSE, _("Resolving %s... "), escnonprint (host));
#ifdef ENABLE_IPV6
{
- memset (&hints, 0, sizeof (hints));
- hints.ai_family = family;
- hints.ai_socktype = SOCK_STREAM;
- if (flags & LH_PASSIVE)
- hints.ai_flags = AI_PASSIVE;
+ int err;
+ struct addrinfo hints, *res;
- err = getaddrinfo_with_timeout (host, NULL, &hints, &res, opt.dns_timeout);
+ 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 (!(flags & LH_SILENT))
+ if (!silent)
logprintf (LOG_VERBOSE, _("failed: %s.\n"),
err != EAI_SYSTEM ? gai_strerror (err) : strerror (errno));
- return NULL;
+ 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
+#else /* not ENABLE_IPV6 */
{
- struct hostent *hptr = gethostbyname_with_timeout (host, opt.dns_timeout);
+ struct hostent *hptr = gethostbyname_with_timeout (host, timeout);
if (!hptr)
{
- if (!(flags & LH_SILENT))
+ if (!silent)
{
if (errno != ETIMEDOUT)
- logprintf (LOG_VERBOSE, _("failed: %s.\n"), herrmsg (h_errno));
+ logprintf (LOG_VERBOSE, _("failed: %s.\n"),
+ host_errstr (h_errno));
else
logputs (LOG_VERBOSE, _("failed: timed out.\n"));
}
return NULL;
}
- assert (hptr->h_length == 4);
- /* Do all systems have h_addr_list, or is it a newer thing? If
- the latter, use address_list_from_single. */
- al = address_list_from_vector (hptr->h_addr_list);
+ /* Do older systems have h_addr_list? */
+ al = address_list_from_ipv4_addresses (hptr->h_addr_list);
}
-#endif
+#endif /* not ENABLE_IPV6 */
/* Print the addresses determined by DNS lookup, but no more than
three. */
- if (!(flags & LH_SILENT))
+ if (!silent && !numeric_address)
{
int i;
int printmax = al->count <= 3 ? al->count : 3;
}
/* Cache the lookup information. */
- if (opt.dns_cache)
- cache_host_lookup (host, al);
+ if (use_cache)
+ cache_store (host, al);
return al;
}
return 0;
}
-/* 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");
-}
-
static int
host_cleanup_mapper (void *key, void *value, void *arg_ignored)
{
projects / wget / blobdiff