X-Git-Url: http://sjero.net/git/?a=blobdiff_plain;f=src%2Fhost.c;h=ab490421ae09866c2cf451db83629001719ed60d;hb=5f0a2b3f0846dd4c2f72fc62e7171200d1fd6e06;hp=03a56fe57cd07a46dee12da1b352363d0e56d75e;hpb=858adf01cd277c64ac7a70786ad8855d1bad970f;p=wget diff --git a/src/host.c b/src/host.c index 03a56fe5..ab490421 100644 --- a/src/host.c +++ b/src/host.c @@ -1,27 +1,40 @@ -/* Dealing with host names. - Copyright (C) 1995, 1996, 1997 Free Software Foundation, Inc. +/* Host name resolution and matching. + Copyright (C) 1995, 1996, 1997, 2000, 2001 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. + (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, write to the Free Software +Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + +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 +#ifndef WINDOWS +#include +#endif + #include #include -#include #ifdef HAVE_STRING_H # include #else @@ -32,13 +45,21 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifdef WINDOWS # include +# define SET_H_ERRNO(err) WSASetLastError (err) #else # include # include -# include +# ifndef __BEOS__ +# include +# endif # include +# define SET_H_ERRNO(err) ((void)(h_errno = (err))) #endif /* WINDOWS */ +#ifndef NO_ADDRESS +#define NO_ADDRESS NO_DATA +#endif + #ifdef HAVE_SYS_UTSNAME_H # include #endif @@ -48,327 +69,549 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "utils.h" #include "host.h" #include "url.h" +#include "hash.h" #ifndef errno extern int errno; #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; -}; +#ifndef h_errno +# ifndef __CYGWIN__ +extern int h_errno; +# endif +#endif -static struct host *hlist; +#ifdef ENABLE_IPV6 +int ip_default_family = AF_UNSPEC; +#else +int ip_default_family = AF_INET; +#endif -static struct host *add_hlist PARAMS ((struct host *, const char *, - const char *, int)); +/* Mapping between known hosts and to lists of their addresses. */ -/* 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; +static struct hash_table *host_name_addresses_map; + +/* Lists of addresses. This should eventually be extended to handle + IPv6. */ - addr = (unsigned long)inet_addr (name); - if ((int)addr != -1) - hp = gethostbyaddr ((char *)&addr, sizeof (addr), AF_INET); - else - hp = gethostbyname (name); - return hp; +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 refcount; /* reference count; when it drops to + 0, the entry is freed. */ +}; + +/* 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 whether this address list entry has been obtained from the + cache. */ + +int +address_list_cached_p (const struct address_list *al) { - for (; l; l = l->next) - if (strcasecmp (l->hostname, host) == 0) - return l; - return NULL; + return al->from_cache; } -/* Like search_host, but searches by address. */ -static struct host * -search_address (struct host *l, const char *address) +/* 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) - { - int cmp = strcmp (l->realname, address); - if (cmp == 0) - return l; - else if (cmp > 0) - return NULL; - } - return NULL; + assert (pos >= al->faulty && pos < al->count); + return al->addresses + pos; } -/* 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. +/* Check whether two address lists have all their IPs in common. */ - Return 1 on successful finding of the hostname, 0 otherwise. */ int -store_hostaddress (unsigned char *where, const char *hostname) +address_list_match_all (const struct address_list *al1, + const struct address_list *al2) { - struct host *t; - unsigned long addr; - struct hostent *hptr; - struct in_addr in; - char *inet_s; - - /* 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) - { - /* 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); - } - /* If we have the numeric address, just store it. */ - if ((int)addr != -1) - { - /* This works on both little and big endian architecture, as - inet_addr returns the address in the proper order. */ -#ifdef WORDS_BIGENDIAN - if (sizeof (addr) == 8) - addr <<= 32; +#ifdef ENABLE_IPV6 + int i; #endif - memcpy (where, &addr, 4); - return 1; - } - /* 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) + if (al1 == al2) + return 1; + if (al1->count != al2->count) 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. */ + + /* 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) { - /* Set the default, 0 quality. */ - hlist = add_hlist (hlist, hostname, inet_s, 0); - return 1; + 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: + if (ADDRESS_IPV4_IN_ADDR (ip1).s_addr + != ADDRESS_IPV4_IN_ADDR (ip2).s_addr) + return 0; + break; + case 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 (); + } } - /* 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; +#endif /* ENABLE_IPV6 */ +} + +/* Mark the INDEXth element of AL as faulty, so that the next time + this address list is used, the faulty element will be skipped. */ + +void +address_list_set_faulty (struct address_list *al, int index) +{ + /* 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; } -/* 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) +#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 + */ +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->type = IPV6_ADDRESS; + ADDRESS_IPV6_IN6_ADDR (ip) = sin6->sin6_addr; +#ifdef HAVE_SOCKADDR_IN6_SCOPE_ID + ADDRESS_IPV6_SCOPE (ip) = 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->type = IPV4_ADDRESS; + ADDRESS_IPV4_IN_ADDR (ip) = sin->sin_addr; + ++ip; + } + assert (ip - al->addresses == cnt); + return al; +} +#else +/* 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_ipv4_addresses (char **h_addr_list) { - struct host *t, *old, *beg; + int count, i; + struct address_list *al = xnew0 (struct address_list); - /* 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)) + count = 0; + while (h_addr_list[count]) + ++count; + assert (count > 0); + + al->addresses = xnew_array (ip_address, count); + al->count = count; + al->refcount = 1; + + for (i = 0; i < count; i++) { - t = (struct host *)xmalloc (sizeof (struct host)); - t->hostname = xstrdup (nhost); - t->realname = xstrdup (nreal); - t->quality = quality; - t->next = l; - return t; + ip_address *ip = &al->addresses[i]; + ip->type = IPV4_ADDRESS; + memcpy (ADDRESS_IPV4_DATA (ip), h_addr_list[i], 4); } - beg = l; - /* Second two one-before-the-last element. */ - while (l->next) + return al; +} +#endif + +static void +address_list_delete (struct address_list *al) +{ + xfree (al->addresses); + xfree (al); +} + +void +address_list_release (struct address_list *al) +{ + --al->refcount; + DEBUGP (("Releasing %p (new refcount %d).\n", al, al->refcount)); + if (al->refcount <= 0) { - 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; + DEBUGP (("Deleting unused %p.\n", al)); + address_list_delete (al); } - 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; } + +/* Versions of gethostbyname and getaddrinfo that support timeout. */ -/* 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. +#ifndef ENABLE_IPV6 - 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) -{ - struct host *l; - struct in_addr in; +struct ghbnwt_context { + const char *host_name; struct hostent *hptr; - char *inet_s; +}; + +static void +gethostbyname_with_timeout_callback (void *arg) +{ + struct ghbnwt_context *ctx = (struct ghbnwt_context *)arg; + ctx->hptr = gethostbyname (ctx->host_name); +} - 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 */ +/* 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)) { - 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); + SET_H_ERRNO (HOST_NOT_FOUND); + errno = ETIMEDOUT; + return NULL; } - else if (!l) /* Not found, with or without quality */ + if (!ctx.hptr) + errno = 0; + return ctx.hptr; +} + +#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; + + if (run_with_timeout (timeout, getaddrinfo_with_timeout_callback, &ctx)) { - /* 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)); + errno = ETIMEDOUT; + return EAI_SYSTEM; } - else /* Found, without quality */ + return ctx.exit_code; +} + +#endif /* ENABLE_IPV6 */ + +/* Pretty-print ADDR. When compiled without IPv6, this is the same as + inet_ntoa. With IPv6, it either prints an IPv6 address or an IPv4 + address. */ + +const char * +pretty_print_address (const ip_address *addr) +{ + switch (addr->type) { - /* 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); + case IPV4_ADDRESS: + return inet_ntoa (ADDRESS_IPV4_IN_ADDR (addr)); +#ifdef ENABLE_IPV6 + case IPV6_ADDRESS: + { + static char buf[128]; + inet_ntop (AF_INET6, &ADDRESS_IPV6_IN6_ADDR (addr), buf, sizeof (buf)); +#if 0 +#ifdef HAVE_SOCKADDR_IN6_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 + buf[sizeof (buf) - 1] = '\0'; + return buf; + } +#endif } + abort (); + 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. */ + +static void +cache_host_lookup (const char *host, struct address_list *al) +{ + 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); - /* 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. */ +#ifdef ENABLE_DEBUG + if (opt.debug) { - /* Set the default, 0 quality. */ - hlist = add_hlist (hlist, host, inet_s, 0); - return xstrdup (l->hostname); + int i; + debug_logprintf ("Caching %s =>", host); + for (i = 0; i < al->count; i++) + debug_logprintf (" %s", pretty_print_address (al->addresses + i)); + debug_logprintf ("\n"); } - /* 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); +#endif } -/* 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) +void +forget_host_lookup (const char *host) { - 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) + struct address_list *al = hash_table_get (host_name_addresses_map, host); + if (al) { - free (p1); - free (p2); - DEBUGP (("They are quite alike.\n")); - return 1; + address_list_release (al); + hash_table_remove (host_name_addresses_map, host); } - else if (opt.simple_check) +} + +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; + + /* Is this necessary? Should this function be changed to 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, in which case we don't need to cache it or bother with + setting up timeouts. Plus, if memory serves me right, Ultrix's + 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. */ + +#ifdef ENABLE_IPV6 + xzero (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) { - free (p1); - free (p2); - DEBUGP (("Since checking is simple, I'd say they are not the same.\n")); - return 0; + al = address_list_from_addrinfo (res); + freeaddrinfo (res); + return al; } - real1 = realhost (p1); - real2 = realhost (p2); - free (p1); - free (p2); - if (strcasecmp (real1, real2) == 0) +#else + { + 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. */ + char **vec[2]; + vec[0] = (char *)&addr_ipv4; + vec[1] = NULL; + return address_list_from_ipv4_addresses (vec); + } + } +#endif + + /* Then, try to find the host in the cache. */ + + if (host_name_addresses_map) { - DEBUGP (("They are alike, after realhost()->%s.\n", real1)); - free (real1); - free (real2); - return 1; + 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; + al->from_cache = 1; + return al; + } } - else + + if (!(flags & LH_SILENT)) + logprintf (LOG_VERBOSE, _("Resolving %s... "), host); + + /* Host name lookup goes on below. */ + +#ifdef ENABLE_IPV6 + { + xzero (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); + + 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); + if (!hptr) + { + if (!(flags & LH_SILENT)) + { + if (errno != ETIMEDOUT) + logprintf (LOG_VERBOSE, _("failed: %s.\n"), herrmsg (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); + } +#endif + + /* Print the addresses determined by DNS lookup, but no more than + three. */ + if (!(flags & LH_SILENT)) { - 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++) + { + logprintf (LOG_VERBOSE, "%s", + pretty_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 (opt.dns_cache) + cache_host_lookup (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) +accept_domain (struct url *u) { assert (u->host != NULL); if (opt.domains) @@ -407,127 +650,6 @@ sufmatch (const char **list, const char *what) return 0; } -/* 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) -{ - static char *address; - - /* Do the drill only the first time, as it won't change. */ - if (!address) - { - 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)) - { - logprintf (LOG_ALWAYS, _("%s: Cannot determine user-id.\n"), - exec_name); - exit (1); - } -#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) @@ -544,20 +666,27 @@ herrmsg (int error) 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) +static int +host_cleanup_mapper (void *key, void *value, void *arg_ignored) { - struct host *l = hlist; + struct address_list *al; + + xfree (key); /* host */ + + al = (struct address_list *)value; + assert (al->refcount == 1); + address_list_delete (al); - while (l) + return 0; +} + +void +host_cleanup (void) +{ + if (host_name_addresses_map) { - struct host *p = l->next; - free (l->hostname); - free (l->realname); - free (l); - l = p; + hash_table_map (host_name_addresses_map, host_cleanup_mapper, NULL); + hash_table_destroy (host_name_addresses_map); + host_name_addresses_map = NULL; } - hlist = NULL; }