Index: head/lib/libc/net/getnameinfo.3 =================================================================== --- head/lib/libc/net/getnameinfo.3 (revision 330999) +++ head/lib/libc/net/getnameinfo.3 (revision 331000) @@ -1,298 +1,312 @@ .\" $KAME: getnameinfo.3,v 1.37 2005/01/05 03:23:05 itojun Exp $ .\" $OpenBSD: getnameinfo.3,v 1.36 2004/12/21 09:48:20 jmc Exp $ .\" .\" Copyright (C) 2004 Internet Systems Consortium, Inc. ("ISC") .\" Copyright (C) 2000, 2001 Internet Software Consortium. .\" .\" Permission to use, copy, modify, and distribute this software for any .\" purpose with or without fee is hereby granted, provided that the above .\" copyright notice and this permission notice appear in all copies. .\" .\" THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH .\" REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY .\" AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT, .\" INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM .\" LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE .\" OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR .\" PERFORMANCE OF THIS SOFTWARE. .\" .\" $FreeBSD$ .\" -.Dd July 28, 2016 +.Dd March 15, 2018 .Dt GETNAMEINFO 3 .Os .Sh NAME .Nm getnameinfo .Nd socket address structure to hostname and service name .Sh SYNOPSIS .In sys/types.h .In sys/socket.h .In netdb.h .Ft int .Fo getnameinfo .Fa "const struct sockaddr *sa" "socklen_t salen" "char *host" .Fa "size_t hostlen" "char *serv" "size_t servlen" "int flags" .Fc .Sh DESCRIPTION The .Fn getnameinfo function is used to convert a .Li sockaddr structure to a pair of host name and service strings. It is a replacement for and provides more flexibility than the .Xr gethostbyaddr 3 and .Xr getservbyport 3 functions and is the converse of the .Xr getaddrinfo 3 function. .Pp If a link-layer address or UNIX-domain address is passed to .Fn getnameinfo , its ASCII representation will be stored in .Fa host . The string pointed to by .Fa serv will be set to the empty string if non-NULL; .Fa flags will always be ignored. For a link-layer address, this can be used as a replacement of the legacy .Xr link_ntoa 3 function. .Pp The .Li sockaddr structure .Fa sa should point to either a .Li sockaddr_in , .Li sockaddr_in6 , .Li sockaddr_dl , or .Li sockaddr_un structure .Po for IPv4 , IPv6, link-layer, or UNIX-domain respectively .Pc that is .Fa salen bytes long. +If +.Fa salen +is shorter than the length corresponding to the specified +address family or longer than +.Fn sizeof "struct sockaddr_storage" , +it returns +.Er EAI_FAMILY . +Note that +.Va sa->sa_len +should be consistent with +.Fa salen +though the value of +.Va sa->sa_len +is not directly used in this function. .Pp The host and service names associated with .Fa sa are stored in .Fa host and .Fa serv which have length parameters .Fa hostlen and .Fa servlen . The maximum value for .Fa hostlen is .Dv NI_MAXHOST and the maximum value for .Fa servlen is .Dv NI_MAXSERV , as defined by .Aq Pa netdb.h . If a length parameter is zero, no string will be stored. Otherwise, enough space must be provided to store the host name or service string plus a byte for the NUL terminator. .Pp The .Fa flags argument is formed by .Tn OR Ns 'ing the following values: .Bl -tag -width "NI_NUMERICSCOPEXX" .It Dv NI_NOFQDN A fully qualified domain name is not required for local hosts. The local part of the fully qualified domain name is returned instead. .It Dv NI_NUMERICHOST Return the address in numeric form, as if calling .Xr inet_ntop 3 , instead of a host name. .It Dv NI_NAMEREQD A name is required. If the host name cannot be found in DNS and this flag is set, a non-zero error code is returned. If the host name is not found and the flag is not set, the address is returned in numeric form. .It NI_NUMERICSERV The service name is returned as a digit string representing the port number. .It NI_NUMERICSCOPE The scope identifier is returned as a digit string. .It NI_DGRAM Specifies that the service being looked up is a datagram service, and causes .Xr getservbyport 3 to be called with a second argument of .Dq udp instead of its default of .Dq tcp . This is required for the few ports (512\-514) that have different services for .Tn UDP and .Tn TCP . .El .Pp This implementation allows numeric IPv6 address notation with scope identifier, as documented in chapter 11 of RFC 4007. IPv6 link-local address will appear as a string like .Dq Li fe80::1%ne0 . Refer to .Xr getaddrinfo 3 for more information. .Sh RETURN VALUES .Fn getnameinfo returns zero on success or one of the error codes listed in .Xr gai_strerror 3 if an error occurs. .Sh EXAMPLES The following code tries to get a numeric host name, and service name, for a given socket address. Observe that there is no hardcoded reference to a particular address family. .Bd -literal -offset indent struct sockaddr *sa; /* input */ char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV]; if (getnameinfo(sa, sa->sa_len, hbuf, sizeof(hbuf), sbuf, sizeof(sbuf), NI_NUMERICHOST | NI_NUMERICSERV)) { errx(1, "could not get numeric hostname"); /* NOTREACHED */ } printf("host=%s, serv=%s\en", hbuf, sbuf); .Ed .Pp The following version checks if the socket address has a reverse address mapping: .Bd -literal -offset indent struct sockaddr *sa; /* input */ char hbuf[NI_MAXHOST]; if (getnameinfo(sa, sa->sa_len, hbuf, sizeof(hbuf), NULL, 0, NI_NAMEREQD)) { errx(1, "could not resolve hostname"); /* NOTREACHED */ } printf("host=%s\en", hbuf); .Ed .Sh SEE ALSO .Xr gai_strerror 3 , .Xr getaddrinfo 3 , .Xr gethostbyaddr 3 , .Xr getservbyport 3 , .Xr inet_ntop 3 , .Xr link_ntoa 3 , .Xr resolver 3 , .Xr inet 4 , .Xr inet6 4 , .Xr unix 4 , .Xr hosts 5 , .Xr resolv.conf 5 , .Xr services 5 , .Xr hostname 7 , .Xr named 8 .Rs .%A R. Gilligan .%A S. Thomson .%A J. Bound .%A J. McCann .%A W. Stevens .%T Basic Socket Interface Extensions for IPv6 .%R RFC 3493 .%D February 2003 .Re .Rs .%A S. Deering .%A B. Haberman .%A T. Jinmei .%A E. Nordmark .%A B. Zill .%T "IPv6 Scoped Address Architecture" .%R RFC 4007 .%D March 2005 .Re .Rs .%A Craig Metz .%T Protocol Independence Using the Sockets API .%B "Proceedings of the freenix track: 2000 USENIX annual technical conference" .%D June 2000 .Re .Sh STANDARDS The .Fn getnameinfo function is defined by the .St -p1003.1-2004 specification and documented in .Tn "RFC 3493" , .Dq Basic Socket Interface Extensions for IPv6 . .Sh CAVEATS .Fn getnameinfo can return both numeric and FQDN forms of the address specified in .Fa sa . There is no return value that indicates whether the string returned in .Fa host is a result of binary to numeric-text translation (like .Xr inet_ntop 3 ) , or is the result of a DNS reverse lookup. Because of this, malicious parties could set up a PTR record as follows: .Bd -literal -offset indent 1.0.0.127.in-addr.arpa. IN PTR 10.1.1.1 .Ed .Pp and trick the caller of .Fn getnameinfo into believing that .Fa sa is .Li 10.1.1.1 when it is actually .Li 127.0.0.1 . .Pp To prevent such attacks, the use of .Dv NI_NAMEREQD is recommended when the result of .Fn getnameinfo is used for access control purposes: .Bd -literal -offset indent struct sockaddr *sa; socklen_t salen; char addr[NI_MAXHOST]; struct addrinfo hints, *res; int error; error = getnameinfo(sa, salen, addr, sizeof(addr), NULL, 0, NI_NAMEREQD); if (error == 0) { memset(&hints, 0, sizeof(hints)); hints.ai_socktype = SOCK_DGRAM; /*dummy*/ hints.ai_flags = AI_NUMERICHOST; if (getaddrinfo(addr, "0", &hints, &res) == 0) { /* malicious PTR record */ freeaddrinfo(res); printf("bogus PTR record\en"); return -1; } /* addr is FQDN as a result of PTR lookup */ } else { /* addr is numeric string */ error = getnameinfo(sa, salen, addr, sizeof(addr), NULL, 0, NI_NUMERICHOST); } .Ed .\".Pp .\".Ox .\"intentionally uses a different .\".Dv NI_MAXHOST .\"value from what .\".Tn "RFC 2553" .\"suggests, to avoid buffer length handling mistakes. Index: head/lib/libc/net/getnameinfo.c =================================================================== --- head/lib/libc/net/getnameinfo.c (revision 330999) +++ head/lib/libc/net/getnameinfo.c (revision 331000) @@ -1,530 +1,540 @@ /* $KAME: getnameinfo.c,v 1.61 2002/06/27 09:25:47 itojun Exp $ */ /*- * SPDX-License-Identifier: BSD-3-Clause * * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project. * Copyright (c) 2000 Ben Harris. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 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. 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 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 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) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * 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. */ /* * Issues to be discussed: * - Thread safe-ness must be checked * - 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). ipngwg rough consensus seems to follow RFC2553. * - What is "local" in NI_FQDN? * - NI_NAMEREQD and NI_NUMERICHOST conflict with each other. * - (KAME extension) always attach textual scopeid (fe80::1%lo0), if * sin6_scope_id is filled - standardization status? * XXX breaks backward compat for code that expects no scopeid. * beware on merge. */ #include __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include static const struct afd *find_afd(int); static int getnameinfo_inet(const struct afd *, const struct sockaddr *, socklen_t, char *, size_t, char *, size_t, int); #ifdef INET6 static int ip6_parsenumeric(const struct sockaddr *, const char *, char *, size_t, int); static int ip6_sa2str(const struct sockaddr_in6 *, char *, size_t, int); #endif static int getnameinfo_link(const struct afd *, const struct sockaddr *, socklen_t, char *, size_t, char *, size_t, int); static int hexname(const u_int8_t *, size_t, char *, size_t); static int getnameinfo_un(const struct afd *, const struct sockaddr *, socklen_t, char *, size_t, char *, size_t, int); static const struct afd { int a_af; size_t a_addrlen; socklen_t a_socklen; int a_off; int (*a_func)(const struct afd *, const struct sockaddr *, socklen_t, char *, size_t, char *, size_t, int); } afdl [] = { #ifdef INET6 {PF_INET6, sizeof(struct in6_addr), sizeof(struct sockaddr_in6), offsetof(struct sockaddr_in6, sin6_addr), getnameinfo_inet}, #endif {PF_INET, sizeof(struct in_addr), sizeof(struct sockaddr_in), offsetof(struct sockaddr_in, sin_addr), getnameinfo_inet}, #define sizeofmember(type, member) (sizeof(((type *)0)->member)) {PF_LOCAL, sizeofmember(struct sockaddr_un, sun_path), sizeof(struct sockaddr_un), offsetof(struct sockaddr_un, sun_path), getnameinfo_un}, {PF_LINK, sizeofmember(struct sockaddr_dl, sdl_data), sizeof(struct sockaddr_dl), offsetof(struct sockaddr_dl, sdl_data), getnameinfo_link}, {0, 0, 0}, }; int getnameinfo(const struct sockaddr *sa, socklen_t salen, char *host, size_t hostlen, char *serv, size_t servlen, int flags) { const struct afd *afd; if (sa == NULL) return (EAI_FAIL); afd = find_afd(sa->sa_family); if (afd == NULL) return (EAI_FAMILY); + /* + * getnameinfo() accepts an salen of sizeof(struct sockaddr_storage) + * at maximum as shown in RFC 4038 Sec.6.2.3. + */ + if (salen > sizeof(struct sockaddr_storage)) + return (EAI_FAMILY); + switch (sa->sa_family) { case PF_LOCAL: /* - * PF_LOCAL uses variable sa->sa_len depending on the + * PF_LOCAL uses variable salen depending on the * content length of sun_path. Require 1 byte in * sun_path at least. */ - if (salen > afd->a_socklen || - salen <= afd->a_socklen - + if (salen <= afd->a_socklen - sizeofmember(struct sockaddr_un, sun_path)) - return (EAI_FAIL); + return (EAI_FAMILY); + else if (salen > afd->a_socklen) + salen = afd->a_socklen; break; case PF_LINK: if (salen <= afd->a_socklen - sizeofmember(struct sockaddr_dl, sdl_data)) - return (EAI_FAIL); + return (EAI_FAMILY); break; default: - if (salen != afd->a_socklen) - return (EAI_FAIL); + if (salen < afd->a_socklen) + return (EAI_FAMILY); + else + salen = afd->a_socklen; break; } return ((*afd->a_func)(afd, sa, salen, host, hostlen, serv, servlen, flags)); } static const struct afd * find_afd(int af) { const struct afd *afd; if (af == PF_UNSPEC) return (NULL); for (afd = &afdl[0]; afd->a_af > 0; afd++) { if (afd->a_af == af) return (afd); } return (NULL); } static int getnameinfo_inet(const struct afd *afd, const struct sockaddr *sa, socklen_t salen, char *host, size_t hostlen, char *serv, size_t servlen, int flags) { struct servent *sp; struct hostent *hp; u_short port; const char *addr; u_int32_t v4a; int h_error; char numserv[512]; char numaddr[512]; /* network byte order */ port = ((const struct sockaddr_in *)sa)->sin_port; addr = (const char *)sa + afd->a_off; if (serv == NULL || servlen == 0) { /* * do nothing in this case. * in case you are wondering if "&&" is more correct than * "||" here: rfc2553bis-03 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) + 1 > servlen) return EAI_MEMORY; strlcpy(serv, sp->s_name, servlen); } else { snprintf(numserv, sizeof(numserv), "%u", ntohs(port)); if (strlen(numserv) + 1 > servlen) return EAI_MEMORY; strlcpy(serv, numserv, servlen); } } switch (sa->sa_family) { case AF_INET: v4a = (u_int32_t) ntohl(((const 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) flags |= NI_NUMERICHOST; break; #ifdef INET6 case AF_INET6: { const struct sockaddr_in6 *sin6; sin6 = (const 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; default: if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr)) { flags |= NI_NUMERICHOST; } else if (IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr)) flags |= NI_NUMERICHOST; break; } } break; #endif } if (host == NULL || hostlen == 0) { /* * do nothing in this case. * in case you are wondering if "&&" is more correct than * "||" here: rfc2553bis-03 says that host == NULL or * hostlen == 0 means that the caller does not want the result. */ } else if (flags & NI_NUMERICHOST) { size_t numaddrlen; /* NUMERICHOST and NAMEREQD conflicts with each other */ if (flags & NI_NAMEREQD) return EAI_NONAME; switch(afd->a_af) { #ifdef INET6 case AF_INET6: { int error; if ((error = ip6_parsenumeric(sa, addr, host, hostlen, flags)) != 0) return(error); break; } #endif default: if (inet_ntop(afd->a_af, addr, numaddr, sizeof(numaddr)) == NULL) return EAI_SYSTEM; numaddrlen = strlen(numaddr); if (numaddrlen + 1 > hostlen) /* don't forget terminator */ return EAI_MEMORY; strlcpy(host, numaddr, hostlen); break; } } else { hp = getipnodebyaddr(addr, afd->a_addrlen, afd->a_af, &h_error); if (hp) { #if 0 /* * commented out, since "for local host" is not * implemented here - see RFC2553 p30 */ if (flags & NI_NOFQDN) { char *p; p = strchr(hp->h_name, '.'); if (p) *p = '\0'; } #endif if (strlen(hp->h_name) + 1 > hostlen) { freehostent(hp); return EAI_MEMORY; } strlcpy(host, hp->h_name, hostlen); freehostent(hp); } else { if (flags & NI_NAMEREQD) return EAI_NONAME; switch(afd->a_af) { #ifdef INET6 case AF_INET6: { int error; if ((error = ip6_parsenumeric(sa, addr, host, hostlen, flags)) != 0) return(error); break; } #endif default: if (inet_ntop(afd->a_af, addr, host, hostlen) == NULL) return EAI_SYSTEM; break; } } } return(0); } #ifdef INET6 static int ip6_parsenumeric(const struct sockaddr *sa, const char *addr, char *host, size_t hostlen, int flags) { size_t numaddrlen; char numaddr[512]; if (inet_ntop(AF_INET6, addr, numaddr, sizeof(numaddr)) == NULL) return EAI_SYSTEM; numaddrlen = strlen(numaddr); if (numaddrlen + 1 > hostlen) /* don't forget terminator */ return EAI_OVERFLOW; strlcpy(host, numaddr, hostlen); if (((const struct sockaddr_in6 *)sa)->sin6_scope_id) { char zonebuf[MAXHOSTNAMELEN]; int zonelen; zonelen = ip6_sa2str( (const struct sockaddr_in6 *)(const void *)sa, zonebuf, sizeof(zonebuf), flags); if (zonelen < 0) return EAI_OVERFLOW; if (zonelen + 1 + numaddrlen + 1 > hostlen) return EAI_OVERFLOW; /* construct */ memcpy(host + numaddrlen + 1, zonebuf, (size_t)zonelen); host[numaddrlen] = SCOPE_DELIMITER; host[numaddrlen + 1 + zonelen] = '\0'; } return 0; } /* ARGSUSED */ static int ip6_sa2str(const struct sockaddr_in6 *sa6, char *buf, size_t bufsiz, int flags) { unsigned int ifindex; const struct in6_addr *a6; int n; ifindex = (unsigned int)sa6->sin6_scope_id; a6 = &sa6->sin6_addr; if ((flags & NI_NUMERICSCOPE) != 0) { n = snprintf(buf, bufsiz, "%u", sa6->sin6_scope_id); if (n < 0 || n >= bufsiz) return -1; else return n; } /* if_indextoname() does not take buffer size. not a good api... */ if ((IN6_IS_ADDR_LINKLOCAL(a6) || IN6_IS_ADDR_MC_LINKLOCAL(a6) || IN6_IS_ADDR_MC_NODELOCAL(a6)) && bufsiz >= IF_NAMESIZE) { char *p = if_indextoname(ifindex, buf); if (p) { return(strlen(p)); } } /* last resort */ n = snprintf(buf, bufsiz, "%u", sa6->sin6_scope_id); if (n < 0 || (size_t)n >= bufsiz) return -1; else return n; } #endif /* INET6 */ /* * getnameinfo_link(): * Format a link-layer address into a printable format, paying attention to * the interface type. */ /* ARGSUSED */ static int getnameinfo_link(const struct afd *afd, const struct sockaddr *sa, socklen_t salen, char *host, size_t hostlen, char *serv, size_t servlen, int flags) { const struct sockaddr_dl *sdl = (const struct sockaddr_dl *)(const void *)sa; const struct fw_hwaddr *iha; int n; if (serv != NULL && servlen > 0) *serv = '\0'; if (sdl->sdl_nlen == 0 && sdl->sdl_alen == 0 && sdl->sdl_slen == 0) { n = snprintf(host, hostlen, "link#%d", sdl->sdl_index); if (n >= hostlen) { *host = '\0'; return (EAI_MEMORY); } return (0); } if (sdl->sdl_nlen > 0 && sdl->sdl_alen == 0) { n = sdl->sdl_nlen; if (n >= hostlen) { *host = '\0'; return (EAI_MEMORY); } memcpy(host, sdl->sdl_data, sdl->sdl_nlen); host[n] = '\0'; return (0); } switch (sdl->sdl_type) { case IFT_IEEE1394: if (sdl->sdl_alen < sizeof(iha->sender_unique_ID_hi) + sizeof(iha->sender_unique_ID_lo)) return EAI_FAMILY; iha = (const struct fw_hwaddr *)(const void *)LLADDR(sdl); return hexname((const u_int8_t *)&iha->sender_unique_ID_hi, sizeof(iha->sender_unique_ID_hi) + sizeof(iha->sender_unique_ID_lo), host, hostlen); /* * The following have zero-length addresses. * IFT_GIF (net/if_gif.c) * IFT_LOOP (net/if_loop.c) * IFT_PPP (net/if_ppp.c, net/if_spppsubr.c) * IFT_SLIP (net/if_sl.c, net/if_strip.c) * IFT_STF (net/if_stf.c) * IFT_L2VLAN (net/if_vlan.c) * IFT_BRIDGE (net/if_bridge.h> */ /* * The following use IPv4 addresses as link-layer addresses: * IFT_OTHER (net/if_gre.c) * IFT_OTHER (netinet/ip_ipip.c) */ /* default below is believed correct for all these. */ case IFT_ARCNET: case IFT_ETHER: case IFT_FDDI: case IFT_HIPPI: case IFT_ISO88025: default: return hexname((u_int8_t *)LLADDR(sdl), (size_t)sdl->sdl_alen, host, hostlen); } } static int hexname(const u_int8_t *cp, size_t len, char *host, size_t hostlen) { int i, n; char *outp = host; *outp = '\0'; for (i = 0; i < len; i++) { n = snprintf(outp, hostlen, "%s%02x", i ? ":" : "", cp[i]); if (n < 0 || n >= hostlen) { *host = '\0'; return EAI_MEMORY; } outp += n; hostlen -= n; } return 0; } /* * getnameinfo_un(): * Format a UNIX IPC domain address (pathname). */ /* ARGSUSED */ static int getnameinfo_un(const struct afd *afd, const struct sockaddr *sa, socklen_t salen, char *host, size_t hostlen, char *serv, size_t servlen, int flags) { size_t pathlen; if (serv != NULL && servlen > 0) *serv = '\0'; if (host != NULL && hostlen > 0) { - pathlen = sa->sa_len - afd->a_off; + pathlen = salen - afd->a_off; if (pathlen + 1 > hostlen) { *host = '\0'; return (EAI_MEMORY); } strlcpy(host, (const char *)sa + afd->a_off, pathlen + 1); } return (0); }