libnsl/nss/netdir_inet_sundry.c

/*
 * 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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * lib/libnsl/nss/netdir_inet_sundry.c
 *
 * This file contains inet-specific implementations of netdir_options,
 * uaddr2taddr, and taddr2uaddr. These implementations
 * used to be in both tcpip.so and switch.so (identical copies).
 * Since we got rid of those, and also it's a good idea to build-in
 * inet-specific implementations in one place, we decided to put
 * them in this file with a not-so glorious name. These are INET-SPECIFIC
 * only, and will not be used for non-inet transports or by third-parties
 * that decide to provide their own nametoaddr libs for inet transports
 * (they are on their own for these as well => they get flexibility).
 *
 * Copied mostly from erstwhile lib/nametoaddr/tcpip/tcpip.c.
 */

#include "mt.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <strings.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <thread.h>
#include <netconfig.h>
#include <netdir.h>
#include <nss_netdir.h>
#include <tiuser.h>
#include <sys/socket.h>
#include <net/if.h>
#include <sys/sockio.h>
#include <sys/fcntl.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <netinet/udp.h>
#include <arpa/inet.h>
#include <rpc/types.h>
#include <rpc/rpc_com.h>
#include <syslog.h>
#include <values.h>
#include <limits.h>
#include <nss_dbdefs.h>
#include "nss.h"

#define MAXIFS 32

/*
 * Extracted from socketvar.h
 */
#define SOV_DEFAULT 1   /* Select based on so_default_version */
#define SOV_SOCKBSD 3   /* Socket with no streams operations */

extern int _so_socket(int, int, int, char *, int);
extern int _so_connect(int, struct sockaddr *, socklen_t, int);
extern int _so_getsockname(int, struct sockaddr *, socklen_t *, int);


static char *inet_netdir_mergeaddr(struct netconfig *, char *, char *);
static int bindresvport(struct netconfig *, int, struct netbuf *);
static int checkresvport(struct netbuf *);
static struct netbuf *ip_uaddr2taddr(char *);
static struct netbuf *ipv6_uaddr2taddr(char *);


extern char *inet_ntoa_r(struct in_addr, char *);

int
__inet_netdir_options(struct netconfig *tp, int opts, int fd, char *par)
{
    struct nd_mergearg *ma;

    switch (opts) {
    case ND_SET_BROADCAST:
        /* Every one is allowed to broadcast without asking */
        return (ND_OK);
    case ND_SET_RESERVEDPORT:   /* bind to a resered port */
        /* LINTED pointer cast */
        return (bindresvport(tp, fd, (struct netbuf *)par));
    case ND_CHECK_RESERVEDPORT: /* check if reserved prot */
        /* LINTED pointer cast */
        return (checkresvport((struct netbuf *)par));
    case ND_MERGEADDR:  /* Merge two addresses */
        /* LINTED pointer cast */
        ma = (struct nd_mergearg *)(par);
        ma->m_uaddr = inet_netdir_mergeaddr(tp, ma->c_uaddr,
            ma->s_uaddr);
        return (_nderror);
    default:
        return (ND_NOCTRL);
    }
}


/*
 * This routine will convert a TCP/IP internal format address
 * into a "universal" format address. In our case it prints out the
 * decimal dot equivalent. h1.h2.h3.h4.p1.p2 where h1-h4 are the host
 * address and p1-p2 are the port number.
 */
