xref: /illumos-gate/usr/src/cmd/ypcmd/rpc_bootstrap.c (revision 2a8bcb4e)

/*
 * 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 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*	Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
/*	  All Rights Reserved   */

/*
 * Portions of this source code were derived from Berkeley
 * under license from the Regents of the University of
 * California.
 */

#include <sys/types.h>
#include <sys/file.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <tiuser.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <netdir.h>
#include <netdb.h>
#include <rpc/rpc.h>
#include <rpc/pmap_clnt.h>
#include <rpcsvc/nis.h>

CLIENT *__clnt_tp_create_bootstrap();
int __rpcb_getaddr_bootstrap();
struct hostent *__files_gethostbyname(char *, sa_family_t);

extern int hostNotKnownLocally;

static char *__map_addr();
static struct hostent host;
static char hostaddr[sizeof (struct in6_addr)];
static char *host_aliases[MAXALIASES];
static char *host_addrs[] = {
	hostaddr,
	NULL
};

/*
 * __clnt_tp_create_bootstrap()
 *
 * This routine is NOT TRANSPORT INDEPENDENT.
 *
 * It relies on the local /etc/hosts file for hostname to address
 * translation and does it itself instead of calling netdir_getbyname
 * thereby avoids recursion.  Secondarily, it will use a validated
 * IP address directly.
 */
CLIENT *
__clnt_tp_create_bootstrap(hostname, prog, vers, nconf)
	char *hostname;
	ulong_t prog, vers;
	struct netconfig    *nconf;
{
	CLIENT *cl;
	struct netbuf	*svc_taddr;
	struct sockaddr_in6	*sa;
	int fd;

	if (nconf == (struct netconfig *)NULL) {
		rpc_createerr.cf_stat = RPC_N2AXLATEFAILURE;
		return (NULL);
	}
	if ((fd = t_open(nconf->nc_device, O_RDWR, NULL)) == -1) {
		rpc_createerr.cf_stat = RPC_TLIERROR;
		return (NULL);
	}
	svc_taddr = (struct netbuf *)malloc(sizeof (struct netbuf));
	if (! svc_taddr) {
		rpc_createerr.cf_stat = RPC_SYSTEMERROR;
		t_close(fd);
		return (NULL);
	}
	sa = (struct sockaddr_in6 *)calloc(1, sizeof (*sa));
	if (! sa) {
		rpc_createerr.cf_stat = RPC_SYSTEMERROR;
		t_close(fd);
		free(svc_taddr);
		return (NULL);
	}
	svc_taddr->maxlen = svc_taddr->len = sizeof (*sa);
	svc_taddr->buf = (char *)sa;
	if (__rpcb_getaddr_bootstrap(prog,
		vers, nconf, svc_taddr, hostname) == FALSE) {
		t_close(fd);
		free(svc_taddr);
		free(sa);
		return (NULL);
	}
	rpc_createerr.cf_stat = RPC_SUCCESS;
	cl = __nis_clnt_create(fd, nconf, 0, svc_taddr, 0, prog, vers, 0, 0);
	if (cl == 0) {
		if (rpc_createerr.cf_stat == RPC_SUCCESS)
			rpc_createerr.cf_stat = RPC_TLIERROR;
		t_close(fd);
	}
	free(svc_taddr);
	free(sa);
	return (cl);
}

/*
 * __rpcb_getaddr_bootstrap()
 *
 * This is our internal function that replaces rpcb_getaddr(). We
 * build our own to prevent calling netdir_getbyname() which could
 * recurse to the nameservice.
 */
