X-Git-Url: http://sjero.net/git/?a=blobdiff_plain;f=src%2Fhost.c;h=ab490421ae09866c2cf451db83629001719ed60d;hb=5f0a2b3f0846dd4c2f72fc62e7171200d1fd6e06;hp=45455bf023559e1ecf038840d74fd402d37901bb;hpb=f3d3a50a5697957befaf94cb44797234a68068c3;p=wget diff --git a/src/host.c b/src/host.c index 45455bf0..ab490421 100644 --- a/src/host.c +++ b/src/host.c @@ -6,7 +6,7 @@ This file is part of GNU Wget. 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 @@ -15,7 +15,17 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License along with Wget; if not, write to the Free Software -Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ +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 @@ -35,6 +45,7 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifdef WINDOWS # include +# define SET_H_ERRNO(err) WSASetLastError (err) #else # include # include @@ -42,6 +53,7 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ # include # endif # include +# define SET_H_ERRNO(err) ((void)(h_errno = (err))) #endif /* WINDOWS */ #ifndef NO_ADDRESS @@ -69,10 +81,10 @@ extern int h_errno; # endif #endif -#ifdef INET6 -int ip_default_family = AF_INET6; +#ifdef ENABLE_IPV6 +int ip_default_family = AF_UNSPEC; #else -int ip_default_family = AF_INET; +int ip_default_family = AF_INET; #endif /* Mapping between known hosts and to lists of their addresses. */ @@ -87,38 +99,94 @@ struct address_list { 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 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 (struct address_list *al, int *start, int *end) +address_list_get_bounds (const struct address_list *al, int *start, int *end) { *start = al->faulty; *end = al->count; } -/* Copy address number INDEX to IP_STORE. */ +/* Return whether this address list entry has been obtained from the + cache. */ -void -address_list_copy_one (struct address_list *al, int index, ip_address *ip_store) +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 * +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. */ int -address_list_match_all (struct address_list *al1, struct address_list *al2) +address_list_match_all (const struct address_list *al1, + const struct address_list *al2) { +#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) + { + 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 (); + } + } + return 1; +#endif /* ENABLE_IPV6 */ } /* Mark the INDEXth element of AL as faulty, so that the next time @@ -141,94 +209,92 @@ address_list_set_faulty (struct address_list *al, int index) al->faulty = 0; } -#ifdef INET6 +#ifdef ENABLE_IPV6 /** * address_list_from_addrinfo * * This function transform an addrinfo links list in and address_list. * * Input: - * addrinfo* Linkt list of addrinfo + * addrinfo* Linked list of addrinfo * * Output: * address_list* New allocated address_list */ static struct address_list * -address_list_from_addrinfo (struct addrinfo *ai) +address_list_from_addrinfo (const struct addrinfo *ai) { struct address_list *al; - struct addrinfo *ai_head = ai; - int cnt = 0; - int i; + const struct addrinfo *ptr; + int cnt; + ip_address *ip; - for (ai = ai_head; ai; ai = ai->ai_next) - if (ai->ai_family == AF_INET || ai->ai_family == AF_INET6) + 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->count = cnt; - al->faulty = 0; - al->refcount = 1; + al = xnew0 (struct address_list); + al->addresses = xnew_array (ip_address, cnt); + al->count = cnt; + al->refcount = 1; - for (i = 0, ai = ai_head; ai; ai = ai->ai_next) - if (ai->ai_family == AF_INET6) + ip = al->addresses; + for (ptr = ai; ptr != NULL; ptr = ptr->ai_next) + if (ptr->ai_family == AF_INET6) { - struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)ai->ai_addr; - memcpy (al->addresses + i, &sin6->sin6_addr, 16); - ++i; + 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 (ai->ai_family == AF_INET) + else if (ptr->ai_family == AF_INET) { - struct sockaddr_in *sin = (struct sockaddr_in *)ai->ai_addr; - map_ipv4_to_ip ((ip4_address *)&sin->sin_addr, al->addresses + i); - ++i; + 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 (i == cnt); + assert (ip - al->addresses == cnt); return al; } #else -/* Create an address_list out of a NULL-terminated list 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_new (char **h_addr_list) +address_list_from_ipv4_addresses (char **h_addr_list) { - int count = 0, i; - - struct address_list *al = xmalloc (sizeof (struct address_list)); + int count, i; + struct address_list *al = xnew0 (struct address_list); + count = 0; 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; + + al->addresses = xnew_array (ip_address, count); + al->count = count; + al->refcount = 1; for (i = 0; i < count; i++) - map_ipv4_to_ip ((ip4_address *)h_addr_list[i], al->addresses + i); + { + ip_address *ip = &al->addresses[i]; + ip->type = IPV4_ADDRESS; + memcpy (ADDRESS_IPV4_DATA (ip), h_addr_list[i], 4); + } return al; } #endif -/* Like address_list_new, but initialized with only one address. */ - -static struct address_list * -address_list_new_one (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->refcount = 1; - memcpy (al->addresses, addr, sizeof (ip_address)); - - return al; -} - static void address_list_delete (struct address_list *al) { @@ -248,236 +314,118 @@ address_list_release (struct address_list *al) } } -/** - * wget_sockaddr_set_address - * - * This function takes an wget_sockaddr and fill in the protocol type, - * the port number and the address, there NULL in address means wildcard. - * Unsuported adress family will abort the whole programm. - * - * Input: - * wget_sockaddr* The space to be filled - * int The wished protocol - * unsigned short The port - * const ip_address The Binary IP adress - * - * Return: - * - Only modify 1. param - */ -void -wget_sockaddr_set_address (wget_sockaddr *sa, - int ip_family, unsigned short port, ip_address *addr) +/* Versions of gethostbyname and getaddrinfo that support timeout. */ + +#ifndef ENABLE_IPV6 + +struct ghbnwt_context { + const char *host_name; + struct hostent *hptr; +}; + +static void +gethostbyname_with_timeout_callback (void *arg) { - if (ip_family == AF_INET) - { - sa->sin.sin_family = ip_family; - sa->sin.sin_port = htons (port); - if (addr == NULL) - memset (&sa->sin.sin_addr, 0, sizeof(ip4_address)); - else - { - ip4_address addr4; - if (!map_ip_to_ipv4 (addr, &addr4)) - /* should the callers have prevented this? */ - abort (); - memcpy (&sa->sin.sin_addr, &addr4, sizeof(ip4_address)); - } - return; - } -#ifdef INET6 - if (ip_family == AF_INET6) - { - sa->sin6.sin6_family = ip_family; - sa->sin6.sin6_port = htons (port); - if (addr == NULL) - memset (&sa->sin6.sin6_addr, 0 , 16); - else - memcpy (&sa->sin6.sin6_addr, addr, 16); - return; - } -#endif - abort(); + struct ghbnwt_context *ctx = (struct ghbnwt_context *)arg; + ctx->hptr = gethostbyname (ctx->host_name); } -/** - * wget_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 -wget_sockaddr_set_port (wget_sockaddr *sa, unsigned short port) +/* 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) { - if (sa->sa.sa_family == AF_INET) + struct ghbnwt_context ctx; + ctx.host_name = host_name; + if (run_with_timeout (timeout, gethostbyname_with_timeout_callback, &ctx)) { - sa->sin.sin_port = htons (port); - return; - } -#ifdef INET6 - if (sa->sa.sa_family == AF_INET6) - { - sa->sin6.sin6_port = htons (port); - return; + SET_H_ERRNO (HOST_NOT_FOUND); + errno = ETIMEDOUT; + return NULL; } -#endif - abort(); -} - -/** - * wget_sockaddr_get_addr - * - * This function return the adress from an sockaddr as byte string. - * Unsuported adress family will abort the whole programm. - * - * Require: - * that the IP-Protocol already is set. - * - * Input: - * wget_sockaddr* Socket Information - * - * Output: - * unsigned char * IP address as byte string. - */ -void * -wget_sockaddr_get_addr (wget_sockaddr *sa) -{ - if (sa->sa.sa_family == AF_INET) - return &sa->sin.sin_addr; -#ifdef INET6 - if (sa->sa.sa_family == AF_INET6) - return &sa->sin6.sin6_addr; -#endif - abort(); - /* unreached */ - return NULL; + if (!ctx.hptr) + errno = 0; + return ctx.hptr; } -/** - * wget_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 -wget_sockaddr_get_port (const wget_sockaddr *sa) -{ - if (sa->sa.sa_family == AF_INET) - return htons (sa->sin.sin_port); -#ifdef INET6 - if (sa->sa.sa_family == AF_INET6) - return htons (sa->sin6.sin6_port); -#endif - abort(); - /* do not complain about return nothing */ - return -1; -} +#else /* ENABLE_IPV6 */ -/** - * 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 - */ -int -sockaddr_len () -{ - if (ip_default_family == AF_INET) - return sizeof (struct sockaddr_in); -#ifdef INET6 - if (ip_default_family == AF_INET6) - return sizeof (struct sockaddr_in6); -#endif - abort(); - /* do not complain about return nothing */ - return 0; -} +struct gaiwt_context { + const char *node; + const char *service; + const struct addrinfo *hints; + struct addrinfo **res; + int exit_code; +}; -/** - * Map an IPv4 adress to the internal adress format. - */ -void -map_ipv4_to_ip (ip4_address *ipv4, ip_address *ip) +static void +getaddrinfo_with_timeout_callback (void *arg) { -#ifdef INET6 - static unsigned char ipv64[12] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff}; - memcpy ((char *)ip + 12, ipv4 , 4); - memcpy ((char *)ip + 0, ipv64, 12); -#else - if ((char *)ip != (char *)ipv4) - memcpy (ip, ipv4, 4); -#endif + struct gaiwt_context *ctx = (struct gaiwt_context *)arg; + ctx->exit_code = getaddrinfo (ctx->node, ctx->service, ctx->hints, ctx->res); } -/* Detect whether an IP adress represents an IPv4 address and, if so, - copy it to IPV4. 0 is returned on failure. - This operation always succeeds when Wget is compiled without IPv6. - If IPV4 is NULL, don't copy, just detect. */ +/* 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. */ -int -map_ip_to_ipv4 (ip_address *ip, ip4_address *ipv4) +static int +getaddrinfo_with_timeout (const char *node, const char *service, + const struct addrinfo *hints, struct addrinfo **res, + double timeout) { -#ifdef INET6 - static unsigned char ipv64[12] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff}; - if (0 != memcmp (ip, ipv64, 12)) - return 0; - if (ipv4) - memcpy (ipv4, (char *)ip + 12, 4); -#else - if (ipv4) - memcpy (ipv4, (char *)ip, 4); -#endif - return 1; + 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)) + { + errno = ETIMEDOUT; + return EAI_SYSTEM; + } + 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. */ -char * -pretty_print_address (ip_address *addr) +const char * +pretty_print_address (const ip_address *addr) { -#ifdef INET6 - ip4_address addr4; - static char buf[128]; - - if (map_ip_to_ipv4 (addr, &addr4)) - return inet_ntoa (*(struct in_addr *)&addr4); - - if (!inet_ntop (AF_INET6, addr, buf, sizeof (buf))) - return ""; - return buf; + switch (addr->type) + { + 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 - return inet_ntoa (*(struct in_addr *)addr); + } + abort (); + return NULL; } /* Add host name HOST with the address ADDR_TEXT to the cache. @@ -493,7 +441,7 @@ cache_host_lookup (const char *host, struct address_list *al) ++al->refcount; hash_table_put (host_name_addresses_map, xstrdup_lower (host), al); -#ifdef DEBUG +#ifdef ENABLE_DEBUG if (opt.debug) { int i; @@ -505,98 +453,157 @@ cache_host_lookup (const char *host, struct address_list *al) #endif } +void +forget_host_lookup (const char *host) +{ + struct address_list *al = hash_table_get (host_name_addresses_map, host); + if (al) + { + address_list_release (al); + hash_table_remove (host_name_addresses_map, host); + } +} + struct address_list * -lookup_host (const char *host, int silent) +lookup_host (const char *host, int flags) { struct address_list *al = NULL; - unsigned long addr_ipv4; /* #### use a 32-bit type here. */ - ip_address addr; - /* First, try to check whether the address is already a numeric - address. */ +#ifdef ENABLE_IPV6 + int err, family; + struct addrinfo hints, *res; -#ifdef INET6 - if (inet_pton (AF_INET6, host, &addr) > 0) - return address_list_new_one (&addr); + /* 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 - - addr_ipv4 = (unsigned long)inet_addr (host); - if ((int)addr_ipv4 != -1) + + /* 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) { - /* ADDR is defined to be in network byte order, which is what - this returns, so we can just copy it to STORE_IP. However, - on big endian 64-bit architectures the value will be stored - in the *last*, not first four bytes. OFFSET makes sure that - we copy the correct four bytes. */ - int offset = 0; -#ifdef WORDS_BIGENDIAN - offset = sizeof (unsigned long) - sizeof (ip4_address); -#endif - map_ipv4_to_ip ((ip4_address *)((char *)&addr_ipv4 + offset), &addr); - return address_list_new_one (&addr); + al = address_list_from_addrinfo (res); + freeaddrinfo (res); + return al; } +#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) { 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; } } - if (!silent) + if (!(flags & LH_SILENT)) logprintf (LOG_VERBOSE, _("Resolving %s... "), host); - /* Host name lookup goes on below. #### We should implement - getaddrinfo_with_timeout and gethostbyname_with_timeout the same - way connect.c implements connect_with_timeout. */ + /* Host name lookup goes on below. */ -#ifdef INET6 +#ifdef ENABLE_IPV6 { - struct addrinfo hints, *ai; - int err; - - memset (&hints, 0, sizeof (hints)); - if (ip_default_family == AF_INET) - hints.ai_family = AF_INET; - else - hints.ai_family = PF_UNSPEC; + xzero (hints); + hints.ai_family = family; hints.ai_socktype = SOCK_STREAM; - err = getaddrinfo (host, NULL, &hints, &ai); + if (flags & LH_PASSIVE) + hints.ai_flags = AI_PASSIVE; - if (err != 0 || ai == NULL) + err = getaddrinfo_with_timeout (host, NULL, &hints, &res, opt.dns_timeout); + + if (err != 0 || res == NULL) { - if (!silent) - logprintf (LOG_VERBOSE, _("failed: %s.\n"), gai_strerror (err)); + 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 (ai); - freeaddrinfo (ai); + al = address_list_from_addrinfo (res); + freeaddrinfo (res); } #else { - struct hostent *hptr = gethostbyname (host); + struct hostent *hptr = gethostbyname_with_timeout (host, opt.dns_timeout); if (!hptr) { - if (!silent) - logprintf (LOG_VERBOSE, _("failed: %s.\n"), herrmsg (h_errno)); + 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; } - /* Do all systems have h_addr_list, or is it a newer thing? If - the latter, use address_list_new_one. */ - al = address_list_new (hptr->h_addr_list); + assert (hptr->h_length == 4); + /* Do older systems have h_addr_list? */ + al = address_list_from_ipv4_addresses (hptr->h_addr_list); } #endif - if (!silent) - logprintf (LOG_VERBOSE, _("done.\n")); + /* Print the addresses determined by DNS lookup, but no more than + three. */ + if (!(flags & LH_SILENT)) + { + 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. */ - cache_host_lookup (host, al); + if (opt.dns_cache) + cache_host_lookup (host, al); return al; }