#endif /* WINDOWS */
#ifndef NO_ADDRESS
-#define NO_ADDRESS NO_DATA
+# define NO_ADDRESS NO_DATA
#endif
-#ifdef HAVE_SYS_UTSNAME_H
-# include <sys/utsname.h>
-#endif
#include <errno.h>
#include "wget.h"
# endif
#endif
-#ifdef ENABLE_IPV6
-int ip_default_family = AF_UNSPEC;
-#else
-int ip_default_family = AF_INET;
-#endif
-
/* Mapping between known hosts and to lists of their addresses. */
static struct hash_table *host_name_addresses_map;
return al->addresses + pos;
}
-/* Check whether two address lists have all their IPs in common. */
+/* Return 1 if IP is one of the addresses in AL. */
int
-address_list_match_all (const struct address_list *al1,
- const struct address_list *al2)
+address_list_find (const struct address_list *al, const ip_address *ip)
{
-#ifdef ENABLE_IPV6
int i;
-#endif
- if (al1 == al2)
- return 1;
- if (al1->count != al2->count)
- return 0;
-
- /* For the comparison to be complete, we'd need to sort the IP
- addresses first. But that's not necessary because this is only
- used as an optimization. */
-
-#ifndef ENABLE_IPV6
- /* In the non-IPv6 case, there is only one address type, so we can
- compare the whole array with memcmp. */
- return 0 == memcmp (al1->addresses, al2->addresses,
- al1->count * sizeof (ip_address));
-#else /* ENABLE_IPV6 */
- for (i = 0; i < al1->count; ++i)
+ switch (ip->type)
{
- const ip_address *ip1 = &al1->addresses[i];
- const ip_address *ip2 = &al2->addresses[i];
-
- if (ip1->type != ip2->type)
- return 0;
-
- switch (ip1->type)
+ case IPV4_ADDRESS:
+ for (i = 0; i < al->count; i++)
{
- case IPV4_ADDRESS:
- if (ADDRESS_IPV4_IN_ADDR (ip1).s_addr
- != ADDRESS_IPV4_IN_ADDR (ip2).s_addr)
- return 0;
- break;
- case IPV6_ADDRESS:
+ 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;
+ }
+ return 0;
+#ifdef ENABLE_IPV6
+ case IPV6_ADDRESS:
+ for (i = 0; i < al->count; i++)
+ {
+ ip_address *cur = al->addresses + i;
+ if (cur->type == IPV6_ADDRESS
#ifdef HAVE_SOCKADDR_IN6_SCOPE_ID
- if (ADDRESS_IPV6_SCOPE (ip1) != ADDRESS_IPV6_SCOPE (ip2))
- return 0;
-#endif /* HAVE_SOCKADDR_IN6_SCOPE_ID */
- if (!IN6_ARE_ADDR_EQUAL (&ADDRESS_IPV6_IN6_ADDR (ip1),
- &ADDRESS_IPV6_IN6_ADDR (ip2)))
- return 0;
- break;
- default:
- abort ();
+ && 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 1;
+ return 0;
#endif /* ENABLE_IPV6 */
+ default:
+ abort ();
+ return 1;
+ }
}
/* Mark the INDEXth element of AL as faulty, so that the next time
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->from_cache = 0;
al->refcount = 1;
ip = al->addresses;
return al;
}
#else
-/* Create an address_list out of a NULL-terminated vector of
- addresses, as returned by gethostbyname. */
+/* 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_vector (char **h_addr_list)
+address_list_from_ipv4_addresses (char **vec)
{
int count, i;
- struct address_list *al = xmalloc (sizeof (struct address_list));
+ struct address_list *al = xnew0 (struct address_list);
count = 0;
- while (h_addr_list[count])
+ while (vec[count])
++count;
assert (count > 0);
+ al->addresses = xnew_array (ip_address, count);
al->count = count;
- al->faulty = 0;
- al->addresses = xmalloc (count * sizeof (ip_address));
- al->from_cache = 0;
al->refcount = 1;
for (i = 0; i < count; i++)
{
ip_address *ip = &al->addresses[i];
ip->type = IPV4_ADDRESS;
- memcpy (ADDRESS_IPV4_DATA (ip), h_addr_list[i], 4);
+ memcpy (ADDRESS_IPV4_DATA (ip), vec[i], 4);
}
return al;
}
-
-/* Like address_list_from_vector, but initialized with a single
- address. */
-
-static struct address_list *
-address_list_from_single (const ip_address *addr)
-{
- struct address_list *al = xmalloc (sizeof (struct address_list));
- al->count = 1;
- al->faulty = 0;
- al->addresses = xmalloc (sizeof (ip_address));
- al->from_cache = 0;
- al->refcount = 1;
- memcpy (al->addresses, addr, sizeof (ip_address));
-
- return al;
-}
#endif
static void
#endif
}
+/* Remove HOST from Wget's DNS cache. Does nothing is HOST is not in
+ the cache. */
+
void
forget_host_lookup (const char *host)
{
}
}
+/* 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 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.
+
+ FLAGS can be a combination of:
+ LH_SILENT - don't print the "resolving ... done" message.
+ LH_IPV4_ONLY - return only IPv4 addresses.
+ LH_IPV6_ONLY - return only IPv6 addresses. */
+
struct address_list *
lookup_host (const char *host, int flags)
{
struct address_list *al = NULL;
#ifdef ENABLE_IPV6
- int err, family;
+ int err;
struct addrinfo hints, *res;
- /* Is this necessary? Should this function be changed to accept a
- FAMILY argument? */
+ xzero (hints);
+ hints.ai_socktype = SOCK_STREAM;
+
+ /* Should we inspect opt.<something> directly? */
if (flags & LH_IPV4_ONLY)
- family = AF_INET;
+ hints.ai_family = AF_INET;
else if (flags & LH_IPV6_ONLY)
- family = AF_INET6;
+ hints.ai_family = AF_INET6;
else
- family = ip_default_family;
+ hints.ai_family = AF_UNSPEC;
#endif
-
+
/* First, try to check whether the address is already a numeric
- address, in which case we don't need to cache it or bother with
- setting up timeouts. Plus, if memory serves me right, Ultrix's
+ 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 succeeds. */
+ flag. Without IPv6, we use inet_addr. */
#ifdef ENABLE_IPV6
- memset (&hints, 0, sizeof (hints));
- hints.ai_family = family;
- hints.ai_socktype = SOCK_STREAM;
- hints.ai_flags = AI_NUMERICHOST;
+ hints.ai_flags = AI_NUMERICHOST;
if (flags & LH_PASSIVE)
- hints.ai_flags = AI_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 */
+ /* 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)
{
{
/* The return value of inet_addr is in network byte order, so
we can just copy it to IP. */
- ip_address ip;
- ip.type = IPV4_ADDRESS;
- memcpy (ADDRESS_IPV4_DATA (&ip), &addr_ipv4, 4);
- return address_list_from_single (&ip);
+ char *vec[2];
+ vec[0] = (char *)&addr_ipv4;
+ vec[1] = NULL;
+ return address_list_from_ipv4_addresses (vec);
}
}
#endif
/* Host name lookup goes on below. */
#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;
-
- err = getaddrinfo_with_timeout (host, NULL, &hints, &res, opt.dns_timeout);
+ hints.ai_flags = 0;
+ if (flags & LH_PASSIVE)
+ hints.ai_flags |= AI_PASSIVE;
- if (err != 0 || res == NULL)
- {
- if (!(flags & LH_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 (!(flags & LH_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);
#else
{
struct hostent *hptr = gethostbyname_with_timeout (host, opt.dns_timeout);
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
projects / wget / blobdiff