/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (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 2011 Nexenta Systems, Inc.  All rights reserved.
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 * Copyright 2012 Milan Jurik. All rights reserved.
 */

/*
 * This is where we have chosen to combine every useful bit of code for
 * all the Solaris frontends to lookup hosts, services, and netdir information
 * for inet family (udp, tcp) transports. gethostbyYY(), getservbyYY(), and
 * netdir_getbyYY() are all implemented on top of this code. Similarly,
 * netdir_options, taddr2uaddr, and uaddr2taddr for inet transports also
 * find a home here.
 *
 * If the netconfig structure supplied has NO nametoaddr libs (i.e. a "-"
 * in /etc/netconfig), this code calls the name service switch, and
 * therefore, /etc/nsswitch.conf is effectively the only place that
 * dictates hosts/serv lookup policy.
 * If an administrator chooses to bypass the name service switch by
 * specifying third party supplied nametoaddr libs in /etc/netconfig, this
 * implementation does NOT call the name service switch, it merely loops
 * through the nametoaddr libs. In this case, if this code was called
 * from gethost/servbyYY() we marshal the inet specific struct into
 * transport independent netbuf or hostserv, and unmarshal the resulting
 * nd_addrlist or hostservlist back into hostent and servent, as the case
 * may be.
 *
 * Goes without saying that most of the future bugs in gethost/servbyYY
 * and netdir_getbyYY are lurking somewhere here.
 */

#include "mt.h"
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <stropts.h>
#include <sys/types.h>
#include <sys/byteorder.h>
#include <sys/ioctl.h>
#include <sys/param.h>
#include <sys/time.h>
#include <errno.h>
#include <fcntl.h>
#include <thread.h>
#include <synch.h>
#include <sys/utsname.h>
#include <netdb.h>
#include <netconfig.h>
#include <netdir.h>
#include <tiuser.h>
#include <sys/socket.h>
#include <sys/sockio.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <net/if.h>
#include <inet/ip.h>
#include <inet/ip6_asp.h>
#include <sys/dlpi.h>
#include <nss_dbdefs.h>
#include <nss_netdir.h>
#include <syslog.h>
#include <nsswitch.h>
#include "nss.h"

#define MAXIFS 32
#define UDPDEV  "/dev/udp"
#define UDP6DEV "/dev/udp6"

#define DOOR_GETHOSTBYNAME_R    _switch_gethostbyname_r
#define DOOR_GETHOSTBYADDR_R    _switch_gethostbyaddr_r
#define DOOR_GETIPNODEBYNAME_R  _switch_getipnodebyname_r
#define DOOR_GETIPNODEBYADDR_R  _switch_getipnodebyaddr_r

#define DONT_SORT       "SORT_ADDRS=NO"
#define DONT_SORT2      "SORT_ADDRS=FALSE"
#define LINESIZE        100

/*
 * constant values of addresses for HOST_SELF_BIND, HOST_SELF_CONNECT
 * and localhost.
 *
 * The following variables are static to the extent that they should
 * not be visible outside of this file.
 */
static char *localaddr[] = {"\000\000\000\000", NULL};
static char *connectaddr[] = {"\177\000\000\001", NULL};
static char *localaddr6[] =
{"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000", NULL};
static char *connectaddr6[] =
{"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001", NULL};

/* IPv4 nd_addrlist */
static mutex_t  nd_addr_lock = DEFAULTMUTEX;
static struct sockaddr_in sa_con;
static struct netbuf nd_conbuf = {sizeof (sa_con),\
    sizeof (sa_con), (char *)&sa_con};
static struct nd_addrlist nd_conaddrlist = {1, &nd_conbuf};

/* IPv6 nd_addrlist */
static mutex_t  nd6_addr_lock = DEFAULTMUTEX;
static struct sockaddr_in6 sa6_con;
static struct netbuf nd6_conbuf = {sizeof (sa6_con),\
        sizeof (sa6_con), (char *)&sa6_con};
static struct nd_addrlist nd6_conaddrlist = {1, &nd6_conbuf};

#define LOCALHOST "localhost"

struct servent *_switch_getservbyname_r(const char *, const char *,
    struct servent *, char *, int);
struct servent *_switch_getservbyport_r(int, const char *, struct servent *,
    char *, int);

static int __herrno2netdir(int h_errnop);
static struct ifinfo *get_local_info(void);
static int getbroadcastnets(struct netconfig *, struct in_addr **);
static int hent2ndaddr(int, char **, int *, struct nd_addrlist **);
static int ndaddr2hent(int, const char *, struct nd_addrlist *,
    struct hostent *, char *, int);
static int hsents2ndhostservs(struct hostent *, struct servent *, ushort_t,
    struct nd_hostservlist **);
static int ndaddr2srent(const char *, const char *, ushort_t, struct servent *,
    char *, int);
static int ndhostserv2hent(struct netbuf *, struct nd_hostservlist *,
    struct hostent *, char *, int);
static int ndhostserv2srent(int, const char *, struct nd_hostservlist *,
    struct servent *, char *, int);
static int nd2herrno(int nerr);
static void order_haddrlist_inet(char **haddrlist, size_t addrcount);
static void order_haddrlist_inet6(char **haddrlist, size_t addrcount);
static int dstcmp(const void *, const void *);
static int nss_strioctl(int af, int cmd, void *ptr, int ilen);
static struct in_addr _inet_makeaddr(in_addr_t, in_addr_t);
static boolean_t _read_nsw_file(void);

/*
 * Begin: PART I
 * Top Level Interfaces that gethost/serv/netdir funnel through.
 */

static int
inetdir_free(int ret, struct in_addr *inaddrs, char **baddrlist)
{
        if (inaddrs)
                free(inaddrs);
        if (baddrlist)
                free(baddrlist);
        _nderror = ret;
        return (ret);
}

/*
 * gethost/servbyname always call this function; if they call
 * with nametoaddr libs in nconf, we call netdir_getbyname
 * implementation: __classic_netdir_getbyname, otherwise nsswitch.
 *
 * netdir_getbyname calls this only if nametoaddr libs are NOT
 * specified for inet transports; i.e. it's supposed to follow
 * the name service switch.
 */
int
_get_hostserv_inetnetdir_byname(struct netconfig *nconf,
    struct nss_netdirbyname_in *args, union nss_netdirbyname_out *res)
{
        int     server_port;
        int *servp = &server_port;
        char    **haddrlist;
        uint32_t dotnameaddr;
        char    *dotnamelist[2];
        struct in_addr  *inaddrs = NULL;
        struct in6_addr v6nameaddr;
        char    **baddrlist = NULL;

        if (nconf == NULL) {
                _nderror = ND_BADARG;
                return (ND_BADARG);
        }

        /*
         * 1. gethostbyname()/netdir_getbyname() special cases:
         */
        switch (args->op_t) {

                case NSS_HOST:
                /*
                 * Worth the performance gain -- assuming a lot of inet apps
                 * actively use "localhost".
                 */
                if (strcmp(args->arg.nss.host.name, LOCALHOST) == 0) {

                        (void) mutex_lock(&nd_addr_lock);
                        IN_SET_LOOPBACK_ADDR(&sa_con);
                        _nderror = ndaddr2hent(AF_INET, args->arg.nss.host.name,
                            &nd_conaddrlist, res->nss.host.hent,
                            args->arg.nss.host.buf,
                            args->arg.nss.host.buflen);
                        (void) mutex_unlock(&nd_addr_lock);
                        if (_nderror != ND_OK)
                                *(res->nss.host.herrno_p) =
                                    nd2herrno(_nderror);
                        return (_nderror);
                }
                /*
                 * If the caller passed in a dot separated IP notation to
                 * gethostbyname, return that back as the address.
                 * The nd_addr_lock mutex was added to be truely re-entrant.
                 */
                if (inet_aton(args->arg.nss.host.name,
                    (struct in_addr *)&dotnameaddr)) {
                        (void) mutex_lock(&nd_addr_lock);
                        (void) memset(&sa_con, 0, sizeof (sa_con));
                        sa_con.sin_family = AF_INET;
                        sa_con.sin_addr.s_addr = dotnameaddr;
                        _nderror = ndaddr2hent(AF_INET, args->arg.nss.host.name,
                            &nd_conaddrlist, res->nss.host.hent,
                            args->arg.nss.host.buf,
                            args->arg.nss.host.buflen);
                        (void) mutex_unlock(&nd_addr_lock);
                        if (_nderror != ND_OK)
                                *(res->nss.host.herrno_p) =
                                    nd2herrno(_nderror);
                        return (_nderror);
                }
                break;

                case NSS_HOST6:
                /*
                 * Handle case of literal address string.
                 */
                if (strchr(args->arg.nss.host6.name, ':') != NULL &&
                    (inet_pton(AF_INET6, args->arg.nss.host6.name,
                    &v6nameaddr) != 0)) {
                        int     ret;

                        (void) mutex_lock(&nd6_addr_lock);
                        (void) memset(&sa6_con, 0, sizeof (sa6_con));
                        sa6_con.sin6_family = AF_INET6;
                        (void) memcpy(&(sa6_con.sin6_addr.s6_addr),
                            &v6nameaddr, sizeof (struct in6_addr));
                        ret = ndaddr2hent(AF_INET6,
                            args->arg.nss.host6.name,
                            &nd6_conaddrlist, res->nss.host.hent,
                            args->arg.nss.host6.buf,
                            args->arg.nss.host6.buflen);
                        (void) mutex_unlock(&nd6_addr_lock);
                        if (ret != ND_OK)
                                *(res->nss.host.herrno_p) = nd2herrno(ret);
                        else
                                res->nss.host.hent->h_aliases = NULL;
                        return (ret);
                }
                break;

                case NETDIR_BY:
                        if (args->arg.nd_hs == 0) {
                                _nderror = ND_BADARG;
                                return (ND_BADARG);
                        }
                        /*
                         * If servname is NULL, return 0 as the port number
                         * If servname is rpcbind, return 111 as the port number
                         * If servname is a number, return it back as the port
                         * number.
                         */
                        if (args->arg.nd_hs->h_serv == 0) {
                                *servp = htons(0);
                        } else if (strcmp(args->arg.nd_hs->h_serv,
                            "rpcbind") == 0) {
                                *servp = htons(111);
                        } else if (strspn(args->arg.nd_hs->h_serv,
                            "0123456789") ==
                            strlen(args->arg.nd_hs->h_serv)) {
                                *servp = htons(atoi(args->arg.nd_hs->h_serv));
                        } else {
                                /* i.e. need to call a name service on this */
                                servp = NULL;
                        }

                        /*
                         * If the hostname is HOST_SELF_BIND, we return 0.0.0.0
                         * so the  binding can be contacted through all
                         * interfaces. If the hostname is HOST_SELF_CONNECT,
                         * we return 127.0.0.1 so the address can be connected
                         * to locally. If the hostname is HOST_ANY, we return
                         * no addresses because IP doesn't know how to specify
                         * a service without a host. And finally if we specify
                         * HOST_BROADCAST then we ask a tli fd to tell us what
                         * the broadcast addresses are for any udp
                         * interfaces on this machine.
                         */
                        if (args->arg.nd_hs->h_host == 0) {
                                _nderror = ND_NOHOST;
                                return (ND_NOHOST);
                        } else if ((strcmp(args->arg.nd_hs->h_host,
                            HOST_SELF_BIND) == 0)) {
                                haddrlist = localaddr;
                        } else if ((strcmp(args->arg.nd_hs->h_host,
                            HOST_SELF_CONNECT) == 0)) {
                                haddrlist = connectaddr;
                        } else if ((strcmp(args->arg.nd_hs->h_host,
                            LOCALHOST) == 0)) {
                                haddrlist = connectaddr;
                        } else if ((int)(dotnameaddr =
                            inet_addr(args->arg.nd_hs->h_host)) != -1) {
                                /*
                                 * If the caller passed in a dot separated IP
                                 * notation to netdir_getbyname, convert that
                                 * back into address.
                                 */

                                dotnamelist[0] = (char *)&dotnameaddr;
                                dotnamelist[1] = NULL;
                                haddrlist = dotnamelist;
                        } else if ((strcmp(args->arg.nd_hs->h_host,
                            HOST_BROADCAST) == 0)) {
                                /*
                                 * Now that inaddrs and baddrlist are
                                 * dynamically allocated, care must be
                                 * taken in freeing up the
                                 * memory at each 'return()' point.
                                 *
                                 * Early return protection (using
                                 * inetdir_free()) is needed only in NETDIR_BY
                                 * cases because dynamic allocation is used
                                 * when args->op_t == NETDIR_BY.
                                 *
                                 * Early return protection is not needed in
                                 * haddrlist==0 conditionals because dynamic
                                 * allocation guarantees haddrlist!=0.
                                 *
                                 * Early return protection is not needed in most
                                 * servp!=0 conditionals because this is handled
                                 * (and returned) first.
                                 */
                                int i, bnets;

                                bnets = getbroadcastnets(nconf, &inaddrs);
                                if (bnets == 0) {
                                        _nderror = ND_NOHOST;
                                        return (ND_NOHOST);
                                }
                                baddrlist = malloc((bnets+1)*sizeof (char *));
                                if (baddrlist == NULL)
                                        return (inetdir_free(ND_NOMEM, inaddrs,
                                            baddrlist));
                                for (i = 0; i < bnets; i++)
                                        baddrlist[i] = (char *)&inaddrs[i];
                                baddrlist[i] = NULL;
                                haddrlist = baddrlist;
                        } else {
                                /* i.e. need to call a name service on this */
                                haddrlist = 0;
                        }

                        if (haddrlist && servp) {
                                int ret;
                                /*
                                 * Convert h_addr_list into nd_addrlist.
                                 * malloc's will be done, freed using
                                 * netdir_free.
                                 */
                                ret = hent2ndaddr(AF_INET, haddrlist, servp,
                                    res->nd_alist);
                                return (inetdir_free(ret, inaddrs, baddrlist));
                        }
                        break;


                case NETDIR_BY6:
                        if (args->arg.nd_hs == 0) {
                                _nderror = ND_BADARG;
                                return (ND_BADARG);
                        }
                        /*
                         * If servname is NULL, return 0 as the port number.
                         * If servname is rpcbind, return 111 as the port number
                         * If servname is a number, return it back as the port
                         * number.
                         */
                        if (args->arg.nd_hs->h_serv == 0) {
                                *servp = htons(0);
                        } else if (strcmp(args->arg.nd_hs->h_serv,
                            "rpcbind") == 0) {
                                *servp = htons(111);
                        } else if (strspn(args->arg.nd_hs->h_serv, "0123456789")
                            == strlen(args->arg.nd_hs->h_serv)) {
                                *servp = htons(atoi(args->arg.nd_hs->h_serv));
                        } else {
                                /* i.e. need to call a name service on this */
                                servp = NULL;
                        }

                        /*
                         * If the hostname is HOST_SELF_BIND, we return ipv6
                         * localaddress so the binding can be contacted through
                         * all interfaces.
                         * If the hostname is HOST_SELF_CONNECT, we return
                         * ipv6 loopback address so the address can be connected
                         * to locally.
                         * If the hostname is HOST_ANY, we return no addresses
                         * because IP doesn't know how to specify a service
                         * without a host.
                         * And finally if we specify HOST_BROADCAST then we
                         * disallow since IPV6 does not have any
                         * broadcast concept.
                         */
                        if (args->arg.nd_hs->h_host == 0) {
                                return (ND_NOHOST);
                        } else if ((strcmp(args->arg.nd_hs->h_host,
                            HOST_SELF_BIND) == 0)) {
                                haddrlist = localaddr6;
                        } else if ((strcmp(args->arg.nd_hs->h_host,
                            HOST_SELF_CONNECT) == 0)) {
                                haddrlist = connectaddr6;
                        } else if ((strcmp(args->arg.nd_hs->h_host,
                            LOCALHOST) == 0)) {
                                haddrlist = connectaddr6;
                        } else if (strchr(args->arg.nd_hs->h_host, ':')
                            != NULL) {

                        /*
                         * If the caller passed in a dot separated IP notation
                         * to netdir_getbyname, convert that back into address.
                         */

                                if ((inet_pton(AF_INET6,
                                    args->arg.nd_hs->h_host,
                                    &v6nameaddr)) != 0) {
                                        dotnamelist[0] = (char *)&v6nameaddr;
                                        dotnamelist[1] = NULL;
                                        haddrlist = dotnamelist;
                                }
                                else
                                        /* not sure what to return */
                                        return (ND_NOHOST);

                        } else if ((strcmp(args->arg.nd_hs->h_host,
                            HOST_BROADCAST) == 0)) {
                                /*
                                 * Don't support broadcast in
                                 * IPV6
                                 */
                                return (ND_NOHOST);
                        } else {
                                /* i.e. need to call a name service on this */
                                haddrlist = 0;
                        }

                        if (haddrlist && servp) {
                                int ret;
                                /*
                                 * Convert h_addr_list into nd_addrlist.
                                 * malloc's will be done, freed
                                 * using netdir_free.
                                 */
                                ret = hent2ndaddr(AF_INET6, haddrlist,
                                    servp, res->nd_alist);
                                return (inetdir_free(ret, inaddrs, baddrlist));
                        }
                        break;


        }

        /*
         * 2. Most common scenario. This is the way we ship /etc/netconfig.
         *    Emphasis on improving performance in the "if" part.
         */
        if (nconf->nc_nlookups == 0) {
                struct hostent  *he = NULL, *tmphe;
                struct servent  *se;
                int     ret;
                nss_XbyY_buf_t  *ndbuf4switch = 0;

        switch (args->op_t) {

                case NSS_HOST:

                he = DOOR_GETHOSTBYNAME_R(args->arg.nss.host.name,
                    res->nss.host.hent, args->arg.nss.host.buf,
                    args->arg.nss.host.buflen,
                    res->nss.host.herrno_p);
                if (he == NULL)
                        return (_nderror = ND_NOHOST);
                return (_nderror = ND_OK);

                case NSS_HOST6:

                he = DOOR_GETIPNODEBYNAME_R(args->arg.nss.host6.name,
                    res->nss.host.hent, args->arg.nss.host.buf,
                    args->arg.nss.host6.buflen,
                    args->arg.nss.host6.af_family,
                    args->arg.nss.host6.flags,
                    res->nss.host.herrno_p);

                if (he == NULL)
                        return (_nderror = ND_NOHOST);
                return (_nderror = ND_OK);

                case NSS_SERV:

                se = _switch_getservbyname_r(args->arg.nss.serv.name,
                    args->arg.nss.serv.proto,
                    res->nss.serv, args->arg.nss.serv.buf,
                    args->arg.nss.serv.buflen);

                _nderror = ND_OK;
                if (se == 0)
                        _nderror = ND_NOSERV;
                return (_nderror);

                case NETDIR_BY:

                if (servp == 0) {
                        char    *proto = (strcmp(nconf->nc_proto,
                            NC_TCP) == 0) ? NC_TCP : NC_UDP;

                        /*
                         * We go through all this for just one port number,
                         * which is most often constant. How about linking in
                         * an indexed database of well-known ports in the name
                         * of performance ?
                         */
                        ndbuf4switch = _nss_XbyY_buf_alloc(
                            sizeof (struct servent), NSS_BUFLEN_SERVICES);
                        if (ndbuf4switch == 0)
                                return (inetdir_free(ND_NOMEM, inaddrs,
                                    baddrlist));
                        se = _switch_getservbyname_r(args->arg.nd_hs->h_serv,
                            proto, ndbuf4switch->result,
                            ndbuf4switch->buffer, ndbuf4switch->buflen);
                        if (!se) {
                                NSS_XbyY_FREE(&ndbuf4switch);
                                return (inetdir_free(ND_NOSERV, inaddrs,
                                    baddrlist));
                        }
                        server_port = se->s_port;
                        NSS_XbyY_FREE(&ndbuf4switch);
                }

                if (haddrlist == 0) {
                        int     h_errnop = 0;

                        ndbuf4switch = _nss_XbyY_buf_alloc(
                            sizeof (struct hostent),
                            NSS_BUFLEN_HOSTS);
                        if (ndbuf4switch == 0) {
                                _nderror = ND_NOMEM;
                                return (ND_NOMEM);
                        }
                        /*
                         * Search the ipnodes (v6) path first,
                         * search will return the v4 addresses
                         * as v4mapped addresses.
                         */
                        if ((tmphe = DOOR_GETIPNODEBYNAME_R(
                            args->arg.nd_hs->h_host,
                            ndbuf4switch->result, ndbuf4switch->buffer,
                            ndbuf4switch->buflen, args->arg.nss.host6.af_family,
                            args->arg.nss.host6.flags, &h_errnop)) != NULL)
                                he = __mappedtov4(tmphe, &h_errnop);

                        if (he == NULL) {
                                /* Failover case, try hosts db for v4 address */
                                he = DOOR_GETHOSTBYNAME_R(
                                    args->arg.nd_hs->h_host,
                                    ndbuf4switch->result, ndbuf4switch->buffer,
                                    ndbuf4switch->buflen, &h_errnop);
                                if (he == NULL) {
                                        NSS_XbyY_FREE(&ndbuf4switch);
                                        _nderror = __herrno2netdir(h_errnop);
                                        return (_nderror);
                                }
                                /*
                                 * Convert h_addr_list into nd_addrlist.
                                 * malloc's will be done, freed using
                                 * netdir_free.
                                 */
                                ret = hent2ndaddr(AF_INET, he->h_addr_list,
                                    &server_port, res->nd_alist);
                        } else {
                                /*
                                 * Convert h_addr_list into nd_addrlist.
                                 * malloc's will be done, freed using
                                 * netdir_free.
                                 */
                                ret = hent2ndaddr(AF_INET, he->h_addr_list,
                                    &server_port, res->nd_alist);
                                freehostent(he);
                        }

                        _nderror = ret;
                        NSS_XbyY_FREE(&ndbuf4switch);
                        return (ret);
                } else {
                        int ret;
                        /*
                         * Convert h_addr_list into nd_addrlist.
                         * malloc's will be done, freed using netdir_free.
                         */
                        ret = hent2ndaddr(AF_INET, haddrlist,
                            &server_port, res->nd_alist);
                        return (inetdir_free(ret, inaddrs, baddrlist));
                }


                case NETDIR_BY6:

                        if (servp == 0) {
                                char    *proto = (strcmp(nconf->nc_proto,
                                    NC_TCP) == 0) ? NC_TCP : NC_UDP;

                                /*
                                 * We go through all this for just
                                 * one port number,
                                 * which is most often constant.
                                 * How about linking in
                                 * an indexed database of well-known
                                 * ports in the name
                                 * of performance ?
                                 */
                                ndbuf4switch = _nss_XbyY_buf_alloc(
                                    sizeof (struct servent),
                                    NSS_BUFLEN_SERVICES);
                                if (ndbuf4switch == 0)
                                        return (inetdir_free(ND_NOMEM, inaddrs,
                                            baddrlist));
                                se = _switch_getservbyname_r(
                                    args->arg.nd_hs->h_serv,
                                    proto, ndbuf4switch->result,
                                    ndbuf4switch->buffer, ndbuf4switch->buflen);
                                if (!se) {
                                        NSS_XbyY_FREE(&ndbuf4switch);
                                        return (inetdir_free(ND_NOSERV, inaddrs,
                                            baddrlist));
                                }
                                server_port = se->s_port;
                                NSS_XbyY_FREE(&ndbuf4switch);
                        }

                        if (haddrlist == 0) {
                                int     h_errnop = 0;

                                ndbuf4switch = _nss_XbyY_buf_alloc(
                                    sizeof (struct hostent),
                                    NSS_BUFLEN_HOSTS);
                                if (ndbuf4switch == 0) {
                                        _nderror = ND_NOMEM;
                                        return (ND_NOMEM);
                                }
                                he = DOOR_GETIPNODEBYNAME_R(
                                    args->arg.nd_hs->h_host,
                                    ndbuf4switch->result, ndbuf4switch->buffer,
                                    ndbuf4switch->buflen,
                                    args->arg.nss.host6.af_family,
                                    args->arg.nss.host6.flags, &h_errnop);
                                if (he == NULL) {
                                        NSS_XbyY_FREE(&ndbuf4switch);
                                        _nderror = __herrno2netdir(h_errnop);
                                        return (_nderror);
                                }
                                /*
                                 * Convert h_addr_list into nd_addrlist.
                                 * malloc's will be done,
                                 * freed using netdir_free.
                                 */
                                ret = hent2ndaddr(AF_INET6,
                                    ((struct hostent *)
                                    (ndbuf4switch->result))->h_addr_list,
                                    &server_port, res->nd_alist);
                                _nderror = ret;
                                NSS_XbyY_FREE(&ndbuf4switch);
                                return (ret);
                        } else {
                                int ret;
                                /*
                                 * Convert h_addr_list into nd_addrlist.
                                 * malloc's will be done,
                                 * freed using netdir_free.
                                 */
                                ret = hent2ndaddr(AF_INET6, haddrlist,
                                    &server_port, res->nd_alist);
                                return (inetdir_free(ret, inaddrs, baddrlist));
                        }

                default:
                        _nderror = ND_BADARG;
                        return (ND_BADARG); /* should never happen */
        }

        } else {
                /* haddrlist is no longer used, so clean up */
                if (inaddrs)
                        free(inaddrs);
                if (baddrlist)
                        free(baddrlist);
        }

        /*
         * 3. We come this far only if nametoaddr libs are specified for
         *    inet transports and we are called by gethost/servbyname only.
         */
        switch (args->op_t) {
                struct  nd_hostserv service;
                struct  nd_addrlist *addrs;
                int ret;

                case NSS_HOST:

                service.h_host = (char *)args->arg.nss.host.name;
                service.h_serv = NULL;
                if ((_nderror = __classic_netdir_getbyname(nconf,
                    &service, &addrs)) != ND_OK) {
                        *(res->nss.host.herrno_p) = nd2herrno(_nderror);
                        return (_nderror);
                }
                /*
                 * convert addresses back into sockaddr for gethostbyname.
                 */
                ret = ndaddr2hent(AF_INET, service.h_host, addrs,
                    res->nss.host.hent, args->arg.nss.host.buf,
                    args->arg.nss.host.buflen);
                if (ret != ND_OK)
                        *(res->nss.host.herrno_p) = nd2herrno(ret);
                netdir_free((char *)addrs, ND_ADDRLIST);
                _nderror = ret;
                return (ret);

                case NSS_SERV:

                if (args->arg.nss.serv.proto == NULL) {
                        /*
                         * A similar HACK showed up in Solaris 2.3.
                         * The caller wild-carded proto -- i.e. will
                         * accept a match using tcp or udp for the port
                         * number. Since we have no hope of getting
                         * directly to a name service switch backend
                         * from here that understands this semantics,
                         * we try calling the netdir interfaces first
                         * with "tcp" and then "udp".
                         */
                        args->arg.nss.serv.proto = "tcp";
                        _nderror = _get_hostserv_inetnetdir_byname(nconf, args,
                            res);
                        if (_nderror != ND_OK) {
                                args->arg.nss.serv.proto = "udp";
                                _nderror =
                                    _get_hostserv_inetnetdir_byname(nconf,
                                    args, res);
                        }
                        return (_nderror);
                }

                /*
                 * Third-parties should optimize their nametoaddr
                 * libraries for the HOST_SELF case.
                 */
                service.h_host = HOST_SELF;
                service.h_serv = (char *)args->arg.nss.serv.name;
                if ((_nderror = __classic_netdir_getbyname(nconf,
                    &service, &addrs)) != ND_OK) {
                        return (_nderror);
                }
                /*
                 * convert addresses back into servent for getservbyname.
                 */
                _nderror = ndaddr2srent(service.h_serv,
                    args->arg.nss.serv.proto,
                    /* LINTED pointer cast */
                    ((struct sockaddr_in *)addrs->n_addrs->buf)->sin_port,
                    res->nss.serv,
                    args->arg.nss.serv.buf, args->arg.nss.serv.buflen);
                netdir_free((char *)addrs, ND_ADDRLIST);
                return (_nderror);

                default:
                _nderror = ND_BADARG;
                return (ND_BADARG); /* should never happen */
        }
}

/*
 * gethostbyaddr/servbyport always call this function; if they call
 * with nametoaddr libs in nconf, we call netdir_getbyaddr
 * implementation __classic_netdir_getbyaddr, otherwise nsswitch.
 *
 * netdir_getbyaddr calls this only if nametoaddr libs are NOT
 * specified for inet transports; i.e. it's supposed to follow
 * the name service switch.
 */
int
_get_hostserv_inetnetdir_byaddr(struct netconfig *nconf,
    struct nss_netdirbyaddr_in *args, union nss_netdirbyaddr_out *res)
{
        if (nconf == 0) {
                _nderror = ND_BADARG;
                return (_nderror);
        }

        /*
         * 1. gethostbyaddr()/netdir_getbyaddr() special cases:
         */
        switch (args->op_t) {

                case NSS_HOST:
                /*
                 * Worth the performance gain: assuming a lot of inet apps
                 * actively use "127.0.0.1".
                 */
                /* LINTED pointer cast */
                if (*(uint32_t *)(args->arg.nss.host.addr) ==
                    htonl(INADDR_LOOPBACK)) {
                        (void) mutex_lock(&nd_addr_lock);
                        IN_SET_LOOPBACK_ADDR(&sa_con);
                        _nderror = ndaddr2hent(AF_INET, LOCALHOST,
                            &nd_conaddrlist, res->nss.host.hent,
                            args->arg.nss.host.buf,
                            args->arg.nss.host.buflen);
                        (void) mutex_unlock(&nd_addr_lock);
                        if (_nderror != ND_OK)
                                *(res->nss.host.herrno_p) =
                                    nd2herrno(_nderror);
                        return (_nderror);
                }
                break;

                case NETDIR_BY:
                case NETDIR_BY_NOSRV:
                {
                        struct sockaddr_in *sin;

                        if (args->arg.nd_nbuf == NULL) {
                                _nderror = ND_BADARG;
                                return (_nderror);
                        }

                        /*
                         * Validate the address which was passed
                         * as the request.
                         */
                        /* LINTED pointer cast */
                        sin = (struct sockaddr_in *)args->arg.nd_nbuf->buf;

                        if ((args->arg.nd_nbuf->len !=
                            sizeof (struct sockaddr_in)) ||
                            (sin->sin_family != AF_INET)) {
                                _nderror = ND_BADARG;
                                return (_nderror);
                        }
                }
                break;

                case NETDIR_BY6:
                case NETDIR_BY_NOSRV6:
                {
                        struct sockaddr_in6 *sin6;

                        if (args->arg.nd_nbuf == NULL) {
                                _nderror = ND_BADARG;
                                return (_nderror);
                        }

                        /*
                         * Validate the address which was passed
                         * as the request.
                         */
                        /* LINTED pointer cast */
                        sin6 = (struct sockaddr_in6 *)args->arg.nd_nbuf->buf;

                        if ((args->arg.nd_nbuf->len !=
                            sizeof (struct sockaddr_in6)) ||
                            (sin6->sin6_family != AF_INET6)) {
                                _nderror = ND_BADARG;
                                return (_nderror);
                        }
                }
                break;

        }

        /*
         * 2. Most common scenario. This is the way we ship /etc/netconfig.
         *    Emphasis on improving performance in the "if" part.
         */
        if (nconf->nc_nlookups == 0) {
                struct hostent  *he = NULL, *tmphe;
                struct servent  *se = NULL;
                nss_XbyY_buf_t  *ndbuf4host = 0;
                nss_XbyY_buf_t  *ndbuf4serv = 0;
                char    *proto =
                    (strcmp(nconf->nc_proto, NC_TCP) == 0) ? NC_TCP : NC_UDP;
                struct  sockaddr_in *sa;
                struct sockaddr_in6 *sin6;
                struct in_addr *addr4 = 0;
                struct in6_addr v4mapbuf;
                int     h_errnop;

        switch (args->op_t) {

                case NSS_HOST:

                he = DOOR_GETHOSTBYADDR_R(args->arg.nss.host.addr,
                    args->arg.nss.host.len, args->arg.nss.host.type,
                    res->nss.host.hent, args->arg.nss.host.buf,
                    args->arg.nss.host.buflen,
                    res->nss.host.herrno_p);
                if (he == 0)
                        _nderror = ND_NOHOST;
                else
                        _nderror = ND_OK;
                return (_nderror);


                case NSS_HOST6:
                he = DOOR_GETIPNODEBYADDR_R(args->arg.nss.host.addr,
                    args->arg.nss.host.len, args->arg.nss.host.type,
                    res->nss.host.hent, args->arg.nss.host.buf,
                    args->arg.nss.host.buflen,
                    res->nss.host.herrno_p);

                if (he == 0)
                        return (ND_NOHOST);
                return (ND_OK);


                case NSS_SERV:

                se = _switch_getservbyport_r(args->arg.nss.serv.port,
                    args->arg.nss.serv.proto,
                    res->nss.serv, args->arg.nss.serv.buf,
                    args->arg.nss.serv.buflen);

                if (se == 0)
                        _nderror = ND_NOSERV;
                else
                        _nderror = ND_OK;
                return (_nderror);

                case NETDIR_BY:
                case NETDIR_BY_NOSRV:

                ndbuf4serv = _nss_XbyY_buf_alloc(sizeof (struct servent),
                    NSS_BUFLEN_SERVICES);
                if (ndbuf4serv == 0) {
                        _nderror = ND_NOMEM;
                        return (_nderror);
                }
                /* LINTED pointer cast */
                sa = (struct sockaddr_in *)(args->arg.nd_nbuf->buf);
                addr4 = (struct in_addr *)&(sa->sin_addr);

                /*
                 * if NETDIR_BY_NOSRV or port == 0 skip the service
                 * lookup.
                 */
                if (args->op_t != NETDIR_BY_NOSRV && sa->sin_port != 0) {
                        se = _switch_getservbyport_r(sa->sin_port, proto,
                            ndbuf4serv->result, ndbuf4serv->buffer,
                            ndbuf4serv->buflen);
                        if (!se) {
                                NSS_XbyY_FREE(&ndbuf4serv);
                                /*
                                 * We can live with this - i.e. the address
                                 * does not
                                 * belong to a well known service. The caller
                                 * traditionally accepts a stringified port
                                 * number
                                 * as the service name. The state of se is used
                                 * ahead to indicate the same.
                                 * However, we do not tolerate this nonsense
                                 * when we cannot get a host name. See below.
                                 */
                        }
                }

                ndbuf4host = _nss_XbyY_buf_alloc(sizeof (struct hostent),
                    NSS_BUFLEN_HOSTS);
                if (ndbuf4host == 0) {
                        if (ndbuf4serv)
                                NSS_XbyY_FREE(&ndbuf4serv);
                        _nderror = ND_NOMEM;
                        return (_nderror);
                }

                /*
                 * Since we're going to search the ipnodes (v6) path first,
                 * we need to treat the address as a v4mapped address.
                 */

                IN6_INADDR_TO_V4MAPPED(addr4, &v4mapbuf);
                if ((tmphe = DOOR_GETIPNODEBYADDR_R((char *)&v4mapbuf,
                    16, AF_INET6, ndbuf4host->result,
                    ndbuf4host->buffer,
                    ndbuf4host->buflen, &h_errnop)) != NULL)
                        he = __mappedtov4(tmphe, &h_errnop);

                if (!he) {
                        /* Failover case, try hosts db for v4 address */
                        he = DOOR_GETHOSTBYADDR_R((char *)
                            &(sa->sin_addr.s_addr), 4,
                            sa->sin_family, ndbuf4host->result,
                            ndbuf4host->buffer, ndbuf4host->buflen,
                            &h_errnop);
                        if (!he) {
                                NSS_XbyY_FREE(&ndbuf4host);
                                if (ndbuf4serv)
                                        NSS_XbyY_FREE(&ndbuf4serv);
                                _nderror = __herrno2netdir(h_errnop);
                                return (_nderror);
                        }
                        /*
                         * Convert host names and service names into hostserv
                         * pairs. malloc's will be done, freed using
                         * netdir_free.
                         */
                        h_errnop = hsents2ndhostservs(he, se,
                            sa->sin_port, res->nd_hslist);
                } else {
                        /*
                         * Convert host names and service names into hostserv
                         * pairs. malloc's will be done, freed using
                         * netdir_free.
                         */
                        h_errnop = hsents2ndhostservs(he, se,
                            sa->sin_port, res->nd_hslist);
                        freehostent(he);
                }

                NSS_XbyY_FREE(&ndbuf4host);
                if (ndbuf4serv)
                        NSS_XbyY_FREE(&ndbuf4serv);
                _nderror = __herrno2netdir(h_errnop);
                return (_nderror);

                case NETDIR_BY6:
                case NETDIR_BY_NOSRV6:

                ndbuf4serv = _nss_XbyY_buf_alloc(sizeof (struct servent),
                    NSS_BUFLEN_SERVICES);
                if (ndbuf4serv == 0) {
                        _nderror = ND_NOMEM;
                        return (ND_NOMEM);
                }
                /* LINTED pointer cast */
                sin6 = (struct sockaddr_in6 *)(args->arg.nd_nbuf->buf);

                /*
                 * if NETDIR_BY_NOSRV6 or port == 0 skip the service
                 * lookup.
                 */
                if (args->op_t != NETDIR_BY_NOSRV6 && sin6->sin6_port == 0) {
                        se = _switch_getservbyport_r(sin6->sin6_port, proto,
                            ndbuf4serv->result, ndbuf4serv->buffer,
                            ndbuf4serv->buflen);
                        if (!se) {
                                NSS_XbyY_FREE(&ndbuf4serv);
                                /*
                                 * We can live with this - i.e. the address does
                                 * not * belong to a well known service. The
                                 * caller traditionally accepts a stringified
                                 * port number
                                 * as the service name. The state of se is used
                                 * ahead to indicate the same.
                                 * However, we do not tolerate this nonsense
                                 * when we cannot get a host name. See below.
                                 */
                        }
                }

                ndbuf4host = _nss_XbyY_buf_alloc(sizeof (struct hostent),
                    NSS_BUFLEN_HOSTS);
                if (ndbuf4host == 0) {
                        if (ndbuf4serv)
                                NSS_XbyY_FREE(&ndbuf4serv);
                        _nderror = ND_NOMEM;
                        return (_nderror);
                }
                he = DOOR_GETIPNODEBYADDR_R((char *)&(sin6->sin6_addr),
                    16, sin6->sin6_family, ndbuf4host->result,
                    ndbuf4host->buffer,
                    ndbuf4host->buflen, &h_errnop);
                if (!he) {
                        NSS_XbyY_FREE(&ndbuf4host);
                        if (ndbuf4serv)
                                NSS_XbyY_FREE(&ndbuf4serv);
                        _nderror = __herrno2netdir(h_errnop);
                        return (_nderror);
                }
                /*
                 * Convert host names and service names into hostserv
                 * pairs. malloc's will be done, freed using netdir_free.
                 */
                h_errnop = hsents2ndhostservs(he, se,
                    sin6->sin6_port, res->nd_hslist);

                NSS_XbyY_FREE(&ndbuf4host);
                if (ndbuf4serv)
                        NSS_XbyY_FREE(&ndbuf4serv);
                _nderror = __herrno2netdir(h_errnop);
                return (_nderror);

                default:
                _nderror = ND_BADARG;
                return (_nderror); /* should never happen */
        }

        }
        /*
         * 3. We come this far only if nametoaddr libs are specified for
         *    inet transports and we are called by gethost/servbyname only.
         */
        switch (args->op_t) {
                struct  netbuf nbuf;
                struct  nd_hostservlist *addrs;
                struct  sockaddr_in sa;

                case NSS_HOST:

                /* LINTED pointer cast */
                sa.sin_addr.s_addr = *(uint32_t *)args->arg.nss.host.addr;
                sa.sin_family = AF_INET;
                /* Hopefully, third-parties get this optimization */
                sa.sin_port = 0;
                nbuf.buf = (char *)&sa;
                nbuf.len = nbuf.maxlen = sizeof (sa);
                if ((_nderror = __classic_netdir_getbyaddr(nconf,
                    &addrs, &nbuf)) != 0) {
                        *(res->nss.host.herrno_p) = nd2herrno(_nderror);
                        return (_nderror);
                }
                /*
                 * convert the host-serv pairs into h_aliases and hent.
                 */
                _nderror = ndhostserv2hent(&nbuf, addrs, res->nss.host.hent,
                    args->arg.nss.host.buf, args->arg.nss.host.buflen);
                if (_nderror != ND_OK)
                        *(res->nss.host.herrno_p) = nd2herrno(_nderror);
                netdir_free((char *)addrs, ND_HOSTSERVLIST);
                return (_nderror);

                case NSS_SERV:

                if (args->arg.nss.serv.proto == NULL) {
                        /*
                         * A similar HACK showed up in Solaris 2.3.
                         * The caller wild-carded proto -- i.e. will
                         * accept a match on tcp or udp for the port
                         * number. Since we have no hope of getting
                         * directly to a name service switch backend
                         * from here that understands this semantics,
                         * we try calling the netdir interfaces first
                         * with "tcp" and then "udp".
                         */
                        args->arg.nss.serv.proto = "tcp";
                        _nderror = _get_hostserv_inetnetdir_byaddr(nconf, args,
                            res);
                        if (_nderror != ND_OK) {
                                args->arg.nss.serv.proto = "udp";
                                _nderror =
                                    _get_hostserv_inetnetdir_byaddr(nconf,
                                    args, res);
                        }
                        return (_nderror);
                }

                /*
                 * Third-party nametoaddr_libs should be optimized for
                 * this case. It also gives a special semantics twist to
                 * netdir_getbyaddr. Only for the INADDR_ANY case, it gives
                 * higher priority to service lookups (over host lookups).
                 * If service lookup fails, the backend returns ND_NOSERV to
                 * facilitate lookup in the "next" naming service.
                 * BugId: 1075403.
                 */
                sa.sin_addr.s_addr = INADDR_ANY;
                sa.sin_family = AF_INET;
                sa.sin_port = (ushort_t)args->arg.nss.serv.port;
                sa.sin_zero[0] = '\0';
                nbuf.buf = (char *)&sa;
                nbuf.len = nbuf.maxlen = sizeof (sa);
                if ((_nderror = __classic_netdir_getbyaddr(nconf,
                    &addrs, &nbuf)) != ND_OK) {
                        return (_nderror);
                }
                /*
                 * convert the host-serv pairs into s_aliases and servent.
                 */
                _nderror = ndhostserv2srent(args->arg.nss.serv.port,
                    args->arg.nss.serv.proto, addrs, res->nss.serv,
                    args->arg.nss.serv.buf, args->arg.nss.serv.buflen);
                netdir_free((char *)addrs, ND_HOSTSERVLIST);
                return (_nderror);

                default:
                _nderror = ND_BADARG;
                return (_nderror); /* should never happen */
        }
}

/*
 * Part II: Name Service Switch interfacing routines.
 */

static DEFINE_NSS_DB_ROOT(db_root_hosts);
static DEFINE_NSS_DB_ROOT(db_root_ipnodes);
static DEFINE_NSS_DB_ROOT(db_root_services);


/*
 * There is a copy of __nss2herrno() in nsswitch/files/gethostent.c.
 * It is there because /etc/lib/nss_files.so.1 cannot call
 * routines in libnsl.  Care should be taken to keep the two copies
 * in sync (except that case NSS_NISSERVDNS_TRYAGAIN is not needed in
 * nsswitch/files).
 */
int
__nss2herrno(nss_status_t nsstat)
{
        switch (nsstat) {
        case NSS_SUCCESS:
                /* no macro-defined success code for h_errno */
                return (0);
        case NSS_NOTFOUND:
                return (HOST_NOT_FOUND);
        case NSS_TRYAGAIN:
                return (TRY_AGAIN);
        case NSS_UNAVAIL:
                return (NO_RECOVERY);
        case NSS_NISSERVDNS_TRYAGAIN:
                return (TRY_AGAIN);
        }
        /* anything else */
        return (NO_RECOVERY);
}

nss_status_t
_herrno2nss(int h_errno)
{
        switch (h_errno) {
        case 0:
                return (NSS_SUCCESS);
        case TRY_AGAIN:
                return (NSS_TRYAGAIN);
        case NO_RECOVERY:
        case NETDB_INTERNAL:
                return (NSS_UNAVAIL);
        case HOST_NOT_FOUND:
        case NO_DATA:
        default:
                return (NSS_NOTFOUND);
        }
}

static int
__herrno2netdir(int h_errnop)
{
        switch (h_errnop) {
                case 0:
                        return (ND_OK);
                case HOST_NOT_FOUND:
                        return (ND_NOHOST);
                case TRY_AGAIN:
                        return (ND_TRY_AGAIN);
                case NO_RECOVERY:
                case NETDB_INTERNAL:
                        return (ND_NO_RECOVERY);
                case NO_DATA:
                        return (ND_NO_DATA);
                default:
                        return (ND_NOHOST);
        }
}

/*
 * The _switch_getXXbyYY_r() routines should be static.  They used to
 * be exported in SunOS 5.3, and in fact publicised as work-around
 * interfaces for getting CNAME/aliases, and therefore, we preserve
 * their signatures here. Just in case.
 */

struct hostent *
_switch_gethostbyname_r(const char *name, struct hostent *result, char *buffer,
    int buflen, int *h_errnop)
{
        nss_XbyY_args_t arg;
        nss_status_t    res;

        NSS_XbyY_INIT(&arg, result, buffer, buflen, str2hostent);
        arg.key.name    = name;
        arg.stayopen    = 0;
        res = nss_search(&db_root_hosts, _nss_initf_hosts,
            NSS_DBOP_HOSTS_BYNAME, &arg);
        arg.status = res;
        if (res != NSS_SUCCESS)
                *h_errnop = arg.h_errno ? arg.h_errno : __nss2herrno(res);
        if (arg.returnval != NULL)
                order_haddrlist_af(result->h_addrtype, result->h_addr_list);
        return ((struct hostent *)NSS_XbyY_FINI(&arg));
}

struct hostent *
_switch_getipnodebyname_r(const char *name, struct hostent *result,
    char *buffer, int buflen, int af_family, int flags, int *h_errnop)
{
        nss_XbyY_args_t arg;
        nss_status_t    res;

        NSS_XbyY_INIT(&arg, result, buffer, buflen, str2hostent6);
        arg.key.ipnode.name     = name;
        arg.key.ipnode.af_family = af_family;
        arg.key.ipnode.flags = flags;
        arg.stayopen    = 0;
        res = nss_search(&db_root_ipnodes, _nss_initf_ipnodes,
            NSS_DBOP_IPNODES_BYNAME, &arg);
        arg.status = res;
        if (res != NSS_SUCCESS)
                *h_errnop = arg.h_errno ? arg.h_errno : __nss2herrno(res);
        if (arg.returnval != NULL)
                order_haddrlist_af(result->h_addrtype, result->h_addr_list);
        return ((struct hostent *)NSS_XbyY_FINI(&arg));
}

struct hostent *
_switch_gethostbyaddr_r(const char *addr, int len, int type,
    struct hostent *result, char *buffer, int buflen, int *h_errnop)
{
        nss_XbyY_args_t arg;
        nss_status_t    res;

        NSS_XbyY_INIT(&arg, result, buffer, buflen, str2hostent);
        arg.key.hostaddr.addr   = addr;
        arg.key.hostaddr.len    = len;
        arg.key.hostaddr.type   = type;
        arg.stayopen            = 0;
        res = nss_search(&db_root_hosts, _nss_initf_hosts,
            NSS_DBOP_HOSTS_BYADDR, &arg);
        arg.status = res;
        if (res != NSS_SUCCESS)
                *h_errnop = arg.h_errno ? arg.h_errno : __nss2herrno(res);
        return (struct hostent *)NSS_XbyY_FINI(&arg);
}

struct hostent *
_switch_getipnodebyaddr_r(const char *addr, int len, int type,
    struct hostent *result, char *buffer, int buflen, int *h_errnop)
{
        nss_XbyY_args_t arg;
        nss_status_t    res;

        NSS_XbyY_INIT(&arg, result, buffer, buflen, str2hostent6);
        arg.key.hostaddr.addr   = addr;
        arg.key.hostaddr.len    = len;
        arg.key.hostaddr.type   = type;
        arg.stayopen            = 0;
        res = nss_search(&db_root_ipnodes, _nss_initf_ipnodes,
            NSS_DBOP_IPNODES_BYADDR, &arg);
        arg.status = res;
        if (res != NSS_SUCCESS)
                *h_errnop = arg.h_errno ? arg.h_errno : __nss2herrno(res);
        return (struct hostent *)NSS_XbyY_FINI(&arg);
}

static void
_nss_initf_services(nss_db_params_t *p)
{
        p->name = NSS_DBNAM_SERVICES;
        p->default_config = NSS_DEFCONF_SERVICES;
}

struct servent *
_switch_getservbyname_r(const char *name, const char *proto,
    struct servent *result, char *buffer, int buflen)
{
        nss_XbyY_args_t arg;
        nss_status_t    res;

        NSS_XbyY_INIT(&arg, result, buffer, buflen, str2servent);
        arg.key.serv.serv.name  = name;
        arg.key.serv.proto      = proto;
        arg.stayopen            = 0;
        res = nss_search(&db_root_services, _nss_initf_services,
            NSS_DBOP_SERVICES_BYNAME, &arg);
        arg.status = res;
        return ((struct servent *)NSS_XbyY_FINI(&arg));
}

struct servent *
_switch_getservbyport_r(int port, const char *proto, struct servent *result,
    char *buffer, int buflen)
{
        nss_XbyY_args_t arg;
        nss_status_t    res;

        NSS_XbyY_INIT(&arg, result, buffer, buflen, str2servent);
        arg.key.serv.serv.port  = port;
        arg.key.serv.proto      = proto;
        arg.stayopen            = 0;
        res = nss_search(&db_root_services, _nss_initf_services,
            NSS_DBOP_SERVICES_BYPORT, &arg);
        arg.status = res;
        return ((struct servent *)NSS_XbyY_FINI(&arg));
}


/*
 * Return values: 0 = success, 1 = parse error, 2 = erange ...
 * The structure pointer passed in is a structure in the caller's space
 * wherein the field pointers would be set to areas in the buffer if
 * need be. instring and buffer should be separate areas.
 *
 * Defined here because we need it and we (libnsl) cannot have a dependency
 * on libsocket (however, libsocket always depends on libnsl).
 */
int
str2servent(const char *instr, int lenstr, void *ent, char *buffer, int buflen)
{
        struct servent  *serv   = (struct servent *)ent;
        const char      *p, *fieldstart, *limit, *namestart;
        ssize_t         fieldlen, namelen = 0;
        char            numbuf[12];
        char            *numend;

        if ((instr >= buffer && (buffer + buflen) > instr) ||
            (buffer >= instr && (instr + lenstr) > buffer)) {
                return (NSS_STR_PARSE_PARSE);
        }

        p = instr;
        limit = p + lenstr;

        while (p < limit && isspace(*p)) {
                p++;
        }
        namestart = p;
        while (p < limit && !isspace(*p)) {
                p++;            /* Skip over the canonical name */
        }
        namelen = p - namestart;

        if (buflen <= namelen) { /* not enough buffer */
                return (NSS_STR_PARSE_ERANGE);
        }
        (void) memcpy(buffer, namestart, namelen);
        buffer[namelen] = '\0';
        serv->s_name = buffer;

        while (p < limit && isspace(*p)) {
                p++;
        }

        fieldstart = p;
        do {
                if (p > limit || isspace(*p)) {
                        /* Syntax error -- no port/proto */
                        return (NSS_STR_PARSE_PARSE);
                }
        } while (*p++ != '/');
        fieldlen = p - fieldstart - 1;
        if (fieldlen == 0 || fieldlen >= sizeof (numbuf)) {
                /* Syntax error -- supposed number is empty or too long */
                return (NSS_STR_PARSE_PARSE);
        }
        (void) memcpy(numbuf, fieldstart, fieldlen);
        numbuf[fieldlen] = '\0';
        serv->s_port = htons((int)strtol(numbuf, &numend, 10));
        if (*numend != '\0') {
                /* Syntax error -- port number isn't a number */
                return (NSS_STR_PARSE_PARSE);
        }

        fieldstart = p;
        while (p < limit && !isspace(*p)) {
                p++;            /* Scan the protocol name */
        }
        fieldlen = p - fieldstart + 1;          /* Include '\0' this time */
        if (fieldlen > buflen - namelen - 1) {
                return (NSS_STR_PARSE_ERANGE);
        }
        serv->s_proto = buffer + namelen + 1;
        (void) memcpy(serv->s_proto, fieldstart, fieldlen - 1);
        serv->s_proto[fieldlen - 1] = '\0';

        while (p < limit && isspace(*p)) {
                p++;
        }
        /*
         * Although nss_files_XY_all calls us with # stripped,
         * we should be able to deal with it here in order to
         * be more useful.
         */
        if (p >= limit || *p == '#') { /* no aliases, no problem */
                char **ptr;

                ptr = (char **)ROUND_UP(buffer + namelen + 1 + fieldlen,
                    sizeof (char *));
                if ((char *)ptr >= buffer + buflen) {
                        /* hope they don't try to peek in */
                        serv->s_aliases = 0;
                        return (NSS_STR_PARSE_ERANGE);
                } else {
                        *ptr = 0;
                        serv->s_aliases = ptr;
                        return (NSS_STR_PARSE_SUCCESS);
                }
        }
        serv->s_aliases = _nss_netdb_aliases(p, (int)(lenstr - (p - instr)),
            buffer + namelen + 1 + fieldlen,
            (int)(buflen - namelen - 1 - fieldlen));
        return (NSS_STR_PARSE_SUCCESS);
}

/*
 * Part III: All `n sundry routines that are useful only in this
 * module. In the interest of keeping this source file shorter,
 * we would create them a new module only if the linker allowed
 * "library-static" functions.
 *
 * Routines to order addresses based on local interfaces and netmasks,
 * to get and check reserved ports, and to get broadcast nets.
 */

union __v4v6addr {
        struct in6_addr in6;
        struct in_addr  in4;
};

struct __ifaddr {
        sa_family_t             af;
        union __v4v6addr        addr;
        union __v4v6addr        mask;
};

struct ifinfo {
        int             count;
        struct __ifaddr *addresses;
};

typedef enum {ADDR_ONLINK = 0, ADDR_OFFLINK} addr_class_t;
#define ADDR_NUMCLASSES 2

typedef enum {IF_ADDR, IF_MASK} __ifaddr_type;
static int      __inet_ifassign(sa_family_t, struct __ifaddr *, __ifaddr_type,
                                void *);
int             __inet_address_is_local_af(void *, sa_family_t, void *);

#define ifaf(index)     (localinfo->addresses[index].af)
#define ifaddr4(index)  (localinfo->addresses[index].addr.in4)
#define ifaddr6(index)  (localinfo->addresses[index].addr.in6)
#define ifmask4(index)  (localinfo->addresses[index].mask.in4)
#define ifmask6(index)  (localinfo->addresses[index].mask.in6)
#define ifinfosize(n)   (sizeof (struct ifinfo) + (n)*sizeof (struct __ifaddr))

#define lifraddrp(lifr) ((lifr.lifr_addr.ss_family == AF_INET6) ? \
        (void *)&((struct sockaddr_in6 *)&lifr.lifr_addr)->sin6_addr : \
        (void *)&((struct sockaddr_in *)&lifr.lifr_addr)->sin_addr)

