/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (the "License"). You may not use this file except in compliance * with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2004 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ #include <sys/types.h> #include <stdlib.h> #include <string.h> #include <strings.h> #include <stdio.h> #include <ctype.h> #include <sys/socket.h> #include <netdb.h> #include <arpa/inet.h> #include <nss_dbdefs.h> #include <netinet/in.h> #include <sys/socket.h> #include <net/if.h> #define sa2sin(x) ((struct sockaddr_in *)(x)) #define sa2sin6(x) ((struct sockaddr_in6 *)(x)) #define NI_MASK (NI_NOFQDN | NI_NUMERICHOST | NI_NAMEREQD | NI_NUMERICSERV | \ NI_DGRAM | NI_WITHSCOPEID) static int addzoneid(const struct sockaddr_in6 *sa, char *host, size_t hostlen); static size_t getzonestr(const struct sockaddr_in6 *sa, char *zonestr, size_t zonelen); static const char *_inet_ntop_native(); /* * getnameinfo: * * Purpose: * Routine for performing Address-to-nodename in a * protocol-independent fashion. * Description: * This function looks up an IP address and port number provided * by the caller in the name service database and returns the nodename * and servname respectively in the buffers provided by the caller. * Input Parameters: * sa - points to either a sockaddr_in structure (for * IPv4) or a sockaddr_in6 structure (for IPv6). * salen - length of the sockaddr_in or sockaddr_in6 structure. * hostlen - length of caller supplied "host" buffer * servlen - length of caller supplied "serv" buffer * flags - changes default actions based on setting. * Possible settings for "flags": * NI_NOFQDN - Always return nodename portion of the fully-qualified * domain name (FQDN). * NI_NUMERICHOST - Always return numeric form of the host's * address. * NI_NAMEREQD - If hostname cannot be located in database, * don't return numeric form of address - return * an error instead. * NI_NUMERICSERV - Always return numeric form of the service address * instead of its name. * NI_DGRAM - Specifies that the service is a datagram service, and * causes getservbyport() to be called with a second * argument of "udp" instead of its default "tcp". * Output Parameters: * host - return the nodename associcated with the IP address in the * buffer pointed to by the "host" argument. * serv - return the service name associated with the port number * in the buffer pointed to by the "serv" argument. * Return Value: * This function indicates successful completion by a zero return * value; a non-zero return value indicates failure. */ int getnameinfo(const struct sockaddr *sa, socklen_t salen, char *host, socklen_t hostlen, char *serv, socklen_t servlen, int flags) { char *addr; size_t alen, slen; in_port_t port; int errnum; int err; /* Verify correctness of buffer lengths */ if ((hostlen == 0) && (servlen == 0)) return (EAI_FAIL); /* Verify correctness of possible flag settings */ if ((flags != 0) && (flags & ~NI_MASK)) return (EAI_BADFLAGS); if (sa == NULL) return (EAI_ADDRFAMILY); switch (sa->sa_family) { case AF_INET: addr = (char *)&sa2sin(sa)->sin_addr; alen = sizeof (struct in_addr); slen = sizeof (struct sockaddr_in); port = (sa2sin(sa)->sin_port); /* network byte order */ break; case AF_INET6: addr = (char *)&sa2sin6(sa)->sin6_addr; alen = sizeof (struct in6_addr); slen = sizeof (struct sockaddr_in6); port = (sa2sin6(sa)->sin6_port); /* network byte order */ break; default: return (EAI_FAMILY); } if (salen != slen) return (EAI_FAIL); /* * Case 1: if Caller sets hostlen != 0, then * fill in "host" buffer that user passed in * with appropriate text string. */ if (hostlen != 0) { if (flags & NI_NUMERICHOST) { /* Caller wants the host's numeric address */ if (inet_ntop(sa->sa_family, addr, host, hostlen) == NULL) return (EAI_SYSTEM); } else { struct hostent *hp; /* Caller wants the name of host */ hp = getipnodebyaddr(addr, alen, sa->sa_family, &errnum); if (hp != NULL) { if (flags & NI_NOFQDN) { char *dot; /* * Caller doesn't want fully-qualified * name. */ dot = strchr(hp->h_name, '.'); if (dot != NULL) *dot = '\0'; } if (strlen(hp->h_name) + 1 > hostlen) { freehostent(hp); return (EAI_OVERFLOW); } (void) strcpy(host, hp->h_name); freehostent(hp); } else { /* * Host's name cannot be located in the name * service database. If NI_NAMEREQD is set, * return error; otherwise, return host's * numeric address. */ if (flags & NI_NAMEREQD) { switch (errnum) { case HOST_NOT_FOUND: return (EAI_NONAME); case TRY_AGAIN: return (EAI_AGAIN); case NO_RECOVERY: return (EAI_FAIL); case NO_ADDRESS: return (EAI_NODATA); default: return (EAI_SYSTEM); } } if (_inet_ntop_native(sa->sa_family, addr, host, hostlen) == NULL) return (EAI_SYSTEM); } } /* * Check for a non-zero sin6_scope_id, indicating a * zone-id needs to be appended to the resultant 'host' * string. */ if ((sa->sa_family == AF_INET6) && (sa2sin6(sa)->sin6_scope_id != 0)) { /* * According to draft-ietf-ipngwg-scoping-arch-XX, only * non-global scope addresses can make use of the * <addr>%<zoneid> format. This implemenation * supports only link scope addresses, since the use of * site-local addressing is not yet fully specified. * If the address meets this criteria, attempt to add a * zone-id to 'host'. If it does not, return * EAI_NONAME. */ if (IN6_IS_ADDR_LINKSCOPE(&(sa2sin6(sa)->sin6_addr))) { if ((err = addzoneid(sa2sin6(sa), host, hostlen)) != 0) { return (err); } } else { return (EAI_NONAME); } } } /* * Case 2: if Caller sets servlen != 0, then * fill in "serv" buffer that user passed in * with appropriate text string. */ if (servlen != 0) { char port_buf[10]; int portlen; if (flags & NI_NUMERICSERV) { /* Caller wants the textual form of the port number */ portlen = snprintf(port_buf, sizeof (port_buf), "%hu", ntohs(port)); if (servlen < portlen + 1) return (EAI_OVERFLOW); (void) strcpy(serv, port_buf); } else { struct servent *sp; /* * Caller wants the name of the service. * If NI_DGRAM is set, get service name for * specified port for udp. */ sp = getservbyport(port, flags & NI_DGRAM ? "udp" : "tcp"); if (sp != NULL) { if (servlen < strlen(sp->s_name) + 1) return (EAI_OVERFLOW); (void) strcpy(serv, sp->s_name); } else { /* * if service is not in the name server's * database, fill buffer with numeric form for * port number. */ portlen = snprintf(port_buf, sizeof (port_buf), "%hu", ntohs(port)); if (servlen < portlen + 1) return (EAI_OVERFLOW); (void) strcpy(serv, port_buf); } } } return (0); } /* * addzoneid(sa, host, hostlen) * * Appends a zone-id to the input 'host' string if the input sin6_scope_id * is non-zero. The resultant 'host' string would be of the form * 'host'%'zone-id'. Where 'zone-id' can be either an interface name or a * literal interface index. * * Return Values: * 0 - on success * EAI_MEMORY - an error occured when forming the output string */ static int addzoneid(const struct sockaddr_in6 *sa, char *host, size_t hostlen) { char zonestr[LIFNAMSIZ]; size_t zonelen; size_t addrlen = strlen(host); /* make sure zonelen is valid sizeof (<addr>%<zoneid>\0) */ if (((zonelen = getzonestr(sa, zonestr, sizeof (zonestr))) == 0) || ((addrlen + 1 + zonelen + 1) > hostlen)) { return (EAI_MEMORY); } /* Create address string of form <addr>%<zoneid> */ host[addrlen] = '%'; /* place address-zoneid delimiter */ (void) strlcpy((host + addrlen + 1), zonestr, (zonelen + 1)); return (0); } /* * getzonestr(sa, zonestr) * * parse zone string from input sockaddr_in6 * * Note: This function calls if_indextoname, a very poor interface, * defined in RFC2553, for converting an interface index to an * interface name. Callers of this function must be sure that * zonestr is atleast LIFNAMSIZ in length, since this is the longest * possible value if_indextoname will return. * * Return values: * 0 an error with calling this function occured * >0 zonestr is filled with a valid zoneid string and the return value is the * length of that string. */ static size_t getzonestr(const struct sockaddr_in6 *sa, char *zonestr, size_t zonelen) { uint32_t ifindex; char *retstr; if (zonestr == NULL) { return (0); } /* * Since this implementation only supports link scope addresses, * there is a one-to-one mapping between interface index and * sin6_scope_id. */ ifindex = sa->sin6_scope_id; if ((retstr = if_indextoname(ifindex, zonestr)) != NULL) { return (strlen(retstr)); } else { int n; /* * Failed to convert ifindex into an interface name, * simply return the literal value of ifindex as * a string. */ if ((n = snprintf(zonestr, zonelen, "%u", ifindex)) < 0) { return (0); } else { if (n >= zonelen) { return (0); } return (n); } } } /* * This is a wrapper function for inet_ntop(). In case the af is AF_INET6 * and the address pointed by src is a IPv4-mapped IPv6 address, it * returns printable IPv4 address, not IPv4-mapped IPv6 address. In other cases * it behaves just like inet_ntop(). */ static const char * _inet_ntop_native(int af, const void *src, char *dst, size_t size) { struct in_addr src4; const char *result; if (af == AF_INET6) { if (IN6_IS_ADDR_V4MAPPED((struct in6_addr *)src)) { IN6_V4MAPPED_TO_INADDR((struct in6_addr *)src, &src4); result = inet_ntop(AF_INET, &src4, dst, size); } else { result = inet_ntop(AF_INET6, src, dst, size); } } else { result = inet_ntop(af, src, dst, size); } return (result); }
