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
#ifdef WINDOWS
# include <winsock.h>
-# define SET_H_ERRNO(err) WSASetLastError(err)
+# define SET_H_ERRNO(err) WSASetLastError (err)
#else
# include <sys/socket.h>
# include <netinet/in.h>
#endif
#ifdef ENABLE_IPV6
-int ip_default_family = AF_INET6;
+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. */
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
al->faulty = 0;
}
-#ifdef HAVE_GETADDRINFO
+#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 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;
+
+ 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_from_vector, but initialized with a single
- address. */
-
-static struct address_list *
-address_list_from_single (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)
{
}
}
\f
-/**
- * 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)
-{
- 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 ENABLE_IPV6
- 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();
-}
-
-/**
- * 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)
-{
- if (sa->sa.sa_family == AF_INET)
- {
- sa->sin.sin_port = htons (port);
- return;
- }
-#ifdef ENABLE_IPV6
- if (sa->sa.sa_family == AF_INET6)
- {
- sa->sin6.sin6_port = htons (port);
- return;
- }
-#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 ENABLE_IPV6
- if (sa->sa.sa_family == AF_INET6)
- return &sa->sin6.sin6_addr;
-#endif
- abort();
- /* unreached */
- return NULL;
-}
-
-/**
- * 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 ENABLE_IPV6
- if (sa->sa.sa_family == AF_INET6)
- return htons (sa->sin6.sin6_port);
-#endif
- 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:
- * socklen_t structure length for socket options
- */
-socklen_t
-sockaddr_len ()
-{
- if (ip_default_family == AF_INET)
- return sizeof (struct sockaddr_in);
-#ifdef ENABLE_IPV6
- if (ip_default_family == AF_INET6)
- return sizeof (struct sockaddr_in6);
-#endif
- abort();
- /* do not complain about return nothing */
- return 0;
-}
-
-/**
- * Map an IPv4 adress to the internal adress format.
- */
-void
-map_ipv4_to_ip (ip4_address *ipv4, ip_address *ip)
-{
-#ifdef ENABLE_IPV6
- 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
-}
-
-/* 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. */
-
-int
-map_ip_to_ipv4 (ip_address *ip, ip4_address *ipv4)
-{
-#ifdef ENABLE_IPV6
- 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;
-}
-\f
/* Versions of gethostbyname and getaddrinfo that support timeout. */
#ifndef ENABLE_IPV6
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)
{
+ switch (addr->type)
+ {
+ case IPV4_ADDRESS:
+ return inet_ntoa (ADDRESS_IPV4_IN_ADDR (addr));
#ifdef ENABLE_IPV6
- 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 "<unknown>";
- return buf;
+ 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.
#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;
- uint32_t addr_ipv4;
- ip_address addr;
-
- /* First, try to check whether the address is already a numeric
- address. */
#ifdef ENABLE_IPV6
- if (inet_pton (AF_INET6, host, &addr) > 0)
- return address_list_from_single (&addr);
+ 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 (!).
- addr_ipv4 = (uint32_t)inet_addr (host);
- if (addr_ipv4 != (uint32_t)-1)
+ 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. */
- map_ipv4_to_ip ((ip4_address *)&addr_ipv4, &addr);
- return address_list_from_single (&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)
{
{
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. */
-#ifdef HAVE_GETADDRINFO
+#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_with_timeout (host, NULL, &hints, &ai, opt.dns_timeout);
+ if (flags & LH_PASSIVE)
+ hints.ai_flags = AI_PASSIVE;
+
+ err = getaddrinfo_with_timeout (host, NULL, &hints, &res, opt.dns_timeout);
- if (err != 0 || ai == NULL)
+ if (err != 0 || res == NULL)
{
- if (!silent)
+ 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;
- hptr = gethostbyname_with_timeout (host, opt.dns_timeout);
+ struct hostent *hptr = gethostbyname_with_timeout (host, opt.dns_timeout);
if (!hptr)
{
- if (!silent)
+ if (!(flags & LH_SILENT))
{
if (errno != ETIMEDOUT)
logprintf (LOG_VERBOSE, _("failed: %s.\n"), herrmsg (h_errno));
}
return NULL;
}
- /* 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);
+ 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 (!silent)
+ if (!(flags & LH_SILENT))
{
int i;
int printmax = al->count <= 3 ? al->count : 3;
projects / wget / blobdiff