#define ifassign(lifr, index, type) \
                        __inet_ifassign(lifr.lifr_addr.ss_family, \
                                &localinfo->addresses[index], type, \
                                lifraddrp(lifr))

/*
 * The number of nanoseconds the order_haddrlist_inet() function waits
 * to retreive IP interface information.  The default is five minutes.
 */
#define IFINFOTIMEOUT   ((hrtime_t)300 * NANOSEC)

/*
 * Sort the addresses in haddrlist.  Since the sorting algorithms are
 * address-family specific, the work is done in the address-family
 * specific order_haddrlist_<family> functions.
 *
 * Do not sort addresses if SORT_ADDRS variable is set to NO or FALSE
 * in the configuration file /etc/default/nss. This is useful in case
 * the order of addresses returned by the nameserver needs to be
 * maintained. (DNS round robin feature is one example)
 */
void
order_haddrlist_af(sa_family_t af, char **haddrlist)
{
        size_t                  addrcount;
        char                    **addrptr;
        static boolean_t        checksortcfg = B_TRUE;
        static boolean_t        nosort = B_FALSE;
        static mutex_t          checksortcfg_lock = DEFAULTMUTEX;

        if (haddrlist == NULL)
                return;

        /*
         * Check if SORT_ADDRS is set to NO or FALSE in the configuration
         * file.  We do not have to sort addresses in that case.
         */
        (void) mutex_lock(&checksortcfg_lock);
        if (checksortcfg == B_TRUE) {
                checksortcfg = B_FALSE;
                nosort = _read_nsw_file();
        }
        (void) mutex_unlock(&checksortcfg_lock);

        if (nosort)
                return;

        /* Count the addresses to sort */
        addrcount = 0;
        for (addrptr = haddrlist; *addrptr != NULL; addrptr++)
                addrcount++;

        /*
         * If there's only one address or no addresses to sort, then
         * there's nothing for us to do.
         */
        if (addrcount <= 1)
                return;

        /* Call the address-family specific sorting functions. */
        switch (af) {
        case AF_INET:
                order_haddrlist_inet(haddrlist, addrcount);
                break;
        case AF_INET6:
                order_haddrlist_inet6(haddrlist, addrcount);
                break;
        default:
                break;
        }
}

