-/* Dealing with host names.
- Copyright (C) 1995, 1996, 1997, 2000 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.
-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
+along with Wget; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
#include <config.h>
#else
# include <sys/socket.h>
# include <netinet/in.h>
-# include <arpa/inet.h>
+# ifndef __BEOS__
+# include <arpa/inet.h>
+# endif
# include <netdb.h>
#endif /* WINDOWS */
+#ifndef NO_ADDRESS
+#define NO_ADDRESS NO_DATA
+#endif
+
#ifdef HAVE_SYS_UTSNAME_H
# include <sys/utsname.h>
#endif
extern int errno;
#endif
-/* Mapping between all known hosts to their addresses (n.n.n.n). */
-struct hash_table *host_name_address_map;
+#ifndef h_errno
+# ifndef __CYGWIN__
+extern int h_errno;
+# endif
+#endif
+
+#define IP4_ADDRESS_LENGTH 4
+
+/* Mapping between known hosts and to lists of their addresses. */
+
+static struct hash_table *host_name_addresses_map;
+\f
+/* Lists of addresses. This should eventually be extended to handle
+ IPv6. */
-/* Mapping between all known addresses (n.n.n.n) to their hosts. This
- is the inverse of host_name_address_map. These two tables share
- the strdup'ed strings. */
-struct hash_table *host_address_name_map;
+struct address_list {
+ int count; /* number of adrresses */
+ unsigned char *buffer; /* buffer which holds all of them. */
-/* Mapping between auxilliary (slave) and master host names. */
-struct hash_table *host_slave_master_map;
+ int faulty; /* number of addresses known not to
+ work. */
+ int refcount; /* so we know whether to free it or
+ not. */
+};
-/* Utility function: like xstrdup(), but also lowercases S. */
+#define ADDR_LOCATION(al, index) ((al)->buffer + index * IP4_ADDRESS_LENGTH)
-static char *
-xstrdup_lower (const char *s)
+/* Get the bounds of the address list. */
+
+void
+address_list_get_bounds (struct address_list *al, int *start, int *end)
{
- char *copy = xstrdup (s);
- char *p = copy;
- for (; *p; p++)
- *p = TOLOWER (*p);
- return copy;
+ *start = al->faulty;
+ *end = al->count;
}
-/* The same as gethostbyname, but supports internet addresses of the
- form `N.N.N.N'. On some systems gethostbyname() knows how to do
- this automatically. */
-struct hostent *
-ngethostbyname (const char *name)
+/* Copy address number INDEX to IP_STORE. */
+
+void
+address_list_copy_one (struct address_list *al, int index,
+ unsigned char *ip_store)
{
- struct hostent *hp;
- unsigned long addr;
+ assert (index >= al->faulty && index < al->count);
+ memcpy (ip_store, ADDR_LOCATION (al, index), IP4_ADDRESS_LENGTH);
+}
- addr = (unsigned long)inet_addr (name);
- if ((int)addr != -1)
- hp = gethostbyaddr ((char *)&addr, sizeof (addr), AF_INET);
- else
- hp = gethostbyname (name);
- return hp;
+/* Check whether two address lists have all their IPs in common. */
+
+int
+address_list_match_all (struct address_list *al1, struct address_list *al2)
+{
+ if (al1 == al2)
+ return 1;
+ if (al1->count != al2->count)
+ return 0;
+ return 0 == memcmp (al1->buffer, al2->buffer,
+ al1->count * IP4_ADDRESS_LENGTH);
}
-/* Add host name HOST with the address ADDR_TEXT to the cache.
- Normally this means that the (HOST, ADDR_TEXT) pair will be to
- host_name_address_map and to host_address_name_map. (It is the
- caller's responsibility to make sure that HOST is not already in
- host_name_address_map.)
+/* 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)
+{
+#if 0
+ /* Warning: INDEX is unused, so this assumes that the address list
+ is traversed in order. In the next release, either enable this
+ assert, or use INDEX. */
+ assert (index == al->faulty);
+#endif
- If the ADDR_TEXT has already been seen and belongs to another host,
- HOST will be added to host_slave_master_map instead. */
+ ++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;
+}
+
+/* Create an address_list out of a NULL-terminated list of addresses,
+ as returned by gethostbyname. */
+
+static struct address_list *
+address_list_new (char **h_addr_list)
+{
+ int count = 0, i;
+
+ struct address_list *al = xmalloc (sizeof (struct address_list));
+
+ while (h_addr_list[count])
+ ++count;
+ assert (count > 0);
+ al->count = count;
+ al->faulty = 0;
+ al->buffer = xmalloc (count * IP4_ADDRESS_LENGTH);
+ al->refcount = 1;
+
+ for (i = 0; i < count; i++)
+ memcpy (ADDR_LOCATION (al, i), h_addr_list[i], IP4_ADDRESS_LENGTH);
+
+ return al;
+}
+
+/* Like address_list_new, but initialized with only one address. */
+
+static struct address_list *
+address_list_new_one (const char *addr)
+{
+ struct address_list *al = xmalloc (sizeof (struct address_list));
+ al->count = 1;
+ al->faulty = 0;
+ al->buffer = xmalloc (IP4_ADDRESS_LENGTH);
+ al->refcount = 1;
+ memcpy (ADDR_LOCATION (al, 0), addr, IP4_ADDRESS_LENGTH);
+
+ return al;
+}
static void
-add_host_to_cache (const char *host, const char *addr_text)
+address_list_delete (struct address_list *al)
+{
+ xfree (al->buffer);
+ xfree (al);
+}
+
+void
+address_list_release (struct address_list *al)
{
- char *canonical_name = hash_table_get (host_address_name_map, addr_text);
- if (canonical_name)
+ --al->refcount;
+ DEBUGP (("Releasing %p (new refcount %d).\n", al, al->refcount));
+ if (al->refcount <= 0)
{
- DEBUGP (("Mapping %s to %s in host_slave_master_map.\n",
- host, canonical_name));
- /* We've already dealt with that host under another name. */
- hash_table_put (host_slave_master_map,
- xstrdup_lower (host),
- xstrdup_lower (canonical_name));
+ DEBUGP (("Deleting unused %p.\n", al));
+ address_list_delete (al);
}
- else
+}
+\f
+/* The same as inet_ntoa, but without the need for a cast, or for
+ #including the netinet stuff. */
+
+char *
+pretty_print_address (const unsigned char *addr)
+{
+ return inet_ntoa (*(struct in_addr *)addr);
+}
+
+/* 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);
+
+#ifdef DEBUG
+ if (opt.debug)
{
- /* This is really the first time we're dealing with that host. */
- char *h_copy = xstrdup_lower (host);
- char *a_copy = xstrdup (addr_text);
- DEBUGP (("Caching %s <-> %s\n", h_copy, a_copy));
- hash_table_put (host_name_address_map, h_copy, a_copy);
- hash_table_put (host_address_name_map, a_copy, h_copy);
+ int i;
+ debug_logprintf ("Caching %s =>", host);
+ for (i = 0; i < al->count; i++)
+ debug_logprintf (" %s",
+ pretty_print_address (ADDR_LOCATION (al, i)));
+ debug_logprintf ("\n");
}
+#endif
}
-/* Store the address of HOSTNAME, internet-style (four octets in
- network order), to WHERE. First try to get the address from the
- cache; if it is not available, call the DNS functions and update
- the cache.
-
- Return 1 on successful finding of the hostname, 0 otherwise. */
-int
-store_hostaddress (unsigned char *where, const char *hostname)
+struct address_list *
+lookup_host (const char *host, int silent)
{
+ struct address_list *al = NULL;
unsigned long addr;
- char *addr_text;
- char *canonical_name;
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 we have the numeric address, just store it. */
+ /* If the address is of the form d.d.d.d, no further lookup is
+ needed. */
+ addr = (unsigned long)inet_addr (host);
if ((int)addr != -1)
{
- /* ADDR is defined to be in network byte order, meaning the code
- works on little and big endian 32-bit architectures without
- change. On big endian 64-bit architectures we need to be
- careful to copy the correct four bytes. */
+ /* 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;
- have_addr:
#ifdef WORDS_BIGENDIAN
- offset = sizeof (unsigned long) - 4;
+ offset = sizeof (unsigned long) - IP4_ADDRESS_LENGTH;
#else
offset = 0;
#endif
- memcpy (where, (char *)&addr + offset, 4);
- return 1;
+ return address_list_new_one ((char *)&addr + offset);
}
- /* By now we know that the address is not of the form d.d.d.d. Try
- to find it in our cache of host addresses. */
- addr_text = hash_table_get (host_name_address_map, hostname);
- if (addr_text)
- {
- DEBUGP (("Found %s in host_name_address_map: %s\n",
- hostname, addr_text));
- addr = (unsigned long)inet_addr (addr_text);
- goto have_addr;
- }
+ /* By now we know that the host name we got is not of the form
+ d.d.d.d. Try to find it in our cache of host names. */
+ if (host_name_addresses_map)
+ al = hash_table_get (host_name_addresses_map, host);
- /* Maybe this host is known to us under another name. If so, we'll
- find it in host_slave_master_map, and use the master name to find
- its address in host_name_address_map. */
- canonical_name = hash_table_get (host_slave_master_map, hostname);
- if (canonical_name)
+ if (al)
{
- addr_text = hash_table_get (host_name_address_map, canonical_name);
- assert (addr_text != NULL);
- DEBUGP (("Found %s as slave of %s -> %s\n",
- hostname, canonical_name, addr_text));
- addr = (unsigned long)inet_addr (addr_text);
- goto have_addr;
+ DEBUGP (("Found %s in host_name_addresses_map (%p)\n", host, al));
+ ++al->refcount;
+ return al;
}
- /* Since all else has failed, let's try gethostbyname(). Note that
- we use gethostbyname() rather than ngethostbyname(), because we
- already know that the address is not numerical. */
- hptr = gethostbyname (hostname);
- if (!hptr)
- return 0;
- /* Copy the address of the host to socket description. */
- memcpy (where, hptr->h_addr_list[0], hptr->h_length);
- assert (hptr->h_length == 4);
-
- /* Now that we've gone through the truoble of calling
- gethostbyname(), we can store this valuable information to the
- cache. 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));
- inet_s = inet_ntoa (in);
- add_host_to_cache (hostname, inet_s);
- return 1;
-}
+ if (!silent)
+ logprintf (LOG_VERBOSE, _("Resolving %s... "), host);
-/* 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. */
-char *
-realhost (const char *host)
-{
- struct in_addr in;
- struct hostent *hptr;
- char *master_name;
-
- DEBUGP (("Checking for %s in host_name_address_map.\n", host));
- if (hash_table_contains (host_name_address_map, host))
+ /* Look up the host using gethostbyname(). */
+ hptr = gethostbyname (host);
+ if (!hptr)
{
- DEBUGP (("Found; %s was already used, by that name.\n", host));
- return xstrdup_lower (host);
+ if (!silent)
+ logprintf (LOG_VERBOSE, _("failed: %s.\n"), herrmsg (h_errno));
+ return NULL;
}
- DEBUGP (("Checking for %s in host_slave_master_map.\n", host));
- master_name = hash_table_get (host_slave_master_map, host);
- if (master_name)
- {
- has_master:
- DEBUGP (("Found; %s was already used, by the name %s.\n",
- host, master_name));
- return xstrdup (master_name);
- }
+ if (!silent)
+ logprintf (LOG_VERBOSE, _("done.\n"));
- DEBUGP (("First time I hear about %s by that name; looking it up.\n",
- host));
- hptr = ngethostbyname (host);
- if (hptr)
- {
- char *inet_s;
- /* Originally, we copied to in.s_addr, but it appears to be
- missing on some systems. */
- memcpy (&in, *hptr->h_addr_list, sizeof (in));
- inet_s = inet_ntoa (in);
-
- add_host_to_cache (host, inet_s);
-
- /* add_host_to_cache() can establish a slave-master mapping. */
- DEBUGP (("Checking again for %s in host_slave_master_map.\n", host));
- master_name = hash_table_get (host_slave_master_map, host);
- if (master_name)
- goto has_master;
- }
+ /* 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);
- return xstrdup_lower (host);
-}
+ /* Cache the lookup information. */
+ cache_host_lookup (host, al);
-/* 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)
-{
- const char *s;
- char *p1, *p2;
- char *real1, *real2;
-
- /* Skip protocol, if present. */
- 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)
- {
- xfree (p1);
- xfree (p2);
- DEBUGP (("They are quite alike.\n"));
- return 1;
- }
- else if (opt.simple_check)
- {
- xfree (p1);
- xfree (p2);
- DEBUGP (("Since checking is simple, I'd say they are not the same.\n"));
- return 0;
- }
- real1 = realhost (p1);
- real2 = realhost (p2);
- xfree (p1);
- xfree (p2);
- if (strcasecmp (real1, real2) == 0)
- {
- DEBUGP (("They are alike, after realhost()->%s.\n", real1));
- xfree (real1);
- xfree (real2);
- return 1;
- }
- else
- {
- DEBUGP (("They are not the same (%s, %s).\n", real1, real2));
- xfree (real1);
- xfree (real2);
- return 0;
- }
+ return al;
}
-
+\f
/* 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)
return _("Unknown error");
}
-void
-clean_hosts (void)
+static int
+host_cleanup_mapper (void *key, void *value, void *arg_ignored)
{
- /* host_name_address_map and host_address_name_map share the
- strings. Because of that, calling free_keys_and_values once
- suffices for both. */
- free_keys_and_values (host_name_address_map);
- hash_table_destroy (host_name_address_map);
- hash_table_destroy (host_address_name_map);
- free_keys_and_values (host_slave_master_map);
- hash_table_destroy (host_slave_master_map);
+ struct address_list *al;
+
+ xfree (key); /* host */
+
+ al = (struct address_list *)value;
+ assert (al->refcount == 1);
+ address_list_delete (al);
+
+ return 0;
}
void
-host_init (void)
+host_cleanup (void)
{
- host_name_address_map = make_string_hash_table (0);
- host_address_name_map = make_string_hash_table (0);
- host_slave_master_map = make_string_hash_table (0);
+ if (host_name_addresses_map)
+ {
+ hash_table_map (host_name_addresses_map, host_cleanup_mapper, NULL);
+ hash_table_destroy (host_name_addresses_map);
+ host_name_addresses_map = NULL;
+ }
}
projects / wget / blobdiff