char *
__inet_taddr2uaddr(struct netconfig *tp, struct netbuf *addr)
{
    struct sockaddr_in  *sa;    /* our internal format */
    struct sockaddr_in6 *sa6;   /* our internal format */
    char            tmp[RPC_INET6_MAXUADDRSIZE];
    unsigned short      myport;

    if (addr == NULL || tp == NULL || addr->buf == NULL) {
        _nderror = ND_BADARG;
        return (NULL);
    }
    if (strcmp(tp->nc_protofmly, NC_INET) == 0) {
        /* LINTED pointer cast */
        sa = (struct sockaddr_in *)(addr->buf);
        myport = ntohs(sa->sin_port);
        (void) inet_ntoa_r(sa->sin_addr, tmp);
    } else {
        /* LINTED pointer cast */
        sa6 = (struct sockaddr_in6 *)(addr->buf);
        myport = ntohs(sa6->sin6_port);
        if (inet_ntop(AF_INET6, sa6->sin6_addr.s6_addr, tmp,
            sizeof (tmp)) == NULL) {
            _nderror = ND_BADARG;
            return (NULL);
        }
    }

    (void) sprintf(tmp + strlen(tmp), ".%d.%d", myport >> 8, myport & 255);
    return (strdup(tmp));   /* Doesn't return static data ! */
}

/*
 * This internal routine will convert one of those "universal" addresses
 * to the internal format used by the Sun TLI TCP/IP provider.
 */
struct netbuf *
__inet_uaddr2taddr(struct netconfig *tp, char *addr)
{
    if (!addr || !tp) {
        _nderror = ND_BADARG;
        return (NULL);
    }
    if (strcmp(tp->nc_protofmly, NC_INET) == 0)
        return (ip_uaddr2taddr(addr));
    else
        return (ipv6_uaddr2taddr(addr));
}

static struct netbuf *
ip_uaddr2taddr(char *addr)
{

    struct sockaddr_in  *sa;
    uint32_t        inaddr;
    unsigned short      inport;
    int         h1, h2, h3, h4, p1, p2;
    struct netbuf       *result;

    result = malloc(sizeof (struct netbuf));
    if (!result) {
        _nderror = ND_NOMEM;
        return (NULL);
    }

    sa = calloc(1, sizeof (*sa));

    if (!sa) {
        free(result);
        _nderror = ND_NOMEM;
        return (NULL);
    }

    result->buf = (char *)(sa);
    result->maxlen = sizeof (struct sockaddr_in);
    result->len = sizeof (struct sockaddr_in);

    /* XXX there is probably a better way to do this. */
    if (sscanf(addr, "%d.%d.%d.%d.%d.%d", &h1, &h2, &h3, &h4,
        &p1, &p2) != 6) {
        free(result);
        _nderror = ND_NO_RECOVERY;
        return (NULL);
    }

    /* convert the host address first */
    inaddr = (h1 << 24) + (h2 << 16) + (h3 << 8) + h4;
    sa->sin_addr.s_addr = htonl(inaddr);

    /* convert the port */
    inport = (p1 << 8) + p2;
    sa->sin_port = htons(inport);

    sa->sin_family = AF_INET;

    return (result);
}

static struct netbuf *
ipv6_uaddr2taddr(char   *addr)
{
    struct sockaddr_in6 *sa;
    unsigned short      inport;
    int  p1, p2;
    struct netbuf       *result;
    char tmpaddr[RPC_INET6_MAXUADDRSIZE];
    char *dot;

    result = malloc(sizeof (struct netbuf));
    if (!result) {
        _nderror = ND_NOMEM;
        return (NULL);
    }

    sa = calloc(1, sizeof (struct sockaddr_in6));
    if (!sa) {
        free(result);
        _nderror = ND_NOMEM;
        return (NULL);
    }
    result->buf = (char *)(sa);
    result->maxlen = sizeof (struct sockaddr_in6);
    result->len = sizeof (struct sockaddr_in6);

    /* retrieve the ipv6 address and port info */

    if (strlen(addr) > sizeof (tmpaddr) - 1) {
        free(result);
        _nderror = ND_NOMEM;
        return (NULL);
    }

    (void) strcpy(tmpaddr, addr);

    if ((dot = strrchr(tmpaddr, '.')) != 0) {
        *dot = '\0';
        p2 = atoi(dot+1);
        if ((dot = strrchr(tmpaddr, '.')) != 0) {
            *dot = '\0';
            p1 = atoi(dot+1);
        }
    }

    if (dot == 0) {
        free(result);
        _nderror = ND_NOMEM;
        return (NULL);
    }

    if (inet_pton(AF_INET6, tmpaddr, sa->sin6_addr.s6_addr) == 0) {
        free(result);
        _nderror = ND_NOMEM;
        return (NULL);
    }

    /* convert the port */
    inport = (p1 << 8) + p2;
    sa->sin6_port = htons(inport);

    sa->sin6_family = AF_INET6;

    return (result);
}