/*
 * Move any local (on-link) addresses toward the beginning of haddrlist.
 * The order within these two classes is preserved.
 *
 * The interface list is retrieved no more often than every
 * IFINFOTIMEOUT nanoseconds. Access to the interface list is
 * protected by an RW lock.
 *
 * If this function encounters an error, haddrlist is unaltered.
 */
static void
order_haddrlist_inet(char **haddrlist, size_t addrcount)
{
        static struct   ifinfo *localinfo = NULL;
        static hrtime_t then = 0; /* the last time localinfo was updated */
        hrtime_t        now;
        static rwlock_t localinfo_lock = DEFAULTRWLOCK;
        uint8_t         *sortbuf;
        size_t          sortbuf_size;
        struct in_addr  **inaddrlist = (struct in_addr **)haddrlist;
        struct in_addr  **sorted;
        struct in_addr  **classnext[ADDR_NUMCLASSES];
        uint_t          classcount[ADDR_NUMCLASSES];
        addr_class_t    *sortclass;
        int             i;
        int             rc;


        /*
         * The classes in the sortclass array correspond to the class
         * of the address in the haddrlist list of the same index.
         * The classes are:
         *
         * ADDR_ONLINK  on-link address
         * ADDR_OFFLINK off-link address
         */
        sortbuf_size = addrcount *
            (sizeof (struct in_addr *) + sizeof (addr_class_t));
        if ((sortbuf = malloc(sortbuf_size)) == NULL)
                return;
        /* LINTED pointer cast */
        sorted = (struct in_addr **)sortbuf;
        /* LINTED pointer cast */
        sortclass = (addr_class_t *)(sortbuf +
            (addrcount * sizeof (struct in_addr *)));

        /*
         * Get a read lock, and check if the interface information
         * is too old.
         */
        (void) rw_rdlock(&localinfo_lock);
        now = gethrtime();
        if (localinfo == NULL || ((now - then) > IFINFOTIMEOUT)) {
                /* Need to update I/F info. Upgrade to write lock. */
                (void) rw_unlock(&localinfo_lock);
                (void) rw_wrlock(&localinfo_lock);
                /*
                 * Another thread might have updated "then" between
                 * the rw_unlock() and rw_wrlock() calls above, so
                 * re-check the timeout.
                 */
                if (localinfo == NULL || ((now - then) > IFINFOTIMEOUT)) {
                        if (localinfo != NULL)
                                free(localinfo);
                        if ((localinfo = get_local_info()) == NULL) {
                                (void) rw_unlock(&localinfo_lock);
                                free(sortbuf);
                                return;
                        }
                        then = now;
                }
                /* Downgrade to read lock */
                (void) rw_unlock(&localinfo_lock);
                (void) rw_rdlock(&localinfo_lock);
                /*
                 * Another thread may have updated the I/F info,
                 * so verify that the 'localinfo' pointer still
                 * is non-NULL.
                 */
                if (localinfo == NULL) {
                        (void) rw_unlock(&localinfo_lock);
                        free(sortbuf);
                        return;
                }
        }

        /*
         * Classify the addresses.  We also maintain the classcount
         * array to keep track of the number of addresses in each
         * class.
         */
        (void) memset(classcount, 0, sizeof (classcount));
        for (i = 0; i < addrcount; i++) {
                if (__inet_address_is_local_af(localinfo, AF_INET,
                    inaddrlist[i]))
                        sortclass[i] = ADDR_ONLINK;
                else
                        sortclass[i] = ADDR_OFFLINK;
                classcount[sortclass[i]]++;
        }

        /* Don't need the interface list anymore in this call */
        (void) rw_unlock(&localinfo_lock);

        /*
         * Each element in the classnext array points to the next
         * element for that class in the sorted address list. 'rc' is
         * the running count of elements as we sum the class
         * sub-totals.
         */
        for (rc = 0, i = 0; i < ADDR_NUMCLASSES; i++) {
                classnext[i] = &sorted[rc];
                rc += classcount[i];
        }

        /* Now for the actual rearrangement of the addresses */
        for (i = 0; i < addrcount; i++) {
                *(classnext[sortclass[i]]) = inaddrlist[i];
                classnext[sortclass[i]]++;
        }

        /* Copy the sorted list to inaddrlist */
        (void) memcpy(inaddrlist, sorted,
            addrcount * sizeof (struct in_addr *));
        free(sortbuf);
}