int
__rpcb_getaddr_bootstrap(program, version, nconf, address, hostname)
	ulong_t program;
	ulong_t version;
	struct netconfig *nconf;
	struct netbuf *address; /* populate with the taddr of the service */
	char *hostname;
{
	char *svc_uaddr;
	struct hostent *hent, tmphent;
	struct sockaddr_in *sa;
	struct sockaddr_in6 *sa6;
	struct netbuf rpcb_taddr;
	struct sockaddr_in local_sa;
	struct sockaddr_in6 local_sa6;
	in_port_t inport;
	int p1, p2;
	char *ipaddr, *port;
	int i, ipaddrlen;
	sa_family_t type;
	char addr[sizeof (in6_addr_t)];
	char *tmphost_addrs[2];

	if (strcmp(nconf->nc_protofmly, NC_INET6) == 0) {
		type = AF_INET6;
	} else if (strcmp(nconf->nc_protofmly, NC_INET) == 0) {
		type = AF_INET;
	} else {
		rpc_createerr.cf_stat = RPC_UNKNOWNADDR;
		return (FALSE);
	}

	/* Get the address of the RPCBIND at hostname */
	hent = __files_gethostbyname(hostname, type);
	if (hent == (struct hostent *)NULL) {
		/* Make sure this is not an IP address before giving up */
		if (inet_pton(type, hostname, addr) == 1) {
			/* This is a numeric address, fill in the blanks */
			hent = &tmphent;
			memset(&tmphent, 0, sizeof (struct hostent));
			hent->h_addrtype = type;
			hent->h_length = (type == AF_INET6) ?
			    sizeof (in6_addr_t) : sizeof (in_addr_t);
			hent->h_addr_list = tmphost_addrs;
			tmphost_addrs[0] = addr;
			tmphost_addrs[1] = NULL;
		} else {
			rpc_createerr.cf_stat = RPC_UNKNOWNHOST;
			hostNotKnownLocally = 1;
			return (FALSE);
		}
	}

	switch (hent->h_addrtype) {
	case AF_INET:
		local_sa.sin_family = AF_INET;
		local_sa.sin_port = htons(111); /* RPCBIND port */
		memcpy((char *)&(local_sa.sin_addr.s_addr),
		    hent->h_addr_list[0], hent->h_length);
		rpcb_taddr.buf = (char *)&local_sa;
		rpcb_taddr.maxlen = sizeof (local_sa);
		rpcb_taddr.len = rpcb_taddr.maxlen;
		break;
	case AF_INET6:
		local_sa6.sin6_family = AF_INET6;
		local_sa6.sin6_port = htons(111); /* RPCBIND port */
		memcpy((char *)&(local_sa6.sin6_addr.s6_addr),
		    hent->h_addr_list[0], hent->h_length);
		rpcb_taddr.buf = (char *)&local_sa6;
		rpcb_taddr.maxlen = sizeof (local_sa6);
		rpcb_taddr.len = rpcb_taddr.maxlen;
		break;
	default:
		rpc_createerr.cf_stat = RPC_N2AXLATEFAILURE;
		return (FALSE);
	}

	svc_uaddr = __map_addr(nconf, &rpcb_taddr, program, version);
	if (! svc_uaddr)
		return (FALSE);

/* do a local uaddr2taddr and stuff in the memory supplied by the caller */
	ipaddr = svc_uaddr;
	ipaddrlen = strlen(ipaddr);
	/* Look for the first '.' starting from the end */
	for (i = ipaddrlen-1; i >= 0; i--)
		if (ipaddr[i] == '.')
			break;
	/* Find the second dot (still counting from the end) */
	for (i--; i >= 0; i--)
		if (ipaddr[i] == '.')
			break;
	/* If we didn't find it, the uaddr has a syntax error */
	if (i < 0) {
		rpc_createerr.cf_stat = RPC_N2AXLATEFAILURE;
		return (FALSE);
	}
	port = &ipaddr[i+1];
	ipaddr[i] = '\0';
	sscanf(port, "%d.%d", &p1, &p2);
	inport = (p1 << 8) + p2;
	if (hent->h_addrtype == AF_INET) {
		sa = (struct sockaddr_in *)address->buf;
		address->len = sizeof (*sa);
		if (inet_pton(AF_INET, ipaddr, &sa->sin_addr) != 1) {
			rpc_createerr.cf_stat = RPC_N2AXLATEFAILURE;
			return (FALSE);
		}
		sa->sin_port = htons(inport);
		sa->sin_family = AF_INET;
	} else {
		sa6 = (struct sockaddr_in6 *)address->buf;
		address->len = sizeof (*sa6);
		if (inet_pton(AF_INET6, ipaddr, &sa6->sin6_addr) != 1) {
			rpc_createerr.cf_stat = RPC_N2AXLATEFAILURE;
			return (FALSE);
		}
		sa6->sin6_port = htons(inport);
		sa6->sin6_family = AF_INET6;
	}
	return (TRUE);
}

