/* Host name resolution and matching.
- Copyright (C) 1995, 1996, 1997, 2000, 2001 Free Software Foundation, Inc.
+ Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
+ 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Free Software Foundation,
+ Inc.
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
+the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
GNU Wget is distributed in the hope that it will be useful,
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.
+along with Wget. If not, see <http://www.gnu.org/licenses/>.
-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. */
+Additional permission under GNU GPL version 3 section 7
-#include <config.h>
+If you modify this program, or any covered work, by linking or
+combining it with the OpenSSL project's OpenSSL library (or a
+modified version of that library), containing parts covered by the
+terms of the OpenSSL or SSLeay licenses, the Free Software Foundation
+grants you additional permission to convey the resulting work.
+Corresponding Source for a non-source form of such a combination
+shall include the source code for the parts of OpenSSL used as well
+as that of the covered work. */
-#ifndef WINDOWS
-#include <netdb.h>
-#endif
+#include "wget.h"
#include <stdio.h>
#include <stdlib.h>
-#ifdef HAVE_STRING_H
-# include <string.h>
-#else
-# include <strings.h>
-#endif
+#include <string.h>
#include <assert.h>
-#include <sys/types.h>
#ifndef WINDOWS
+# include <sys/types.h>
# include <sys/socket.h>
# include <netinet/in.h>
# ifndef __BEOS__
# include <arpa/inet.h>
# endif
-# include <netdb.h>
+# ifdef __VMS
+# include "vms_ip.h"
+# else /* def __VMS */
+# include <netdb.h>
+# endif /* def __VMS [else] */
# define SET_H_ERRNO(err) ((void)(h_errno = (err)))
#else /* WINDOWS */
+# include <winsock2.h>
+# include <ws2tcpip.h>
# define SET_H_ERRNO(err) WSASetLastError (err)
#endif /* WINDOWS */
#include <errno.h>
-#include "wget.h"
#include "utils.h"
#include "host.h"
#include "url.h"
#include "hash.h"
-#include "connect.h" /* for socket_has_inet6 */
-#ifndef errno
-extern int errno;
+#ifndef NO_ADDRESS
+# define NO_ADDRESS NO_DATA
#endif
-#ifndef h_errno
-# ifndef __CYGWIN__
+#if !HAVE_DECL_H_ERRNO && !defined(WINDOWS)
extern int h_errno;
-# endif
#endif
-#ifndef NO_ADDRESS
-# define NO_ADDRESS NO_DATA
-#endif
/* Lists of IP addresses that result from running DNS queries. See
lookup_host for details. */
struct address_list {
- int count; /* number of adrresses */
- ip_address *addresses; /* pointer to the string of addresses */
+ int count; /* number of adrresses */
+ ip_address *addresses; /* pointer to the string of addresses */
- int faulty; /* number of addresses known not to work. */
- int connected; /* whether we were able to connect to
- one of the addresses in the list,
- at least once. */
+ int faulty; /* number of addresses known not to work. */
+ bool connected; /* whether we were able to connect to
+ one of the addresses in the list,
+ at least once. */
- int refcount; /* reference count; when it drops to
- 0, the entry is freed. */
+ int refcount; /* reference count; when it drops to
+ 0, the entry is freed. */
};
/* Get the bounds of the address list. */
return al->addresses + pos;
}
-/* Return non-zero if AL contains IP, zero otherwise. */
+/* Return true if AL contains IP, false otherwise. */
-int
+bool
address_list_contains (const struct address_list *al, const ip_address *ip)
{
int i;
- switch (ip->type)
+ switch (ip->family)
{
- case IPV4_ADDRESS:
+ case AF_INET:
for (i = 0; i < al->count; i++)
- {
- ip_address *cur = al->addresses + i;
- if (cur->type == IPV4_ADDRESS
- && (ADDRESS_IPV4_IN_ADDR (cur).s_addr
- ==
- ADDRESS_IPV4_IN_ADDR (ip).s_addr))
- return 1;
- }
- return 0;
+ {
+ ip_address *cur = al->addresses + i;
+ if (cur->family == AF_INET
+ && (cur->data.d4.s_addr == ip->data.d4.s_addr))
+ return true;
+ }
+ return false;
#ifdef ENABLE_IPV6
- case IPV6_ADDRESS:
+ case AF_INET6:
for (i = 0; i < al->count; i++)
- {
- ip_address *cur = al->addresses + i;
- if (cur->type == IPV6_ADDRESS
+ {
+ ip_address *cur = al->addresses + i;
+ if (cur->family == AF_INET6
#ifdef HAVE_SOCKADDR_IN6_SCOPE_ID
- && ADDRESS_IPV6_SCOPE (cur) == ADDRESS_IPV6_SCOPE (ip)
+ && cur->ipv6_scope == ip->ipv6_scope
#endif
- && IN6_ARE_ADDR_EQUAL (&ADDRESS_IPV6_IN6_ADDR (cur),
- &ADDRESS_IPV6_IN6_ADDR (ip)))
- return 1;
- }
- return 0;
+ && IN6_ARE_ADDR_EQUAL (&cur->data.d6, &ip->data.d6))
+ return true;
+ }
+ return false;
#endif /* ENABLE_IPV6 */
default:
abort ();
void
address_list_set_connected (struct address_list *al)
{
- al->connected = 1;
+ al->connected = true;
}
/* Return the value of the "connected" flag. */
-int
+bool
address_list_connected_p (const struct address_list *al)
{
return al->connected;
ip = al->addresses;
for (ptr = ai; ptr != NULL; ptr = ptr->ai_next)
- if (ptr->ai_family == AF_INET6)
+ 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;
+ const struct sockaddr_in6 *sin6 =
+ (const struct sockaddr_in6 *)ptr->ai_addr;
+ ip->family = AF_INET6;
+ ip->data.d6 = sin6->sin6_addr;
#ifdef HAVE_SOCKADDR_IN6_SCOPE_ID
- ADDRESS_IPV6_SCOPE (ip) = sin6->sin6_scope_id;
+ ip->ipv6_scope = sin6->sin6_scope_id;
#endif
- ++ip;
- }
+ ++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;
+ const struct sockaddr_in *sin =
+ (const struct sockaddr_in *)ptr->ai_addr;
+ ip->family = AF_INET;
+ ip->data.d4 = sin->sin_addr;
+ ++ip;
}
assert (ip - al->addresses == cnt);
return al;
}
-#define IS_IPV4(addr) (((const ip_address *) addr)->type == IPV4_ADDRESS)
+#define IS_IPV4(addr) (((const ip_address *) addr)->family == AF_INET)
-/* Compare two IP addresses by type, giving preference to the IPv4
+/* Compare two IP addresses by family, giving preference to the IPv4
address (sorting it first). In other words, return -1 if ADDR1 is
IPv4 and ADDR2 is IPv6, +1 if ADDR1 is IPv6 and ADDR2 is IPv4, and
0 otherwise.
return !IS_IPV4 (addr1) - !IS_IPV4 (addr2);
}
-#define IS_IPV6(addr) (((const ip_address *) addr)->type == IPV6_ADDRESS)
+#define IS_IPV6(addr) (((const ip_address *) addr)->family == AF_INET6)
/* Like the above, but give preference to the IPv6 address. */
for (i = 0; i < count; i++)
{
ip_address *ip = &al->addresses[i];
- ip->type = IPV4_ADDRESS;
- memcpy (ADDRESS_IPV4_DATA (ip), vec[i], 4);
+ ip->family = AF_INET;
+ memcpy (IP_INADDR_DATA (ip), vec[i], 4);
}
return al;
{
--al->refcount;
DEBUGP (("Releasing 0x%0*lx (new refcount %d).\n", PTR_FORMAT (al),
- al->refcount));
+ al->refcount));
if (al->refcount <= 0)
{
DEBUGP (("Deleting unused 0x%0*lx.\n", PTR_FORMAT (al)));
}
/* Print error messages for host errors. */
-static char *
+static const char *
host_errstr (int error)
{
/* Can't use switch since some of these constants can be equal,
static int
getaddrinfo_with_timeout (const char *node, const char *service,
- const struct addrinfo *hints, struct addrinfo **res,
- double timeout)
+ const struct addrinfo *hints, struct addrinfo **res,
+ double timeout)
{
struct gaiwt_context ctx;
ctx.node = node;
#endif /* ENABLE_IPV6 */
\f
-/* 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. */
+/* Return a textual representation of ADDR, i.e. the dotted quad for
+ IPv4 addresses, and the colon-separated list of hex words (with all
+ zeros omitted, etc.) for IPv6 addresses. */
const char *
-pretty_print_address (const ip_address *addr)
+print_address (const ip_address *addr)
{
- 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;
- }
+ static char buf[64];
+ if (!inet_ntop (addr->family, IP_INADDR_DATA (addr), buf, sizeof buf))
+ snprintf (buf, sizeof buf, "<error: %s>", strerror (errno));
+ return buf;
+#else
+ return inet_ntoa (addr->data.d4);
#endif
- }
- abort ();
}
-/* The following two functions were adapted from glibc. */
+/* The following two functions were adapted from glibc's
+ implementation of inet_pton, written by Paul Vixie. */
-static int
+static bool
is_valid_ipv4_address (const char *str, const char *end)
{
- int saw_digit = 0;
+ bool saw_digit = false;
int octets = 0;
int val = 0;
int ch = *str++;
if (ch >= '0' && ch <= '9')
- {
- val = val * 10 + (ch - '0');
-
- if (val > 255)
- return 0;
- if (saw_digit == 0)
- {
- if (++octets > 4)
- return 0;
- saw_digit = 1;
- }
- }
- else if (ch == '.' && saw_digit == 1)
- {
- if (octets == 4)
- return 0;
- val = 0;
- saw_digit = 0;
- }
+ {
+ val = val * 10 + (ch - '0');
+
+ if (val > 255)
+ return false;
+ if (!saw_digit)
+ {
+ if (++octets > 4)
+ return false;
+ saw_digit = true;
+ }
+ }
+ else if (ch == '.' && saw_digit)
+ {
+ if (octets == 4)
+ return false;
+ val = 0;
+ saw_digit = false;
+ }
else
- return 0;
+ return false;
}
if (octets < 4)
- return 0;
-
- return 1;
+ return false;
+
+ return true;
}
-int
+bool
is_valid_ipv6_address (const char *str, const char *end)
{
/* Use lower-case for these to avoid clash with system headers. */
const char *curtok;
int tp;
const char *colonp;
- int saw_xdigit;
+ bool saw_xdigit;
unsigned int val;
tp = 0;
colonp = NULL;
if (str == end)
- return 0;
-
+ return false;
+
/* Leading :: requires some special handling. */
if (*str == ':')
{
++str;
if (str == end || *str != ':')
- return 0;
+ return false;
}
curtok = str;
- saw_xdigit = 0;
+ saw_xdigit = false;
val = 0;
while (str < end)
int ch = *str++;
/* if ch is a number, add it to val. */
- if (ISXDIGIT (ch))
- {
- val <<= 4;
- val |= XDIGIT_TO_NUM (ch);
- if (val > 0xffff)
- return 0;
- saw_xdigit = 1;
- continue;
- }
+ if (c_isxdigit (ch))
+ {
+ val <<= 4;
+ val |= XDIGIT_TO_NUM (ch);
+ if (val > 0xffff)
+ return false;
+ saw_xdigit = true;
+ continue;
+ }
/* if ch is a colon ... */
if (ch == ':')
- {
- curtok = str;
- if (saw_xdigit == 0)
- {
- if (colonp != NULL)
- return 0;
- colonp = str + tp;
- continue;
- }
- else if (str == end)
- return 0;
- if (tp > ns_in6addrsz - ns_int16sz)
- return 0;
- tp += ns_int16sz;
- saw_xdigit = 0;
- val = 0;
- continue;
- }
+ {
+ curtok = str;
+ if (!saw_xdigit)
+ {
+ if (colonp != NULL)
+ return false;
+ colonp = str + tp;
+ continue;
+ }
+ else if (str == end)
+ return false;
+ if (tp > ns_in6addrsz - ns_int16sz)
+ return false;
+ tp += ns_int16sz;
+ saw_xdigit = false;
+ val = 0;
+ continue;
+ }
/* if ch is a dot ... */
if (ch == '.' && (tp <= ns_in6addrsz - ns_inaddrsz)
- && is_valid_ipv4_address (curtok, end) == 1)
- {
- tp += ns_inaddrsz;
- saw_xdigit = 0;
- break;
- }
-
- return 0;
+ && is_valid_ipv4_address (curtok, end) == 1)
+ {
+ tp += ns_inaddrsz;
+ saw_xdigit = false;
+ break;
+ }
+
+ return false;
}
- if (saw_xdigit == 1)
+ if (saw_xdigit)
{
- if (tp > ns_in6addrsz - ns_int16sz)
- return 0;
+ if (tp > ns_in6addrsz - ns_int16sz)
+ return false;
tp += ns_int16sz;
}
if (colonp != NULL)
{
- if (tp == ns_in6addrsz)
- return 0;
+ if (tp == ns_in6addrsz)
+ return false;
tp = ns_in6addrsz;
}
if (tp != ns_in6addrsz)
- return 0;
+ return false;
- return 1;
+ return true;
}
\f
/* Simple host cache, used by lookup_host to speed up resolving. The
++al->refcount;
hash_table_put (host_name_addresses_map, xstrdup_lower (host), al);
-#ifdef ENABLE_DEBUG
- if (opt.debug)
+ IF_DEBUG
{
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 (" %s", print_address (al->addresses + i));
debug_logprintf ("\n");
}
-#endif
}
/* Remove HOST from the DNS cache. Does nothing is HOST is not in
LH_SILENT - don't print the "resolving ... done" messages.
LH_BIND - resolve addresses for use with bind, which under
IPv6 means to use AI_PASSIVE flag to getaddrinfo.
- Passive lookups are not cached under IPv6.
+ Passive lookups are not cached under IPv6.
LH_REFRESH - if HOST is cached, remove the entry from the cache
and resolve it anew. */
lookup_host (const char *host, int flags)
{
struct address_list *al;
- int silent = flags & LH_SILENT;
- int use_cache;
- int numeric_address = 0;
+ bool silent = !!(flags & LH_SILENT);
+ bool use_cache;
+ bool numeric_address = false;
double timeout = opt.dns_timeout;
#ifndef ENABLE_IPV6
uint32_t addr_ipv4 = (uint32_t)inet_addr (host);
if (addr_ipv4 != (uint32_t) -1)
{
- /* No need to cache host->addr relation, just return the
- address. */
- char *vec[2];
- vec[0] = (char *)&addr_ipv4;
- vec[1] = NULL;
- return address_list_from_ipv4_addresses (vec);
+ /* No need to cache host->addr relation, just return the
+ address. */
+ char *vec[2];
+ vec[0] = (char *)&addr_ipv4;
+ vec[1] = NULL;
+ return address_list_from_ipv4_addresses (vec);
}
}
#else /* ENABLE_IPV6 */
{
const char *end = host + strlen (host);
if (is_valid_ipv4_address (host, end) || is_valid_ipv6_address (host, end))
- numeric_address = 1;
+ numeric_address = true;
}
#endif
use_cache = opt.dns_cache;
#ifdef ENABLE_IPV6
if ((flags & LH_BIND) || numeric_address)
- use_cache = 0;
+ use_cache = false;
#endif
/* Try to find the host in the cache so we don't need to talk to the
if (use_cache)
{
if (!(flags & LH_REFRESH))
- {
- al = cache_query (host);
- if (al)
- return al;
- }
+ {
+ al = cache_query (host);
+ if (al)
+ return al;
+ }
else
- cache_remove (host);
+ cache_remove (host);
}
/* No luck with the cache; resolve HOST. */
if (!silent && !numeric_address)
- logprintf (LOG_VERBOSE, _("Resolving %s... "), escnonprint (host));
+ {
+ char *str = NULL, *name;
+
+ if (opt.enable_iri && (name = idn_decode ((char *) host)) != NULL)
+ {
+ int len = strlen (host) + strlen (name) + 4;
+ str = xmalloc (len);
+ snprintf (str, len, "%s (%s)", name, host);
+ str[len-1] = '\0';
+ xfree (name);
+ }
+
+ logprintf (LOG_VERBOSE, _("Resolving %s... "),
+ quotearg_style (escape_quoting_style, str ? str : host));
+
+ if (str)
+ xfree (str);
+ }
#ifdef ENABLE_IPV6
{
else if (opt.ipv6_only)
hints.ai_family = AF_INET6;
else
- {
- hints.ai_family = AF_UNSPEC;
-#ifdef AI_ADDRCONFIG
- hints.ai_flags |= AI_ADDRCONFIG;
-#else
- /* On systems without AI_ADDRCONFIG, emulate it by manually
- checking whether the system supports IPv6 sockets. */
- if (!socket_has_inet6 ())
- hints.ai_family = AF_INET;
-#endif
- }
+ /* We tried using AI_ADDRCONFIG, but removed it because: it
+ misinterprets IPv6 loopbacks, it is broken on AIX 5.1, and
+ it's unneeded since we sort the addresses anyway. */
+ hints.ai_family = AF_UNSPEC;
+
if (flags & LH_BIND)
hints.ai_flags |= AI_PASSIVE;
#ifdef AI_NUMERICHOST
if (numeric_address)
{
- /* Where available, the AI_NUMERICHOST hint can prevent costly
- access to DNS servers. */
- hints.ai_flags |= AI_NUMERICHOST;
- timeout = 0; /* no timeout needed when "resolving"
- numeric hosts -- avoid setting up
- signal handlers and such. */
+ /* Where available, the AI_NUMERICHOST hint can prevent costly
+ access to DNS servers. */
+ hints.ai_flags |= AI_NUMERICHOST;
+ timeout = 0; /* no timeout needed when "resolving"
+ numeric hosts -- avoid setting up
+ signal handlers and such. */
}
#endif
err = getaddrinfo_with_timeout (host, NULL, &hints, &res, timeout);
if (err != 0 || res == NULL)
{
- if (!silent)
- logprintf (LOG_VERBOSE, _("failed: %s.\n"),
- err != EAI_SYSTEM ? gai_strerror (err) : strerror (errno));
- return NULL;
+ if (!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);
if (!al)
{
- logprintf (LOG_VERBOSE,
- _("failed: No IPv4/IPv6 addresses for host.\n"));
- return NULL;
+ logprintf (LOG_VERBOSE,
+ _("failed: No IPv4/IPv6 addresses for host.\n"));
+ return NULL;
}
/* Reorder addresses so that IPv4 ones (or IPv6 ones, as per
the addresses with the same family is undisturbed. */
if (al->count > 1 && opt.prefer_family != prefer_none)
stable_sort (al->addresses, al->count, sizeof (ip_address),
- opt.prefer_family == prefer_ipv4
- ? cmp_prefer_ipv4 : cmp_prefer_ipv6);
+ opt.prefer_family == prefer_ipv4
+ ? cmp_prefer_ipv4 : cmp_prefer_ipv6);
}
#else /* not ENABLE_IPV6 */
{
struct hostent *hptr = gethostbyname_with_timeout (host, timeout);
if (!hptr)
{
- if (!silent)
- {
- if (errno != ETIMEDOUT)
- logprintf (LOG_VERBOSE, _("failed: %s.\n"),
- host_errstr (h_errno));
- else
- logputs (LOG_VERBOSE, _("failed: timed out.\n"));
- }
- return NULL;
+ if (!silent)
+ {
+ if (errno != ETIMEDOUT)
+ logprintf (LOG_VERBOSE, _("failed: %s.\n"),
+ host_errstr (h_errno));
+ else
+ logputs (LOG_VERBOSE, _("failed: timed out.\n"));
+ }
+ return NULL;
}
/* Do older systems have h_addr_list? */
al = address_list_from_ipv4_addresses (hptr->h_addr_list);
#endif /* not ENABLE_IPV6 */
/* Print the addresses determined by DNS lookup, but no more than
- three. */
+ three if show_all_dns_entries is not specified. */
if (!silent && !numeric_address)
{
int i;
- int printmax = al->count <= 3 ? al->count : 3;
+ int printmax = al->count;
+
+ if (!opt.show_all_dns_entries && printmax > 3)
+ printmax = 3;
+
for (i = 0; i < printmax; i++)
- {
- logprintf (LOG_VERBOSE, "%s",
- pretty_print_address (al->addresses + i));
- if (i < printmax - 1)
- logputs (LOG_VERBOSE, ", ");
- }
+ {
+ logputs (LOG_VERBOSE, print_address (al->addresses + i));
+ if (i < printmax - 1)
+ logputs (LOG_VERBOSE, ", ");
+ }
if (printmax != al->count)
- logputs (LOG_VERBOSE, ", ...");
+ logputs (LOG_VERBOSE, ", ...");
logputs (LOG_VERBOSE, "\n");
}
\f
/* Determine whether a URL is acceptable to be followed, according to
a list of domains to accept. */
-int
+bool
accept_domain (struct url *u)
{
assert (u->host != NULL);
if (opt.domains)
{
if (!sufmatch ((const char **)opt.domains, u->host))
- return 0;
+ return false;
}
if (opt.exclude_domains)
{
if (sufmatch ((const char **)opt.exclude_domains, u->host))
- return 0;
+ return false;
}
- return 1;
+ return true;
}
/* Check whether WHAT is matched in LIST, each element of LIST being a
match_backwards() in utils.c).
If an element of LIST matched, 1 is returned, 0 otherwise. */
-int
+bool
sufmatch (const char **list, const char *what)
{
int i, j, k, lw;
lw = strlen (what);
for (i = 0; list[i]; i++)
{
+ if (list[i][0] == '\0')
+ continue;
+
for (j = strlen (list[i]), k = lw; j >= 0 && k >= 0; j--, k--)
- if (TOLOWER (list[i][j]) != TOLOWER (what[k]))
- break;
+ if (c_tolower (list[i][j]) != c_tolower (what[k]))
+ break;
/* The domain must be first to reach to beginning. */
if (j == -1)
- return 1;
+ return true;
}
- return 0;
-}
-
-static int
-host_cleanup_mapper (void *key, void *value, void *arg_ignored)
-{
- struct address_list *al;
-
- xfree (key); /* host */
-
- al = (struct address_list *)value;
- assert (al->refcount == 1);
- address_list_delete (al);
-
- return 0;
+ return false;
}
void
{
if (host_name_addresses_map)
{
- hash_table_map (host_name_addresses_map, host_cleanup_mapper, NULL);
+ hash_table_iterator iter;
+ for (hash_table_iterate (host_name_addresses_map, &iter);
+ hash_table_iter_next (&iter);
+ )
+ {
+ char *host = iter.key;
+ struct address_list *al = iter.value;
+ xfree (host);
+ assert (al->refcount == 1);
+ address_list_delete (al);
+ }
hash_table_destroy (host_name_addresses_map);
host_name_addresses_map = NULL;
}
}
+
+bool
+is_valid_ip_address (const char *name)
+{
+ const char *endp;
+
+ endp = name + strlen(name);
+ if (is_valid_ipv4_address (name, endp))
+ return true;
+#ifdef ENABLE_IPV6
+ if (is_valid_ipv6_address (name, endp))
+ return true;
+#endif
+ return false;
+}
projects / wget / blobdiff