#include "host.h"
#include "url.h"
#include "hash.h"
+#include "connect.h" /* for socket_has_inet6 */
#ifndef errno
extern int errno;
# endif
#endif
-/* Mapping between known hosts and to lists of their addresses. */
-
-static struct hash_table *host_name_addresses_map;
-
-#ifdef ENABLE_IPV6
-/* The default IP family for looking up host names. This should be
- moved to an entry in struct options when we implement the
- --inet4/--inet6 flags. */
-static int ip_default_family = AF_UNSPEC;
-#endif
-\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 from_cache; /* whether this entry was pulled from
- cache or freshly looked up. */
+ 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. */
*end = al->count;
}
-/* Return whether this address list entry has been obtained from the
- cache. */
-
-int
-address_list_cached_p (const struct address_list *al)
-{
- return al->from_cache;
-}
-
/* Return a pointer to the address at position POS. */
const ip_address *
return al->addresses + pos;
}
-/* Return 1 if IP is one of the addresses in AL. */
+/* Return non-zero if AL contains IP, zero otherwise. */
int
-address_list_find (const struct address_list *al, const ip_address *ip)
+address_list_contains (const struct address_list *al, const ip_address *ip)
{
int i;
switch (ip->type)
#endif /* ENABLE_IPV6 */
default:
abort ();
- return 1;
+ return 0;
}
}
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* Linked 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)
{
return NULL;
al = xnew0 (struct address_list);
- al->addresses = xnew_array (ip_address, cnt);
- al->count = cnt;
- al->refcount = 1;
+ 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)
assert (ip - al->addresses == cnt);
return al;
}
-#else
+
+#else /* not ENABLE_IPV6 */
+
/* Create an address_list from a NULL-terminated vector of IPv4
addresses. This kind of vector is returned by gethostbyname. */
++count;
assert (count > 0);
- al->addresses = xnew_array (ip_address, count);
- al->count = count;
- al->refcount = 1;
+ al->addresses = xnew_array (ip_address, count);
+ al->count = count;
+ al->refcount = 1;
for (i = 0; i < count; i++)
{
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)
{
|| error == NO_RECOVERY
|| error == NO_DATA
|| error == NO_ADDRESS)
- return _("Host not found");
+ return _("Unknown host");
else if (error == TRY_AGAIN)
/* Message modeled after what gai_strerror returns in similar
circumstances. */
abort ();
return NULL;
}
+\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. */
-/* 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. */
+/* 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;
+}
+
+/* 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 Wget's DNS cache. Does nothing is HOST is not in
+/* Remove HOST from the DNS cache. Does nothing is HOST is not in
the cache. */
-void
-forget_host_lookup (const char *host)
+static void
+cache_remove (const char *host)
{
- struct address_list *al = hash_table_get (host_name_addresses_map, 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);
}
}
-
-/* Look up HOST in DNS and return a list of IP addresses.
+\f
+/* Look up HOST in DNS and return a list of IP addresses. The
+ addresses in the list are in the same order in which
+ gethostbyname/getaddrinfo returned them.
This function caches its result so that, if the same host is passed
- the second time, the addresses are returned without the DNS lookup.
- If you want to force lookup, call forget_host_lookup() prior to
- this function, or set opt.dns_cache to 0 to globally disable
- caching.
-
- If SILENT is non-zero, progress messages are not printed. */
+ 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.)
+
+ 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 silent)
+lookup_host (const char *host, int flags)
{
- struct address_list *al = NULL;
-
-#ifdef ENABLE_IPV6
- int err;
- struct addrinfo hints, *res;
- xzero (hints);
- hints.ai_socktype = SOCK_STREAM;
- hints.ai_family = ip_default_family;
-#endif
-
- /* First, try to check whether the address is already a numeric
- address, in which case we don't want to cache it or bother with
- setting up timeouts. Plus, old (e.g. Ultrix) implementations of
- gethostbyname can't handle numeric addresses (!).
-
- Where getaddrinfo is available, we do it using the AI_NUMERICHOST
- flag. Without IPv6, we use inet_addr. */
-
-#ifdef ENABLE_IPV6
- hints.ai_flags = AI_NUMERICHOST;
+ struct address_list *al;
+ int silent = flags & LH_SILENT;
+ int use_cache;
- /* No need to specify timeout, as we're not resolving HOST, but
- merely translating it from the 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. gethostbyname is not required to accept
+ dotted-decimal IPv4 addresses, and some implementations (e.g. the
+ Ultrix one and possibly Winsock) indeed don't. */
{
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 IP. */
+ /* No need to cache host->addr relation, just return the
+ address. */
char *vec[2];
vec[0] = (char *)&addr_ipv4;
vec[1] = NULL;
}
#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)
+ 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;
- al->from_cache = 1;
- return al;
+ al = cache_query (host);
+ if (al)
+ return al;
}
+ else
+ cache_remove (host);
}
- /* No luck with the cache; resolve the host name. */
+ /* No luck with the cache; resolve HOST. */
if (!silent)
logprintf (LOG_VERBOSE, _("Resolving %s... "), host);
#ifdef ENABLE_IPV6
- hints.ai_flags = 0;
+ {
+ 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
+ {
+ hints.ai_family = AF_UNSPEC;
+#ifdef HAVE_GETADDRINFO_AI_ADDRCONFIG
+ hints.ai_flags |= AI_ADDRCONFIG;
+#else
+ /* On systems without AI_ADDRCONFIG, emulate it by manually
+ checking whether the system supports IPv6 sockets. */
+ if (!socket_has_inet6 ())
+ hints.ai_family = AF_INET;
+#endif
+ }
+ if (flags & LH_BIND)
+ hints.ai_flags |= AI_PASSIVE;
- err = getaddrinfo_with_timeout (host, NULL, &hints, &res, opt.dns_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);
+ err = getaddrinfo_with_timeout (host, NULL, &hints, &res, opt.dns_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;
+ }
+ }
#else
{
struct hostent *hptr = gethostbyname_with_timeout (host, opt.dns_timeout);
}
/* Cache the lookup information. */
- if (opt.dns_cache)
- cache_host_lookup (host, al);
+ if (use_cache)
+ cache_store (host, al);
return al;
}
-
-/* Resolve HOST to get an address for use with bind(2). Do *not* use
- this for sockets to be used with connect(2).
-
- This is a function separate from lookup_host because the results it
- returns are different -- it uses the AI_PASSIVE flag to
- getaddrinfo. Because of this distinction, it doesn't store the
- results in the cache. It prints nothing and implements no timeouts
- because it should normally only be used with local addresses
- (typically "localhost" or numeric addresses of different local
- interfaces.)
-
- Without IPv6, this function just calls lookup_host. */
-
-struct address_list *
-lookup_host_passive (const char *host)
-{
-#ifdef ENABLE_IPV6
- struct address_list *al = NULL;
- int err;
- struct addrinfo hints, *res;
-
- xzero (hints);
- hints.ai_socktype = SOCK_STREAM;
- hints.ai_family = ip_default_family;
- hints.ai_flags = AI_PASSIVE;
-
- err = getaddrinfo (host, NULL, &hints, &res);
- if (err != 0 || res == NULL)
- return NULL;
- al = address_list_from_addrinfo (res);
- freeaddrinfo (res);
- return al;
-#else
- return lookup_host (host, 1);
-#endif
-}
\f
/* Determine whether a URL is acceptable to be followed, according to
a list of domains to accept. */
projects / wget / blobdiff