/*
 * This function implements the IPv6 Default Address Selection's
 * destination address ordering mechanism.  The algorithm is described
 * in getaddrinfo(3SOCKET).
 */
static void
order_haddrlist_inet6(char **haddrlist, size_t addrcount)
{
        struct dstinforeq *dinfo, *dinfoptr;
        struct in6_addr **in6addrlist = (struct in6_addr **)haddrlist;
        struct in6_addr **in6addr;

        if ((dinfo = calloc(addrcount, sizeof (struct dstinforeq))) == NULL)
                return;

        /* Initialize the dstinfo array we'll use for SIOCGDSTINFO */
        dinfoptr = dinfo;
        for (in6addr = in6addrlist; *in6addr != NULL; in6addr++) {
                dinfoptr->dir_daddr = **in6addr;
                dinfoptr++;
        }

        if (nss_strioctl(AF_INET6, SIOCGDSTINFO, dinfo,
            addrcount * sizeof (struct dstinforeq)) < 0) {
                free(dinfo);
                return;
        }

        /* Sort the dinfo array */
        qsort(dinfo, addrcount, sizeof (struct dstinforeq), dstcmp);

        /* Copy the addresses back into in6addrlist */
        dinfoptr = dinfo;
        for (in6addr = in6addrlist; *in6addr != NULL; in6addr++) {
                **in6addr = dinfoptr->dir_daddr;
                dinfoptr++;
        }

        free(dinfo);
}