/*
 * Interface caching routines.  The cache is refreshed every
 * IF_CACHE_REFRESH_TIME seconds.  A read-write lock is used to
 * protect the cache.
 */
#define IF_CACHE_REFRESH_TIME 10

static int if_cache_refresh_time = IF_CACHE_REFRESH_TIME;
static rwlock_t iflock = DEFAULTRWLOCK;
static time_t last_updated = 0;     /* protected by iflock */

/*
 * Changing the data type of if_flags from uint_t to uint64_t to accomodate
 * extra flags. Refer <net/if.h> for the extra flags.
 */
typedef struct if_info_s {
    struct in_addr if_netmask;  /* netmask in network order */
    struct in_addr if_address;  /* address in network order */
    uint64_t if_flags;      /* interface flags */
} if_info_t;

static if_info_t *if_info = NULL;   /* if cache, protected by iflock */
static int n_ifs = 0;           /* number of cached interfaces */
static int numifs_last = 0;     /* number of interfaces last seen */

/*
 * Builds the interface cache.  Write lock on iflock is needed
 * for calling this routine.  It sets _nderror for error returns.
 * Returns TRUE if successful, FALSE otherwise.
 * Changing the structures ifreq and ifconf to lifreq and lifconf to
 * have larger flag field. This is to accomodate the extra flags associated
 * with the interface. Also introducing lifn which will contain the number
 * of IPV4 interfaces present.
 */
