usr/src/lib/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);
}