/*
 * Determine number of leading bits that are common between two addresses.
 * Only consider bits which fall within the prefix length plen.
 */
static uint_t
ip_addr_commonbits_v6(const in6_addr_t *a1, const in6_addr_t *a2)
{
        uint_t          bits;
        uint_t          i;
        uint32_t        diff;   /* Bits that differ */

        for (i = 0; i < 4; i++) {
                if (a1->_S6_un._S6_u32[i] != a2->_S6_un._S6_u32[i])
                        break;
        }
        bits = i * 32;

        if (bits == IPV6_ABITS)
                return (IPV6_ABITS);

        /*
         * Find number of leading common bits in the word which might
         * have some common bits by searching for the first one from the left
         * in the xor of the two addresses.
         */
        diff = ntohl(a1->_S6_un._S6_u32[i] ^ a2->_S6_un._S6_u32[i]);
        if (diff & 0xffff0000ul)
                diff >>= 16;
        else
                bits += 16;
        if (diff & 0xff00)
                diff >>= 8;
        else
                bits += 8;
        if (diff & 0xf0)
                diff >>= 4;
        else
                bits += 4;
        if (diff & 0xc)
                diff >>= 2;
        else
                bits += 2;
        if (!(diff & 2))
                bits++;

        /*
         * We don't need to shift and check for the last bit.  The
         * check for IPV6_ABITS above would have caught that.
         */

        return (bits);
}


