254 lines
7.1 KiB
Text
254 lines
7.1 KiB
Text
--- src/host.c.orig Mon Sep 21 18:55:42 1998
|
|
+++ src/host.c Fri Sep 24 15:49:42 1999
|
|
@@ -75,12 +75,58 @@
|
|
static struct host *add_hlist PARAMS ((struct host *, const char *,
|
|
const char *, int));
|
|
|
|
+#ifdef INET6
|
|
+/*
|
|
+ * The same as gethostbyname2, but supports internet addresses of the
|
|
+ * form `N.N.N.N' and 'X:X:X:X:X:X:X:X'.
|
|
+ *
|
|
+ * Return the pointer of struct hostent on successful finding of the
|
|
+ * hostname, NULL pointer otherwise.
|
|
+ */
|
|
+struct hostent *
|
|
+ngethostbyname2 (const char *name, int af)
|
|
+{
|
|
+ struct hostent *hp = (struct hostent *) NULL;
|
|
+ char *addr;
|
|
+ size_t socksize;
|
|
+
|
|
+ /* Support only 2 types address family */
|
|
+ if (af != AF_INET6 && af != AF_INET)
|
|
+ return (struct hostent *) NULL;
|
|
+
|
|
+ hp = gethostbyname2(name, af);
|
|
+ if (!hp) {
|
|
+ if (inet_pton(af, name, addr) != -1) {
|
|
+ switch (af) {
|
|
+ case AF_INET:
|
|
+ socksize = sizeof (struct sockaddr_in);
|
|
+ break;
|
|
+ case AF_INET6:
|
|
+ socksize = sizeof (struct sockaddr_in6);
|
|
+ break;
|
|
+ }
|
|
+ hp = gethostbyaddr(addr, socksize, af);
|
|
+ }
|
|
+ }
|
|
+ return hp;
|
|
+}
|
|
+#endif /* INET6 */
|
|
+
|
|
/* The same as gethostbyname, but supports internet addresses of the
|
|
form `N.N.N.N'. */
|
|
struct hostent *
|
|
ngethostbyname (const char *name)
|
|
{
|
|
struct hostent *hp;
|
|
+#ifdef INET6
|
|
+ const int af[] = { AF_INET, AF_INET6 };
|
|
+ int i;
|
|
+
|
|
+ for (i = 0; i < 2; i++)
|
|
+ if ((hp = ngethostbyname2(name, af[i])) != NULL)
|
|
+ return hp;
|
|
+ return (struct hostent *) NULL;
|
|
+#else
|
|
unsigned long addr;
|
|
|
|
addr = (unsigned long)inet_addr (name);
|
|
@@ -89,6 +135,7 @@
|
|
else
|
|
hp = gethostbyname (name);
|
|
return hp;
|
|
+#endif
|
|
}
|
|
|
|
/* Search for HOST in the linked list L, by hostname. Return the
|
|
@@ -117,11 +164,159 @@
|
|
return NULL;
|
|
}
|
|
|
|
-/* Store the address of HOSTNAME, internet-style, to WHERE. First
|
|
- check for it in the host list, and (if not found), use
|
|
- ngethostbyname to get it.
|
|
+#ifdef INET6
|
|
+int
|
|
+convert_hostaddress(int af, const char *hostname, void *address)
|
|
+{
|
|
+ struct host *t;
|
|
+ int valid;
|
|
+
|
|
+ valid = inet_pton(af, hostname, address);
|
|
+ if (valid == -1 || valid == 0) {
|
|
+ /* If it is not of that form, try to find it in the cache. */
|
|
+ t = search_host (hlist, hostname);
|
|
+ if (t)
|
|
+ valid = inet_pton(af, t->realname, address);
|
|
+ if (valid != -1 && valid != 0)
|
|
+ return 1;
|
|
+ } else
|
|
+ return 1;
|
|
+ return 0;
|
|
+}
|
|
+
|
|
+/*
|
|
+ * Store the address of HOSTNAME, internet-style, to WHERE. First
|
|
+ * check for it in the host list, and (if not found), use
|
|
+ * ngethostbyname to get it.
|
|
+ *
|
|
+ * Return 1 on successful finding of the hostname, 0 otherwise.
|
|
+ */
|
|
+int
|
|
+store_hostaddress (struct sockaddr_storage *where, const char *hostname)
|
|
+{
|
|
+ struct host *t;
|
|
+ struct addrinfo hints, *res;
|
|
+ union {
|
|
+ struct in_addr in;
|
|
+ struct in6_addr in6;
|
|
+ } addr_un;
|
|
+ struct sockaddr_in *sin;
|
|
+ struct sockaddr_in6 *sin6;
|
|
+ char *addr_s;
|
|
+ char addr_st[INET6_ADDRSTRLEN];
|
|
+ int af, valid ,i, err;
|
|
+ int family;
|
|
+ const int afs[] = { AF_INET6, AF_INET };
|
|
+#define MAX_AF 2
|
|
|
|
- Return 1 on successful finding of the hostname, 0 otherwise. */
|
|
+ if (opt.inet)
|
|
+ family = AF_INET;
|
|
+ else if (opt.inet6)
|
|
+ family = AF_INET6;
|
|
+ else
|
|
+ family = 0;
|
|
+ /*
|
|
+ * If the address is of the form d.d.d.d, there will be no trouble
|
|
+ * with it.
|
|
+ */
|
|
+ if (!family) {
|
|
+ for (i = 0; i < MAX_AF; i++) {
|
|
+ valid = convert_hostaddress(afs[i], hostname, &addr_un);
|
|
+ af = afs[i];
|
|
+ }
|
|
+ } else {
|
|
+ valid = convert_hostaddress(family, hostname, &addr_un);
|
|
+ af = family;
|
|
+ }
|
|
+ /* If we have the numeric address, just store it. */
|
|
+ if (valid) {
|
|
+ /* This works on both little and big endian architecture, as
|
|
+ * inet_addr returns the address in the proper order. It
|
|
+ * appears to work on 64-bit machines too.
|
|
+ */
|
|
+ switch (af) {
|
|
+ case AF_INET:
|
|
+ sin = (struct sockaddr_in *) where;
|
|
+ memcpy(&sin->sin_addr, &addr_un.in, sizeof(struct in_addr));
|
|
+ sin->sin_family = AF_INET;
|
|
+ return 1;
|
|
+ case AF_INET6:
|
|
+ sin6 = (struct sockaddr_in6 *) where;
|
|
+ memcpy(&sin6->sin6_addr, &addr_un.in6, sizeof(struct in6_addr));
|
|
+ sin6->sin6_family = AF_INET6;
|
|
+ return 1;
|
|
+ default:
|
|
+ return 0;
|
|
+ }
|
|
+ }
|
|
+ /*
|
|
+ * Since all else has failed, let's try gethostbyname2(). Note that
|
|
+ * we use gethostbyname2() rather than ngethostbyname2(), because we
|
|
+ * *know* the address is not numerical.
|
|
+ */
|
|
+ bzero(&hints, sizeof(hints));
|
|
+ hints.ai_socktype = SOCK_STREAM;
|
|
+ hints.ai_protocol = 0;
|
|
+ if (!family) {
|
|
+ hints.ai_family = AF_UNSPEC;
|
|
+ } else {
|
|
+ hints.ai_family = family;
|
|
+ }
|
|
+ err = getaddrinfo(hostname, NULL, &hints, &res);
|
|
+ if (err) {
|
|
+ fprintf(stderr, "%s: %s\n", hostname, gai_strerror(err));
|
|
+ return 0;
|
|
+ }
|
|
+ /*
|
|
+ * Copy the address of the host to socket description.
|
|
+ */
|
|
+ switch (res->ai_family) {
|
|
+ case AF_INET:
|
|
+ sin = (struct sockaddr_in *) where;
|
|
+ memcpy(&sin->sin_addr, &((struct sockaddr_in *)res->ai_addr)->sin_addr, sizeof (struct in_addr));
|
|
+ sin->sin_family = AF_INET;
|
|
+ memcpy (&addr_un.in.s_addr, &((struct sockaddr_in *)res->ai_addr)->sin_addr, sizeof (addr_un.in));
|
|
+ inet_ntop(AF_INET, &addr_un.in, addr_st, sizeof (struct in_addr));
|
|
+ STRDUP_ALLOCA (addr_s, addr_st);
|
|
+ freeaddrinfo(res);
|
|
+ break;
|
|
+ case AF_INET6:
|
|
+ sin6 = (struct sockaddr_in6 *) where;
|
|
+ memcpy(&sin6->sin6_addr, &((struct sockaddr_in6 *)res->ai_addr)->sin6_addr, sizeof (struct in6_addr));
|
|
+ sin6->sin6_family = AF_INET6;
|
|
+ memcpy (&addr_un.in6, &((struct sockaddr_in6 *)res->ai_addr)->sin6_addr, sizeof (addr_un.in6));
|
|
+ inet_ntop(AF_INET6, &addr_un.in6, addr_st, sizeof (struct in6_addr));
|
|
+ STRDUP_ALLOCA (addr_s, addr_st);
|
|
+ freeaddrinfo(res);
|
|
+ break;
|
|
+ default:
|
|
+ freeaddrinfo(res);
|
|
+ return 0;
|
|
+ }
|
|
+ /*
|
|
+ * Now that we're here, we could as well cache the hostname for
|
|
+ * future use, as in realhost(). 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.
|
|
+ */
|
|
+ t = search_address (hlist, addr_s);
|
|
+ if (t) /* Found in the list, as realname. */
|
|
+ {
|
|
+ /* Set the default, 0 quality. */
|
|
+ hlist = add_hlist (hlist, hostname, addr_s, 0);
|
|
+ return 1;
|
|
+ }
|
|
+ /* Since this is really the first time this host is encountered,
|
|
+ * set quality to 1.
|
|
+ */
|
|
+ hlist = add_hlist (hlist, hostname, addr_s, 1);
|
|
+ return 1;
|
|
+}
|
|
+#undef MAX_AF
|
|
+#else /* INET6 */
|
|
int
|
|
store_hostaddress (unsigned char *where, const char *hostname)
|
|
{
|
|
@@ -131,8 +326,10 @@
|
|
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. */
|
|
+ /*
|
|
+ * 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 ((int)addr == -1)
|
|
{
|
|
@@ -178,6 +375,7 @@
|
|
hlist = add_hlist (hlist, hostname, inet_s, 1);
|
|
return 1;
|
|
}
|
|
+#endif /* INET6 */
|
|
|
|
/* Add a host to the host list. The list is sorted by addresses. For
|
|
equal addresses, the entries with quality should bubble towards the
|