From d9056b0e3240e176c6cfdfc13ac1cf384b0a04fd Mon Sep 17 00:00:00 2001
From: itojun <>
Date: Thu, 30 Dec 1999 08:54:20 +0000
Subject: replace NRL get{addr,name}info with KAME get{addr,name}info.
removed functionality:
new code will not return AF_LOCAL addrinfo struct.
added funtionality:
SOCK_RAW is permitted as ai_socktype (no servname allowed).
draft-ietf-ipngwg-scopedaddr-format-00.txt
---
src/lib/libc/net/gai_strerror.c | 6 +
src/lib/libc/net/getaddrinfo.c | 1434 ++++++++++++++++++++++++++-------------
src/lib/libc/net/getnameinfo.c | 446 ++++++------
3 files changed, 1214 insertions(+), 672 deletions(-)
(limited to 'src/lib')
diff --git a/src/lib/libc/net/gai_strerror.c b/src/lib/libc/net/gai_strerror.c
index c701c8f422..708fb23d18 100644
--- a/src/lib/libc/net/gai_strerror.c
+++ b/src/lib/libc/net/gai_strerror.c
@@ -1,3 +1,5 @@
+/* $OpenBSD: gai_strerror.c,v 1.4 1999/12/30 08:54:20 itojun Exp $ */
+
/*
* %%% copyright-cmetz-97-bsd
* Copyright (c) 1997-1999, Craig Metz, All rights reserved.
@@ -65,6 +67,10 @@ gai_strerror(int errnum)
return "memory allocation failure";
case EAI_SYSTEM:
return "system error";
+ case EAI_BADHINTS:
+ return "invalid value for hints";
+ case EAI_PROTOCOL:
+ return "resolved protocol is unknown";
default:
return "unknown/invalid error";
}
diff --git a/src/lib/libc/net/getaddrinfo.c b/src/lib/libc/net/getaddrinfo.c
index 5f3fa20c3a..9c89de2863 100644
--- a/src/lib/libc/net/getaddrinfo.c
+++ b/src/lib/libc/net/getaddrinfo.c
@@ -1,7 +1,9 @@
+/* $OpenBSD: getaddrinfo.c,v 1.5 1999/12/30 08:54:20 itojun Exp $ */
+
/*
- * %%% copyright-cmetz-96-bsd
- * Copyright (c) 1996-1999, Craig Metz, All rights reserved.
- *
+ * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
+ * All rights reserved.
+ *
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
@@ -10,18 +12,14 @@
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- * must display the following acknowledgement:
- * This product includes software developed by Craig Metz and
- * by other contributors.
- * 4. Neither the name of the author nor the names of contributors
+ * 3. Neither the name of the project nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
@@ -31,537 +29,1055 @@
* SUCH DAMAGE.
*/
-/* getaddrinfo() v1.38 */
-
/*
- I'd like to thank Matti Aarnio for finding some bugs in this code and
- sending me patches, as well as everyone else who has contributed to this
- code (by reporting bugs, suggesting improvements, and commented on its
- behavior and proposed changes).
-*/
+ * "#ifdef FAITH" part is local hack for supporting IPv4-v6 translator.
+ *
+ * Issues to be discussed:
+ * - Thread safe-ness must be checked.
+ * - Return values. There are nonstandard return values defined and used
+ * in the source code. This is because RFC2553 is silent about which error
+ * code must be returned for which situation.
+ * Note:
+ * - We use getipnodebyname() just for thread-safeness. There's no intent
+ * to let it do PF_UNSPEC (actually we never pass PF_UNSPEC to
+ * getipnodebyname().
+ * - The code filters out AFs that are not supported by the kernel,
+ * when resolving FQDNs and globbing NULL hostname. Is it the right
+ * thing to do? What is the relationship with post-RFC2553 AI_ADDRCONFIG
+ * in ai_flags?
+ */
+
+#if 0
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#else
+#define HAVE_SOCKADDR_SA_LEN
+#define INET6
+#endif
#include <sys/types.h>
-#include <stdlib.h>
-#include <unistd.h>
+#include <sys/param.h>
+#if 0
+#include <sys/sysctl.h>
+#endif
#include <sys/socket.h>
-#include <string.h>
-#include <stdio.h>
-#include <sys/utsname.h>
-#include <sys/un.h>
+#include <net/if.h>
#include <netinet/in.h>
#include <arpa/inet.h>
+#include <arpa/nameser.h>
#include <netdb.h>
+#include <resolv.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <stdio.h>
#include <errno.h>
-#define GAIH_OKIFUNSPEC 0x0100
-#define GAIH_EAI ~(GAIH_OKIFUNSPEC)
-
-static struct addrinfo nullreq = {
- 0, PF_UNSPEC, 0, 0, 0, NULL, NULL, NULL
+#if 0
+#ifndef HAVE_PORTABLE_PROTOTYPE
+#include "cdecl_ext.h"
+#endif
+
+#ifndef HAVE_U_INT32_T
+#include "bittypes.h"
+#endif
+
+#ifndef HAVE_SOCKADDR_STORAGE
+#include "sockstorage.h"
+#endif
+
+#ifndef HAVE_ADDRINFO
+#include "addrinfo.h"
+#endif
+
+#if defined(__KAME__) && defined(INET6)
+# define FAITH
+#endif
+#endif
+
+#define SUCCESS 0
+#define ANY 0
+#define YES 1
+#define NO 0
+
+#ifdef FAITH
+static int translate = NO;
+static struct in6_addr faith_prefix = IN6ADDR_ANY_INIT;
+#endif
+
+static const char in_addrany[] = { 0, 0, 0, 0 };
+static const char in6_addrany[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
-
-struct gaih_service {
- char *name;
- int num;
+static const char in_loopback[] = { 127, 0, 0, 1 };
+static const char in6_loopback[] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1
};
-struct gaih_servtuple {
- struct gaih_servtuple *next;
- int socktype;
- int protocol;
- int port;
+struct sockinet {
+ u_char si_len;
+ u_char si_family;
+ u_short si_port;
+ u_int32_t si_scope_id;
};
-static struct gaih_servtuple nullserv = {
- NULL, 0, 0, 0
+static const struct afd {
+ int a_af;
+ int a_addrlen;
+ int a_socklen;
+ int a_off;
+ const char *a_addrany;
+ const char *a_loopback;
+ int a_scoped;
+} afdl [] = {
+#ifdef INET6
+ {PF_INET6, sizeof(struct in6_addr),
+ sizeof(struct sockaddr_in6),
+ offsetof(struct sockaddr_in6, sin6_addr),
+ in6_addrany, in6_loopback, 1},
+#endif
+ {PF_INET, sizeof(struct in_addr),
+ sizeof(struct sockaddr_in),
+ offsetof(struct sockaddr_in, sin_addr),
+ in_addrany, in_loopback, 0},
+ {0, 0, 0, 0, NULL, NULL, 0},
};
-struct gaih_addrtuple {
- struct gaih_addrtuple *next;
- int family;
- char addr[16];
- char *cname;
+struct explore {
+ int e_af;
+ int e_socktype;
+ int e_protocol;
+ const char *e_protostr;
+ int e_wild;
+#define WILD_AF(ex) ((ex)->e_wild & 0x01)
+#define WILD_SOCKTYPE(ex) ((ex)->e_wild & 0x02)
+#define WILD_PROTOCOL(ex) ((ex)->e_wild & 0x04)
};
-static struct gaih_typeproto {
- int socktype;
- int protocol;
- char *name;
-} gaih_inet_typeproto[] = {
- { 0, 0, NULL },
- { SOCK_STREAM, IPPROTO_TCP, "tcp" },
- { SOCK_DGRAM, IPPROTO_UDP, "udp" },
- { 0, 0, NULL }
+static const struct explore explore[] = {
+#if 0
+ { PF_LOCAL, 0, ANY, ANY, NULL, 0x01 },
+#endif
+#ifdef INET6
+ { PF_INET6, SOCK_DGRAM, IPPROTO_UDP, "udp", 0x07 },
+ { PF_INET6, SOCK_STREAM, IPPROTO_TCP, "tcp", 0x07 },
+ { PF_INET6, SOCK_RAW, ANY, NULL, 0x05 },
+#endif
+ { PF_INET, SOCK_DGRAM, IPPROTO_UDP, "udp", 0x07 },
+ { PF_INET, SOCK_STREAM, IPPROTO_TCP, "tcp", 0x07 },
+ { PF_INET, SOCK_RAW, ANY, NULL, 0x05 },
+ { -1, 0, 0, NULL, 0 },
};
-static int
-netdb_lookup_addr(const char *name, int af,
- const struct addrinfo *req, struct gaih_addrtuple **pat)
+#ifdef INET6
+#define PTON_MAX 16
+#else
+#define PTON_MAX 4
+#endif
+
+
+static int str_isnumber __P((const char *));
+static int explore_fqdn __P((const struct addrinfo *, const char *,
+ const char *, struct addrinfo **));
+static int explore_null __P((const struct addrinfo *, const char *,
+ const char *, struct addrinfo **));
+static int explore_numeric __P((const struct addrinfo *, const char *,
+ const char *, struct addrinfo **));
+static int explore_numeric_scope __P((const struct addrinfo *, const char *,
+ const char *, struct addrinfo **));
+static int get_name __P((const char *, const struct afd *, struct addrinfo **,
+ char *, const struct addrinfo *, const char *));
+static int get_canonname __P((const struct addrinfo *,
+ struct addrinfo *, const char *));
+static struct addrinfo *get_ai __P((const struct addrinfo *,
+ const struct afd *, const char *));
+static int get_portmatch __P((const struct addrinfo *, const char *));
+static int get_port __P((struct addrinfo *, const char *, int));
+static const struct afd *find_afd __P((int));
+
+#if 0
+static char *ai_errlist[] = {
+ "Success",
+ "Address family for hostname not supported", /* EAI_ADDRFAMILY */
+ "Temporary failure in name resolution", /* EAI_AGAIN */
+ "Invalid value for ai_flags", /* EAI_BADFLAGS */
+ "Non-recoverable failure in name resolution", /* EAI_FAIL */
+ "ai_family not supported", /* EAI_FAMILY */
+ "Memory allocation failure", /* EAI_MEMORY */
+ "No address associated with hostname", /* EAI_NODATA */
+ "hostname nor servname provided, or not known", /* EAI_NONAME */
+ "servname not supported for ai_socktype", /* EAI_SERVICE */
+ "ai_socktype not supported", /* EAI_SOCKTYPE */
+ "System error returned in errno", /* EAI_SYSTEM */
+ "Invalid value for hints", /* EAI_BADHINTS */
+ "Resolved protocol is unknown", /* EAI_PROTOCOL */
+ "Unknown error", /* EAI_MAX */
+};
+#endif
+
+/* XXX macros that make external reference is BAD. */
+
+#define GET_AI(ai, afd, addr) \
+do { \
+ /* external reference: pai, error, and label free */ \
+ (ai) = get_ai(pai, (afd), (addr)); \
+ if ((ai) == NULL) { \
+ error = EAI_MEMORY; \
+ goto free; \
+ } \
+} while (0)
+
+#define GET_PORT(ai, serv) \
+do { \
+ /* external reference: error and label free */ \
+ error = get_port((ai), (serv), 0); \
+ if (error != 0) \
+ goto free; \
+} while (0)
+
+#define GET_CANONNAME(ai, str) \
+do { \
+ /* external reference: pai, error and label free */ \
+ error = get_canonname(pai, (ai), (str)); \
+ if (error != 0) \
+ goto free; \
+} while (0)
+
+#define ERR(err) \
+do { \
+ /* external reference: error, and label bad */ \
+ error = (err); \
+ goto bad; \
+} while (0)
+
+#define MATCH_FAMILY(x, y, w) \
+ ((x) == (y) || ((w) && ((x) == PF_UNSPEC || (y) == PF_UNSPEC)))
+#define MATCH(x, y, w) \
+ ((x) == (y) || ((w) && ((x) == ANY || (y) == ANY)))
+
+static int
+str_isnumber(p)
+ const char *p;
{
- int rval = 0, herrno, i;
- char *prevcname = NULL;
- struct hostent *h;
-
- h = gethostbyname2(name, af);
- herrno = h_errno;
-
- if (!h) {
- switch (herrno) {
- case NETDB_INTERNAL:
- return -EAI_SYSTEM;
- case HOST_NOT_FOUND:
- return 1;
- case TRY_AGAIN:
- return -EAI_AGAIN;
- case NO_RECOVERY:
- return -EAI_FAIL;
- case NO_DATA:
- return 1;
- default:
- return -EAI_FAIL;
- }
+ char *q = (char *)p;
+ while (*q) {
+ if (! isdigit(*q))
+ return NO;
+ q++;
}
+ return YES;
+}
- for (i = 0; h->h_addr_list[i]; i++) {
- while (*pat)
- pat = &((*pat)->next);
-
- if (!(*pat = malloc(sizeof(struct gaih_addrtuple))))
- return -EAI_MEMORY;
- memset(*pat, 0, sizeof(struct gaih_addrtuple));
-
- switch ((*pat)->family = af) {
- case AF_INET:
- memcpy((*pat)->addr, h->h_addr_list[i],
- sizeof(struct in_addr));
- break;
- case AF_INET6:
- memcpy((*pat)->addr, h->h_addr_list[i],
- sizeof(struct in6_addr));
+int
+getaddrinfo(hostname, servname, hints, res)
+ const char *hostname, *servname;
+ const struct addrinfo *hints;
+ struct addrinfo **res;
+{
+ struct addrinfo sentinel;
+ struct addrinfo *cur;
+ int error = 0;
+ struct addrinfo ai;
+ struct addrinfo ai0;
+ struct addrinfo *pai;
+ const struct afd *afd;
+ const struct explore *ex;
+#ifndef AI_MASK
+#define AI_MASK (AI_PASSIVE | AI_CANONNAME | AI_NUMERICHOST)
+#endif
+
+#ifdef FAITH
+ static int firsttime = 1;
+
+ if (firsttime) {
+ /* translator hack */
+ char *q = getenv("GAI");
+ if (q && inet_pton(AF_INET6, q, &faith_prefix) == 1)
+ translate = YES;
+ firsttime = 0;
+ }
+#endif
+
+ sentinel.ai_next = NULL;
+ cur = &sentinel;
+ pai = &ai;
+ pai->ai_flags = 0;
+ pai->ai_family = PF_UNSPEC;
+ pai->ai_socktype = ANY;
+ pai->ai_protocol = ANY;
+ pai->ai_addrlen = 0;
+ pai->ai_canonname = NULL;
+ pai->ai_addr = NULL;
+ pai->ai_next = NULL;
+
+ if (hostname == NULL && servname == NULL)
+ return EAI_NONAME;
+ if (hints) {
+ /* error check for hints */
+ if (hints->ai_addrlen || hints->ai_canonname ||
+ hints->ai_addr || hints->ai_next)
+ ERR(EAI_BADHINTS); /* xxx */
+ if (hints->ai_flags & ~AI_MASK)
+ ERR(EAI_BADFLAGS);
+ switch (hints->ai_family) {
+ case PF_UNSPEC:
+ case PF_INET:
+#ifdef INET6
+ case PF_INET6:
+#endif
break;
default:
- return -EAI_FAIL;
+ ERR(EAI_FAMILY);
}
-
- if (req->ai_flags & AI_CANONNAME) {
- if (prevcname && !strcmp(prevcname, h->h_name))
- (*pat)->cname = prevcname;
- else
- prevcname = (*pat)->cname = strdup(h->h_name);
+ memcpy(pai, hints, sizeof(*pai));
+
+ /*
+ * if both socktype/protocol are specified, check if they
+ * are meaningful combination.
+ */
+ if (pai->ai_socktype != ANY && pai->ai_protocol != ANY) {
+ for (ex = explore; ex->e_af >= 0; ex++) {
+ if (pai->ai_family != ex->e_af)
+ continue;
+ if (ex->e_socktype == ANY)
+ continue;
+ if (ex->e_protocol == ANY)
+ continue;
+ if (pai->ai_socktype == ex->e_socktype
+ && pai->ai_protocol != ex->e_protocol) {
+ ERR(EAI_BADHINTS);
+ }
+ }
}
- pat = &((*pat)->next);
}
- return rval;
-}
-static int
-gaih_local(const char *name, const struct gaih_service *service,
- const struct addrinfo *req, struct addrinfo **pai)
-{
- struct utsname utsname;
- struct addrinfo *ai;
- struct sockaddr_un *sun;
- int siz;
-
- if (name || (req->ai_flags & AI_CANONNAME))
- if (uname(&utsname) < 0)
- return (-EAI_SYSTEM);
-
- if (name && strcmp(name, "localhost") && strcmp(name, "local") &&
- strcmp(name, "unix") && strcmp(name, utsname.nodename))
- return (GAIH_OKIFUNSPEC | -EAI_NONAME);
-
- siz = sizeof(struct addrinfo) + sizeof(struct sockaddr_un);
- if (req->ai_flags & AI_CANONNAME)
- siz += strlen(utsname.nodename) + 1;
-
- if (!(ai = malloc(siz)))
- return -EAI_MEMORY;
-
- *pai = ai;
- ai->ai_next = NULL;
- ai->ai_flags = req->ai_flags;
- ai->ai_family = AF_LOCAL;
- ai->ai_socktype = req->ai_socktype ? req->ai_socktype : SOCK_STREAM;
- ai->ai_protocol = req->ai_protocol;
- ai->ai_addrlen = sizeof(struct sockaddr_un);
- ai->ai_addr = (void *)ai + sizeof(struct addrinfo);
-
- sun = (struct sockaddr_un *)ai->ai_addr;
- sun->sun_len = sizeof(struct sockaddr_un);
- sun->sun_family = AF_LOCAL;
- memset(&sun->sun_path, 0, sizeof sun->sun_path);
-
- if (service) {
- char *c;
-
- c = strchr(service->name, '/');
- if (c) {
- if (strlen(service->name) >= sizeof(sun->sun_path))
- return (GAIH_OKIFUNSPEC | -EAI_SERVICE);
- strlcpy(sun->sun_path, service->name, sizeof (sun->sun_path));
- } else {
- if (strlen(P_tmpdir "/") + strlen(service->name) + 1 >=
- sizeof(sun->sun_path))
- return(GAIH_OKIFUNSPEC | -EAI_SERVICE);
- snprintf(sun->sun_path, sizeof(sun->sun_path), "%s/%s",
- P_tmpdir, service->name);
- }
- } else {
- extern char *_mktemp __P((char *));
- char tmpn[MAXPATHLEN], *c;
-
- snprintf(tmpn, sizeof tmpn, "%stmp.XXXXXXXXXXXXX", P_tmpdir);
- if (!(c = _mktemp(tmpn)))
- return (GAIH_OKIFUNSPEC | -EAI_SYSTEM);
- strlcpy(sun->sun_path, c, sizeof(sun->sun_path));
+ /*
+ * check for special cases. (1) numeric servname is disallowed if
+ * socktype/protocol are left unspecified. (2) servname is disallowed
+ * for raw and other inet{,6} sockets.
+ */
+ if (MATCH_FAMILY(pai->ai_family, PF_INET, 1)
+ || MATCH_FAMILY(pai->ai_family, PF_INET6, 1)) {
+ ai0 = *pai;
+
+ if (pai->ai_family == PF_UNSPEC)
+ pai->ai_family = PF_INET6;
+ error = get_portmatch(pai, servname);
+ if (error)
+ ERR(error);
+
+ *pai = ai0;
}
- ai->ai_canonname = NULL;
- if (req->ai_flags & AI_CANONNAME) {
- ai->ai_canonname = (void *)sun + sizeof(struct sockaddr_un);
- strlcpy(ai->ai_canonname, utsname.nodename,
- strlen(utsname.nodename)+1);
- }
- return 0;
-}
+ ai0 = *pai;
-static int
-gaih_inet_serv(char *servicename, struct gaih_typeproto *tp,
- struct gaih_servtuple **st)
-{
- struct servent *s;
+ /* NULL hostname, or numeric hostname */
+ for (ex = explore; ex->e_af >= 0; ex++) {
+ *pai = ai0;
- s = getservbyname(servicename, tp->name);
- if (!s)
- return (GAIH_OKIFUNSPEC | -EAI_SERVICE);
+ if (!MATCH_FAMILY(pai->ai_family, ex->e_af, WILD_AF(ex)))
+ continue;
+ if (!MATCH(pai->ai_socktype, ex->e_socktype, WILD_SOCKTYPE(ex)))
+ continue;
+ if (!MATCH(pai->ai_protocol, ex->e_protocol, WILD_PROTOCOL(ex)))
+ continue;
- if (!(*st = malloc(sizeof(struct gaih_servtuple))))
- return (-EAI_MEMORY);
+ if (pai->ai_family == PF_UNSPEC)
+ pai->ai_family = ex->e_af;
+ if (pai->ai_socktype == ANY && ex->e_socktype != ANY)
+ pai->ai_socktype = ex->e_socktype;
+ if (pai->ai_protocol == ANY && ex->e_protocol != ANY)
+ pai->ai_protocol = ex->e_protocol;
- (*st)->next = NULL;
- (*st)->socktype = tp->socktype;
- (*st)->protocol = tp->protocol;
- (*st)->port = s->s_port;
- return (0);
-}
+ if (hostname == NULL)
+ error = explore_null(pai, hostname, servname, &cur->ai_next);
+ else
+ error = explore_numeric_scope(pai, hostname, servname, &cur->ai_next);
-static int
-gaih_inet(const char *name, const struct gaih_service *service,
- const struct addrinfo*req, struct addrinfo **pai)
-{
- struct gaih_typeproto *tp = gaih_inet_typeproto;
- struct gaih_servtuple *st = &nullserv;
- struct gaih_addrtuple *at = NULL;
- char *prevcname = NULL;
- struct gaih_servtuple *st2;
- struct gaih_addrtuple *at2 = at;
- struct addrinfo *ai = NULL;
- int canonlen, addrlen, rval = 0;
-
- if (req->ai_protocol || req->ai_socktype) {
- for (tp++; tp->name &&
- ((req->ai_socktype != tp->socktype) || !req->ai_socktype) &&
- ((req->ai_protocol != tp->protocol) || !req->ai_protocol); tp++);
- if (!tp->name) {
- rval = GAIH_OKIFUNSPEC | -EAI_SERVICE;
- if (req->ai_socktype)
- rval = GAIH_OKIFUNSPEC | -EAI_SOCKTYPE;
- goto ret;
- }
+ if (error)
+ goto free;
+
+ while (cur && cur->ai_next)
+ cur = cur->ai_next;
}
- if (service && (service->num < 0)) {
- if (tp->name) {
- rval = gaih_inet_serv(service->name, tp, &st);
- if (rval)
- goto ret;
- } else {
- struct gaih_servtuple **pst = &st;
- for (tp++; tp->name; tp++) {
- rval = gaih_inet_serv(service->name, tp, pst);
- if (rval) {
- if (rval & GAIH_OKIFUNSPEC)
- continue;
- goto ret;
- }
- pst = &((*pst)->next);
+
+ /*
+ * XXX
+ * If numreic representation of AF1 can be interpreted as FQDN
+ * representation of AF2, we need to think again about the code below.
+ */
+ if (sentinel.ai_next)
+ goto good;
+
+ if (pai->ai_flags & AI_NUMERICHOST)
+ ERR(EAI_NONAME);
+ if (hostname == NULL)
+ ERR(EAI_NONAME);
+
+ /*
+ * hostname as alphabetical name.
+ * we would like to prefer AF_INET6 than AF_INET, so we'll make a
+ * outer loop by AFs.
+ */
+ for (afd = afdl; afd->a_af; afd++) {
+ *pai = ai0;
+
+ if (!MATCH_FAMILY(pai->ai_family, afd->a_af, 1))
+ continue;
+
+ for (ex = explore; ex->e_af >= 0; ex++) {
+ *pai = ai0;
+
+ if (pai->ai_family == PF_UNSPEC)
+ pai->ai_family = afd->a_af;
+
+ if (!MATCH_FAMILY(pai->ai_family, ex->e_af, WILD_AF(ex)))
+ continue;
+ if (!MATCH(pai->ai_socktype, ex->e_socktype,
+ WILD_SOCKTYPE(ex))) {
+ continue;
}
- if (st == &nullserv) {
- rval = GAIH_OKIFUNSPEC | -EAI_SERVICE;
- goto ret;
+ if (!MATCH(pai->ai_protocol, ex->e_protocol,
+ WILD_PROTOCOL(ex))) {
+ continue;
}
+
+ if (pai->ai_family == PF_UNSPEC)
+ pai->ai_family = ex->e_af;
+ if (pai->ai_socktype == ANY && ex->e_socktype != ANY)
+ pai->ai_socktype = ex->e_socktype;
+ if (pai->ai_protocol == ANY && ex->e_protocol != ANY)
+ pai->ai_protocol = ex->e_protocol;
+
+ error = explore_fqdn(pai, hostname, servname,
+ &cur->ai_next);
+
+ while (cur && cur->ai_next)
+ cur = cur->ai_next;
}
- } else {
- if (!(st = malloc(sizeof(struct gaih_servtuple)))) {
- rval = -EAI_MEMORY;
- goto ret;
- }
+ }
- st->next = NULL;
- st->socktype = tp->socktype;
- st->protocol = tp->protocol;
- if (service)
- st->port = htons(service->num);
- else
- st->port = 0;
+ /* XXX */
+ if (sentinel.ai_next)
+ error = 0;
+
+ if (error)
+ goto free;
+ if (error == 0) {
+ if (sentinel.ai_next) {
+ good:
+ *res = sentinel.ai_next;
+ return SUCCESS;
+ } else
+ error = EAI_FAIL;
}
+ free:
+ bad:
+ if (sentinel.ai_next)
+ freeaddrinfo(sentinel.ai_next);
+ *res = NULL;
+ return error;
+}
- if (!name) {
- if (!(at = malloc(sizeof(struct gaih_addrtuple)))) {
- rval = -EAI_MEMORY;
- goto ret;
+/*
+ * FQDN hostname, DNS lookup
+ */
+static int
+explore_fqdn(pai, hostname, servname, res)
+ const struct addrinfo *pai;
+ const char *hostname;
+ const char *servname;
+ struct addrinfo **res;
+{
+ int s;
+ struct hostent *hp;
+ int h_error;
+ int af;
+ char **aplist = NULL, *apbuf = NULL;
+ char *ap;
+ struct addrinfo sentinel, *cur;
+ int i;
+#ifndef USE_GETIPNODEBY
+ int naddrs;
+#endif
+ const struct afd *afd;
+ int error;
+
+ *res = NULL;
+ sentinel.ai_next = NULL;
+ cur = &sentinel;
+
+ /*
+ * filter out AFs that are not supported by the kernel
+ * XXX errno?
+ */
+ s = socket(pai->ai_family, SOCK_DGRAM, 0);
+ if (s < 0) {
+ if (errno != EMFILE)
+ return 0;
+ } else
+ close(s);
+
+ /*
+ * if the servname does not match socktype/protocol, ignore it.
+ */
+ if (get_portmatch(pai, servname) != 0)
+ return 0;
+
+ afd = find_afd(pai->ai_family);
+
+ /*
+ * post-RFC2553: should look at (pai->ai_flags & AI_ADDRCONFIG)
+ * rather than hardcoding it. we may need to add AI_ADDRCONFIG
+ * handling code by ourselves in case we don't have getipnodebyname().
+ */
+#ifdef USE_GETIPNODEBY
+ hp = getipnodebyname(hostname, pai->ai_family, AI_ADDRCONFIG, &h_error);
+#else
+ hp = gethostbyname2(hostname, pai->ai_family);
+ h_error = h_errno;
+#endif
+
+ if (hp == NULL) {
+ switch (h_error) {
+ case HOST_NOT_FOUND:
+ case NO_DATA:
+ error = EAI_NODATA;
+ break;
+ case TRY_AGAIN:
+ error = EAI_AGAIN;
+ break;
+ case NO_RECOVERY:
+ case NETDB_INTERNAL:
+ default:
+ error = EAI_FAIL;
+ break;
}
+ } else if ((hp->h_name == NULL) || (hp->h_name[0] == 0)
+ || (hp->h_addr_list[0] == NULL)) {
+#ifdef USE_GETIPNODEBY
+ freehostent(hp);
+#endif
+ hp = NULL;
+ error = EAI_FAIL;
+ }
- memset(at, 0, sizeof(struct gaih_addrtuple));
-
- if (req->ai_family)
- at->family = req->ai_family;
- else {
- if (!(at->next = malloc(sizeof(struct gaih_addrtuple)))) {
- rval = -EAI_MEMORY;
- goto ret;
- }
+ if (hp == NULL)
+ goto free;
+
+#ifdef USE_GETIPNODEBY
+ aplist = hp->h_addr_list;
+#else
+ /*
+ * hp will be overwritten if we use gethostbyname2().
+ * always deep copy for simplification.
+ */
+ for (naddrs = 0; hp->h_addr_list[naddrs] != NULL; naddrs++)
+ ;
+ naddrs++;
+ aplist = (char **)malloc(sizeof(aplist[0]) * naddrs);
+ apbuf = (char *)malloc(hp->h_length * naddrs);
+ if (aplist == NULL || apbuf == NULL) {
+ error = EAI_MEMORY;
+ goto free;
+ }
+ memset(aplist, 0, sizeof(aplist[0]) * naddrs);
+ for (i = 0; i < naddrs; i++) {
+ if (hp->h_addr_list[i] == NULL) {
+ aplist[i] = NULL;
+ continue;
+ }
+ memcpy(&apbuf[i * hp->h_length], hp->h_addr_list[i],
+ hp->h_length);
+ aplist[i] = &apbuf[i * hp->h_length];
+ }
+#endif
+
+ for (i = 0; aplist[i] != NULL; i++) {
+ af = hp->h_addrtype;
+ ap = aplist[i];
+ if (af == AF_INET6
+ && IN6_IS_ADDR_V4MAPPED((struct in6_addr *)ap)) {
+ af = AF_INET;
+ ap = ap + sizeof(struct in6_addr)
+ - sizeof(struct in_addr);
+ }
- at->family = AF_INET6;
+ if (af != pai->ai_family)
+ continue;
- memset(at->next, 0, sizeof(struct gaih_addrtuple));
- at->next->family = AF_INET;
+ if ((pai->ai_flags & AI_CANONNAME) == 0) {
+ GET_AI(cur->ai_next, afd, ap);
+ GET_PORT(cur->ai_next, servname);
+ } else {
+ /*
+ * if AI_CANONNAME and if reverse lookup
+ * fail, return ai anyway to pacify
+ * calling application.
+ *
+ * XXX getaddrinfo() is a name->address
+ * translation function, and it looks
+ * strange that we do addr->name
+ * translation here.
+ */
+ get_name(ap, afd, &cur->ai_next,
+ ap, pai, servname);
}
- goto build;
+ while (cur && cur->ai_next)
+ cur = cur->ai_next;
}
- if (!req->ai_family || (req->ai_family == AF_INET)) {
- struct in_addr in_addr;
- if (inet_pton(AF_INET, name, &in_addr) > 0) {
- if (!(at = malloc(sizeof(struct gaih_addrtuple)))) {
- rval = -EAI_MEMORY;
- goto ret;
- }
+ *res = sentinel.ai_next;
+ return 0;
- memset(at, 0, sizeof(struct gaih_addrtuple));
+free:
+#ifdef USE_GETIPNODEBY
+ if (hp)
+ freehostent(hp);
+#endif
+ if (aplist)
+ free(aplist);
+ if (apbuf)
+ free(apbuf);
+ if (sentinel.ai_next)
+ freeaddrinfo(sentinel.ai_next);
+ return error;
+}
- at->family = AF_INET;
- memcpy(at->addr, &in_addr, sizeof(struct in_addr));
- goto build;
- }
+/*
+ * hostname == NULL.
+ * passive socket -> anyaddr (0.0.0.0 or ::)
+ * non-passive socket -> localhost (127.0.0.1 or ::1)
+ */
+static int
+explore_null(pai, hostname, servname, res)
+ const struct addrinfo *pai;
+ const char *hostname;
+ const char *servname;
+ struct addrinfo **res;
+{
+ int s;
+ const struct afd *afd;
+ struct addrinfo *cur;
+ struct addrinfo sentinel;
+ int error;
+
+ *res = NULL;
+ sentinel.ai_next = NULL;
+ cur = &sentinel;
+
+ /*
+ * filter out AFs that are not supported by the kernel
+ * XXX errno?
+ */
+ s = socket(pai->ai_family, SOCK_DGRAM, 0);
+ if (s < 0) {
+ if (errno != EMFILE)
+ return 0;
+ } else
+ close(s);
+
+ /*
+ * if the servname does not match socktype/protocol, ignore it.
+ */
+ if (get_portmatch(pai, servname) != 0)
+ return 0;
+
+ afd = find_afd(pai->ai_family);
+
+ if (pai->ai_flags & AI_PASSIVE) {
+ GET_AI(cur->ai_next, afd, afd->a_addrany);
+ /* xxx meaningless?
+ * GET_CANONNAME(cur->ai_next, "anyaddr");
+ */
+ GET_PORT(cur->ai_next, servname);
+ } else {
+ GET_AI(cur->ai_next, afd, afd->a_loopback);
+ /* xxx meaningless?
+ * GET_CANONNAME(cur->ai_next, "localhost");
+ */
+ GET_PORT(cur->ai_next, servname);
}
+ cur = cur->ai_next;
- if (!req->ai_family || (req->ai_family == AF_INET6)) {
- struct in6_addr in6_addr;
- if (inet_pton(AF_INET6, name, &in6_addr) > 0) {
- if (!(at = malloc(sizeof(struct gaih_addrtuple)))) {
- rval = -EAI_MEMORY;
- goto ret;
- }
+ *res = sentinel.ai_next;
+ return 0;
- memset(at, 0, sizeof(struct gaih_addrtuple));
+free:
+ if (sentinel.ai_next)
+ freeaddrinfo(sentinel.ai_next);
+ return error;
+}
- at->family = AF_INET6;
- memcpy(at->addr, &in6_addr, sizeof(struct in6_addr));
- goto build;
+/*
+ * numeric hostname
+ */
+static int
+explore_numeric(pai, hostname, servname, res)
+ const struct addrinfo *pai;
+ const char *hostname;
+ const char *servname;
+ struct addrinfo **res;
+{
+ const struct afd *afd;
+ struct addrinfo *cur;
+ struct addrinfo sentinel;
+ int error;
+ char pton[PTON_MAX];
+ int flags;
+
+ *res = NULL;
+ sentinel.ai_next = NULL;
+ cur = &sentinel;
+
+ /*
+ * if the servname does not match socktype/protocol, ignore it.
+ */
+ if (get_portmatch(pai, servname) != 0)
+ return 0;
+
+ afd = find_afd(pai->ai_family);
+ flags = pai->ai_flags;
+
+ if (inet_pton(afd->a_af, hostname, pton) == 1) {
+ u_int32_t v4a;
+#ifdef INET6
+ u_char pfx;
+#endif
+
+ switch (afd->a_af) {
+ case AF_INET:
+ v4a = (u_int32_t)ntohl(((struct in_addr *)pton)->s_addr);
+ if (IN_MULTICAST(v4a) || IN_EXPERIMENTAL(v4a))
+ flags &= ~AI_CANONNAME;
+ v4a >>= IN_CLASSA_NSHIFT;
+ if (v4a == 0 || v4a == IN_LOOPBACKNET)
+ flags &= ~AI_CANONNAME;
+ break;
+#ifdef INET6
+ case AF_INET6:
+ pfx = ((struct in6_addr *)pton)->s6_addr[0];
+ if (pfx == 0 || pfx == 0xfe || pfx == 0xff)
+ flags &= ~AI_CANONNAME;
+ break;
+#endif
}
+
+ if (pai->ai_family == afd->a_af ||
+ pai->ai_family == PF_UNSPEC /*?*/) {
+ if ((flags & AI_CANONNAME) == 0) {
+ GET_AI(cur->ai_next, afd, pton);
+ GET_PORT(cur->ai_next, servname);
+ } else {
+ /*
+ * if AI_CANONNAME and if reverse lookup
+ * fail, return ai anyway to pacify
+ * calling application.
+ *
+ * XXX getaddrinfo() is a name->address
+ * translation function, and it looks
+ * strange that we do addr->name
+ * translation here.
+ */
+ get_name(pton, afd, &cur->ai_next,
+ pton, pai, servname);
+ }
+ while (cur && cur->ai_next)
+ cur = cur->ai_next;
+ } else
+ ERR(EAI_FAMILY); /*xxx*/
}
- if (!(req->ai_flags & AI_NUMERICHOST)) {
- if (!req->ai_family || (req->ai_family == AF_INET6))
- if ((rval = netdb_lookup_addr(name, AF_INET6, req, &at)) < 0)
- goto ret;
- if (!req->ai_family || (req->ai_family == AF_INET))
- if ((rval = netdb_lookup_addr(name, AF_INET, req, &at)) < 0)
- goto ret;
+ *res = sentinel.ai_next;
+ return 0;
- if (!rval)
- goto build;
- }
+free:
+bad:
+ if (sentinel.ai_next)
+ freeaddrinfo(sentinel.ai_next);
+ return error;
+}
- if (!at) {
- rval = GAIH_OKIFUNSPEC | -EAI_NONAME;
- goto ret;
+/*
+ * numeric hostname with scope
+ */
+static int
+explore_numeric_scope(pai, hostname, servname, res)
+ const struct addrinfo *pai;
+ const char *hostname;
+ const char *servname;
+ struct addrinfo **res;
+{
+#ifndef SCOPE_DELIMITER
+ return explore_numeric(pai, hostname, servname, res);
+#else
+ const struct afd *afd;
+ struct addrinfo *cur;
+ int error;
+ char *cp, *hostname2 = NULL;
+ int scope;
+ struct sockaddr_in6 *sin6;
+
+ /*
+ * if the servname does not match socktype/protocol, ignore it.
+ */
+ if (get_portmatch(pai, servname) != 0)
+ return 0;
+
+ afd = find_afd(pai->ai_family);
+ if (!afd->a_scoped)
+ return explore_numeric(pai, hostname, servname, res);
+
+ cp = strchr(hostname, SCOPE_DELIMITER);
+ if (cp == NULL)
+ return explore_numeric(pai, hostname, servname, res);
+
+ /*
+ * Handle special case of <scoped_address><delimiter><scope id>
+ */
+ hostname2 = strdup(hostname);
+ if (hostname2 == NULL)
+ return EAI_MEMORY;
+ /* terminate at the delimiter */
+ hostname2[cp - hostname] = '\0';
+
+ cp++;
+ switch (pai->ai_family) {
+#ifdef INET6
+ case AF_INET6:
+ scope = if_nametoindex(cp);
+ if (scope == 0) {
+ free(hostname2);
+ return (EAI_NONAME);
+ }
+ break;
+#endif
}
-build:
- at2 = at;
- while (at2) {
- if (req->ai_flags & AI_CANONNAME) {
- if (at2->cname)
- canonlen = strlen(at2->cname) + 1;
- else
- if (name)
- canonlen = strlen(name) + 1;
- else
- canonlen = 2;
- } else
- canonlen = 0;
+ error = explore_numeric(pai, hostname2, servname, res);
+ if (error == 0) {
+ for (cur = *res; cur; cur = cur->ai_next) {
+ if (cur->ai_family != AF_INET6)
+ continue;
+ sin6 = (struct sockaddr_in6 *)cur->ai_addr;
+ if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr) ||
+ IN6_IS_ADDR_MC_LINKLOCAL(&sin6->sin6_addr))
+ sin6->sin6_scope_id = scope;
+ }
+ }
- if (at2->family == AF_INET6)
- addrlen = sizeof(struct sockaddr_in6);
- else
- addrlen = sizeof(struct sockaddr_in);
-
- st2 = st;
- while (st2) {
- if (!(ai = malloc(sizeof(struct addrinfo) +
- addrlen + canonlen))) {
- rval = -EAI_MEMORY;
- goto ret;
- }
+ free(hostname2);
- *pai = ai;
- memset(ai, 0, sizeof(struct addrinfo) + addrlen + canonlen);
-
- ai->ai_flags = req->ai_flags;
- ai->ai_family = at2->family;
- ai->ai_socktype = st2->socktype;
- ai->ai_protocol = st2->protocol;
- ai->ai_addrlen = addrlen;
- ai->ai_addr = (void *)ai + sizeof(struct addrinfo);
- ai->ai_addr->sa_len = addrlen;
- ai->ai_addr->sa_family = at2->family;
-
- switch (at2->family) {
- case AF_INET6:
- {
- struct sockaddr_in6 *sin6 = (void *)ai->ai_addr;
-
- memcpy(&sin6->sin6_addr, at2->addr,
- sizeof(sin6->sin6_addr));
- sin6->sin6_port = st2->port;
- break;
- }
- default:
- {
- struct sockaddr_in *sin = (void *)ai->ai_addr;
-
- memcpy(&sin->sin_addr, at2->addr,
- sizeof(sin->sin_addr));
- sin->sin_port = st2->port;
- break;
- }
- }
+ return error;
+#endif
+}
- if (canonlen) {
- ai->ai_canonname = (void *) ai->ai_addr + addrlen;
-
- if (at2->cname) {
- strcpy(ai->ai_canonname, at2->cname);
- if (prevcname != at2->cname) {
- if (prevcname)
- free(prevcname);
- prevcname = at2->cname;
- }
- } else
- strcpy(ai->ai_canonname, name ? name : "*");
- }
- pai = &(ai->ai_next);
- st2 = st2->next;
- }
- at2 = at2->next;
- }
- rval = 0;
-
-ret:
- if (st != &nullserv) {
- struct gaih_servtuple *st2 = st;
- while (st) {
- st2 = st->next;
- free(st);
- st = st2;
+static int
+get_name(addr, afd, res, numaddr, pai, servname)
+ const char *addr;
+ const struct afd *afd;
+ struct addrinfo **res;
+ char *numaddr;
+ const struct addrinfo *pai;
+ const char *servname;
+{
+ struct hostent *hp = NULL;
+ struct addrinfo *cur = NULL;
+ int error = 0;
+ char *ap = NULL, *cn = NULL;
+#ifdef USE_GETIPNODEBY
+ int h_error;
+
+ hp = getipnodebyaddr(addr, afd->a_addrlen, afd->a_af, &h_error);
+#else
+ hp = gethostbyaddr(addr, afd->a_addrlen, afd->a_af);
+#endif
+ if (hp && hp->h_name && hp->h_name[0] && hp->h_addr_list[0]) {
+#ifdef USE_GETIPNODEBY
+ GET_AI(cur, afd, hp->h_addr_list[0]);
+ GET_PORT(cur, servname);
+ GET_CANONNAME(cur, hp->h_name);
+#else
+ /* hp will be damaged if we use gethostbyaddr() */
+ if ((ap = (char *)malloc(hp->h_length)) == NULL) {
+ error = EAI_MEMORY;
+ goto free;
}
- }
- if (at) {
- struct gaih_addrtuple *at2 = at;
- while (at) {
- at2 = at->next;
- free(at);
- at = at2;
+ memcpy(ap, hp->h_addr_list[0], hp->h_length);
+ if ((cn = strdup(hp->h_name)) == NULL) {
+ error = EAI_MEMORY;
+ goto free;
}
+
+ GET_AI(cur, afd, ap);
+ GET_PORT(cur, servname);
+ GET_CANONNAME(cur, cn);
+ free(ap); ap = NULL;
+ free(cn); cn = NULL;
+#endif
+ } else {
+ GET_AI(cur, afd, numaddr);
+ GET_PORT(cur, servname);
}
- return rval;
+
+#ifdef USE_GETIPNODEBY
+ if (hp)
+ freehostent(hp);
+#endif
+ *res = cur;
+ return SUCCESS;
+ free:
+ if (cur)
+ freeaddrinfo(cur);
+ if (ap)
+ free(ap);
+ if (cn)
+ free(cn);
+#ifdef USE_GETIPNODEBY
+ if (hp)
+ freehostent(hp);
+#endif
+ *res = NULL;
+ return error;
}
-static struct gaih {
- int family;
- char *name;
- int (*gaih) __P((const char *name,
- const struct gaih_service *service,
- const struct addrinfo *req, struct addrinfo **pai));
-} gaih[] = {
- { PF_INET6, "inet6", gaih_inet },
- { PF_INET, "inet", gaih_inet },
- { PF_LOCAL, "local", gaih_local },
- { -1, NULL, NULL}
-};
+static int
+get_canonname(pai, ai, str)
+ const struct addrinfo *pai;
+ struct addrinfo *ai;
+ const char *str;
+{
+ if ((pai->ai_flags & AI_CANONNAME) != 0) {
+ ai->ai_canonname = (char *)malloc(strlen(str) + 1);
+ if (ai->ai_canonname == NULL)
+ return EAI_MEMORY;
+ strcpy(ai->ai_canonname, str);
+ }
+ return 0;
+}
-int
-getaddrinfo(const char *name, const char *service,
- const struct addrinfo *req, struct addrinfo **pai)
+static struct addrinfo *
+get_ai(pai, afd, addr)
+ const struct addrinfo *pai;
+ const struct afd *afd;
+ const char *addr;
{
- int rval = EAI_SYSTEM; /* XXX */
- int j = 0;
- struct addrinfo *p = NULL, **end;
- struct gaih *g = gaih, *pg = NULL;
- struct gaih_service gaih_service, *pservice;
+ char *p;
+ struct addrinfo *ai;
- if (name && (name[0] == '*') && !name[1])
- name = NULL;
+ ai = (struct addrinfo *)malloc(sizeof(struct addrinfo)
+ + (afd->a_socklen));
+ if (ai == NULL)
+ return NULL;
+
+ memcpy(ai, pai, sizeof(struct addrinfo));
+ ai->ai_addr = (struct sockaddr *)(ai + 1);
+ memset(ai->ai_addr, 0, afd->a_socklen);
+#ifdef HAVE_SOCKADDR_SA_LEN
+ ai->ai_addr->sa_len = afd->a_socklen;
+#endif
+ ai->ai_addrlen = afd->a_socklen;
+ ai->ai_addr->sa_family = ai->ai_family = afd->a_af;
+ p = (char *)(ai->ai_addr);
+ memcpy(p + afd->a_off, addr, afd->a_addrlen);
+ return ai;
+}
- if (service && service[0] == '*' && service[1] == '\0')
- service = NULL;
+static int
+get_portmatch(ai, servname)
+ const struct addrinfo *ai;
+ const char *servname;
+{
- if (!req)
- req = &nullreq;
+ /* get_port does not touch first argument. when matchonly == 1. */
+ return get_port((struct addrinfo *)ai, servname, 1);
+}
+
+static int
+get_port(ai, servname, matchonly)
+ struct addrinfo *ai;
+ const char *servname;
+ int matchonly;
+{
+ const char *proto;
+ struct servent *sp;
+ int port;
+ int allownumeric;
+
+ if (servname == NULL)
+ return 0;
+ if (ai->ai_family != AF_INET && ai->ai_family != AF_INET6)
+ return 0;
+
+ switch (ai->ai_socktype) {
+ case SOCK_RAW:
+ return EAI_SERVICE;
+ case SOCK_DGRAM:
+ case SOCK_STREAM:
+ allownumeric = 1;
+ break;
+ case ANY:
+ allownumeric = 0;
+ break;
+ default:
+ return EAI_SOCKTYPE;
+ }
- if (req->ai_flags & ~(AI_CANONNAME | AI_PASSIVE | AI_NUMERICHOST | AI_EXT))
- return (EAI_BADFLAGS);
+ if (str_isnumber(servname)) {
+ if (!allownumeric)
+ return EAI_SERVICE;
+ port = htons(atoi(servname));
+ if (port < 0 || port > 65535)
+ return EAI_SERVICE;
+ } else {
+ switch (ai->ai_socktype) {
+ case SOCK_DGRAM:
+ proto = "udp";
+ break;
+ case SOCK_STREAM:
+ proto = "tcp";
+ break;
+ default:
+ proto = NULL;
+ break;
+ }
- if (service && *service) {
- char *c;
+ if ((sp = getservbyname(servname, proto)) == NULL)
+ return EAI_SERVICE;
+ port = sp->s_port;
+ }
- gaih_service.num = strtoul(service, &c, 10);
- if (*c)
- gaih_service.num = -1;
- gaih_service.name = (void *)service;
- pservice = &gaih_service;
- } else
- pservice = NULL;
-
- if (pai)
- end = &p;
- else
- end = NULL;
-
- while (g->gaih) {
- if ((req->ai_family == g->family) || !req->ai_family) {
- j++;
- if (!((pg && (pg->gaih == g->gaih)))) {
- pg = g;
- rval = g->gaih(name, pservice, req, end);
- if (rval) {
- if (!req->ai_family && (rval & GAIH_OKIFUNSPEC))
- continue;
-
- if (p)
- freeaddrinfo(p);
-
- return -(rval & GAIH_EAI);
- }
- if (end)
- while (*end)
- end = &((*end)->ai_next);
- }
+ if (!matchonly) {
+ switch (ai->ai_family) {
+ case AF_INET:
+ ((struct sockaddr_in *)ai->ai_addr)->sin_port = port;
+ break;
+#ifdef INET6
+ case AF_INET6:
+ ((struct sockaddr_in6 *)ai->ai_addr)->sin6_port = port;
+ break;
+#endif
}
- g++;
}
- if (!j)
- return (EAI_FAMILY);
+ return 0;
+}
+
+static const struct afd *
+find_afd(af)
+ int af;
+{
+ const struct afd *afd;
- if (p) {
- *pai = p;
- return (0);
+ if (af == PF_UNSPEC)
+ return NULL;
+ for (afd = afdl; afd->a_af; afd++) {
+ if (afd->a_af == af)
+ return afd;
}
- if (!pai && !rval)
- return (0);
- return EAI_NONAME;
+ return NULL;
}
diff --git a/src/lib/libc/net/getnameinfo.c b/src/lib/libc/net/getnameinfo.c
index 62c4b9d928..787beec9c6 100644
--- a/src/lib/libc/net/getnameinfo.c
+++ b/src/lib/libc/net/getnameinfo.c
@@ -1,7 +1,9 @@
+/* $OpenBSD: getnameinfo.c,v 1.5 1999/12/30 08:54:20 itojun Exp $ */
+
/*
- * %%% copyright-cmetz-96-bsd
- * Copyright (c) 1996-1999, Craig Metz, All rights reserved.
- *
+ * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
+ * All rights reserved.
+ *
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
@@ -10,18 +12,14 @@
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- * must display the following acknowledgement:
- * This product includes software developed by Craig Metz and
- * by other contributors.
- * 4. Neither the name of the author nor the names of contributors
+ * 3. Neither the name of the project nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
@@ -29,236 +27,258 @@
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
- *
*/
-/* getnameinfo() v1.38 */
+/*
+ * Issues to be discussed:
+ * - Thread safe-ness must be checked
+ * - Return values. There seems to be no standard for return value (RFC2553)
+ * but INRIA implementation returns EAI_xxx defined for getaddrinfo().
+ * - RFC2553 says that we should raise error on short buffer. X/Open says
+ * we need to truncate the result. We obey RFC2553 (and X/Open should be
+ * modified).
+ */
+
+#if 0
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#else
+#define HAVE_SA_LEN
+#define INET6
+#endif
#include <sys/types.h>
#include <sys/socket.h>
+#include <net/if.h>
#include <netinet/in.h>
-#include <sys/un.h>
-#include <sys/utsname.h>
-#include <netdb.h>
#include <arpa/inet.h>
-#include <errno.h>
-#include <string.h>
+#include <arpa/nameser.h>
+#include <netdb.h>
#include <resolv.h>
+#include <string.h>
+#include <stddef.h>
-#ifndef min
-#define min(x,y) (((x) > (y)) ? (y) : (x))
-#endif /* min */
-
-static int
-netdb_lookup_name(int family, void *addr, int addrlen, char *name,
- int namelen, int flags)
-{
- struct hostent *hostent;
- char *c, *c2;
- int i;
-
- if (!(hostent = gethostbyaddr(addr, addrlen, family))) {
- switch (h_errno) {
- case NETDB_INTERNAL:
- return(EAI_SYSTEM);
- case HOST_NOT_FOUND:
- return(1);
- case TRY_AGAIN:
- return(EAI_AGAIN);
- case NO_RECOVERY:
- return(EAI_FAIL);
- case NO_DATA:
- return(1);
- default:
- return(EAI_FAIL);
- }
- }
-
- endhostent();
-
- c = hostent->h_name;
- if ((flags & NI_NOFQDN) && (_res.options & RES_INIT) && _res.defdname[0] &&
- (c2 = strstr(c + 1, _res.defdname)) && (*(--c2) == '.')) {
- *c2 = 0;
- i = min(c2 - c, namelen);
- strlcpy(name, c, i);
- } else
- strlcpy(name, c, namelen);
- return 0;
-}
-
-int
-getnameinfo(const struct sockaddr *sa, size_t addrlen, char *host,
- size_t hostlen, char *serv, size_t servlen, int flags)
-{
- int rval;
- int saved_errno;
-
- if (sa == NULL || addrlen != sa->sa_len)
- return EAI_FAIL;
- saved_errno = errno;
+#if 0
+#ifndef HAVE_PORTABLE_PROTOTYPE
+#include "cdecl_ext.h"
+#endif
- if (host && hostlen > 0) {
- switch (sa->sa_family) {
- case AF_INET6:
- {
- struct sockaddr_in6 *sin6 = (void *)sa;
+#ifndef HAVE_ADDRINFO
+#include "addrinfo.h"
+#endif
+#endif
- if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
- if (flags & NI_NUMERICHOST)
- goto inet6_noname;
- strlcpy(host, "*", hostlen);
- break;
- }
+#define SUCCESS 0
+#define ANY 0
+#define YES 1
+#define NO 0
- if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
- struct sockaddr_in sin;
+static struct afd {
+ int a_af;
+ int a_addrlen;
+ int a_socklen;
+ int a_off;
+} afdl [] = {
+#ifdef INET6
+ {PF_INET6, sizeof(struct in6_addr), sizeof(struct sockaddr_in6),
+ offsetof(struct sockaddr_in6, sin6_addr)},
+#endif
+ {PF_INET, sizeof(struct in_addr), sizeof(struct sockaddr_in),
+ offsetof(struct sockaddr_in, sin_addr)},
+ {0, 0, 0},
+};
- memset(&sin, 0, sizeof(struct sockaddr_in));
- sin.sin_len = sizeof(struct sockaddr_in);
- sin.sin_family = AF_INET;
- sin.sin_port = sin6->sin6_port;
- sin.sin_addr.s_addr =
- ((u_int32_t *)&sin6->sin6_addr)[3];
- if (!(rval = getnameinfo((struct sockaddr *)&sin,
- sizeof(struct sockaddr_in), host, hostlen,
- serv, servlen, flags | NI_NAMEREQD)))
- goto ret;
- if (rval != EAI_NONAME)
- goto ret;
- goto inet6_noname;
- }
+struct sockinet {
+ u_char si_len;
+ u_char si_family;
+ u_short si_port;
+};
- if (flags & NI_NUMERICHOST)
- goto inet6_noname;
- if ((rval = netdb_lookup_name(AF_INET6,
- &sin6->sin6_addr, sizeof(struct in6_addr),
- host, hostlen, flags)) < 0)
- goto ret;
+#define ENI_NOSOCKET 0
+#define ENI_NOSERVNAME 1
+#define ENI_NOHOSTNAME 2
+#define ENI_MEMORY 3
+#define ENI_SYSTEM 4
+#define ENI_FAMILY 5
+#define ENI_SALEN 6
- if (!rval)
- break;
- inet6_noname:
- if (flags & NI_NAMEREQD) {
- rval = EAI_NONAME;
- goto ret;
- }
- if (!inet_ntop(AF_INET6, &sin6->sin6_addr, host, hostlen)) {
- rval = EAI_NONAME;
- goto ret;
- }
- break;
- }
- case AF_INET:
- {
- struct sockaddr_in *sin = (void *)sa;
+int
+getnameinfo(sa, salen, host, hostlen, serv, servlen, flags)
+ const struct sockaddr *sa;
+ size_t salen;
+ char *host;
+ size_t hostlen;
+ char *serv;
+ size_t servlen;
+ int flags;
+{
+ struct afd *afd;
+ struct servent *sp;
+ struct hostent *hp;
+ u_short port;
+ int family, i;
+ char *addr, *p;
+ u_int32_t v4a;
+ int h_error;
+ char numserv[512];
+ char numaddr[512];
- if (flags & NI_NUMERICHOST)
- goto inet_noname;
+ if (sa == NULL)
+ return ENI_NOSOCKET;
- if (sin->sin_addr.s_addr == 0) {
- strlcpy(host, "*", hostlen);
- break;
- }
+#ifdef HAVE_SA_LEN /*XXX*/
+ if (sa->sa_len != salen)
+ return ENI_SALEN;
+#endif
+
+ family = sa->sa_family;
+ for (i = 0; afdl[i].a_af; i++)
+ if (afdl[i].a_af == family) {
+ afd = &afdl[i];
+ goto found;
+ }
+ return ENI_FAMILY;
+
+ found:
+ if (salen != afd->a_socklen)
+ return ENI_SALEN;
+
+ port = ((struct sockinet *)sa)->si_port; /* network byte order */
+ addr = (char *)sa + afd->a_off;
- if ((rval = netdb_lookup_name(AF_INET,
- &sin->sin_addr, sizeof(struct in_addr),
- host, hostlen, flags)) < 0)
- goto ret;
+ if (serv == NULL || servlen == 0) {
+ /*
+ * do nothing in this case.
+ * in case you are wondering if "&&" is more correct than
+ * "||" here: RFC2553 says that serv == NULL OR servlen == 0
+ * means that the caller does not want the result.
+ */
+ } else {
+ if (flags & NI_NUMERICSERV)
+ sp = NULL;
+ else {
+ sp = getservbyport(port,
+ (flags & NI_DGRAM) ? "udp" : "tcp");
+ }
+ if (sp) {
+ if (strlen(sp->s_name) > servlen)
+ return ENI_MEMORY;
+ strcpy(serv, sp->s_name);
+ } else {
+ snprintf(numserv, sizeof(numserv), "%d", ntohs(port));
+ if (strlen(numserv) > servlen)
+ return ENI_MEMORY;
+ strcpy(serv, numserv);
+ }
+ }
- if (!rval)
- break;
- inet_noname:
- if (flags & NI_NAMEREQD) {
- rval = EAI_NONAME;
- goto ret;
- }
- if (!inet_ntop(AF_INET, &sin->sin_addr, host, hostlen)) {
- rval = EAI_NONAME;
- goto ret;
- }
+ switch (sa->sa_family) {
+ case AF_INET:
+ v4a = (u_int32_t)
+ ntohl(((struct sockaddr_in *)sa)->sin_addr.s_addr);
+ if (IN_MULTICAST(v4a) || IN_EXPERIMENTAL(v4a))
+ flags |= NI_NUMERICHOST;
+ v4a >>= IN_CLASSA_NSHIFT;
+ if (v4a == 0 || v4a == IN_LOOPBACKNET)
+ flags |= NI_NUMERICHOST;
+ break;
+#ifdef INET6
+ case AF_INET6:
+ {
+ struct sockaddr_in6 *sin6;
+ sin6 = (struct sockaddr_in6 *)sa;
+ switch (sin6->sin6_addr.s6_addr[0]) {
+ case 0x00:
+ if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr))
+ ;
+ else if (IN6_IS_ADDR_LOOPBACK(&sin6->sin6_addr))
+ ;
+ else
+ flags |= NI_NUMERICHOST;
break;
- }
- case AF_LOCAL:
- if (!(flags & NI_NUMERICHOST)) {
- struct utsname utsname;
-
- if (!uname(&utsname)) {
- strlcpy(host, utsname.nodename, hostlen);
- break;
- }
- }
-
- if (flags & NI_NAMEREQD) {
- rval = EAI_NONAME;
- goto ret;
+ default:
+ if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr)) {
+ flags |= NI_NUMERICHOST;
}
-
- strlcpy(host, "localhost", hostlen);
+ else if (IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr))
+ flags |= NI_NUMERICHOST;
break;
- default:
- rval = EAI_FAMILY;
- goto ret;
}
+ }
+ break;
+#endif
}
+ if (host == NULL || hostlen == 0) {
+ /*
+ * do nothing in this case.
+ * in case you are wondering if "&&" is more correct than
+ * "||" here: RFC2553 says that host == NULL OR hostlen == 0
+ * means that the caller does not want the result.
+ */
+ } else if (flags & NI_NUMERICHOST) {
+ /* NUMERICHOST and NAMEREQD conflicts with each other */
+ if (flags & NI_NAMEREQD)
+ return ENI_NOHOSTNAME;
+ if (inet_ntop(afd->a_af, addr, numaddr, sizeof(numaddr))
+ == NULL)
+ return ENI_SYSTEM;
+ if (strlen(numaddr) > hostlen)
+ return ENI_MEMORY;
+ strcpy(host, numaddr);
+#if defined(INET6) && defined(NI_WITHSCOPEID)
+ if (afd->a_af == AF_INET6 &&
+ (IN6_IS_ADDR_LINKLOCAL((struct in6_addr *)addr) ||
+ IN6_IS_ADDR_MULTICAST((struct in6_addr *)addr)) &&
+ ((struct sockaddr_in6 *)sa)->sin6_scope_id) {
+#ifndef ALWAYS_WITHSCOPE
+ if (flags & NI_WITHSCOPEID)
+#endif /* !ALWAYS_WITHSCOPE */
+ {
+ char *ep = strchr(host, '\0');
+ unsigned int ifindex =
+ ((struct sockaddr_in6 *)sa)->sin6_scope_id;
- if (serv && servlen > 0) {
- switch (sa->sa_family) {
- case AF_INET:
- {
- struct sockaddr_in *sin = (void *)sa;
- struct servent *s;
-
- if ((flags & NI_NUMERICSERV) == 0) {
- s = getservbyport(sin->sin_port,
- (flags & NI_DGRAM) ? "udp" : "tcp");
- if (s) {
- strlcpy(serv, s->s_name, servlen);
- break;
- }
- if (sin->sin_port == 0) {
- strlcpy(serv, "*", servlen);
- break;
- }
+ *ep = SCOPE_DELIMITER;
+ if ((if_indextoname(ifindex, ep + 1)) == NULL)
+ /* XXX what should we do? */
+ strncpy(ep + 1, "???", 3);
}
- snprintf(serv, servlen, "%d", ntohs(sin->sin_port));
- break;
- }
- case AF_INET6:
- {
- struct sockaddr_in6 *sin6 = (void *)sa;
- struct servent *s;
-
- if ((flags & NI_NUMERICSERV) == 0) {
+ }
+#endif /* INET6 */
+ } else {
+#ifdef USE_GETIPNODEBY
+ hp = getipnodebyaddr(addr, afd->a_addrlen, afd->a_af, &h_error);
+#else
+ hp = gethostbyaddr(addr, afd->a_addrlen, afd->a_af);
+ h_error = h_errno;
+#endif
- s = getservbyport(sin6->sin6_port,
- (flags & NI_DGRAM) ? "udp" : "tcp");
- if (s) {
- strlcpy(serv, s->s_name, servlen);
- break;
- }
- if (sin6->sin6_port == 0) {
- strlcpy(serv, "*", servlen);
- break;
- }
+ if (hp) {
+ if (flags & NI_NOFQDN) {
+ p = strchr(hp->h_name, '.');
+ if (p) *p = '\0';
}
- snprintf(serv, servlen, "%d", ntohs(sin6->sin6_port));
- break;
- }
- case AF_LOCAL:
- {
- struct sockaddr_un *sun = (void *)sa;
-
- strlcpy(serv, sun->sun_path, servlen);
- break;
- }
+ if (strlen(hp->h_name) > hostlen) {
+#ifdef USE_GETIPNODEBY
+ freehostent(hp);
+#endif
+ return ENI_MEMORY;
+ }
+ strcpy(host, hp->h_name);
+#ifdef USE_GETIPNODEBY
+ freehostent(hp);
+#endif
+ } else {
+ if (flags & NI_NAMEREQD)
+ return ENI_NOHOSTNAME;
+ if (inet_ntop(afd->a_af, addr, numaddr, sizeof(numaddr))
+ == NULL)
+ return ENI_NOHOSTNAME;
+ if (strlen(numaddr) > hostlen)
+ return ENI_MEMORY;
+ strcpy(host, numaddr);
}
}
- rval = 0;
-
-ret:
- if (rval == 1)
- rval = EAI_FAIL;
- errno = saved_errno;
- return (rval);
+ return SUCCESS;
}
--
cgit v1.2.3-55-g6feb