/*
 * __map_addr()
 *
 */
static char *
__map_addr(nc, rpcb_taddr, prog, ver)
	struct netconfig	*nc;		/* Our transport	*/
	struct netbuf		*rpcb_taddr;	/* RPCBIND address */
	ulong_t			prog, ver;	/* Name service Prog/vers */
{
	register CLIENT *client;
	RPCB 		parms;		/* Parameters for RPC binder	  */
	enum clnt_stat	clnt_st;	/* Result from the rpc call	  */
	int		fd;		/* Stream file descriptor	  */
	char 		*ua = NULL;	/* Universal address of service	  */
	struct timeval	tv;		/* Timeout for our rpcb call	  */

	/*
	 * First we open a connection to the remote rpcbind process.
	 */
	if ((fd = t_open(nc->nc_device, O_RDWR, NULL)) == -1) {
		rpc_createerr.cf_stat = RPC_TLIERROR;
		return (NULL);
	}

	client = __nis_clnt_create(fd, nc, 0, rpcb_taddr, 0,
	    RPCBPROG, RPCBVERS, 0, 0);
	if (!client) {
		t_close(fd);
		rpc_createerr.cf_stat = RPC_TLIERROR;
		return (NULL);
	}

	/*
	 * Now make the call to get the NIS service address.
	 */
	tv.tv_sec = 10;
	tv.tv_usec = 0;
	parms.r_prog = prog;
	parms.r_vers = ver;
	parms.r_netid = nc->nc_netid;	/* not needed */
	parms.r_addr = "";	/* not needed; just for xdring */
	parms.r_owner = "";	/* not needed; just for xdring */
	clnt_st = clnt_call(client, RPCBPROC_GETADDR, xdr_rpcb, (char *)&parms,
	    xdr_wrapstring, (char *)&ua, tv);

	rpc_createerr.cf_stat = clnt_st;
	if (clnt_st == RPC_SUCCESS) {

		clnt_destroy(client);
		t_close(fd);
		if (*ua == '\0') {
			xdr_free(xdr_wrapstring, (char *)&ua);
			return (NULL);
		}
		return (ua);
	} else if (((clnt_st == RPC_PROGVERSMISMATCH) ||
	    (clnt_st == RPC_PROGUNAVAIL) ||
	    (clnt_st == RPC_TIMEDOUT)) &&
	    (strcmp(nc->nc_protofmly, NC_INET) == 0)) {
		/*
		 * version 3 not available. Try version 2
		 * The assumption here is that the netbuf
		 * is arranged in the sockaddr_in
		 * style for IP cases.
		 */
		ushort_t	port;
		struct sockaddr_in	*sa;
		struct netbuf 		remote;
		int		protocol;
		char	buf[32];
		char	*res;

		clnt_control(client, CLGET_SVC_ADDR, (char *)&remote);
		sa = (struct sockaddr_in *)(remote.buf);
		protocol = strcmp(nc->nc_proto, NC_TCP) ? IPPROTO_UDP :
		    IPPROTO_TCP;
		port = (ushort_t)pmap_getport(sa, prog, ver, protocol);

		if (port != 0) {
			/* print s_addr (and port) in host byte order */
			sa->sin_addr.s_addr = ntohl(sa->sin_addr.s_addr);
			sprintf(buf, "%d.%d.%d.%d.%d.%d",
			    (sa->sin_addr.s_addr >> 24) & 0xff,
			    (sa->sin_addr.s_addr >> 16) & 0xff,
			    (sa->sin_addr.s_addr >>  8) & 0xff,
			    (sa->sin_addr.s_addr) & 0xff,
			    (port >> 8) & 0xff,
			    port & 0xff);
			res = strdup(buf);
			if (res != 0) {
				rpc_createerr.cf_stat = RPC_SUCCESS;
			} else {
				rpc_createerr.cf_stat = RPC_SYSTEMERROR;
			}
		} else {
			rpc_createerr.cf_stat = RPC_UNKNOWNADDR;
			res = NULL;
		}
		clnt_destroy(client);
		t_close(fd);
		return (res);
	}
	clnt_destroy(client);
	t_close(fd);
	return (NULL);
}

