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