#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"
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;
}
-/* 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
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)
{
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. */
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)
{
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 {
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. */
+ If SILENT is non-zero, progress messages are not printed. */
struct address_list *
-lookup_host (const char *host, int flags)
+lookup_host (const char *host, int silent)
{
struct address_list *al = NULL;
-#ifdef ENABLE_IPV6
- int err;
- struct addrinfo hints, *res;
-
- xzero (hints);
- hints.ai_socktype = SOCK_STREAM;
-
- /* Should we inspect opt.<something> directly? */
- if (flags & LH_IPV4_ONLY)
- hints.ai_family = AF_INET;
- else if (flags & LH_IPV6_ONLY)
- hints.ai_family = AF_INET6;
- else
- hints.ai_family = AF_UNSPEC;
-#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;
- if (flags & LH_PASSIVE)
- hints.ai_flags |= AI_PASSIVE;
-
- /* No need to call getaddrinfo_with_timeout here, as we're not
- resolving anything, but merely translating the address 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 names a
+ numeric IPv4 address. gethostbyname is not required to accept
+ dotted-decimal IPv4 addresses, and some older implementations
+ (e.g. the Ultrix one) indeed didn'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. */
+ /* Try to find the host in the cache. */
if (host_name_addresses_map)
{
{
DEBUGP (("Found %s in host_name_addresses_map (%p)\n", host, al));
++al->refcount;
- al->from_cache = 1;
return al;
}
}
- if (!(flags & LH_SILENT))
- logprintf (LOG_VERBOSE, _("Resolving %s... "), host);
+ /* No luck with the cache; resolve the host name. */
- /* Host name lookup goes on below. */
+ if (!silent)
+ logprintf (LOG_VERBOSE, _("Resolving %s... "), host);
#ifdef ENABLE_IPV6
- hints.ai_flags = 0;
- 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);
- 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);
+ xzero (hints);
+ hints.ai_socktype = SOCK_STREAM;
+ hints.ai_family = AF_UNSPEC; /* #### should look at opt.ipv4_only
+ and opt.ipv6_only */
+ hints.ai_flags = 0;
+
+ 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.\n"));
+ return NULL;
+ }
+ }
#else
{
struct hostent *hptr = gethostbyname_with_timeout (host, opt.dns_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 older systems have h_addr_list? */
al = address_list_from_ipv4_addresses (hptr->h_addr_list);
}
/* Print the addresses determined by DNS lookup, but no more than
three. */
- if (!(flags & LH_SILENT))
+ if (!silent)
{
int i;
int printmax = al->count <= 3 ? al->count : 3;
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 = AF_UNSPEC; /* #### should look at opt.ipv4_only
+ and opt.ipv6_only */
+ 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. */
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