static bool_t
get_if_info(void)
{
    size_t      needed;
    struct lifreq   *buf = NULL;
    int     numifs;
    struct lifconf  lifc;
    struct lifreq   *lifr;
    struct lifnum   lifn;

    lifn.lifn_family = AF_INET;
    lifn.lifn_flags = 0;
getifnum:
    if (nss_ioctl(AF_INET, SIOCGLIFNUM, &lifn) == -1) {
        numifs = MAXIFS;
    } else {
        numifs = lifn.lifn_count;
    }
    /*
     * Add a small fudge factor in case interfaces are plumbed
     * between the SIOCGLIFNUM and SIOCGLIFCONF.
     */
    needed = (numifs + 4) * sizeof (struct lifreq);
    if (buf == NULL)
        buf = malloc(needed);
    else
        buf = realloc(buf, needed);
    if (buf == NULL) {
        _nderror = ND_NOMEM;
        return (FALSE);
    }

    lifc.lifc_family = AF_INET;
    lifc.lifc_flags = 0;
    lifc.lifc_len = needed;
    lifc.lifc_buf = (char *)buf;
    if (nss_ioctl(AF_INET, 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;

        free(buf);
        free(if_info);
        if_info = NULL;
        _nderror = ND_SYSTEM;
        return (FALSE);
    }
    numifs = lifc.lifc_len / (int)sizeof (struct lifreq);

    if (if_info == NULL || numifs > numifs_last) {
        if (if_info == NULL)
            if_info = malloc(numifs * sizeof (if_info_t));
        else
            if_info = realloc(if_info, numifs * sizeof (if_info_t));
        if (if_info == NULL) {
            free(buf);
            _nderror = ND_NOMEM;
            return (FALSE);
        }
        numifs_last = numifs;
    }

    n_ifs = 0;
    for (lifr = buf; lifr < (buf + numifs); lifr++) {
        if (lifr->lifr_addr.ss_family != AF_INET)
            continue;

        if_info[n_ifs].if_address =
            ((struct sockaddr_in *)&lifr->lifr_addr)->sin_addr;

        if (nss_ioctl(AF_INET, SIOCGLIFFLAGS, lifr) < 0)
            continue;

        if ((lifr->lifr_flags & IFF_UP) == 0)
            continue;
        if_info[n_ifs].if_flags = lifr->lifr_flags;

        if (nss_ioctl(AF_INET, SIOCGLIFNETMASK, lifr) < 0)
            continue;

        if_info[n_ifs].if_netmask =
            ((struct sockaddr_in *)&lifr->lifr_addr)->sin_addr;
        n_ifs++;
    }
    free(buf);
    return (TRUE);
}


/*
 * Update the interface cache based on last update time.
 */
static bool_t
update_if_cache(void)
{
    time_t  curtime;

    (void) rw_wrlock(&iflock);
    /*
     * Check if some other thread has beaten this one to it.
     */
    (void) time(&curtime);
    if ((curtime - last_updated) >= if_cache_refresh_time) {
        if (!get_if_info()) {
            (void) rw_unlock(&iflock);
            return (FALSE);
        }
        (void) time(&last_updated);
    }
    (void) rw_unlock(&iflock);
    return (TRUE);
}


/*
 * Given an IP address, check if this matches any of the interface
 * addresses.  If an error occurs, return FALSE so that the caller
 * will not assume that this address belongs to this machine.
 */
static bool_t
is_my_address(struct in_addr addr)
{
    time_t      curtime;
    if_info_t   *ifn;

    (void) time(&curtime);
    if ((curtime - last_updated) >= if_cache_refresh_time) {
        /*
         * Cache needs to be refreshed.
         */
        if (!update_if_cache())
            return (FALSE);
    }
    (void) rw_rdlock(&iflock);
    for (ifn = if_info; ifn < (if_info + n_ifs); ifn++) {
        if (addr.s_addr == ifn->if_address.s_addr) {
            (void) rw_unlock(&iflock);
            return (TRUE);
        }
    }
    (void) rw_unlock(&iflock);
    return (FALSE);
}


/*
 * Given a host name, check if it is this host.
 */
bool_t
__inet_netdir_is_my_host(const char *host)
{
    int     error;
    char        buf[NSS_BUFLEN_HOSTS];
    struct hostent  res, *h;
    char        **c;
    struct in_addr  in;

    h = gethostbyname_r(host, (void *)&res, buf, sizeof (buf), &error);
    if (h == NULL)
        return (FALSE);
    if (h->h_addrtype != AF_INET)
        return (FALSE);
    for (c = h->h_addr_list; *c != NULL; c++) {
        (void) memcpy(&in.s_addr, *c, sizeof (in.s_addr));
        if (is_my_address(in))
            return (TRUE);
    }
    return (FALSE);
}


/*
 * Given an IP address, find the interface address that has the best
 * prefix match.  Return the address in network order.
 */
static uint32_t
get_best_match(struct in_addr addr)
{
    if_info_t *bestmatch, *ifn;
    int bestcount, count, limit;
    uint32_t mask, netmask, clnt_addr, if_addr;
    bool_t found, subnet_match;
    int subnet_count;

    bestmatch = NULL;               /* no match yet */
    bestcount = BITSPERBYTE * sizeof (uint32_t);    /* worst match */
    clnt_addr = ntohl(addr.s_addr);         /* host order */

    subnet_match = FALSE;       /* subnet match not found yet */
    subnet_count = bestcount;   /* worst subnet match */

    for (ifn = if_info; ifn < (if_info + n_ifs); ifn++) {
        netmask = ntohl(ifn->if_netmask.s_addr);  /* host order */
        if_addr = ntohl(ifn->if_address.s_addr);  /* host order */

        /*
         * set initial count to first bit set in netmask, with
         * zero being the number of the least significant bit.
         */
        count = 0;
        for (mask = netmask; mask && ((mask & 1) == 0); mask >>= 1)
            count++;

        /*
         * Set limit so that we don't try to match prefixes shorter
         * than the inherent netmask for the class (A, B, C, etc).
         */
        if (IN_CLASSC(if_addr))
            limit = IN_CLASSC_NSHIFT;
        else if (IN_CLASSB(if_addr))
            limit = IN_CLASSB_NSHIFT;
        else if (IN_CLASSA(if_addr))
            limit = IN_CLASSA_NSHIFT;
        else
            limit = 0;

        /*
         * We assume that the netmask consists of a contiguous
         * sequence of 1-bits starting with the most significant bit.
         * Prefix comparison starts at the subnet mask level.
         * The prefix mask used for comparison is progressively
         * reduced until it equals the inherent mask for the
         * interface address class.  The algorithm finds an
         * interface in the following order of preference:
         *
         * (1) the longest subnet match
         * (2) the best partial subnet match
         * (3) the first non-loopback && non-PPP interface
         * (4) the first non-loopback interface (PPP is OK)
         */
        found = FALSE;
        while (netmask && count < subnet_count) {
            if ((netmask & clnt_addr) == (netmask & if_addr)) {
                bestcount = count;
                bestmatch = ifn;
                found = TRUE;
                break;
            }
            netmask <<= 1;
            count++;
            if (count >= bestcount || count > limit || subnet_match)
                break;
        }
        /*
         * If a subnet level match occurred, note this for
         * comparison with future subnet matches.
         */
        if (found && (netmask == ntohl(ifn->if_netmask.s_addr))) {
            subnet_match = TRUE;
            subnet_count = count;
        }
    }

    /*
     * If we don't have a match, select the first interface that
     * is not a loopback interface (and preferably not a PPP interface)
     * as the best match.
     */
    if (bestmatch == NULL) {
        for (ifn = if_info; ifn < (if_info + n_ifs); ifn++) {
            if ((ifn->if_flags & IFF_LOOPBACK) == 0) {
                bestmatch = ifn;

                /*
                 * If this isn't a PPP interface, we're
                 * done.  Otherwise, keep walking through
                 * the list in case we have a non-loopback
                 * iface that ISN'T a PPP further down our
                 * list...
                 */
                if ((ifn->if_flags & IFF_POINTOPOINT) == 0) {
                    break;
                }
            }
        }
    }

    if (bestmatch != NULL)
        return (bestmatch->if_address.s_addr);
    else
        return (0);
}

static int
is_myself(struct sockaddr_in6 *sa6)
{
    struct sioc_addrreq areq;
    int s;

    if ((s = open("/dev/udp6", O_RDONLY)) < 0) {
        syslog(LOG_ERR, "is_myself: can't open /dev/udp6: %m");
        return (0);
    }

    (void) memcpy(&areq.sa_addr, sa6, sizeof (struct sockaddr_storage));
    areq.sa_res = -1;

    if (ioctl(s, SIOCTMYADDR, (caddr_t)&areq) < 0) {
        syslog(LOG_ERR, "is_myself:SIOCTMYADDR failed: %m");
        (void) close(s);
        return (0);
    }

    (void) close(s);
    return (areq.sa_res);

}
/*
 * For a given destination address, determine a source address to use.
 * Returns wildcard address if it cannot determine the source address.
 * copied from ping.c.
 */
union any_in_addr {
    struct in6_addr addr6;
    struct in_addr addr;
};

static bool_t
select_server_addr(union any_in_addr *dst_addr, int family,
    union any_in_addr *src_addr)
{
    struct sockaddr *sock;
    struct sockaddr_in *sin;
    struct sockaddr_in6 *sin6;
    int tmp_fd;
    socklen_t sock_len;

    sock = calloc(1, sizeof (struct sockaddr_in6));
    if (sock == NULL) {
        return (FALSE);
    }

    if (family == AF_INET) {
        /* LINTED pointer cast */
        sin = (struct sockaddr_in *)sock;
        sin->sin_family = AF_INET;
        sin->sin_port = 111;
        sin->sin_addr = dst_addr->addr;
        sock_len = sizeof (struct sockaddr_in);
    } else {
        /* LINTED pointer cast */
        sin6 = (struct sockaddr_in6 *)sock;
        sin6->sin6_family = AF_INET6;
        sin6->sin6_port = 111;
        sin6->sin6_addr = dst_addr->addr6;
        sock_len = sizeof (struct sockaddr_in6);
    }

    /* open a UDP socket */
    tmp_fd = _so_socket(family, SOCK_DGRAM, 0, NULL, SOV_SOCKBSD);
    if (tmp_fd < 0) {
        syslog(LOG_ERR, "select_server_addr: connect failed\n");
        return (FALSE);
    }

    /* connect it */
    if (_so_connect(tmp_fd, sock, sock_len, SOV_SOCKBSD) < 0) {
        /*
         * If there's no route to the destination, this connect() call
         * fails. We just return all-zero (wildcard) as the source
         * address, so that user can get to see "no route to dest"
         * message, as it'll try to send the probe packet out and will
         * receive ICMP unreachable.
         */
        if (family == AF_INET) {
            src_addr->addr.s_addr = INADDR_ANY;
        } else {
            /*
             * Since in6addr_any is not in the scope
             * use the following hack
             */
            (void) memset(src_addr->addr6.s6_addr,
                0, sizeof (struct in6_addr));
        }
        (void) close(tmp_fd);
        free(sock);
        return (FALSE);
    }

    /* get the local sock info */
    if (_so_getsockname(tmp_fd, sock, &sock_len, SOV_DEFAULT) < 0) {
        syslog(LOG_ERR, "select_server_addr: getsockname failed\n");
        (void) close(tmp_fd);
        free(sock);
        return (FALSE);
    }

    if (family == AF_INET) {
        /* LINTED pointer cast */
        sin = (struct sockaddr_in *)sock;
        src_addr->addr = sin->sin_addr;
    } else {
        /* LINTED pointer cast */
        sin6 = (struct sockaddr_in6 *)sock;
        src_addr->addr6 = sin6->sin6_addr;
    }

    (void) close(tmp_fd);
    free(sock);
    return (TRUE);
}

/*
 * This internal routine will merge one of those "universal" addresses
 * to the one which will make sense to the remote caller.
 */
static char *
inet_netdir_mergeaddr(struct netconfig *tp, char *ruaddr, char *uaddr)
{
    char    tmp[SYS_NMLN], *cp;
    int j;
    struct  in_addr clientaddr, bestmatch;
    time_t  curtime;
    int af;

    if (!uaddr || !ruaddr || !tp) {
        _nderror = ND_BADARG;
        return (NULL);
    }
    (void) bzero(tmp, SYS_NMLN);

    if (strcmp(tp->nc_protofmly, NC_INET) == 0)
        af = AF_INET;
    else
        af = AF_INET6;

    if (af == AF_INET) {
        if (strncmp(ruaddr, "0.0.0.0.", strlen("0.0.0.0.")) == 0)
            /* thats me: return the way it is */
            return (strdup(uaddr));

        /*
         * Convert remote uaddr into an in_addr so that we can compare
         * to it.  Shave off last two dotted-decimal values.
         */
        for (cp = ruaddr, j = 0; j < 4; j++, cp++)
            if ((cp = strchr(cp, '.')) == NULL)
                break;

        if (cp != NULL)
            *--cp = '\0';   /* null out the dot after the IP addr */
        else {
            _nderror = ND_NOHOST;
            return (NULL);
        }

        clientaddr.s_addr = inet_addr(ruaddr);

        /* We know cp is not NULL due to the check above */
        *cp = '.';  /* Put the dot back in the IP addr */

        (void) time(&curtime);
        if ((curtime - last_updated) >= if_cache_refresh_time) {
            /*
             * Cache needs to be refreshed.
             */
            if (!update_if_cache())
                return (NULL);
        }

        /*
         * Find the best match now.
         */
        (void) rw_rdlock(&iflock);
        bestmatch.s_addr = get_best_match(clientaddr);
        (void) rw_unlock(&iflock);

        if (bestmatch.s_addr)
            _nderror = ND_OK;
        else {
            _nderror = ND_NOHOST;
            return (NULL);
        }

        /* prepare the reply */
        (void) memset(tmp, '\0', sizeof (tmp));

        /* reply consists of the IP addr of the closest interface */
        (void) strcpy(tmp, inet_ntoa(bestmatch));

        /*
         * ... and the port number part (last two dotted-decimal values)
         * of uaddr
         */
        for (cp = uaddr, j = 0; j < 4; j++, cp++)
            cp = strchr(cp, '.');
        (void) strcat(tmp, --cp);

    } else {
        /* IPv6 */
        char *dot;
        char *truaddr;
        struct sockaddr_in6 sa;
        struct sockaddr_in6 server_addr;
        union any_in_addr in_addr, out_addr;

        if (strncmp(ruaddr, "::", strlen("::")) == 0)
            if (*(ruaddr + strlen("::")) == '\0')
                /* thats me: return the way it is */
                return (strdup(uaddr));

        bzero(&sa, sizeof (sa));
        bzero(&server_addr, sizeof (server_addr));
        truaddr = &tmp[0];
        (void) strcpy(truaddr, ruaddr);

        /*
         * now extract the server ip address from
         * the address supplied by client.  It can be
         * client's own IP address.
         */

        if ((dot = strrchr(truaddr, '.')) != 0) {
            *dot = '\0';
            if ((dot = strrchr(truaddr, '.')) != 0)
                *dot = '\0';
        }

        if (dot == 0) {
            _nderror = ND_NOHOST;
            return (NULL);
        }

        if (inet_pton(af, truaddr, sa.sin6_addr.s6_addr)
            != 1) {
            _nderror = ND_NOHOST;
            return (NULL);
        }

        in_addr.addr6 = sa.sin6_addr;
        sa.sin6_family = AF_INET6;

        /* is it my IP address */
        if (!is_myself(&sa)) {
            /* have the kernel select one for me */
            if (select_server_addr(&in_addr, af, &out_addr) ==
                FALSE)
                return (NULL);
            server_addr.sin6_addr = out_addr.addr6;
        } else {
            (void) memcpy(&server_addr, &sa, sizeof (server_addr));
        }

        if (inet_ntop(af, server_addr.sin6_addr.s6_addr, tmp,
            sizeof (tmp)) == NULL) {
            _nderror = ND_NOHOST;
            return (NULL);
        }

        /* now extract the port info */
        if ((dot = strrchr(uaddr, '.')) != 0) {
            char *p = --dot;

            while (*p-- != '.')
                ;
            p++;
            (void) strcat(tmp + strlen(tmp), p);
            _nderror = ND_OK;
        } else {
            _nderror = ND_NOHOST;
            return (NULL);
        }

    }
    return (strdup(tmp));
}

static int
bindresvport(struct netconfig *nconf, int fd, struct netbuf *addr)
{
    int res;
    struct sockaddr_in myaddr;
    struct sockaddr_in6 myaddr6;
    struct sockaddr_in *sin;
    struct sockaddr_in6 *sin6;
    int i;
    struct t_bind tbindstr, *tres;
    struct t_info tinfo;
    struct t_optmgmt req, resp;
    struct opthdr *opt;
    int reqbuf[64/sizeof (int)];
    int *optval;

    union {
        struct sockaddr_in *sin;
        struct sockaddr_in6 *sin6;
        char *buf;
    } u;

    _nderror = ND_SYSTEM;
    if (geteuid()) {
        errno = EACCES;
        return (-1);
    }
    if ((i = t_getstate(fd)) != T_UNBND) {
        if (t_errno == TBADF)
            errno = EBADF;
        if (i != -1)
            errno = EISCONN;
        return (-1);
    }

    if (strcmp(nconf->nc_protofmly, NC_INET) == 0) {
        if (addr == NULL) {
            sin = &myaddr;
            (void) memset(sin, 0, sizeof (*sin));
            sin->sin_family = AF_INET;
            u.buf = (char *)sin;
        } else
            u.buf = (char *)addr->buf;
    } else if (strcmp(nconf->nc_protofmly, NC_INET6) == 0) {
        if (addr == NULL) {
            sin6 = &myaddr6;
            (void) memset(sin6, 0, sizeof (*sin6));
            sin6->sin6_family = AF_INET6;
            u.buf = (char *)sin6;
        } else
            u.buf = addr->buf;

    } else {
        errno = EPFNOSUPPORT;
        return (-1);
    }

    /* Transform sockaddr_in to netbuf */
    if (t_getinfo(fd, &tinfo) == -1)
        return (-1);
    /* LINTED pointer cast */
    tres = (struct t_bind *)t_alloc(fd, T_BIND, T_ADDR);
    if (tres == NULL) {
        _nderror = ND_NOMEM;
        return (-1);
    }

    tbindstr.qlen = 0; /* Always 0; user should change if he wants to */
    tbindstr.addr.buf = (char *)u.buf;
    tbindstr.addr.len = tbindstr.addr.maxlen = __rpc_get_a_size(tinfo.addr);

    /*
     * Use *_ANONPRIVBIND to ask the kernel to pick a port in the
     * priviledged range for us.
     */
    opt = (struct opthdr *)reqbuf;
    if (strcmp(nconf->nc_proto, NC_TCP) == 0) {
        opt->level = IPPROTO_TCP;
        opt->name = TCP_ANONPRIVBIND;
    } else if (strcmp(nconf->nc_proto, NC_UDP) == 0) {
        opt->level = IPPROTO_UDP;
        opt->name = UDP_ANONPRIVBIND;
    } else {
        errno = EPROTONOSUPPORT;
        (void) t_free((char *)tres, T_BIND);
        return (-1);
    }

    opt->len = sizeof (int);
    req.flags = T_NEGOTIATE;
    req.opt.len = sizeof (struct opthdr) + opt->len;
    req.opt.buf = (char *)opt;
    /* LINTED pointer cast */
    optval = (int *)((char *)reqbuf + sizeof (struct opthdr));
    *optval = 1;
    resp.flags = 0;
    resp.opt.buf = (char *)reqbuf;
    resp.opt.maxlen = sizeof (reqbuf);
    if (t_optmgmt(fd, &req, &resp) < 0 || resp.flags != T_SUCCESS) {
        (void) t_free((char *)tres, T_BIND);
        return (-1);
    }

    if (u.sin->sin_family == AF_INET)
        u.sin->sin_port = htons(0);
    else
        u.sin6->sin6_port = htons(0);
    res = t_bind(fd, &tbindstr, tres);
    if (res != 0) {
        if (t_errno == TNOADDR) {
            _nderror = ND_FAILCTRL;
            res = 1;
        }
    } else {
        _nderror = ND_OK;
    }

    /*
     * Always turn off the option when we are done.  Note that by doing
     * this, if the caller has set this option before calling
     * bindresvport(), it will be unset.  Better be safe...
     */
    *optval = 0;
    resp.flags = 0;
    resp.opt.buf = (char *)reqbuf;
    resp.opt.maxlen = sizeof (reqbuf);
    if (t_optmgmt(fd, &req, &resp) < 0 || resp.flags != T_SUCCESS) {
        (void) t_free((char *)tres, T_BIND);
        if (res == 0)
            (void) t_unbind(fd);
        _nderror = ND_FAILCTRL;
        return (-1);
    }

    (void) t_free((char *)tres, T_BIND);
    return (res);
}

static int
checkresvport(struct netbuf *addr)
{
    struct sockaddr_in *sin;
    unsigned short port;

    if (addr == NULL) {
        _nderror = ND_FAILCTRL;
        return (-1);
    }
    /*
     * Still works for IPv6 since the first two memebers of
     * both address structure point to family and port # respectively
     */
    /* LINTED pointer cast */
    sin = (struct sockaddr_in *)(addr->buf);
    port = ntohs(sin->sin_port);
    if (port < IPPORT_RESERVED)
        return (0);
    return (1);
}