/*
 * The following group of functions named rule_*() are individual
 * sorting rules for the AF_INET6 address sorting algorithm.  The
 * functions compare two addresses (described by two dstinforeq
 * structures), and determines if one is "greater" than the other, or
 * if the two are equal according to that rule.
 */
typedef int (*rulef_t)(const struct dstinforeq *, const struct dstinforeq *);

/*
 * These values of these constants are no accident.  Since qsort()
 * implements the AF_INET6 address sorting, the comparison function
 * must return an integer less than, equal to, or greater than zero to
 * indicate if the first address is considered "less than", "equal
 * to", or "greater than" the second one.  Since we want the best
 * addresses first on the list, "less than" is considered preferrable.
 */
#define RULE_PREFER_DA  -1
#define RULE_PREFER_DB  1
#define RULE_EQUAL      0

/* Prefer the addresses that is reachable. */
static int
rule_reachable(const struct dstinforeq *da, const struct dstinforeq *db)
{
        if (da->dir_dreachable == db->dir_dreachable)
                return (RULE_EQUAL);
        if (da->dir_dreachable)
                return (RULE_PREFER_DA);
        return (RULE_PREFER_DB);
}

/* Prefer the address whose scope matches that of its source address. */
static int
rule_matchscope(const struct dstinforeq *da, const struct dstinforeq *db)
{
        boolean_t da_scope_match, db_scope_match;

        da_scope_match = da->dir_dscope == da->dir_sscope;
        db_scope_match = db->dir_dscope == db->dir_sscope;

        if (da_scope_match == db_scope_match)
                return (RULE_EQUAL);
        if (da_scope_match)
                return (RULE_PREFER_DA);
        return (RULE_PREFER_DB);
}

/* Avoid the address with the link local source address. */
static int
rule_avoidlinklocal(const struct dstinforeq *da, const struct dstinforeq *db)
{
        if (da->dir_sscope == IP6_SCOPE_LINKLOCAL &&
            da->dir_dscope != IP6_SCOPE_LINKLOCAL &&
            db->dir_sscope != IP6_SCOPE_LINKLOCAL)
                return (RULE_PREFER_DB);
        if (db->dir_sscope == IP6_SCOPE_LINKLOCAL &&
            db->dir_dscope != IP6_SCOPE_LINKLOCAL &&
            da->dir_sscope != IP6_SCOPE_LINKLOCAL)
                return (RULE_PREFER_DA);
        return (RULE_EQUAL);
}

/* Prefer the address whose source address isn't deprecated. */
static int
rule_deprecated(const struct dstinforeq *da, const struct dstinforeq *db)
{
        if (da->dir_sdeprecated == db->dir_sdeprecated)
                return (RULE_EQUAL);
        if (db->dir_sdeprecated)
                return (RULE_PREFER_DA);
        return (RULE_PREFER_DB);
}

/* Prefer the address whose label matches that of its source address. */
static int
rule_label(const struct dstinforeq *da, const struct dstinforeq *db)
{
        if (da->dir_labelmatch == db->dir_labelmatch)
                return (RULE_EQUAL);
        if (da->dir_labelmatch)
                return (RULE_PREFER_DA);
        return (RULE_PREFER_DB);
}

/* Prefer the address with the higher precedence. */
static int
rule_precedence(const struct dstinforeq *da, const struct dstinforeq *db)
{
        if (da->dir_precedence == db->dir_precedence)
                return (RULE_EQUAL);
        if (da->dir_precedence > db->dir_precedence)
                return (RULE_PREFER_DA);
        return (RULE_PREFER_DB);
}

/* Prefer the address whose output interface isn't an IP tunnel */
static int
rule_native(const struct dstinforeq *da, const struct dstinforeq *db)
{
        boolean_t isatun, isbtun;

        /* Get the common case out of the way early */
        if (da->dir_dmactype == db->dir_dmactype)
                return (RULE_EQUAL);

        isatun = da->dir_dmactype == DL_IPV4 || da->dir_dmactype == DL_IPV6;
        isbtun = db->dir_dmactype == DL_IPV4 || db->dir_dmactype == DL_IPV6;

        if (isatun == isbtun)
                return (RULE_EQUAL);
        if (isbtun)
                return (RULE_PREFER_DA);
        return (RULE_PREFER_DB);
}

/* Prefer the address with the smaller scope. */
static int
rule_scope(const struct dstinforeq *da, const struct dstinforeq *db)
{
        if (da->dir_dscope == db->dir_dscope)
                return (RULE_EQUAL);
        if (da->dir_dscope < db->dir_dscope)
                return (RULE_PREFER_DA);
        return (RULE_PREFER_DB);
}

/*
 * Prefer the address that has the most leading bits in common with its
 * source address.
 */
static int
rule_prefix(const struct dstinforeq *da, const struct dstinforeq *db)
{
        uint_t da_commonbits, db_commonbits;
        boolean_t da_isipv4, db_isipv4;

        da_isipv4 = IN6_IS_ADDR_V4MAPPED(&da->dir_daddr);
        db_isipv4 = IN6_IS_ADDR_V4MAPPED(&db->dir_daddr);

        /*
         * At this point, the order doesn't matter if the two addresses
         * aren't of the same address family.
         */
        if (da_isipv4 != db_isipv4)
                return (RULE_EQUAL);

        da_commonbits = ip_addr_commonbits_v6(&da->dir_daddr, &da->dir_saddr);
        db_commonbits = ip_addr_commonbits_v6(&db->dir_daddr, &db->dir_saddr);

        if (da_commonbits > db_commonbits)
                return (RULE_PREFER_DA);
        if (da_commonbits < db_commonbits)
                return (RULE_PREFER_DB);
        return (RULE_EQUAL);
}

/*
 * This is the function passed to qsort() that does the AF_INET6
 * address comparisons.  It compares two addresses using a list of
 * rules.  The rules are applied in order until one prefers one
 * address over the other.
 */
static int
dstcmp(const void *da, const void *db)
{
        int index, result;
        rulef_t rules[] = {
            rule_reachable,
            rule_matchscope,
            rule_avoidlinklocal,
            rule_deprecated,
            rule_label,
            rule_precedence,
            rule_native,
            rule_scope,
            rule_prefix,
            NULL
        };

        result = 0;
        for (index = 0; rules[index] != NULL; index++) {
                result = (rules[index])(da, db);
                if (result != RULE_EQUAL)
                        break;
        }

        return (result);
}

/*
 * Given haddrlist and a port number, mallocs and populates a new
 * nd_addrlist.  The new nd_addrlist maintains the order of the addresses
 * in haddrlist, which have already been sorted by order_haddrlist_inet()
 * or order_haddrlist_inet6().  For IPv6 this function filters out
 * IPv4-mapped IPv6 addresses.
 */
int
hent2ndaddr(int af, char **haddrlist, int *servp, struct nd_addrlist **nd_alist)
{
        struct nd_addrlist      *result;
        int                     num;
        struct netbuf           *na;
        struct sockaddr_in      *sinbuf, *sin;
        struct sockaddr_in6     *sin6buf, *sin6;
        struct in_addr          **inaddr, **inaddrlist;
        struct in6_addr         **in6addr, **in6addrlist;

        /* Address count */
        num = 0;
        if (af == AF_INET6) {
                in6addrlist = (struct in6_addr **)haddrlist;

                /*
                 * Exclude IPv4-mapped IPv6 addresses from the count, as
                 * these are not included in the nd_addrlist we return.
                 */
                for (in6addr = in6addrlist; *in6addr != NULL; in6addr++)
                        if (!IN6_IS_ADDR_V4MAPPED(*in6addr))
                                num++;
        } else {
                inaddrlist = (struct in_addr **)haddrlist;

                for (inaddr = inaddrlist; *inaddr != NULL; inaddr++)
                        num++;
        }
        if (num == 0)
                return (ND_NOHOST);

        result = malloc(sizeof (struct nd_addrlist));
        if (result == 0)
                return (ND_NOMEM);

        result->n_cnt = num;
        result->n_addrs = calloc(num, sizeof (struct netbuf));
        if (result->n_addrs == 0) {
                free(result);
                return (ND_NOMEM);
        }

        na = result->n_addrs;
        if (af == AF_INET) {
                sinbuf = calloc(num, sizeof (struct sockaddr_in));
                if (sinbuf == NULL) {
                        free(result->n_addrs);
                        free(result);
                        return (ND_NOMEM);
                }

                sin = sinbuf;
                for (inaddr = inaddrlist; *inaddr != NULL; inaddr++) {
                        na->len = na->maxlen = sizeof (struct sockaddr_in);
                        na->buf = (char *)sin;
                        sin->sin_family = AF_INET;
                        sin->sin_addr = **inaddr;
                        sin->sin_port = *servp;
                        na++;
                        sin++;
                }
        } else if (af == AF_INET6) {
                sin6buf = calloc(num, sizeof (struct sockaddr_in6));
                if (sin6buf == NULL) {
                        free(result->n_addrs);
                        free(result);
                        return (ND_NOMEM);
                }

                sin6 = sin6buf;
                for (in6addr = in6addrlist; *in6addr != NULL; in6addr++) {
                        if (IN6_IS_ADDR_V4MAPPED(*in6addr))
                                continue;

                        na->len = na->maxlen = sizeof (struct sockaddr_in6);
                        na->buf = (char *)sin6;
                        sin6->sin6_family = AF_INET6;
                        sin6->sin6_addr = **in6addr;
                        sin6->sin6_port = *servp;
                        na++;
                        sin6++;
                }
        }
        *(nd_alist) = result;
        return (ND_OK);
}

/*
 * Given a hostent and a servent, mallocs and populates
 * a new nd_hostservlist with host and service names.
 *
 * We could be passed in a NULL servent, in which case stringify port.
 */
int
hsents2ndhostservs(struct hostent *he, struct servent *se,
    ushort_t port, struct nd_hostservlist **hslist)
{
        struct  nd_hostservlist *result;
        struct  nd_hostserv *hs;
        int     hosts, servs, i, j;
        char    **hn, **sn;

        if ((result = malloc(sizeof (struct nd_hostservlist))) == 0)
                return (ND_NOMEM);

        /*
         * We initialize the counters to 1 rather than zero because
         * we have to count the "official" name as well as the aliases.
         */
        for (hn = he->h_aliases, hosts = 1; hn && *hn; hn++, hosts++) {};
        if (se) {
                for (sn = se->s_aliases, servs = 1; sn && *sn; sn++, servs++) {
                };
        } else
                servs = 1;

        if ((hs = calloc(hosts * servs, sizeof (struct nd_hostserv))) == 0) {
                free(result);
                return (ND_NOMEM);
        }

        result->h_cnt   = servs * hosts;
        result->h_hostservs = hs;

        for (i = 0, hn = he->h_aliases; i < hosts; i++) {
                sn = se ? se->s_aliases : NULL;

                for (j = 0; j < servs; j++) {
                        if (i == 0)
                                hs->h_host = strdup(he->h_name);
                        else
                                hs->h_host = strdup(*hn);
                        if (j == 0) {
                                if (se)
                                        hs->h_serv = strdup(se->s_name);
                                else {
                                        /* Convert to a number string */
                                        char stmp[16];

                                        (void) sprintf(stmp, "%d", port);
                                        hs->h_serv = strdup(stmp);
                                }
                        } else
                                hs->h_serv = strdup(*sn++);

                        if ((hs->h_host == 0) || (hs->h_serv == 0)) {
                                free(result->h_hostservs);
                                free(result);
                                return (ND_NOMEM);
                        }
                        hs++;
                }
                if (i)
                        hn++;
        }
        *(hslist) = result;
        return (ND_OK);
}

/*
 * Process results from nd_addrlist ( returned by netdir_getbyname)
 * into a hostent using buf.
 * *** ASSUMES that nd_addrlist->n_addrs->buf contains IP addresses in
 * sockaddr_in's ***
 */