#define	bcmp(s1, s2, len)	memcmp(s1, s2, len)
#define	bcopy(s1, s2, len)	memcpy(s2, s1, len)

#define	MAXALIASES	35

static char line[BUFSIZ+1];

static char *_hosts4_6[] = { "/etc/inet/hosts", "/etc/inet/ipnodes", 0 };

static char *any();

static struct hostent *__files_gethostent();

struct hostent *
__files_gethostbyname(char *nam, sa_family_t af)
{
	register struct hostent *hp;
	register char **cp;
	char **file = _hosts4_6;
	FILE *hostf;

	if ((af != AF_INET) && (af != AF_INET6))
		return (0);

	for (; *file != 0; file++) {

		if ((hostf = fopen(*file, "r")) == 0)
			continue;

		while (hp = __files_gethostent(hostf)) {
			if (hp->h_addrtype != af)
				continue;
			if (strcasecmp(hp->h_name, nam) == 0) {
				(void) fclose(hostf);
				return (hp);
			}
			for (cp = hp->h_aliases; cp != 0 && *cp != 0; cp++)
				if (strcasecmp(*cp, nam) == 0) {
					(void) fclose(hostf);
					return (hp);
				}
		}

		(void) fclose(hostf);
	}

	return (0);
}

#define	isV6Addr(s)	(strchr(s, (int)':') != 0)

static struct hostent *
__files_gethostent(FILE *hostf)
{
	char *p;
	register char *cp, **q;
	struct in6_addr in6;
	struct in_addr in4;
	void *addr;
	sa_family_t af;
	int len;

	if (hostf == NULL)
		return (NULL);
again:
	if ((p = fgets(line, BUFSIZ, hostf)) == NULL)
		return (NULL);
	if (*p == '#')
		goto again;
	cp = any(p, "#\n");
	if (cp == NULL)
		goto again;
	*cp = '\0';
	cp = any(p, " \t");
	if (cp == NULL)
		goto again;
	*cp++ = '\0';
	/* THIS STUFF IS INTERNET SPECIFIC */
	host.h_addr_list = host_addrs;
	if (isV6Addr(p)) {
		af = AF_INET6;
		addr = (void *)&in6;
		len = sizeof (in6);
	} else {
		af = AF_INET;
		addr = (void *)&in4;
		len = sizeof (in4);
	}
	if (inet_pton(af, p, addr) != 1)
		goto again;
	bcopy(addr, host.h_addr_list[0], len);
	host.h_length = len;
	host.h_addrtype = af;
	while (*cp == ' ' || *cp == '\t')
		cp++;
	host.h_name = cp;
	q = host.h_aliases = host_aliases;
	cp = any(cp, " \t");
	if (cp != NULL)
		*cp++ = '\0';
	while (cp && *cp) {
		if (*cp == ' ' || *cp == '\t') {
			cp++;
			continue;
		}
		if (q < &host_aliases[MAXALIASES - 1])
			*q++ = cp;
		cp = any(cp, " \t");
		if (cp != NULL)
			*cp++ = '\0';
	}
	*q = NULL;
	return (&host);
}

static char *
any(cp, match)
	register char *cp;
	char *match;
{
	register char *mp, c;

	while (c = *cp) {
		for (mp = match; *mp; mp++)
			if (*mp == c)
				return (cp);
		cp++;
	}
	return ((char *)0);
}