X-Git-Url: http://sjero.net/git/?a=blobdiff_plain;f=src%2Fhost.c;h=ab490421ae09866c2cf451db83629001719ed60d;hb=5f0a2b3f0846dd4c2f72fc62e7171200d1fd6e06;hp=d0fd7e7c948e849c71dbfef4d3f6bcd57dc9f989;hpb=90cb3309da2d5eaa65f5477bd45b30d2d18996db;p=wget diff --git a/src/host.c b/src/host.c index d0fd7e7c..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 @@ -99,7 +99,11 @@ 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. */ @@ -111,55 +115,78 @@ address_list_get_bounds (const struct address_list *al, int *start, int *end) *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 (const 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 (const struct address_list *al1, const 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) { -#ifdef ENABLE_IPv6 - if (al1->addresses[i].type != al2->addresses[i].type) + const ip_address *ip1 = &al1->addresses[i]; + const ip_address *ip2 = &al2->addresses[i]; + + if (ip1->type != ip2->type) return 0; - if (al1->addresses[i].type == IPv6_ADDRESS) - { - const struct in6_addr *addr1 = &al1->addresses[i].addr.ipv6.addr; - const struct in6_addr *addr2 = &al2->addresses[i].addr.ipv6.addr; + 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 ((al1->addresses[i].address.scope_id - != al2->addresses[i].address.scope_id) - || !IN6_ARE_ADDR_EQUAL (addr1, addr2)) -#else - if (!IN6_ARE_ADDR_EQUAL (addr1, addr2)) -#endif + if (ADDRESS_IPV6_SCOPE (ip1) != ADDRESS_IPV6_SCOPE (ip2)) return 0; - } - else -#endif - { - const struct in_addr *addr1 = (const struct in_addr *)&al1->addresses[i].addr.ipv4.addr; - const struct in_addr *addr2 = (const struct in_addr *)&al2->addresses[i].addr.ipv4.addr; - - if (addr1->s_addr != addr2->s_addr) +#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 @@ -189,7 +216,7 @@ address_list_set_faulty (struct address_list *al, int index) * 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 @@ -199,83 +226,70 @@ address_list_from_addrinfo (const struct addrinfo *ai) { struct address_list *al; const struct addrinfo *ptr; - int cnt = 0; - int i; + 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 = 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, ptr = ai; ptr != NULL; ptr = ptr->ai_next) + 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; - al->addresses[i].addr.ipv6.addr = sin6->sin6_addr; - al->addresses[i].type = IPv6_ADDRESS; + ip->type = IPV6_ADDRESS; + ADDRESS_IPV6_IN6_ADDR (ip) = sin6->sin6_addr; #ifdef HAVE_SOCKADDR_IN6_SCOPE_ID - al->addresses[i].addr.ipv6.scope_id = sin6->sin6_scope_id; + ADDRESS_IPV6_SCOPE (ip) = sin6->sin6_scope_id; #endif - ++i; + ++ip; } else if (ptr->ai_family == AF_INET) { const struct sockaddr_in *sin = (const struct sockaddr_in *)ptr->ai_addr; - al->addresses[i].addr.ipv4.addr = sin->sin_addr; - al->addresses[i].type = IPv4_ADDRESS; - ++i; + 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 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 **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; - - for (i = 0; i < count; i++) { - /* Mauro Tortonesi: is this safe? */ - memcpy (&((al->addresses + i)->addr.ipv4.addr.s_addr), h_addr_list[i], 4); - (al->addresses + i)->type = IPv4_ADDRESS; - } - return al; -} + al->addresses = xnew_array (ip_address, count); + al->count = count; + al->refcount = 1; -/* 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->refcount = 1; - memcpy (al->addresses, addr, sizeof (ip_address)); + 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); + } return al; } @@ -300,196 +314,6 @@ address_list_release (struct address_list *al) } } -/** - * sockaddr_set_address - * - * This function takes a sockaddr struct and fills in the protocol type, - * the port number and the address. If ENABLE_IPV6 is defined, the sa - * parameter should point to a sockaddr_storage structure; if not, it - * should point to a sockaddr_in structure. - * If the address parameter is NULL, the function will use the unspecified - * address (0.0.0.0 for IPv4 and :: for IPv6). - * Unsupported address family will abort the whole programm. - * - * Input: - * struct sockaddr* The space to be filled - * unsigned short The port - * const ip_address The IP address - * - * Return: - * - Only modifies 1st parameter. - */ -void -sockaddr_set_address (struct sockaddr *sa, unsigned short port, - const ip_address *addr) -{ - if (addr->type == IPv4_ADDRESS) - { - struct sockaddr_in *sin = (struct sockaddr_in *)sa; - - sin->sin_family = AF_INET; - sin->sin_port = htons (port); - if (addr == NULL) - sin->sin_addr.s_addr = INADDR_ANY; - else - sin->sin_addr = addr->addr.ipv4.addr; - } -#ifdef ENABLE_IPV6 - else if (addr->type == IPv6_ADDRESS) - { - struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa; - - sin6->sin6_family = AF_INET6; - sin6->sin6_port = htons (port); - if (addr == NULL) - sin6->sin6_addr = in6addr_any; - else - sin6->sin6_addr = addr->addr.ipv6.addr; -#ifdef HAVE_SOCKADDR_IN6_SCOPE_ID - sin6->sin6_scope_id = addr->addr.ipv6.scope_id; -#endif /* HAVE_SOCKADDR_IN6_SCOPE_ID */ - } -#endif /* ENABLE_IPV6 */ - else - abort (); -} - -void -sockaddr_get_address (const struct sockaddr *sa, unsigned short *port, - ip_address *addr) -{ - if (sa->sa_family == AF_INET) - { - struct sockaddr_in *sin = (struct sockaddr_in *)sa; - - addr->type = IPv4_ADDRESS; - addr->addr.ipv4.addr = sin->sin_addr; - if (port != NULL) - *port = ntohs (sin->sin_port); - } -#ifdef ENABLE_IPV6 - else if (sa->sa_family == AF_INET6) - { - struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa; - - addr->type = IPv6_ADDRESS; - addr->addr.ipv6.addr = sin6->sin6_addr; -#ifdef HAVE_SOCKADDR_IN6_SCOPE_ID - addr->addr.ipv6.scope_id = sin6->sin6_scope_id; -#endif - if (port != NULL) - *port = ntohs (sin6->sin6_port); - } -#endif - else - abort (); -} - -#if 0 /* currently unused */ -/** - * 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 -sockaddr_set_port (struct sockaddr *sa, unsigned short port) -{ - if (sa->sa_family == AF_INET) - { - struct sockaddr_in *sin = (struct sockaddr_in *)sa; - sin->sin_port = htons (port); - } -#ifdef ENABLE_IPV6 - else if (sa->sa_family == AF_INET6) - { - struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa; - sin6->sin6_port = htons (port); - } -#endif - else - abort (); -} -#endif - -/** - * 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 -sockaddr_get_port (const struct sockaddr *sa) -{ - if (sa->sa_family == AF_INET) { - const struct sockaddr_in *sin = (const struct sockaddr_in *)sa; - return htons (sin->sin_port); -#ifdef ENABLE_IPV6 - } else if (sa->sa_family == AF_INET6) { - const struct sockaddr_in6 *sin6 = (const struct sockaddr_in6 *)sa; - return htons (sin6->sin6_port); -#endif - } else - abort (); - /* do not complain about return nothing */ - return -1; -} - -/** - * 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 - */ -socklen_t -sockaddr_len (const struct sockaddr *sa) -{ - if (sa->sa_family == AF_INET) - { - return sizeof (struct sockaddr_in); - } -#ifdef ENABLE_IPV6 - else if (sa->sa_family == AF_INET6) - { - return sizeof (struct sockaddr_in6); - } -#endif - else - abort (); - /* do not complain about return nothing */ - return 0; -} - /* Versions of gethostbyname and getaddrinfo that support timeout. */ #ifndef ENABLE_IPV6 @@ -578,21 +402,23 @@ pretty_print_address (const ip_address *addr) { switch (addr->type) { - case IPv4_ADDRESS: - return inet_ntoa (addr->addr.ipv4.addr); + case IPV4_ADDRESS: + return inet_ntoa (ADDRESS_IPV4_IN_ADDR (addr)); #ifdef ENABLE_IPV6 - case IPv6_ADDRESS: + case IPV6_ADDRESS: { - int len; static char buf[128]; - inet_ntop (AF_INET6, &addr->addr.ipv6.addr, buf, sizeof (buf)); + inet_ntop (AF_INET6, &ADDRESS_IPV6_IN6_ADDR (addr), buf, sizeof (buf)); #if 0 #ifdef HAVE_SOCKADDR_IN6_SCOPE_ID - /* print also scope_id for all ?non-global? addresses */ - snprintf (buf + len, sizeof (buf) - len, "%%%d", addr->addr.ipv6.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 - len = strlen (buf); buf[sizeof (buf) - 1] = '\0'; return buf; } @@ -627,6 +453,17 @@ 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 flags) { @@ -636,23 +473,26 @@ lookup_host (const char *host, int flags) int err, family; struct addrinfo hints, *res; - /* This ip_default_family+flags business looks like bad design to - me. This function should rather accept a FAMILY argument. */ - if (flags & LH_IPv4_ONLY) + /* 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) + 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. Where getaddrinfo is available, we do it using the - AI_NUMERICHOST flag. Without IPv6, we check whether inet_addr - succeeds. */ + 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 - memset (&hints, 0, sizeof (hints)); + xzero (hints); hints.ai_family = family; hints.ai_socktype = SOCK_STREAM; hints.ai_flags = AI_NUMERICHOST; @@ -675,14 +515,11 @@ lookup_host (const char *host, int flags) if (addr_ipv4 != (uint32_t) -1) { /* The return value of inet_addr is in network byte order, so - we can just copy it to ADDR. */ - ip_address addr; - /* This has a huge number of dereferences because C doesn't - support anonymous unions and because struct in_addr adds a - cast. */ - addr.addr.ipv4.addr.s_addr = addr_ipv4; - addr.type = IPv4_ADDRESS; - return address_list_from_single (&addr); + 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 @@ -696,6 +533,7 @@ lookup_host (const char *host, int flags) { DEBUGP (("Found %s in host_name_addresses_map (%p)\n", host, al)); ++al->refcount; + al->from_cache = 1; return al; } } @@ -707,7 +545,7 @@ lookup_host (const char *host, int flags) #ifdef ENABLE_IPV6 { - memset (&hints, 0, sizeof (hints)); + xzero (hints); hints.ai_family = family; hints.ai_socktype = SOCK_STREAM; if (flags & LH_PASSIVE) @@ -740,9 +578,8 @@ lookup_host (const char *host, int flags) 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