int
ndaddr2hent(int af, const char *nam, struct nd_addrlist *addrs,
    struct hostent *result, char *buffer, int buflen)
{
        int     i, count;
        struct  in_addr *addrp;
        struct  in6_addr *addr6p;
        char    **addrvec;
        struct  netbuf *na;
        size_t  len;

        result->h_name          = buffer;
        result->h_addrtype      = af;
        result->h_length        = (af == AF_INET) ? sizeof (*addrp):
            sizeof (*addr6p);

        /*
         * Build addrlist at start of buffer (after name);  store the
         * addresses themselves at the end of the buffer.
         */
        len = strlen(nam) + 1;
        addrvec = (char **)ROUND_UP(buffer + len, sizeof (*addrvec));
        result->h_addr_list     = addrvec;

        if (af == AF_INET) {
                addrp = (struct in_addr *)ROUND_DOWN(buffer + buflen,
                    sizeof (*addrp));

                count = addrs->n_cnt;
                if ((char *)(&addrvec[count + 1]) > (char *)(&addrp[-count]))
                        return (ND_NOMEM);

                (void) memcpy(buffer, nam, len);

                for (na = addrs->n_addrs, i = 0;  i < count;  na++, i++) {
                        --addrp;
                        (void) memcpy(addrp,
                            /* LINTED pointer cast */
                            &((struct sockaddr_in *)na->buf)->sin_addr,
                            sizeof (*addrp));
                        *addrvec++ = (char *)addrp;
                }
        } else {
                addr6p = (struct in6_addr *)ROUND_DOWN(buffer + buflen,
                    sizeof (*addr6p));

                count = addrs->n_cnt;
                if ((char *)(&addrvec[count + 1]) > (char *)(&addr6p[-count]))
                        return (ND_NOMEM);

                (void) memcpy(buffer, nam, len);

                for (na = addrs->n_addrs, i = 0;  i < count;  na++, i++) {
                        --addr6p;
                        (void) memcpy(addr6p,
                            /* LINTED pointer cast */
                            &((struct sockaddr_in6 *)na->buf)->sin6_addr,
                            sizeof (*addr6p));
                        *addrvec++ = (char *)addr6p;
                }
        }
        *addrvec = 0;
        result->h_aliases = addrvec;

        return (ND_OK);
}

/*
 * Process results from nd_addrlist ( returned by netdir_getbyname)
 * into a servent using buf.
 */
int
ndaddr2srent(const char *name, const char *proto, ushort_t port,
    struct servent *result, char *buffer, int buflen)
{
        size_t  i;
        char    *bufend = (buffer + buflen);

        result->s_port = (int)port;

        result->s_aliases =
            (char **)ROUND_UP(buffer, sizeof (char *));
        result->s_aliases[0] = NULL;
        buffer = (char *)&result->s_aliases[1];
        result->s_name = buffer;
        i = strlen(name) + 1;
        if ((buffer + i) > bufend)
                return (ND_NOMEM);
        (void) memcpy(buffer, name, i);
        buffer += i;

        result->s_proto = buffer;
        i = strlen(proto) + 1;
        if ((buffer + i) > bufend)
                return (ND_NOMEM);
        (void) memcpy(buffer, proto, i);
        buffer += i;

        return (ND_OK);
}

/*
 * Process results from nd_hostservlist ( returned by netdir_getbyaddr)
 * into a hostent using buf.
 * *** ASSUMES that nd_buf->buf is a sockaddr_in ***
 */
int
ndhostserv2hent(struct netbuf *nbuf, struct nd_hostservlist *addrs,
    struct hostent *result, char *buffer, int buflen)
{
        int     i, count;
        char    *aliasp;
        char    **aliasvec;
        struct  sockaddr_in *sa;
        struct  nd_hostserv *hs;
        const   char *la;
        size_t  length;

        /* First, give the lonely address a specious home in h_addr_list. */
        aliasp   = (char  *)ROUND_UP(buffer, sizeof (sa->sin_addr));
        /* LINTED pointer cast */
        sa = (struct sockaddr_in *)nbuf->buf;
        (void) memcpy(aliasp, &(sa->sin_addr), sizeof (sa->sin_addr));
        aliasvec = (char **)ROUND_UP(aliasp + sizeof (sa->sin_addr),
            sizeof (*aliasvec));
        result->h_addr_list = aliasvec;
        *aliasvec++ = aliasp;
        *aliasvec++ = 0;

        /*
         * Build h_aliases at start of buffer (after addr and h_addr_list);
         * store the alias strings at the end of the buffer (before h_name).
         */

        aliasp = buffer + buflen;

        result->h_aliases       = aliasvec;

        hs = addrs->h_hostservs;
        if (!hs)
                return (ND_NOHOST);

        length = strlen(hs->h_host) + 1;
        aliasp -= length;
        if ((char *)(&aliasvec[1]) > aliasp)
                return (ND_NOMEM);
        (void) memcpy(aliasp, hs->h_host, length);

        result->h_name          = aliasp;
        result->h_addrtype      = AF_INET;
        result->h_length        = sizeof (sa->sin_addr);

        /*
         * Assumption: the netdir nametoaddr_libs
         * sort the vector of (host, serv) pairs in such a way that
         * all pairs with the same host name are contiguous.
         */
        la = hs->h_host;
        count = addrs->h_cnt;
        for (i = 0;  i < count;  i++, hs++)
                if (strcmp(la, hs->h_host) != 0) {
                        size_t len = strlen(hs->h_host) + 1;

                        aliasp -= len;
                        if ((char *)(&aliasvec[2]) > aliasp)
                                return (ND_NOMEM);
                        (void) memcpy(aliasp, hs->h_host, len);
                        *aliasvec++ = aliasp;
                        la = hs->h_host;
                }
        *aliasvec = 0;

        return (ND_OK);
}

/*
 * Process results from nd_hostservlist ( returned by netdir_getbyaddr)
 * into a servent using buf.
 */
int
ndhostserv2srent(int port, const char *proto, struct nd_hostservlist *addrs,
    struct servent *result, char *buffer, int buflen)
{
        int     i, count;
        char    *aliasp;
        char    **aliasvec;
        struct  nd_hostserv *hs;
        const   char *host_cname;
        size_t  leni, lenj;

        result->s_port = port;
        /*
         * Build s_aliases at start of buffer;
         * store proto and aliases at the end of the buffer (before h_name).
         */

        aliasp = buffer + buflen;
        aliasvec = (char **)ROUND_UP(buffer, sizeof (char *));

        result->s_aliases       = aliasvec;

        hs = addrs->h_hostservs;
        if (!hs)
                return (ND_NOHOST);
        host_cname = hs->h_host;

        leni = strlen(proto) + 1;
        lenj = strlen(hs->h_serv) + 1;
        if ((char *)(&aliasvec[2]) > (aliasp - leni - lenj))
                return (ND_NOMEM);

        aliasp -= leni;
        (void) memcpy(aliasp, proto, leni);
        result->s_proto = aliasp;

        aliasp -= lenj;
        (void) memcpy(aliasp, hs->h_serv, lenj);
        result->s_name = aliasp;

        /*
         * Assumption: the netdir nametoaddr_libs
         * do a host aliases first and serv aliases next
         * enumeration for creating the list of hostserv
         * structures.
         */
        count = addrs->h_cnt;
        for (i = 0;
            i < count && hs->h_serv && strcmp(hs->h_host, host_cname) == 0;
            i++, hs++) {
                size_t len = strlen(hs->h_serv) + 1;

                aliasp -= len;
                if ((char *)(&aliasvec[2]) > aliasp)
                        return (ND_NOMEM);
                (void) memcpy(aliasp, hs->h_serv, len);
                *aliasvec++ = aliasp;
        }
        *aliasvec = NULL;

        return (ND_OK);
}


static int
nd2herrno(int nerr)
{
        switch (nerr) {
        case ND_OK:
                return (0);
        case ND_TRY_AGAIN:
                return (TRY_AGAIN);
        case ND_NO_RECOVERY:
        case ND_BADARG:
        case ND_NOMEM:
                return (NO_RECOVERY);
        case ND_NO_DATA:
                return (NO_DATA);
        case ND_NOHOST:
        case ND_NOSERV:
                return (HOST_NOT_FOUND);
        default:
                return (NO_RECOVERY);
        }
}

/*
 * This is a utility function so that various parts of libnsl can
 * easily send ioctls down to ip.
 *
 */
int
nss_ioctl(int af, int cmd, void *arg)
{
        int     fd;
        char    *devpath;
        int     retv;

        switch (af) {
        case AF_INET6:
                devpath = UDP6DEV;
                break;
        case AF_INET:
        case AF_UNSPEC:
        default:
                devpath = UDPDEV;
        }
        if ((fd = open(devpath, O_RDONLY)) < 0) {
                return (-1);
        }
        while ((retv = ioctl(fd, cmd, arg)) == -1) {
                if (errno != EINTR)
        break;
        }
        (void) close(fd);
        return (retv);
}

static int
nss_strioctl(int af, int cmd, void *ptr, int ilen)
{
        struct strioctl str;

        str.ic_cmd = cmd;
        str.ic_timout = 0;
        str.ic_len = ilen;
        str.ic_dp = ptr;

        return (nss_ioctl(af, I_STR, &str));
}

static struct ifinfo *
get_local_info(void)
{
        int     numifs;
        int     n;
        char    *buf = NULL;
        size_t  needed;
        struct lifconf  lifc;
        struct lifreq   lifreq, *lifr;
        struct lifnum   lifn;
        struct ifinfo   *localinfo;

        lifn.lifn_family = AF_UNSPEC;
        lifn.lifn_flags = 0;

getifnum:
        if (nss_ioctl(AF_UNSPEC, SIOCGLIFNUM, &lifn) == -1) {
                numifs = MAXIFS;
        } else {
                numifs = lifn.lifn_count;
        }

        /*
         * Add a small fudge factor in case interfaces get plumbed between
         * the call to SIOCGLIFNUM and SIOCGLIFCONF.
         */
        needed = (numifs + 4) * sizeof (lifreq);
        if (buf == NULL)
                buf = malloc(needed);
        else
                buf = realloc(buf, needed);
        if (buf == NULL) {
                (void) syslog(LOG_ERR, "n2a get_local_info: malloc failed: %m");
                _nderror = ND_NOMEM;
                return (NULL);
        }
        lifc.lifc_family = AF_UNSPEC;
        lifc.lifc_flags = 0;
        lifc.lifc_len = needed;
        lifc.lifc_buf = buf;
        if (nss_ioctl(AF_UNSPEC, SIOCGLIFCONF, &lifc) == -1) {
                /*
                 * IP returns EINVAL if the buffer was too small to fit
                 * all of the entries.  If that's the case, go back and
                 * try again.
                 */
                if (errno == EINVAL)
                        goto getifnum;

                (void) syslog(LOG_ERR, "n2a get_local_info: "
                    "ioctl (get interface configuration): %m");
                free(buf);
                _nderror = ND_SYSTEM;
                return (NULL);
        }
        /* LINTED pointer cast */
        lifr = (struct lifreq *)buf;
        numifs = lifc.lifc_len/sizeof (lifreq);
        localinfo = malloc(ifinfosize(numifs));
        if (localinfo == NULL) {
                (void) syslog(LOG_ERR, "n2a get_local_info: malloc failed: %m");
                free(buf);
                _nderror = ND_SYSTEM;
                return (NULL);
        }

        /* LINTED pointer cast */
        localinfo->addresses = (struct __ifaddr *)
            ((char *)localinfo + sizeof (struct ifinfo));

        for (localinfo->count = 0, n = numifs; n > 0; n--, lifr++) {
                int af;

                lifreq = *lifr;
                af = lifreq.lifr_addr.ss_family;

                /* Squirrel away the address */
                if (ifassign(lifreq, localinfo->count, IF_ADDR) == 0)
                        continue;

                if (nss_ioctl(af, SIOCGLIFFLAGS, &lifreq) < 0) {
                        (void) syslog(LOG_ERR,
                            "n2a get_local_info: "
                            "ioctl (get interface flags): %m");
                        continue;
                }
                if (!(lifreq.lifr_flags & IFF_UP))
                        continue;

                if (nss_ioctl(af, SIOCGLIFNETMASK, &lifreq) < 0) {
                        (void) syslog(LOG_ERR,
                            "n2a get_local_info: "
                            "ioctl (get interface netmask): %m");
                        continue;
                }

                if (ifassign(lifreq, localinfo->count, IF_MASK) == 0)
                        continue;

                localinfo->count++;
        }

        free(buf);
        return (localinfo);
}

static int
__inet_ifassign(sa_family_t af, struct __ifaddr *ifa, __ifaddr_type type,
    void *addr) {
        switch (type) {
        case IF_ADDR:
                ifa->af = af;
                if (af == AF_INET6) {
                        ifa->addr.in6 = *(struct in6_addr *)addr;
                } else {
                        ifa->addr.in4 = *(struct in_addr *)addr;
                }
                break;
        case IF_MASK:
                if (ifa->af == af) {
                        if (af == AF_INET6) {
                                ifa->mask.in6 = *(struct in6_addr *)addr;
                        } else {
                                ifa->mask.in4 = *(struct in_addr *)addr;
                        }
                } else {
                        return (0);
                }
                break;
        default:
                return (0);
        }

        return (1);
}

