ca81c3971c
Mostly, several functions that take pointers as arguments, almost always char * pointers, had those pointers qualified with "const". Those that returned pointers to previously const-qualified arguments had their return values qualified as const. Some structure members were qualified as const to retain that attribute from the variables from which they were assigned. Minor other ISC style cleanups.
578 lines
13 KiB
C
578 lines
13 KiB
C
/*-
|
|
* Copyright (c) 1997 Berkeley Software Design, Inc. All rights reserved.
|
|
* The Berkeley Software Design Inc. software License Agreement specifies
|
|
* the terms and conditions for redistribution.
|
|
*
|
|
* BSDI $Id: getaddrinfo.c,v 1.18 2000/06/01 17:39:24 tale Exp $
|
|
*/
|
|
|
|
#include <config.h>
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/un.h>
|
|
|
|
#include <netinet/in.h>
|
|
|
|
#include <arpa/nameser.h>
|
|
#include <arpa/inet.h>
|
|
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#include <stdlib.h>
|
|
#include <resolv.h>
|
|
|
|
#include <lwres/lwres.h>
|
|
#include <lwres/net.h>
|
|
#include <lwres/netdb.h> /* XXX #include <netdb.h> */
|
|
|
|
#define SA(addr) ((struct sockaddr *)(addr))
|
|
#define SIN(addr) ((struct sockaddr_in *)(addr))
|
|
#define SIN6(addr) ((struct sockaddr_in6 *)(addr))
|
|
#define SUN(addr) ((struct sockaddr_un *)(addr))
|
|
|
|
static struct addrinfo
|
|
*ai_reverse(struct addrinfo *oai),
|
|
*ai_clone(struct addrinfo *oai, int family),
|
|
*ai_alloc(int family, int addrlen);
|
|
#ifdef AF_LOCAL
|
|
static int get_local(const char *name, int socktype, struct addrinfo **res);
|
|
#endif
|
|
|
|
static int add_ipv4(const char *hostname, int flags, struct addrinfo **aip,
|
|
int socktype, int port);
|
|
static int add_ipv6(const char *hostname, int flags, struct addrinfo **aip,
|
|
int socktype, int port);
|
|
static void set_order(int, int (**)(const char *, int, struct addrinfo **,
|
|
int, int));
|
|
|
|
#define FOUND_IPV4 0x1
|
|
#define FOUND_IPV6 0x2
|
|
#define FOUND_MAX 2
|
|
|
|
#define ISC_AI_MASK (AI_PASSIVE|AI_CANONNAME|AI_NUMERICHOST)
|
|
|
|
int
|
|
lwres_getaddrinfo(const char *hostname, const char *servname,
|
|
const struct addrinfo *hints, struct addrinfo **res)
|
|
{
|
|
struct servent *sp;
|
|
const char *proto;
|
|
int family, socktype, flags, protocol;
|
|
struct addrinfo *ai, *ai_list;
|
|
int port, err, i;
|
|
int (*net_order[FOUND_MAX+1])(const char *, int, struct addrinfo **,
|
|
int, int);
|
|
|
|
if (hostname == NULL && servname == NULL)
|
|
return (EAI_NONAME);
|
|
|
|
proto = NULL;
|
|
if (hints != NULL) {
|
|
if (hints->ai_flags & ~(ISC_AI_MASK))
|
|
return (EAI_BADFLAGS);
|
|
if (hints->ai_addrlen || hints->ai_canonname ||
|
|
hints->ai_addr || hints->ai_next) {
|
|
errno = EINVAL;
|
|
return (EAI_SYSTEM);
|
|
}
|
|
family = hints->ai_family;
|
|
socktype = hints->ai_socktype;
|
|
protocol = hints->ai_protocol;
|
|
flags = hints->ai_flags;
|
|
switch (family) {
|
|
case AF_UNSPEC:
|
|
switch (hints->ai_socktype) {
|
|
case SOCK_STREAM: proto = "tcp"; break;
|
|
case SOCK_DGRAM: proto = "udp"; break;
|
|
}
|
|
break;
|
|
case AF_INET:
|
|
case AF_INET6:
|
|
switch (hints->ai_socktype) {
|
|
case 0: break;
|
|
case SOCK_STREAM: proto = "tcp"; break;
|
|
case SOCK_DGRAM: proto = "udp"; break;
|
|
case SOCK_RAW: break;
|
|
default: return (EAI_SOCKTYPE);
|
|
}
|
|
break;
|
|
#ifdef AF_LOCAL
|
|
case AF_LOCAL:
|
|
switch (hints->ai_socktype) {
|
|
case 0: break;
|
|
case SOCK_STREAM: break;
|
|
case SOCK_DGRAM: break;
|
|
default: return (EAI_SOCKTYPE);
|
|
}
|
|
break;
|
|
#endif
|
|
default:
|
|
return (EAI_FAMILY);
|
|
}
|
|
} else {
|
|
protocol = 0;
|
|
family = 0;
|
|
socktype = 0;
|
|
flags = 0;
|
|
}
|
|
|
|
#ifdef AF_LOCAL
|
|
/*
|
|
* First, deal with AF_LOCAL. If the family was not set,
|
|
* then assume AF_LOCAL if the first character of the
|
|
* hostname/servname is '/'.
|
|
*/
|
|
|
|
if (hostname &&
|
|
(family == AF_LOCAL || (family == 0 && *hostname == '/')))
|
|
return (get_local(hostname, socktype, res));
|
|
|
|
if (servname &&
|
|
(family == AF_LOCAL || (family == 0 && *servname == '/')))
|
|
return (get_local(servname, socktype, res));
|
|
#endif
|
|
|
|
/*
|
|
* Ok, only AF_INET and AF_INET6 left.
|
|
*/
|
|
ai_list = NULL;
|
|
|
|
/*
|
|
* First, look up the service name (port) if it was
|
|
* requested. If the socket type wasn't specified, then
|
|
* try and figure it out.
|
|
*/
|
|
if (servname) {
|
|
char *e;
|
|
|
|
port = strtol(servname, &e, 10);
|
|
if (*e == '\0') {
|
|
if (socktype == 0)
|
|
return (EAI_SOCKTYPE);
|
|
if (port < 0 || port > 65535)
|
|
return (EAI_SERVICE);
|
|
port = htons(port);
|
|
} else {
|
|
sp = getservbyname(servname, proto);
|
|
if (sp == NULL)
|
|
return (EAI_SERVICE);
|
|
port = sp->s_port;
|
|
if (socktype == 0) {
|
|
if (strcmp(sp->s_proto, "tcp"))
|
|
socktype = SOCK_STREAM;
|
|
else if (strcmp(sp->s_proto, "udp"))
|
|
socktype = SOCK_DGRAM;
|
|
}
|
|
}
|
|
} else
|
|
port = 0;
|
|
|
|
/*
|
|
* Next, deal with just a service name, and no hostname.
|
|
* (we verified that one of them was non-null up above).
|
|
*/
|
|
if (hostname == NULL && (flags & AI_PASSIVE) != 0) {
|
|
if (family == AF_INET || family == 0) {
|
|
ai = ai_alloc(AF_INET, sizeof(struct sockaddr_in));
|
|
if (ai == NULL)
|
|
return (EAI_MEMORY);
|
|
ai->ai_socktype = socktype;
|
|
ai->ai_protocol = protocol;
|
|
SIN(ai->ai_addr)->sin_port = port;
|
|
ai->ai_next = ai_list;
|
|
ai_list = ai;
|
|
}
|
|
|
|
if (family == AF_INET6 || family == 0) {
|
|
ai = ai_alloc(AF_INET6, sizeof(struct sockaddr_in6));
|
|
if (ai == NULL) {
|
|
lwres_freeaddrinfo(ai_list);
|
|
return (EAI_MEMORY);
|
|
}
|
|
ai->ai_socktype = socktype;
|
|
ai->ai_protocol = protocol;
|
|
SIN6(ai->ai_addr)->sin6_port = port;
|
|
ai->ai_next = ai_list;
|
|
ai_list = ai;
|
|
}
|
|
|
|
*res = ai_list;
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* If the family isn't specified or AI_NUMERICHOST specified,
|
|
* check first to see if it * is a numeric address.
|
|
* Though the gethostbyname2() routine
|
|
* will recognize numeric addresses, it will only recognize
|
|
* the format that it is being called for. Thus, a numeric
|
|
* AF_INET address will be treated by the AF_INET6 call as
|
|
* a domain name, and vice versa. Checking for both numerics
|
|
* here avoids that.
|
|
*/
|
|
if (hostname != NULL &&
|
|
(family == 0 || (flags & AI_NUMERICHOST) != 0)) {
|
|
char abuf[sizeof(struct in6_addr)];
|
|
char nbuf[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx00")];
|
|
int addrsize, addroff;
|
|
|
|
if (lwres_net_aton(hostname, (struct in_addr *)abuf)) {
|
|
if (family == AF_INET6) {
|
|
/*
|
|
* Convert to a V4 mapped address.
|
|
*/
|
|
struct in6_addr *a6 = (struct in6_addr *)abuf;
|
|
memcpy(&a6->s6_addr[12], &a6->s6_addr[0], 4);
|
|
memset(&a6->s6_addr[10], 0xff, 2);
|
|
memset(&a6->s6_addr[0], 0, 10);
|
|
goto inet6_addr;
|
|
}
|
|
addrsize = sizeof(struct in_addr);
|
|
addroff = (char *)(&SIN(0)->sin_addr) - (char *)0;
|
|
family = AF_INET;
|
|
goto common;
|
|
|
|
} else if (lwres_net_pton(AF_INET6, hostname, abuf)) {
|
|
if (family && family != AF_INET6)
|
|
return (EAI_NONAME);
|
|
inet6_addr:
|
|
addrsize = sizeof(struct in6_addr);
|
|
addroff = (char *)(&SIN6(0)->sin6_addr) - (char *)0;
|
|
family = AF_INET6;
|
|
|
|
common:
|
|
if ((ai = ai_clone(ai_list, family)) == NULL)
|
|
return (EAI_MEMORY);
|
|
ai_list = ai;
|
|
ai->ai_socktype = socktype;
|
|
SIN(ai->ai_addr)->sin_port = port;
|
|
memcpy((char *)ai->ai_addr + addroff, abuf, addrsize);
|
|
if (flags & AI_CANONNAME) {
|
|
lwres_net_ntop(family, abuf, nbuf,
|
|
sizeof(nbuf));
|
|
ai->ai_canonname = strdup(nbuf);
|
|
}
|
|
goto done;
|
|
} else if ((flags & AI_NUMERICHOST) != 0){
|
|
return (EAI_NONAME);
|
|
}
|
|
}
|
|
|
|
set_order(family, net_order);
|
|
for (i = 0; i < FOUND_MAX; i++) {
|
|
if (net_order[i] == NULL)
|
|
break;
|
|
if ((err = (net_order[i])(hostname, flags, &ai_list,
|
|
socktype, port)) != 0)
|
|
return(err);
|
|
}
|
|
|
|
if (ai_list == NULL)
|
|
return (EAI_NODATA);
|
|
|
|
done:
|
|
ai_list = ai_reverse(ai_list);
|
|
|
|
*res = ai_list;
|
|
return (0);
|
|
}
|
|
|
|
static char *
|
|
lwres_strsep(char **stringp, const char *delim) {
|
|
char *string = *stringp;
|
|
char *s;
|
|
const char *d;
|
|
char sc, dc;
|
|
|
|
if (string == NULL)
|
|
return (NULL);
|
|
|
|
for (s = string; (sc = *s) != '\0'; s++)
|
|
for (d = delim; (dc = *d) != '\0'; d++)
|
|
if (sc == dc) {
|
|
*s++ = '\0';
|
|
*stringp = s;
|
|
return (string);
|
|
}
|
|
*stringp = NULL;
|
|
return (string);
|
|
}
|
|
|
|
static void
|
|
set_order(int family, int (**net_order)(const char *, int, struct addrinfo **,
|
|
int, int))
|
|
{
|
|
char *order, *tok;
|
|
int found;
|
|
|
|
if (family) {
|
|
switch (family) {
|
|
case AF_INET:
|
|
*net_order++ = add_ipv4;
|
|
break;
|
|
case AF_INET6:
|
|
*net_order++ = add_ipv6;
|
|
break;
|
|
}
|
|
} else {
|
|
order = getenv("NET_ORDER");
|
|
found = 0;
|
|
while (order != NULL) {
|
|
/*
|
|
* We ignore any unknown names.
|
|
*/
|
|
tok = lwres_strsep(&order, ":");
|
|
if (strcasecmp(tok, "inet6") == 0) {
|
|
if ((found & FOUND_IPV6) == 0)
|
|
*net_order++ = add_ipv6;
|
|
found |= FOUND_IPV6;
|
|
} else if (strcasecmp(tok, "inet") == 0 ||
|
|
strcasecmp(tok, "inet4") == 0) {
|
|
if ((found & FOUND_IPV4) == 0)
|
|
*net_order++ = add_ipv4;
|
|
found |= FOUND_IPV4;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Add in anything that we didn't find.
|
|
*/
|
|
if ((found & FOUND_IPV4) == 0)
|
|
*net_order++ = add_ipv4;
|
|
if ((found & FOUND_IPV6) == 0)
|
|
*net_order++ = add_ipv6;
|
|
}
|
|
*net_order = NULL;
|
|
return;
|
|
}
|
|
|
|
static char v4_loop[4] = { 127, 0, 0, 1 };
|
|
|
|
/*
|
|
* The test against 0 is there to keep the Solaris compiler
|
|
* from complaining about "end-of-loop code not reached".
|
|
*/
|
|
#define ERR(code) \
|
|
do { result = (code); \
|
|
if (result != 0) goto cleanup; \
|
|
} while (0)
|
|
|
|
static int
|
|
add_ipv4(const char *hostname, int flags, struct addrinfo **aip,
|
|
int socktype, int port)
|
|
{
|
|
struct addrinfo *ai;
|
|
lwres_context_t *lwrctx = NULL;
|
|
lwres_gabnresponse_t *by = NULL;
|
|
lwres_addr_t *addr;
|
|
lwres_result_t lwres;
|
|
int result = 0;
|
|
|
|
lwres = lwres_context_create(&lwrctx, NULL, NULL, NULL);
|
|
if (lwres != 0)
|
|
ERR(EAI_FAIL);
|
|
if (hostname == NULL && (flags & AI_PASSIVE) == 0) {
|
|
if ((ai = ai_clone(*aip, AF_INET)) == NULL) {
|
|
lwres_freeaddrinfo(*aip);
|
|
ERR(EAI_MEMORY);
|
|
}
|
|
|
|
*aip = ai;
|
|
ai->ai_socktype = socktype;
|
|
SIN(ai->ai_addr)->sin_port = port;
|
|
memcpy(&SIN(ai->ai_addr)->sin_addr, v4_loop, 4);
|
|
} else if (lwres_getaddrsbyname(lwrctx, hostname,
|
|
LWRES_ADDRTYPE_V4, &by) == 0) {
|
|
addr = LWRES_LIST_HEAD(by->addrs);
|
|
while (addr != NULL) {
|
|
ai = ai_clone(*aip, AF_INET);
|
|
if (ai == NULL) {
|
|
lwres_freeaddrinfo(*aip);
|
|
ERR(EAI_MEMORY);
|
|
}
|
|
*aip = ai;
|
|
ai->ai_socktype = socktype;
|
|
SIN(ai->ai_addr)->sin_port = port;
|
|
memcpy(&SIN(ai->ai_addr)->sin_addr,
|
|
addr->address, 4);
|
|
if (flags & AI_CANONNAME)
|
|
ai->ai_canonname = strdup(by->realname);
|
|
addr = LWRES_LIST_NEXT(addr, link);
|
|
}
|
|
}
|
|
cleanup:
|
|
if (by != NULL)
|
|
lwres_gabnresponse_free(lwrctx, &by);
|
|
if (lwrctx != NULL)
|
|
lwres_context_destroy(&lwrctx);
|
|
return(result);
|
|
}
|
|
|
|
static char v6_loop[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 };
|
|
|
|
static int
|
|
add_ipv6(const char *hostname, int flags, struct addrinfo **aip,
|
|
int socktype, int port)
|
|
{
|
|
struct addrinfo *ai;
|
|
lwres_context_t *lwrctx = NULL;
|
|
lwres_gabnresponse_t *by = NULL;
|
|
lwres_addr_t *addr;
|
|
lwres_result_t lwres;
|
|
int result = 0;
|
|
|
|
lwres = lwres_context_create(&lwrctx, NULL, NULL, NULL);
|
|
if (lwres != 0)
|
|
ERR(EAI_FAIL);
|
|
|
|
if (hostname == NULL && (flags & AI_PASSIVE) == 0) {
|
|
if ((ai = ai_clone(*aip, AF_INET6)) == NULL) {
|
|
lwres_freeaddrinfo(*aip);
|
|
ERR(EAI_MEMORY);
|
|
}
|
|
|
|
*aip = ai;
|
|
ai->ai_socktype = socktype;
|
|
SIN6(ai->ai_addr)->sin6_port = port;
|
|
memcpy(&SIN6(ai->ai_addr)->sin6_addr, v6_loop, 16);
|
|
} else if (lwres_getaddrsbyname(lwrctx, hostname,
|
|
LWRES_ADDRTYPE_V6, &by) == 0) {
|
|
addr = LWRES_LIST_HEAD(by->addrs);
|
|
while (addr != NULL) {
|
|
if ((ai = ai_clone(*aip, AF_INET6)) == NULL) {
|
|
lwres_freeaddrinfo(*aip);
|
|
ERR(EAI_MEMORY);
|
|
}
|
|
*aip = ai;
|
|
ai->ai_socktype = socktype;
|
|
SIN6(ai->ai_addr)->sin6_port = port;
|
|
memcpy(&SIN6(ai->ai_addr)->sin6_addr,
|
|
addr->address, 16);
|
|
if (flags & AI_CANONNAME)
|
|
ai->ai_canonname = strdup(by->realname);
|
|
addr = LWRES_LIST_NEXT(addr, link);
|
|
}
|
|
}
|
|
cleanup:
|
|
if (by != NULL)
|
|
lwres_gabnresponse_free(lwrctx, &by);
|
|
if (lwrctx != NULL)
|
|
lwres_context_destroy(&lwrctx);
|
|
return (result);
|
|
}
|
|
|
|
void
|
|
lwres_freeaddrinfo(struct addrinfo *ai) {
|
|
struct addrinfo *ai_next;
|
|
|
|
while (ai != NULL) {
|
|
ai_next = ai->ai_next;
|
|
if (ai->ai_addr)
|
|
free(ai->ai_addr);
|
|
if (ai->ai_canonname)
|
|
free(ai->ai_canonname);
|
|
free(ai);
|
|
ai = ai_next;
|
|
}
|
|
}
|
|
|
|
#ifdef AF_LOCAL
|
|
static int
|
|
get_local(const char *name, int socktype, struct addrinfo **res) {
|
|
struct addrinfo *ai;
|
|
struct sockaddr_un *sun;
|
|
|
|
if (socktype == 0)
|
|
return (EAI_SOCKTYPE);
|
|
|
|
if ((ai = ai_alloc(AF_LOCAL, sizeof(*sun))) == NULL)
|
|
return (EAI_MEMORY);
|
|
|
|
sun = SUN(ai->ai_addr);
|
|
strncpy(sun->sun_path, name, sizeof(sun->sun_path));
|
|
|
|
ai->ai_socktype = socktype;
|
|
/*
|
|
* ai->ai_flags, ai->ai_protocol, ai->ai_canonname,
|
|
* and ai->ai_next were initialized to zero.
|
|
*/
|
|
|
|
*res = ai;
|
|
return (0);
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Allocate an addrinfo structure, and a sockaddr structure
|
|
* of the specificed length. We initialize:
|
|
* ai_addrlen
|
|
* ai_family
|
|
* ai_addr
|
|
* ai_addr->sa_family
|
|
* ai_addr->sa_len (HAVE_SA_LEN)
|
|
* and everything else is initialized to zero.
|
|
*/
|
|
static struct addrinfo *
|
|
ai_alloc(int family, int addrlen) {
|
|
struct addrinfo *ai;
|
|
|
|
if ((ai = (struct addrinfo *)calloc(1, sizeof(*ai))) == NULL)
|
|
return (NULL);
|
|
|
|
if ((ai->ai_addr = SA(calloc(1, addrlen))) == NULL) {
|
|
free(ai);
|
|
return (NULL);
|
|
}
|
|
ai->ai_addrlen = addrlen;
|
|
ai->ai_family = family;
|
|
ai->ai_addr->sa_family = family;
|
|
#ifdef HAVE_SA_LEN
|
|
ai->ai_addr->sa_len = addrlen;
|
|
#endif
|
|
return (ai);
|
|
}
|
|
|
|
static struct addrinfo *
|
|
ai_clone(struct addrinfo *oai, int family) {
|
|
struct addrinfo *ai;
|
|
|
|
ai = ai_alloc(family, ((family == AF_INET6) ?
|
|
sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in)));
|
|
|
|
if (ai == NULL) {
|
|
lwres_freeaddrinfo(oai);
|
|
return (NULL);
|
|
}
|
|
if (oai == NULL)
|
|
return (ai);
|
|
|
|
ai->ai_flags = oai->ai_flags;
|
|
ai->ai_socktype = oai->ai_socktype;
|
|
ai->ai_protocol = oai->ai_protocol;
|
|
ai->ai_canonname = NULL;
|
|
ai->ai_next = oai;
|
|
return (ai);
|
|
}
|
|
|
|
static struct addrinfo *
|
|
ai_reverse(struct addrinfo *oai) {
|
|
struct addrinfo *nai, *tai;
|
|
|
|
nai = NULL;
|
|
|
|
while (oai) {
|
|
/*
|
|
* Grab one off the old list.
|
|
*/
|
|
tai = oai;
|
|
oai = oai->ai_next;
|
|
/*
|
|
* Put it on the front of the new list.
|
|
*/
|
|
tai->ai_next = nai;
|
|
nai = tai;
|
|
}
|
|
return (nai);
|
|
}
|