1/*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 *
21 * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
22 * Use is subject to license terms.
23 */
24
25/*	Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
26/*	  All Rights Reserved   */
27
28/*
29 * Portions of this source code were derived from Berkeley
30 * under license from the Regents of the University of
31 * California.
32 */
33
34#pragma ident	"%Z%%M%	%I%	%E% SMI"
35
36#include <sys/types.h>
37#include <sys/file.h>
38#include <stdlib.h>
39#include <ctype.h>
40#include <string.h>
41#include <tiuser.h>
42#include <netinet/in.h>
43#include <arpa/inet.h>
44#include <sys/socket.h>
45#include <netdir.h>
46#include <netdb.h>
47#include <rpc/rpc.h>
48#include <rpc/pmap_clnt.h>
49#include <rpcsvc/nis.h>
50
51CLIENT *__clnt_tp_create_bootstrap();
52int __rpcb_getaddr_bootstrap();
53struct hostent *__files_gethostbyname(char *, sa_family_t);
54
55extern int hostNotKnownLocally;
56
57static char *__map_addr();
58static struct hostent host;
59static char hostaddr[sizeof (struct in6_addr)];
60static char *host_aliases[MAXALIASES];
61static char *host_addrs[] = {
62	hostaddr,
63	NULL
64};
65
66/*
67 * __clnt_tp_create_bootstrap()
68 *
69 * This routine is NOT TRANSPORT INDEPENDENT.
70 *
71 * It relies on the local /etc/hosts file for hostname to address
72 * translation and does it itself instead of calling netdir_getbyname
73 * thereby avoids recursion.  Secondarily, it will use a validated
74 * IP address directly.
75 */
76CLIENT *
77__clnt_tp_create_bootstrap(hostname, prog, vers, nconf)
78	char *hostname;
79	ulong_t prog, vers;
80	struct netconfig    *nconf;
81{
82	CLIENT *cl;
83	struct netbuf	*svc_taddr;
84	struct sockaddr_in6	*sa;
85	int fd;
86
87	if (nconf == (struct netconfig *)NULL) {
88		rpc_createerr.cf_stat = RPC_N2AXLATEFAILURE;
89		return (NULL);
90	}
91	if ((fd = t_open(nconf->nc_device, O_RDWR, NULL)) == -1) {
92		rpc_createerr.cf_stat = RPC_TLIERROR;
93		return (NULL);
94	}
95	svc_taddr = (struct netbuf *)malloc(sizeof (struct netbuf));
96	if (! svc_taddr) {
97		rpc_createerr.cf_stat = RPC_SYSTEMERROR;
98		t_close(fd);
99		return (NULL);
100	}
101	sa = (struct sockaddr_in6 *)calloc(1, sizeof (*sa));
102	if (! sa) {
103		rpc_createerr.cf_stat = RPC_SYSTEMERROR;
104		t_close(fd);
105		free(svc_taddr);
106		return (NULL);
107	}
108	svc_taddr->maxlen = svc_taddr->len = sizeof (*sa);
109	svc_taddr->buf = (char *)sa;
110	if (__rpcb_getaddr_bootstrap(prog,
111		vers, nconf, svc_taddr, hostname) == FALSE) {
112		t_close(fd);
113		free(svc_taddr);
114		free(sa);
115		return (NULL);
116	}
117	rpc_createerr.cf_stat = RPC_SUCCESS;
118	cl = __nis_clnt_create(fd, nconf, 0, svc_taddr, 0, prog, vers, 0, 0);
119	if (cl == 0) {
120		if (rpc_createerr.cf_stat == RPC_SUCCESS)
121			rpc_createerr.cf_stat = RPC_TLIERROR;
122		t_close(fd);
123	}
124	free(svc_taddr);
125	free(sa);
126	return (cl);
127}
128
129/*
130 * __rpcb_getaddr_bootstrap()
131 *
132 * This is our internal function that replaces rpcb_getaddr(). We
133 * build our own to prevent calling netdir_getbyname() which could
134 * recurse to the nameservice.
135 */
136int
137__rpcb_getaddr_bootstrap(program, version, nconf, address, hostname)
138	ulong_t program;
139	ulong_t version;
140	struct netconfig *nconf;
141	struct netbuf *address; /* populate with the taddr of the service */
142	char *hostname;
143{
144	char *svc_uaddr;
145	struct hostent *hent, tmphent;
146	struct sockaddr_in *sa;
147	struct sockaddr_in6 *sa6;
148	struct netbuf rpcb_taddr;
149	struct sockaddr_in local_sa;
150	struct sockaddr_in6 local_sa6;
151	in_port_t inport;
152	int p1, p2;
153	char *ipaddr, *port;
154	int i, ipaddrlen;
155	sa_family_t type;
156	char addr[sizeof (in6_addr_t)];
157	char *tmphost_addrs[2];
158
159	if (strcmp(nconf->nc_protofmly, NC_INET6) == 0) {
160		type = AF_INET6;
161	} else if (strcmp(nconf->nc_protofmly, NC_INET) == 0) {
162		type = AF_INET;
163	} else {
164		rpc_createerr.cf_stat = RPC_UNKNOWNADDR;
165		return (FALSE);
166	}
167
168	/* Get the address of the RPCBIND at hostname */
169	hent = __files_gethostbyname(hostname, type);
170	if (hent == (struct hostent *)NULL) {
171		/* Make sure this is not an IP address before giving up */
172		if (inet_pton(type, hostname, addr) == 1) {
173			/* This is a numeric address, fill in the blanks */
174			hent = &tmphent;
175			memset(&tmphent, 0, sizeof (struct hostent));
176			hent->h_addrtype = type;
177			hent->h_length = (type == AF_INET6) ?
178			    sizeof (in6_addr_t) : sizeof (in_addr_t);
179			hent->h_addr_list = tmphost_addrs;
180			tmphost_addrs[0] = addr;
181			tmphost_addrs[1] = NULL;
182		} else {
183			rpc_createerr.cf_stat = RPC_UNKNOWNHOST;
184			hostNotKnownLocally = 1;
185			return (FALSE);
186		}
187	}
188
189	switch (hent->h_addrtype) {
190	case AF_INET:
191		local_sa.sin_family = AF_INET;
192		local_sa.sin_port = htons(111); /* RPCBIND port */
193		memcpy((char *)&(local_sa.sin_addr.s_addr),
194		    hent->h_addr_list[0], hent->h_length);
195		rpcb_taddr.buf = (char *)&local_sa;
196		rpcb_taddr.maxlen = sizeof (local_sa);
197		rpcb_taddr.len = rpcb_taddr.maxlen;
198		break;
199	case AF_INET6:
200		local_sa6.sin6_family = AF_INET6;
201		local_sa6.sin6_port = htons(111); /* RPCBIND port */
202		memcpy((char *)&(local_sa6.sin6_addr.s6_addr),
203		    hent->h_addr_list[0], hent->h_length);
204		rpcb_taddr.buf = (char *)&local_sa6;
205		rpcb_taddr.maxlen = sizeof (local_sa6);
206		rpcb_taddr.len = rpcb_taddr.maxlen;
207		break;
208	default:
209		rpc_createerr.cf_stat = RPC_N2AXLATEFAILURE;
210		return (FALSE);
211	}
212
213	svc_uaddr = __map_addr(nconf, &rpcb_taddr, program, version);
214	if (! svc_uaddr)
215		return (FALSE);
216
217/* do a local uaddr2taddr and stuff in the memory supplied by the caller */
218	ipaddr = svc_uaddr;
219	ipaddrlen = strlen(ipaddr);
220	/* Look for the first '.' starting from the end */
221	for (i = ipaddrlen-1; i >= 0; i--)
222		if (ipaddr[i] == '.')
223			break;
224	/* Find the second dot (still counting from the end) */
225	for (i--; i >= 0; i--)
226		if (ipaddr[i] == '.')
227			break;
228	/* If we didn't find it, the uaddr has a syntax error */
229	if (i < 0) {
230		rpc_createerr.cf_stat = RPC_N2AXLATEFAILURE;
231		return (FALSE);
232	}
233	port = &ipaddr[i+1];
234	ipaddr[i] = '\0';
235	sscanf(port, "%d.%d", &p1, &p2);
236	inport = (p1 << 8) + p2;
237	if (hent->h_addrtype == AF_INET) {
238		sa = (struct sockaddr_in *)address->buf;
239		address->len = sizeof (*sa);
240		if (inet_pton(AF_INET, ipaddr, &sa->sin_addr) != 1) {
241			rpc_createerr.cf_stat = RPC_N2AXLATEFAILURE;
242			return (FALSE);
243		}
244		sa->sin_port = htons(inport);
245		sa->sin_family = AF_INET;
246	} else {
247		sa6 = (struct sockaddr_in6 *)address->buf;
248		address->len = sizeof (*sa6);
249		if (inet_pton(AF_INET6, ipaddr, &sa6->sin6_addr) != 1) {
250			rpc_createerr.cf_stat = RPC_N2AXLATEFAILURE;
251			return (FALSE);
252		}
253		sa6->sin6_port = htons(inport);
254		sa6->sin6_family = AF_INET6;
255	}
256	return (TRUE);
257}
258
259/*
260 * __map_addr()
261 *
262 */
263static char *
264__map_addr(nc, rpcb_taddr, prog, ver)
265	struct netconfig	*nc;		/* Our transport	*/
266	struct netbuf		*rpcb_taddr;	/* RPCBIND address */
267	ulong_t			prog, ver;	/* Name service Prog/vers */
268{
269	register CLIENT *client;
270	RPCB 		parms;		/* Parameters for RPC binder	  */
271	enum clnt_stat	clnt_st;	/* Result from the rpc call	  */
272	int		fd;		/* Stream file descriptor	  */
273	char 		*ua = NULL;	/* Universal address of service	  */
274	struct timeval	tv;		/* Timeout for our rpcb call	  */
275
276	/*
277	 * First we open a connection to the remote rpcbind process.
278	 */
279	if ((fd = t_open(nc->nc_device, O_RDWR, NULL)) == -1) {
280		rpc_createerr.cf_stat = RPC_TLIERROR;
281		return (NULL);
282	}
283
284	client = __nis_clnt_create(fd, nc, 0, rpcb_taddr, 0,
285	    RPCBPROG, RPCBVERS, 0, 0);
286	if (!client) {
287		t_close(fd);
288		rpc_createerr.cf_stat = RPC_TLIERROR;
289		return (NULL);
290	}
291
292	/*
293	 * Now make the call to get the NIS service address.
294	 */
295	tv.tv_sec = 10;
296	tv.tv_usec = 0;
297	parms.r_prog = prog;
298	parms.r_vers = ver;
299	parms.r_netid = nc->nc_netid;	/* not needed */
300	parms.r_addr = "";	/* not needed; just for xdring */
301	parms.r_owner = "";	/* not needed; just for xdring */
302	clnt_st = clnt_call(client, RPCBPROC_GETADDR, xdr_rpcb, (char *)&parms,
303	    xdr_wrapstring, (char *)&ua, tv);
304
305	rpc_createerr.cf_stat = clnt_st;
306	if (clnt_st == RPC_SUCCESS) {
307
308		clnt_destroy(client);
309		t_close(fd);
310		if (*ua == '\0') {
311			xdr_free(xdr_wrapstring, (char *)&ua);
312			return (NULL);
313		}
314		return (ua);
315	} else if (((clnt_st == RPC_PROGVERSMISMATCH) ||
316	    (clnt_st == RPC_PROGUNAVAIL) ||
317	    (clnt_st == RPC_TIMEDOUT)) &&
318	    (strcmp(nc->nc_protofmly, NC_INET) == 0)) {
319		/*
320		 * version 3 not available. Try version 2
321		 * The assumption here is that the netbuf
322		 * is arranged in the sockaddr_in
323		 * style for IP cases.
324		 */
325		ushort_t	port;
326		struct sockaddr_in	*sa;
327		struct netbuf 		remote;
328		int		protocol;
329		char	buf[32];
330		char	*res;
331
332		clnt_control(client, CLGET_SVC_ADDR, (char *)&remote);
333		sa = (struct sockaddr_in *)(remote.buf);
334		protocol = strcmp(nc->nc_proto, NC_TCP) ? IPPROTO_UDP :
335		    IPPROTO_TCP;
336		port = (ushort_t)pmap_getport(sa, prog, ver, protocol);
337
338		if (port != 0) {
339			/* print s_addr (and port) in host byte order */
340			sa->sin_addr.s_addr = ntohl(sa->sin_addr.s_addr);
341			sprintf(buf, "%d.%d.%d.%d.%d.%d",
342			    (sa->sin_addr.s_addr >> 24) & 0xff,
343			    (sa->sin_addr.s_addr >> 16) & 0xff,
344			    (sa->sin_addr.s_addr >>  8) & 0xff,
345			    (sa->sin_addr.s_addr) & 0xff,
346			    (port >> 8) & 0xff,
347			    port & 0xff);
348			res = strdup(buf);
349			if (res != 0) {
350				rpc_createerr.cf_stat = RPC_SUCCESS;
351			} else {
352				rpc_createerr.cf_stat = RPC_SYSTEMERROR;
353			}
354		} else {
355			rpc_createerr.cf_stat = RPC_UNKNOWNADDR;
356			res = NULL;
357		}
358		clnt_destroy(client);
359		t_close(fd);
360		return (res);
361	}
362	clnt_destroy(client);
363	t_close(fd);
364	return (NULL);
365}
366
367#define	bcmp(s1, s2, len)	memcmp(s1, s2, len)
368#define	bcopy(s1, s2, len)	memcpy(s2, s1, len)
369
370#define	MAXALIASES	35
371
372static char line[BUFSIZ+1];
373
374static char *_hosts4_6[] = { "/etc/inet/hosts", "/etc/inet/ipnodes", 0 };
375
376static char *any();
377
378static struct hostent *__files_gethostent();
379
380struct hostent *
381__files_gethostbyname(char *nam, sa_family_t af)
382{
383	register struct hostent *hp;
384	register char **cp;
385	char **file = _hosts4_6;
386	FILE *hostf;
387
388	if ((af != AF_INET) && (af != AF_INET6))
389		return (0);
390
391	for (; *file != 0; file++) {
392
393		if ((hostf = fopen(*file, "r")) == 0)
394			continue;
395
396		while (hp = __files_gethostent(hostf)) {
397			if (hp->h_addrtype != af)
398				continue;
399			if (strcasecmp(hp->h_name, nam) == 0) {
400				(void) fclose(hostf);
401				return (hp);
402			}
403			for (cp = hp->h_aliases; cp != 0 && *cp != 0; cp++)
404				if (strcasecmp(*cp, nam) == 0) {
405					(void) fclose(hostf);
406					return (hp);
407				}
408		}
409
410		(void) fclose(hostf);
411	}
412
413	return (0);
414}
415
416#define	isV6Addr(s)	(strchr(s, (int)':') != 0)
417
418static struct hostent *
419__files_gethostent(FILE *hostf)
420{
421	char *p;
422	register char *cp, **q;
423	struct in6_addr in6;
424	struct in_addr in4;
425	void *addr;
426	sa_family_t af;
427	int len;
428
429	if (hostf == NULL)
430		return (NULL);
431again:
432	if ((p = fgets(line, BUFSIZ, hostf)) == NULL)
433		return (NULL);
434	if (*p == '#')
435		goto again;
436	cp = any(p, "#\n");
437	if (cp == NULL)
438		goto again;
439	*cp = '\0';
440	cp = any(p, " \t");
441	if (cp == NULL)
442		goto again;
443	*cp++ = '\0';
444	/* THIS STUFF IS INTERNET SPECIFIC */
445	host.h_addr_list = host_addrs;
446	if (isV6Addr(p)) {
447		af = AF_INET6;
448		addr = (void *)&in6;
449		len = sizeof (in6);
450	} else {
451		af = AF_INET;
452		addr = (void *)&in4;
453		len = sizeof (in4);
454	}
455	if (inet_pton(af, p, addr) != 1)
456		goto again;
457	bcopy(addr, host.h_addr_list[0], len);
458	host.h_length = len;
459	host.h_addrtype = af;
460	while (*cp == ' ' || *cp == '\t')
461		cp++;
462	host.h_name = cp;
463	q = host.h_aliases = host_aliases;
464	cp = any(cp, " \t");
465	if (cp != NULL)
466		*cp++ = '\0';
467	while (cp && *cp) {
468		if (*cp == ' ' || *cp == '\t') {
469			cp++;
470			continue;
471		}
472		if (q < &host_aliases[MAXALIASES - 1])
473			*q++ = cp;
474		cp = any(cp, " \t");
475		if (cp != NULL)
476			*cp++ = '\0';
477	}
478	*q = NULL;
479	return (&host);
480}
481
482static char *
483any(cp, match)
484	register char *cp;
485	char *match;
486{
487	register char *mp, c;
488
489	while (c = *cp) {
490		for (mp = match; *mp; mp++)
491			if (*mp == c)
492				return (cp);
493		cp++;
494	}
495	return ((char *)0);
496}
497