/*
 *  Some higher-level routines for determining if an address is
 *  on a local network.
 *
 *      __inet_get_local_interfaces() - get an opaque handle with
 *          with a list of local interfaces
 *      __inet_address_is_local() - return 1 if an address is
 *          on a local network; 0 otherwise
 *      __inet_free_local_interfaces() - free handle that was
 *          returned by __inet_get_local_interfaces()
 *
 *  A typical calling sequence is:
 *
 *      p = __inet_get_local_interfaces();
 *      if (__inet_address_is_local(p, inaddr)) {
 *          ...
 *      }
 *      __inet_free_local_interfaces(p);
 */

/*
 *  Return an opaque pointer to a list of configured interfaces.
 */
void *
__inet_get_local_interfaces(void)
{
        return (get_local_info());
}

/*
 *  Free memory allocated by inet_local_interfaces().
 */
void
__inet_free_local_interfaces(void *p)
{
        free(p);
}

/*
 *  Determine if an address is on a local network.
 *
 *  Might have made sense to use SIOCTONLINK, except that it doesn't
 *  handle matching on IPv4 network addresses.
 */
int
__inet_address_is_local_af(void *p, sa_family_t af, void *addr) {

        struct ifinfo   *localinfo = (struct ifinfo *)p;
        int             i, a;
        struct in_addr  v4addr;

        if (localinfo == 0)
                return (0);

        if (af == AF_INET6 && IN6_IS_ADDR_V4MAPPED((struct in6_addr *)addr)) {
                IN6_V4MAPPED_TO_INADDR((struct in6_addr *)addr, &v4addr);
                af = AF_INET;
                addr = (void *)&v4addr;
        }

        for (i = 0; i < localinfo->count; i++) {
                if (ifaf(i) == af) {
                        if (af == AF_INET6) {
                                struct in6_addr *a6 = (struct in6_addr *)addr;
                                for (a = 0; a < sizeof (a6->s6_addr); a++) {
                                        if ((a6->s6_addr[a] &
                                                ifmask6(i).s6_addr[a]) !=
                                                (ifaddr6(i).s6_addr[a] &
                                                ifmask6(i).s6_addr[a]))
                                                break;
                                }
                                if (a >= sizeof (a6->s6_addr))
                                        return (1);
                        } else {
                                if ((((struct in_addr *)addr)->s_addr &
                                                ifmask4(i).s_addr) ==
                                        (ifaddr4(i).s_addr &
                                                ifmask4(i).s_addr))
                                        return (1);
                        }
                }
        }

        return (0);
}

int
__inet_address_is_local(void *p, struct in_addr addr)
{
        return (__inet_address_is_local_af(p, AF_INET, &addr));
}

int
__inet_uaddr_is_local(void *p, struct netconfig *nc, char *uaddr)
{
        struct netbuf           *taddr;
        sa_family_t             af;
        int                     ret;

        taddr = uaddr2taddr(nc, uaddr);
        if (taddr == 0)
                return (0);

        /* LINTED pointer cast */
        af = ((struct sockaddr *)taddr->buf)->sa_family;

        ret = __inet_address_is_local_af(p, af, (af == AF_INET6) ?
            /* LINTED pointer cast */
            (void *)&((struct sockaddr_in6 *)taddr->buf)->sin6_addr :
            /* LINTED pointer cast */
            (void *)&((struct sockaddr_in *)taddr->buf)->sin_addr);

        netdir_free(taddr, ND_ADDR);
        return (ret);
}


int
__inet_address_count(void *p)
{
        struct ifinfo *lp = (struct ifinfo *)p;

        if (lp != 0) {
                return (lp->count);
        } else {
                return (0);
        }
}

uint32_t
__inet_get_addr(void *p, int n)
{
        struct ifinfo *localinfo = (struct ifinfo *)p;

        if (localinfo == 0 || n >= localinfo->count || ifaf(n) != AF_INET)
                return (0);

        return (ifaddr4(n).s_addr);
}

uint32_t
__inet_get_network(void *p, int n)
{
        struct ifinfo *localinfo = (struct ifinfo *)p;

        if (localinfo == 0 || n >= localinfo->count || ifaf(n) != AF_INET)
                return (0);

        return (ifaddr4(n).s_addr & ifmask4(n).s_addr);
}

char *
__inet_get_uaddr(void *p, struct netconfig *nc, int n)
{
        struct ifinfo *localinfo = (struct ifinfo *)p;
        char *uaddr;
        struct sockaddr_in sin4;
        struct sockaddr_in6 sin6;
        struct netbuf nb;

        if (localinfo == 0 || nc == 0 || n >= localinfo->count)
                return (0);

        if (ifaf(n) == AF_INET6) {
                if (strcmp(NC_INET6, nc->nc_protofmly) != 0)
                        return (0);
                (void) memset(&sin6, 0, sizeof (sin6));
                sin6.sin6_family = AF_INET6;
                sin6.sin6_addr = ifaddr6(n);
                nb.buf = (char *)&sin6;
                nb.len = sizeof (sin6);
        } else {
                if (strcmp(NC_INET, nc->nc_protofmly) != 0)
                        return (0);
                (void) memset(&sin4, 0, sizeof (sin4));
                sin4.sin_family = AF_INET;
                sin4.sin_addr = ifaddr4(n);
                nb.buf = (char *)&sin4;
                nb.len = sizeof (sin4);
        }

        nb.maxlen = nb.len;

        uaddr = taddr2uaddr(nc, &nb);
        return (uaddr);
}

char *
__inet_get_networka(void *p, int n)
{
        struct ifinfo   *localinfo = (struct ifinfo *)p;

        if (localinfo == 0 || n >= localinfo->count)
                return (0);

        if (ifaf(n) == AF_INET6) {
                char            buf[INET6_ADDRSTRLEN];
                struct in6_addr in6;
                int             i;

                for (i = 0; i < sizeof (in6.s6_addr); i++) {
                        in6.s6_addr[i] = ifaddr6(n).s6_addr[i] &
                            ifmask6(n).s6_addr[i];
                }
                return (strdup(inet_ntop(AF_INET6, &in6, buf, sizeof (buf))));
        } else {
                struct in_addr  in4;

                in4.s_addr = ifaddr4(n).s_addr & ifmask4(n).s_addr;
                return (strdup(inet_ntoa(in4)));
        }
}

static int
in_list(struct in_addr *addrs, int n, struct in_addr a)
{
        int i;

        for (i = 0; i < n; i++) {
                if (addrs[i].s_addr == a.s_addr)
                        return (1);
        }
        return (0);
}

static int
getbroadcastnets(struct netconfig *tp, struct in_addr **addrs)
{
        struct ifconf ifc;
        struct ifreq ifreq, *ifr;
        struct sockaddr_in *sin;
        struct in_addr a;
        int fd;
        int n, i, numifs;
        char *buf;
        int     use_loopback = 0;

        _nderror = ND_SYSTEM;
        fd = open(tp->nc_device, O_RDONLY);
        if (fd < 0) {
                (void) syslog(LOG_ERR,
            "broadcast: open to get interface configuration: %m");
                return (0);
        }
        if (ioctl(fd, SIOCGIFNUM, (char *)&numifs) < 0)
                numifs = MAXIFS;
        buf = malloc(numifs * sizeof (struct ifreq));
        if (buf == NULL) {
                (void) syslog(LOG_ERR, "broadcast: malloc failed: %m");
                (void) close(fd);
                return (0);
        }
        *addrs = malloc(numifs * sizeof (struct in_addr));
        if (*addrs == NULL) {
                (void) syslog(LOG_ERR, "broadcast: malloc failed: %m");
                free(buf);
                (void) close(fd);
                return (0);
        }
        ifc.ifc_len = numifs * (int)sizeof (struct ifreq);
        ifc.ifc_buf = buf;
        /*
         * Ideally, this ioctl should also tell me, how many bytes were
         * finally allocated, but it doesnt.
         */
        if (ioctl(fd, SIOCGIFCONF, (char *)&ifc) < 0) {
                (void) syslog(LOG_ERR,
            "broadcast: ioctl (get interface configuration): %m");
                free(buf);
                free(*addrs);
                (void) close(fd);
                return (0);
        }

retry:
        /* LINTED pointer cast */
        ifr = (struct ifreq *)buf;
        for (i = 0, n = ifc.ifc_len / (int)sizeof (struct ifreq);
            n > 0; n--, ifr++) {
                ifreq = *ifr;
                if (ioctl(fd, SIOCGIFFLAGS, (char *)&ifreq) < 0) {
                        (void) syslog(LOG_ERR, "broadcast: "
                            "ioctl (get interface flags): %m");
                        continue;
                }
                if (!(ifreq.ifr_flags & IFF_UP) ||
                    (ifr->ifr_addr.sa_family != AF_INET))
                        continue;
                if (ifreq.ifr_flags & IFF_BROADCAST) {
                        /* LINTED pointer cast */
                        sin = (struct sockaddr_in *)&ifr->ifr_addr;
                        if (ioctl(fd, SIOCGIFBRDADDR, (char *)&ifreq) < 0) {
                                /* May not work with other implementation */
                                a = _inet_makeaddr(
                                    inet_netof(sin->sin_addr),
                                    INADDR_ANY);
                                if (!in_list(*addrs, i, a))
                                        (*addrs)[i++] = a;
                        } else {
                                /* LINTED pointer cast */
                                a = ((struct sockaddr_in *)
                                    &ifreq.ifr_addr)->sin_addr;
                                if (!in_list(*addrs, i, a))
                                        (*addrs)[i++] = a;
                        }
                        continue;
                }
                if (use_loopback && (ifreq.ifr_flags & IFF_LOOPBACK)) {
                        /* LINTED pointer cast */
                        sin = (struct sockaddr_in *)&ifr->ifr_addr;
                        a = sin->sin_addr;
                        if (!in_list(*addrs, i, a))
                                (*addrs)[i++] = a;
                        continue;
                }
                if (ifreq.ifr_flags & IFF_POINTOPOINT) {
                        if (ioctl(fd, SIOCGIFDSTADDR, (char *)&ifreq) < 0)
                                continue;
                        /* LINTED pointer cast */
                        a = ((struct sockaddr_in *)
                            &ifreq.ifr_addr)->sin_addr;
                        if (!in_list(*addrs, i, a))
                                (*addrs)[i++] = a;
                        continue;
                }
        }
        if (i == 0 && !use_loopback) {
                use_loopback = 1;
                goto retry;
        }
        free(buf);
        (void) close(fd);
        if (i)
                _nderror = ND_OK;
        else
                free(*addrs);
        return (i);
}

/*
 * This is lifted straight from libsocket/inet/inet_mkaddr.c.
 * Copied here to avoid our dependency on libsocket. More importantly,
 * to make sure partially static apps that use libnsl, but not
 * libsocket, don't get screwed up.
 * If you understand the above paragraph, try to get rid of
 * this copy of inet_makeaddr; if you don;t, leave it alone.
 *
 * Formulate an Internet address from network + host.  Used in
 * building addresses stored in the ifnet structure.
 */
static struct in_addr
_inet_makeaddr(in_addr_t net, in_addr_t host)
{
        in_addr_t addr;
        struct in_addr inaddr;

        if (net < 128)
                addr = (net << IN_CLASSA_NSHIFT) | (host & IN_CLASSA_HOST);
        else if (net < 65536)
                addr = (net << IN_CLASSB_NSHIFT) | (host & IN_CLASSB_HOST);
        else if (net < 16777216L)
                addr = (net << IN_CLASSC_NSHIFT) | (host & IN_CLASSC_HOST);
        else
                addr = net | host;
        inaddr.s_addr = htonl(addr);
        return (inaddr);
}

/*
 * Routine to read the default configuration file and check if SORT_ADDRS
 * is set to NO or FALSE. This routine is called by order_haddrlist_af()
 * to determine if the addresses need to be sorted.
 */
static boolean_t
_read_nsw_file(void)
{
        char    defval[LINESIZE];
        FILE    *defl;
        boolean_t       nosort = B_FALSE;


        do {
                defl = fopen(__NSW_DEFAULT_FILE, "rF");
        } while ((defl == NULL) && (errno == EINTR));

        if (defl == NULL)
                return (B_FALSE);

        while (fgets(defval, sizeof (defval), defl) != NULL) {
                if ((strncmp(DONT_SORT, defval, sizeof (DONT_SORT) - 1) == 0) ||
                    (strncmp(DONT_SORT2, defval,
                    sizeof (DONT_SORT2) - 1) == 0)) {
                        nosort = B_TRUE;
                        break;
                }
        }
        (void) fclose(defl);
        return (nosort);
}