xref: /illumos-gate/usr/src/lib/libnsl/rpc/rpcb_clnt.c (revision a9e987e0)
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 
23 /*
24  * Copyright 2014 Gary Mills
25  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
26  * Use is subject to license terms.
27  */
28 
29 /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
30 /* All Rights Reserved */
31 /*
32  * Portions of this source code were derived from Berkeley
33  * 4.3 BSD under license from the Regents of the University of
34  * California.
35  */
36 
37 /*
38  * interface to rpcbind rpc service.
39  */
40 
41 #include "mt.h"
42 #include "rpc_mt.h"
43 #include <assert.h>
44 #include <rpc/rpc.h>
45 #include <rpc/rpcb_prot.h>
46 #include <netconfig.h>
47 #include <netdir.h>
48 #include <netdb.h>
49 #include <rpc/nettype.h>
50 #include <syslog.h>
51 #ifdef PORTMAP
52 #include <netinet/in.h>		/* FOR IPPROTO_TCP/UDP definitions */
53 #include <rpc/pmap_prot.h>
54 #endif
55 #include <sys/utsname.h>
56 #include <errno.h>
57 #include <stdlib.h>
58 #include <string.h>
59 #include <unistd.h>
60 
61 static struct timeval tottimeout = { 60, 0 };
62 static const struct timeval rmttimeout = { 3, 0 };
63 static struct timeval rpcbrmttime = { 15, 0 };
64 
65 extern bool_t xdr_wrapstring(XDR *, char **);
66 
67 static const char nullstring[] = "\000";
68 
69 extern CLIENT *_clnt_tli_create_timed(int, const struct netconfig *,
70 			struct netbuf *, rpcprog_t, rpcvers_t, uint_t, uint_t,
71 			const struct timeval *);
72 
73 static CLIENT *_getclnthandle_timed(char *, struct netconfig *, char **,
74 			struct timeval *);
75 
76 
77 /*
78  * The life time of a cached entry should not exceed 5 minutes
79  * since automountd attempts an unmount every 5 minutes.
80  * It is arbitrarily set a little lower (3 min = 180 sec)
81  * to reduce the time during which an entry is stale.
82  */
83 #define	CACHE_TTL 180
84 #define	CACHESIZE 6
85 
86 struct address_cache {
87 	char *ac_host;
88 	char *ac_netid;
89 	char *ac_uaddr;
90 	struct netbuf *ac_taddr;
91 	struct address_cache *ac_next;
92 	time_t ac_maxtime;
93 };
94 
95 static struct address_cache *front;
96 static int cachesize;
97 
98 extern int lowvers;
99 extern int authdes_cachesz;
100 /*
101  * This routine adjusts the timeout used for calls to the remote rpcbind.
102  * Also, this routine can be used to set the use of portmapper version 2
103  * only when doing rpc_broadcasts
104  * These are private routines that may not be provided in future releases.
105  */
106 bool_t
107 __rpc_control(int request, void *info)
108 {
109 	switch (request) {
110 	case CLCR_GET_RPCB_TIMEOUT:
111 		*(struct timeval *)info = tottimeout;
112 		break;
113 	case CLCR_SET_RPCB_TIMEOUT:
114 		tottimeout = *(struct timeval *)info;
115 		break;
116 	case CLCR_GET_LOWVERS:
117 		*(int *)info = lowvers;
118 		break;
119 	case CLCR_SET_LOWVERS:
120 		lowvers = *(int *)info;
121 		break;
122 	case CLCR_GET_RPCB_RMTTIME:
123 		*(struct timeval *)info = rpcbrmttime;
124 		break;
125 	case CLCR_SET_RPCB_RMTTIME:
126 		rpcbrmttime = *(struct timeval *)info;
127 		break;
128 	case CLCR_GET_CRED_CACHE_SZ:
129 		*(int *)info = authdes_cachesz;
130 		break;
131 	case CLCR_SET_CRED_CACHE_SZ:
132 		authdes_cachesz = *(int *)info;
133 		break;
134 	default:
135 		return (FALSE);
136 	}
137 	return (TRUE);
138 }
139 
140 /*
141  *	It might seem that a reader/writer lock would be more reasonable here.
142  *	However because getclnthandle(), the only user of the cache functions,
143  *	may do a delete_cache() operation if a check_cache() fails to return an
144  *	address useful to clnt_tli_create(), we may as well use a mutex.
145  */
146 /*
147  * As it turns out, if the cache lock is *not* a reader/writer lock, we will
148  * block all clnt_create's if we are trying to connect to a host that's down,
149  * since the lock will be held all during that time.
150  */
151 extern rwlock_t	rpcbaddr_cache_lock;
152 
153 /*
154  * The routines check_cache(), add_cache(), delete_cache() manage the
155  * cache of rpcbind addresses for (host, netid).
156  */
157 
158 static struct address_cache *
159 check_cache(char *host, char *netid)
160 {
161 	struct address_cache *cptr;
162 
163 	/* READ LOCK HELD ON ENTRY: rpcbaddr_cache_lock */
164 
165 	assert(RW_READ_HELD(&rpcbaddr_cache_lock));
166 	for (cptr = front; cptr != NULL; cptr = cptr->ac_next) {
167 		if ((strcmp(cptr->ac_host, host) == 0) &&
168 		    (strcmp(cptr->ac_netid, netid) == 0) &&
169 		    (time(NULL) <= cptr->ac_maxtime)) {
170 			return (cptr);
171 		}
172 	}
173 	return (NULL);
174 }
175 
176 static void
177 delete_cache(struct netbuf *addr)
178 {
179 	struct address_cache *cptr, *prevptr = NULL;
180 
181 	/* WRITE LOCK HELD ON ENTRY: rpcbaddr_cache_lock */
182 	assert(RW_WRITE_HELD(&rpcbaddr_cache_lock));
183 	for (cptr = front; cptr != NULL; cptr = cptr->ac_next) {
184 		if (!memcmp(cptr->ac_taddr->buf, addr->buf, addr->len)) {
185 			free(cptr->ac_host);
186 			free(cptr->ac_netid);
187 			free(cptr->ac_taddr->buf);
188 			free(cptr->ac_taddr);
189 			if (cptr->ac_uaddr)
190 				free(cptr->ac_uaddr);
191 			if (prevptr)
192 				prevptr->ac_next = cptr->ac_next;
193 			else
194 				front = cptr->ac_next;
195 			free(cptr);
196 			cachesize--;
197 			break;
198 		}
199 		prevptr = cptr;
200 	}
201 }
202 
203 static void
204 add_cache(char *host, char *netid, struct netbuf *taddr, char *uaddr)
205 {
206 	struct address_cache  *ad_cache, *cptr, *prevptr;
207 
208 	ad_cache = malloc(sizeof (struct address_cache));
209 	if (!ad_cache) {
210 		goto memerr;
211 	}
212 	ad_cache->ac_maxtime = time(NULL) + CACHE_TTL;
213 	ad_cache->ac_host = strdup(host);
214 	ad_cache->ac_netid = strdup(netid);
215 	ad_cache->ac_uaddr = uaddr ? strdup(uaddr) : NULL;
216 	ad_cache->ac_taddr = malloc(sizeof (struct netbuf));
217 	if (!ad_cache->ac_host || !ad_cache->ac_netid || !ad_cache->ac_taddr ||
218 	    (uaddr && !ad_cache->ac_uaddr)) {
219 		goto memerr1;
220 	}
221 
222 	ad_cache->ac_taddr->len = ad_cache->ac_taddr->maxlen = taddr->len;
223 	ad_cache->ac_taddr->buf = malloc(taddr->len);
224 	if (ad_cache->ac_taddr->buf == NULL) {
225 		goto memerr1;
226 	}
227 
228 	(void) memcpy(ad_cache->ac_taddr->buf, taddr->buf, taddr->len);
229 
230 /* VARIABLES PROTECTED BY rpcbaddr_cache_lock:  cptr */
231 
232 	(void) rw_wrlock(&rpcbaddr_cache_lock);
233 	if (cachesize < CACHESIZE) {
234 		ad_cache->ac_next = front;
235 		front = ad_cache;
236 		cachesize++;
237 	} else {
238 		/* Free the last entry */
239 		cptr = front;
240 		prevptr = NULL;
241 		while (cptr->ac_next) {
242 			prevptr = cptr;
243 			cptr = cptr->ac_next;
244 		}
245 
246 		free(cptr->ac_host);
247 		free(cptr->ac_netid);
248 		free(cptr->ac_taddr->buf);
249 		free(cptr->ac_taddr);
250 		if (cptr->ac_uaddr)
251 			free(cptr->ac_uaddr);
252 
253 		if (prevptr) {
254 			prevptr->ac_next = NULL;
255 			ad_cache->ac_next = front;
256 			front = ad_cache;
257 		} else {
258 			front = ad_cache;
259 			ad_cache->ac_next = NULL;
260 		}
261 		free(cptr);
262 	}
263 	(void) rw_unlock(&rpcbaddr_cache_lock);
264 	return;
265 memerr1:
266 	if (ad_cache->ac_host)
267 		free(ad_cache->ac_host);
268 	if (ad_cache->ac_netid)
269 		free(ad_cache->ac_netid);
270 	if (ad_cache->ac_uaddr)
271 		free(ad_cache->ac_uaddr);
272 	if (ad_cache->ac_taddr)
273 		free(ad_cache->ac_taddr);
274 	free(ad_cache);
275 memerr:
276 	syslog(LOG_ERR, "add_cache : out of memory.");
277 }
278 
279 /*
280  * This routine will return a client handle that is connected to the
281  * rpcbind. Returns NULL on error and free's everything.
282  */
283 static CLIENT *
284 getclnthandle(char *host, struct netconfig *nconf, char **targaddr)
285 {
286 	return (_getclnthandle_timed(host, nconf, targaddr, NULL));
287 }
288 
289 /*
290  * Same as getclnthandle() except it takes an extra timeout argument.
291  * This is for bug 4049792: clnt_create_timed does not timeout.
292  *
293  * If tp is NULL, use default timeout to get a client handle.
294  */
295 static CLIENT *
296 _getclnthandle_timed(char *host, struct netconfig *nconf, char **targaddr,
297 							struct timeval *tp)
298 {
299 	CLIENT *client = NULL;
300 	struct netbuf *addr;
301 	struct netbuf addr_to_delete;
302 	struct nd_addrlist *nas;
303 	struct nd_hostserv rpcbind_hs;
304 	struct address_cache *ad_cache;
305 	char *tmpaddr;
306 	int neterr;
307 	int j;
308 
309 /* VARIABLES PROTECTED BY rpcbaddr_cache_lock:  ad_cache */
310 
311 	/* Get the address of the rpcbind.  Check cache first */
312 	addr_to_delete.len = 0;
313 	(void) rw_rdlock(&rpcbaddr_cache_lock);
314 	ad_cache = check_cache(host, nconf->nc_netid);
315 	if (ad_cache != NULL) {
316 		addr = ad_cache->ac_taddr;
317 		client = _clnt_tli_create_timed(RPC_ANYFD, nconf, addr,
318 		    RPCBPROG, RPCBVERS4, 0, 0, tp);
319 		if (client != NULL) {
320 			if (targaddr) {
321 				/*
322 				 * case where a client handle is created
323 				 * without a targaddr and the handle is
324 				 * requested with a targaddr
325 				 */
326 				if (ad_cache->ac_uaddr != NULL) {
327 					*targaddr = strdup(ad_cache->ac_uaddr);
328 					if (*targaddr == NULL) {
329 						syslog(LOG_ERR,
330 						"_getclnthandle_timed: strdup "
331 						"failed.");
332 						rpc_createerr.cf_stat =
333 						    RPC_SYSTEMERROR;
334 						(void) rw_unlock(
335 						    &rpcbaddr_cache_lock);
336 						return (NULL);
337 					}
338 				} else {
339 					*targaddr = NULL;
340 				}
341 			}
342 			(void) rw_unlock(&rpcbaddr_cache_lock);
343 			return (client);
344 		}
345 		if (rpc_createerr.cf_stat == RPC_SYSTEMERROR) {
346 			(void) rw_unlock(&rpcbaddr_cache_lock);
347 			return (NULL);
348 		}
349 		addr_to_delete.len = addr->len;
350 		addr_to_delete.buf = malloc(addr->len);
351 		if (addr_to_delete.buf == NULL) {
352 			addr_to_delete.len = 0;
353 		} else {
354 			(void) memcpy(addr_to_delete.buf, addr->buf, addr->len);
355 		}
356 	}
357 	(void) rw_unlock(&rpcbaddr_cache_lock);
358 	if (addr_to_delete.len != 0) {
359 		/*
360 		 * Assume this may be due to cache data being
361 		 *  outdated
362 		 */
363 		(void) rw_wrlock(&rpcbaddr_cache_lock);
364 		delete_cache(&addr_to_delete);
365 		(void) rw_unlock(&rpcbaddr_cache_lock);
366 		free(addr_to_delete.buf);
367 	}
368 	rpcbind_hs.h_host = host;
369 	rpcbind_hs.h_serv = "rpcbind";
370 
371 	if ((neterr = netdir_getbyname(nconf, &rpcbind_hs, &nas)) != 0) {
372 		if (neterr == ND_NOHOST)
373 			rpc_createerr.cf_stat = RPC_UNKNOWNHOST;
374 		else
375 			rpc_createerr.cf_stat = RPC_N2AXLATEFAILURE;
376 		return (NULL);
377 	}
378 	/* XXX nas should perhaps be cached for better performance */
379 
380 	for (j = 0; j < nas->n_cnt; j++) {
381 		addr = &(nas->n_addrs[j]);
382 	client = _clnt_tli_create_timed(RPC_ANYFD, nconf, addr, RPCBPROG,
383 	    RPCBVERS4, 0, 0, tp);
384 	if (client)
385 		break;
386 	}
387 
388 	if (client) {
389 		tmpaddr = targaddr ? taddr2uaddr(nconf, addr) : NULL;
390 		add_cache(host, nconf->nc_netid, addr, tmpaddr);
391 		if (targaddr) {
392 			*targaddr = tmpaddr;
393 		}
394 	}
395 	netdir_free((char *)nas, ND_ADDRLIST);
396 	return (client);
397 }
398 
399 /*
400  * This routine will return a client handle that is connected to the local
401  * rpcbind. Returns NULL on error.
402  */
403 static CLIENT *
404 local_rpcb(void)
405 {
406 	static struct netconfig *loopnconf;
407 	static char hostname[MAXHOSTNAMELEN + 1];
408 	extern mutex_t loopnconf_lock;
409 
410 /* VARIABLES PROTECTED BY loopnconf_lock: loopnconf */
411 	(void) mutex_lock(&loopnconf_lock);
412 	if (loopnconf == NULL) {
413 		struct netconfig *nconf, *tmpnconf = NULL;
414 		void *nc_handle;
415 
416 		if ((hostname[0] == '\0') && (gethostname(hostname,
417 		    sizeof (hostname)) < 0)) {
418 			syslog(LOG_ERR, "local_rpcb: gethostname failed.");
419 			rpc_createerr.cf_stat = RPC_UNKNOWNHOST;
420 			(void) mutex_unlock(&loopnconf_lock);
421 			return (NULL);
422 		}
423 		nc_handle = setnetconfig();
424 		if (nc_handle == NULL) {
425 			/* fails to open netconfig file */
426 			rpc_createerr.cf_stat = RPC_UNKNOWNPROTO;
427 			(void) mutex_unlock(&loopnconf_lock);
428 			return (NULL);
429 		}
430 		while (nconf = getnetconfig(nc_handle)) {
431 			if (strcmp(nconf->nc_protofmly, NC_LOOPBACK) == 0) {
432 				tmpnconf = nconf;
433 				if (nconf->nc_semantics == NC_TPI_CLTS)
434 					break;
435 			}
436 		}
437 		if (tmpnconf == NULL) {
438 			rpc_createerr.cf_stat = RPC_UNKNOWNPROTO;
439 			(void) mutex_unlock(&loopnconf_lock);
440 			return (NULL);
441 		}
442 		loopnconf = getnetconfigent(tmpnconf->nc_netid);
443 		/* loopnconf is never freed */
444 		(void) endnetconfig(nc_handle);
445 	}
446 	(void) mutex_unlock(&loopnconf_lock);
447 	return (getclnthandle(hostname, loopnconf, NULL));
448 }
449 
450 /*
451  * Set a mapping between program, version and address.
452  * Calls the rpcbind service to do the mapping.
453  */
454 bool_t
455 rpcb_set(const rpcprog_t program, const rpcvers_t version,
456 		const struct netconfig *nconf, const struct netbuf *address)
457 {
458 	CLIENT *client;
459 	bool_t rslt = FALSE;
460 	RPCB parms;
461 	char uidbuf[32];
462 
463 	/* parameter checking */
464 	if (nconf == NULL) {
465 		rpc_createerr.cf_stat = RPC_UNKNOWNPROTO;
466 		return (FALSE);
467 	}
468 	if (address == NULL) {
469 		rpc_createerr.cf_stat = RPC_UNKNOWNADDR;
470 		return (FALSE);
471 	}
472 	client = local_rpcb();
473 	if (!client)
474 		return (FALSE);
475 
476 	parms.r_addr = taddr2uaddr((struct netconfig *)nconf,
477 	    (struct netbuf *)address); /* convert to universal */
478 	if (!parms.r_addr) {
479 		rpc_createerr.cf_stat = RPC_N2AXLATEFAILURE;
480 		return (FALSE); /* no universal address */
481 	}
482 	parms.r_prog = program;
483 	parms.r_vers = version;
484 	parms.r_netid = nconf->nc_netid;
485 	/*
486 	 * Though uid is not being used directly, we still send it for
487 	 * completeness.  For non-unix platforms, perhaps some other
488 	 * string or an empty string can be sent.
489 	 */
490 	(void) sprintf(uidbuf, "%d", (int)geteuid());
491 	parms.r_owner = uidbuf;
492 
493 	CLNT_CALL(client, RPCBPROC_SET, (xdrproc_t)xdr_rpcb, (char *)&parms,
494 	    (xdrproc_t)xdr_bool, (char *)&rslt, tottimeout);
495 
496 	CLNT_DESTROY(client);
497 	free(parms.r_addr);
498 	return (rslt);
499 }
500 
501 /*
502  * Remove the mapping between program, version and netbuf address.
503  * Calls the rpcbind service to do the un-mapping.
504  * If netbuf is NULL, unset for all the transports, otherwise unset
505  * only for the given transport.
506  */
507 bool_t
508 rpcb_unset(const rpcprog_t program, const rpcvers_t version,
509 						const struct netconfig *nconf)
510 {
511 	CLIENT *client;
512 	bool_t rslt = FALSE;
513 	RPCB parms;
514 	char uidbuf[32];
515 
516 	client = local_rpcb();
517 	if (!client)
518 		return (FALSE);
519 
520 	parms.r_prog = program;
521 	parms.r_vers = version;
522 	if (nconf)
523 		parms.r_netid = nconf->nc_netid;
524 	else
525 		parms.r_netid = (char *)&nullstring[0]; /* unsets  all */
526 	parms.r_addr = (char *)&nullstring[0];
527 	(void) sprintf(uidbuf, "%d", (int)geteuid());
528 	parms.r_owner = uidbuf;
529 
530 	CLNT_CALL(client, RPCBPROC_UNSET, (xdrproc_t)xdr_rpcb, (char *)&parms,
531 	    (xdrproc_t)xdr_bool, (char *)&rslt, tottimeout);
532 
533 	CLNT_DESTROY(client);
534 	return (rslt);
535 }
536 
537 /*
538  * From the merged list, find the appropriate entry
539  */
540 static struct netbuf *
541 got_entry(rpcb_entry_list_ptr relp, struct netconfig *nconf)
542 {
543 	struct netbuf *na = NULL;
544 	rpcb_entry_list_ptr sp;
545 	rpcb_entry *rmap;
546 
547 	for (sp = relp; sp != NULL; sp = sp->rpcb_entry_next) {
548 		rmap = &sp->rpcb_entry_map;
549 		if ((strcmp(nconf->nc_proto, rmap->r_nc_proto) == 0) &&
550 		    (strcmp(nconf->nc_protofmly, rmap->r_nc_protofmly) == 0) &&
551 		    (nconf->nc_semantics == rmap->r_nc_semantics) &&
552 		    (rmap->r_maddr != NULL) && (rmap->r_maddr[0] != NULL)) {
553 			na = uaddr2taddr(nconf, rmap->r_maddr);
554 			break;
555 		}
556 	}
557 	return (na);
558 }
559 
560 /*
561  * Quick check to see if rpcbind is up.  Tries to connect over
562  * local transport.
563  */
564 bool_t
565 __rpcbind_is_up(void)
566 {
567 	char hostname[MAXHOSTNAMELEN + 1];
568 	char uaddr[SYS_NMLN];
569 	struct netbuf *addr;
570 	int fd;
571 	struct t_call *sndcall;
572 	struct netconfig *netconf;
573 	bool_t res;
574 
575 	if (gethostname(hostname, sizeof (hostname)) < 0)
576 		return (TRUE);
577 
578 	if ((fd = t_open("/dev/ticotsord", O_RDWR, NULL)) == -1)
579 		return (TRUE);
580 
581 	if (t_bind(fd, NULL, NULL) == -1) {
582 		(void) t_close(fd);
583 		return (TRUE);
584 	}
585 
586 	/* LINTED pointer cast */
587 	if ((sndcall = (struct t_call *)t_alloc(fd, T_CALL, 0)) == NULL) {
588 		(void) t_close(fd);
589 		return (TRUE);
590 	}
591 
592 	uaddr[0] = '\0';
593 	(void) strlcpy(uaddr, hostname, sizeof (uaddr) - 5);
594 	(void) strcat(uaddr, ".rpc");
595 	if ((netconf = getnetconfigent("ticotsord")) == NULL) {
596 		(void) t_free((char *)sndcall, T_CALL);
597 		(void) t_close(fd);
598 		return (FALSE);
599 	}
600 	addr = uaddr2taddr(netconf, uaddr);
601 	freenetconfigent(netconf);
602 	if (addr == NULL || addr->buf == NULL) {
603 		if (addr)
604 			free(addr);
605 		(void) t_free((char *)sndcall, T_CALL);
606 		(void) t_close(fd);
607 		return (FALSE);
608 	}
609 	sndcall->addr.maxlen = addr->maxlen;
610 	sndcall->addr.len = addr->len;
611 	sndcall->addr.buf = addr->buf;
612 
613 	if (t_connect(fd, sndcall, NULL) == -1)
614 		res = FALSE;
615 	else
616 		res = TRUE;
617 
618 	sndcall->addr.maxlen = sndcall->addr.len = 0;
619 	sndcall->addr.buf = NULL;
620 	(void) t_free((char *)sndcall, T_CALL);
621 	free(addr->buf);
622 	free(addr);
623 	(void) t_close(fd);
624 
625 	return (res);
626 }
627 
628 
629 /*
630  * An internal function which optimizes rpcb_getaddr function.  It returns
631  * the universal address of the remote service or NULL.  It also optionally
632  * returns the client handle that it uses to contact the remote rpcbind.
633  * The caller will re-purpose the client handle to contact the remote service.
634  *
635  * The algorithm used: First try version 4.  Then try version 3 (svr4).
636  * Finally, if the transport is TCP or UDP, try version 2 (portmap).
637  * Version 4 is now available with all current systems on the network.
638  * With this algorithm, we get performance as well as a plan for
639  * obsoleting version 2.
640  *
641  * XXX: Due to some problems with t_connect(), we do not reuse the same client
642  * handle for COTS cases and hence in these cases we do not return the
643  * client handle.  This code will change if t_connect() ever
644  * starts working properly.  Also look under clnt_vc.c.
645  */
646 struct netbuf *
647 __rpcb_findaddr_timed(rpcprog_t program, rpcvers_t version,
648 	struct netconfig *nconf, char *host, CLIENT **clpp, struct timeval *tp)
649 {
650 	static bool_t check_rpcbind = TRUE;
651 	CLIENT *client = NULL;
652 	RPCB parms;
653 	enum clnt_stat clnt_st;
654 	char *ua = NULL;
655 	uint_t vers;
656 	struct netbuf *address = NULL;
657 	void *handle;
658 	rpcb_entry_list_ptr relp = NULL;
659 	bool_t tmp_client = FALSE;
660 
661 	/* parameter checking */
662 	if (nconf == NULL) {
663 		rpc_createerr.cf_stat = RPC_UNKNOWNPROTO;
664 		/*
665 		 * Setting rpc_createerr.cf_stat is sufficient.
666 		 * No details in rpc_createerr.cf_error needed.
667 		 */
668 		return (NULL);
669 	}
670 
671 	parms.r_addr = NULL;
672 
673 	/*
674 	 * Use default total timeout if no timeout is specified.
675 	 */
676 	if (tp == NULL)
677 		tp = &tottimeout;
678 
679 	/*
680 	 * Check if rpcbind is up.  This prevents needless delays when
681 	 * accessing applications such as the keyserver while booting
682 	 * disklessly.
683 	 */
684 	if (check_rpcbind && strcmp(nconf->nc_protofmly, NC_LOOPBACK) == 0) {
685 		if (!__rpcbind_is_up()) {
686 			rpc_createerr.cf_stat = RPC_PMAPFAILURE;
687 			rpc_createerr.cf_error.re_errno = 0;
688 			rpc_createerr.cf_error.re_terrno = 0;
689 			goto error;
690 		}
691 		check_rpcbind = FALSE;
692 	}
693 
694 	/*
695 	 * First try version 4.
696 	 */
697 	parms.r_prog = program;
698 	parms.r_vers = version;
699 	parms.r_owner = (char *)&nullstring[0];	/* not needed; */
700 	/* just for xdring */
701 	parms.r_netid = nconf->nc_netid; /* not really needed */
702 
703 	/*
704 	 * If a COTS transport is being used, try getting address via CLTS
705 	 * transport.  This works only with version 4.
706 	 */
707 	if (nconf->nc_semantics == NC_TPI_COTS_ORD ||
708 	    nconf->nc_semantics == NC_TPI_COTS) {
709 		tmp_client = TRUE;
710 		if ((handle = __rpc_setconf("datagram_v")) != NULL) {
711 			struct netconfig *nconf_clts;
712 
713 			while ((nconf_clts = __rpc_getconf(handle)) != NULL) {
714 				if (strcmp(nconf_clts->nc_protofmly,
715 				    nconf->nc_protofmly) != 0) {
716 					continue;
717 				}
718 				/*
719 				 * Sets rpc_createerr.cf_error members
720 				 * on failure
721 				 */
722 				client = _getclnthandle_timed(host, nconf_clts,
723 				    &parms.r_addr, tp);
724 				break;
725 			}
726 			__rpc_endconf(handle);
727 		}
728 	} else {
729 		/* Sets rpc_createerr.cf_error members on failure */
730 		client = _getclnthandle_timed(host, nconf, &parms.r_addr, tp);
731 	}
732 
733 	if (client != NULL) {
734 
735 		/* Set rpcbind version 4 */
736 		vers = RPCBVERS4;
737 		CLNT_CONTROL(client, CLSET_VERS, (char *)&vers);
738 
739 		/*
740 		 * We also send the remote system the address we used to
741 		 * contact it in case it can help it connect back with us
742 		 */
743 		if (parms.r_addr == NULL) {
744 			parms.r_addr = strdup(""); /* for XDRing */
745 			if (parms.r_addr == NULL) {
746 				syslog(LOG_ERR, "__rpcb_findaddr_timed: "
747 				    "strdup failed.");
748 				/* Construct a system error */
749 				rpc_createerr.cf_error.re_errno = errno;
750 				rpc_createerr.cf_error.re_terrno = 0;
751 				rpc_createerr.cf_stat = RPC_SYSTEMERROR;
752 				goto error;
753 			}
754 		}
755 
756 		CLNT_CONTROL(client, CLSET_RETRY_TIMEOUT,
757 		    (char *)&rpcbrmttime);
758 
759 		/* Sets error structure members in client handle */
760 		clnt_st = CLNT_CALL(client, RPCBPROC_GETADDRLIST,
761 		    (xdrproc_t)xdr_rpcb, (char *)&parms,
762 		    (xdrproc_t)xdr_rpcb_entry_list_ptr, (char *)&relp, *tp);
763 
764 		switch (clnt_st) {
765 		case RPC_SUCCESS: /* Call succeeded */
766 			address = got_entry(relp, nconf);
767 			xdr_free((xdrproc_t)xdr_rpcb_entry_list_ptr,
768 			    (char *)&relp);
769 			if (address != NULL) {
770 				/* Program number and version number matched */
771 				goto done;
772 			}
773 			/* Program and version not found for this transport */
774 			/*
775 			 * XXX: should have returned with RPC_PROGUNAVAIL
776 			 * or perhaps RPC_PROGNOTREGISTERED error but
777 			 * since the remote machine might not always be able
778 			 * to send the address on all transports, we try the
779 			 * regular way with version 3, then 2
780 			 */
781 			/* Try the next version */
782 			break;
783 		case RPC_PROGVERSMISMATCH: /* RPC protocol mismatch */
784 			clnt_geterr(client, &rpc_createerr.cf_error);
785 			if (rpc_createerr.cf_error.re_vers.low > vers) {
786 				rpc_createerr.cf_stat = clnt_st;
787 				goto error;  /* a new version, can't handle */
788 			}
789 			/* Try the next version */
790 			break;
791 		case RPC_PROCUNAVAIL: /* Procedure unavailable */
792 		case RPC_PROGUNAVAIL: /* Program not available */
793 		case RPC_TIMEDOUT: /* Call timed out */
794 			/* Try the next version */
795 			break;
796 		default:
797 			clnt_geterr(client, &rpc_createerr.cf_error);
798 			rpc_createerr.cf_stat = RPC_PMAPFAILURE;
799 			goto error;
800 			break;
801 		}
802 
803 	} else {
804 
805 		/* No client */
806 		tmp_client = FALSE;
807 
808 	} /* End of version 4 */
809 
810 	/* Destroy a temporary client */
811 	if (client != NULL && tmp_client) {
812 		CLNT_DESTROY(client);
813 		client = NULL;
814 		free(parms.r_addr);
815 		parms.r_addr = NULL;
816 	}
817 	tmp_client = FALSE;
818 
819 	/*
820 	 * Try version 3
821 	 */
822 
823 	/* Now the same transport is to be used to get the address */
824 	if (client == NULL) {
825 		/* Sets rpc_createerr.cf_error members on failure */
826 		client = _getclnthandle_timed(host, nconf, &parms.r_addr, tp);
827 	}
828 	address = NULL;
829 	if (client != NULL) {
830 		if (parms.r_addr == NULL) {
831 			parms.r_addr = strdup("");	/* for XDRing */
832 			if (parms.r_addr == NULL) {
833 				syslog(LOG_ERR, "__rpcb_findaddr_timed: "
834 				    "strdup failed.");
835 				/* Construct a system error */
836 				rpc_createerr.cf_error.re_errno = errno;
837 				rpc_createerr.cf_error.re_terrno = 0;
838 				rpc_createerr.cf_stat = RPC_SYSTEMERROR;
839 				goto error;
840 			}
841 		}
842 
843 		CLNT_CONTROL(client, CLSET_RETRY_TIMEOUT,
844 		    (char *)&rpcbrmttime);
845 		vers = RPCBVERS; /* Set the version */
846 		CLNT_CONTROL(client, CLSET_VERS, (char *)&vers);
847 
848 		/* Sets error structure members in client handle */
849 		clnt_st = CLNT_CALL(client, RPCBPROC_GETADDR,
850 		    (xdrproc_t)xdr_rpcb, (char *)&parms,
851 		    (xdrproc_t)xdr_wrapstring, (char *)&ua, *tp);
852 
853 		switch (clnt_st) {
854 		case RPC_SUCCESS: /* Call succeeded */
855 			if (ua != NULL) {
856 				if (ua[0] != '\0') {
857 					address = uaddr2taddr(nconf, ua);
858 				}
859 				xdr_free((xdrproc_t)xdr_wrapstring,
860 				    (char *)&ua);
861 
862 				if (address != NULL) {
863 					goto done;
864 				}
865 				/* NULL universal address */
866 				/* But client call was successful */
867 				clnt_geterr(client, &rpc_createerr.cf_error);
868 				rpc_createerr.cf_stat = RPC_PROGNOTREGISTERED;
869 				goto error;
870 			}
871 #ifndef PORTMAP
872 			clnt_geterr(client, &rpc_createerr.cf_error);
873 			rpc_createerr.cf_stat = RPC_UNKNOWNPROTO;
874 			goto error;
875 #endif
876 			/* Try the next version */
877 			break;
878 		case RPC_PROGVERSMISMATCH: /* RPC protocol mismatch */
879 			clnt_geterr(client, &rpc_createerr.cf_error);
880 #ifdef PORTMAP
881 			if (rpc_createerr.cf_error.re_vers.low > vers) {
882 				rpc_createerr.cf_stat = clnt_st;
883 				goto error;  /* a new version, can't handle */
884 			}
885 #else
886 			rpc_createerr.cf_stat = clnt_st;
887 			goto error;
888 #endif
889 			/* Try the next version */
890 			break;
891 #ifdef PORTMAP
892 		case RPC_PROCUNAVAIL: /* Procedure unavailable */
893 		case RPC_PROGUNAVAIL: /* Program not available */
894 		case RPC_TIMEDOUT: /* Call timed out */
895 			/* Try the next version */
896 			break;
897 #endif
898 		default:
899 			clnt_geterr(client, &rpc_createerr.cf_error);
900 			rpc_createerr.cf_stat = RPC_PMAPFAILURE;
901 			goto error;
902 			break;
903 		}
904 	} /* End of version 3 */
905 #ifndef PORTMAP
906 	/* cf_error members set by creation failure */
907 	rpc_createerr.cf_stat = RPC_PROGNOTREGISTERED;
908 #endif
909 	/*
910 	 * Try version 2
911 	 */
912 
913 #ifdef PORTMAP
914 	/* Try version 2 for TCP or UDP */
915 	if (strcmp(nconf->nc_protofmly, NC_INET) == 0) {
916 		ushort_t port = 0;
917 		struct netbuf remote;
918 		uint_t pmapvers = 2;
919 		struct pmap pmapparms;
920 
921 		/*
922 		 * Try UDP only - there are some portmappers out
923 		 * there that use UDP only.
924 		 */
925 		if (strcmp(nconf->nc_proto, NC_TCP) == 0) {
926 			struct netconfig *newnconf;
927 
928 			if (client != NULL) {
929 				CLNT_DESTROY(client);
930 				client = NULL;
931 				free(parms.r_addr);
932 				parms.r_addr = NULL;
933 			}
934 			if ((handle = __rpc_setconf("udp")) == NULL) {
935 				/* Construct an unknown protocol error */
936 				rpc_createerr.cf_stat = RPC_UNKNOWNPROTO;
937 				goto error;
938 			}
939 
940 			/*
941 			 * The following to reinforce that you can
942 			 * only request for remote address through
943 			 * the same transport you are requesting.
944 			 * ie. requesting unversial address
945 			 * of IPv4 has to be carried through IPv4.
946 			 * Can't use IPv6 to send out the request.
947 			 * The mergeaddr in rpcbind can't handle
948 			 * this.
949 			 */
950 			for (;;) {
951 				if ((newnconf = __rpc_getconf(handle))
952 				    == NULL) {
953 					__rpc_endconf(handle);
954 					/*
955 					 * Construct an unknown protocol
956 					 * error
957 					 */
958 					rpc_createerr.cf_stat =
959 					    RPC_UNKNOWNPROTO;
960 					goto error;
961 				}
962 				/*
963 				 * here check the protocol family to
964 				 * be consistent with the request one
965 				 */
966 				if (strcmp(newnconf->nc_protofmly,
967 				    nconf->nc_protofmly) == 0)
968 					break;
969 			}
970 
971 			/* Sets rpc_createerr.cf_error members on failure */
972 			client = _getclnthandle_timed(host, newnconf,
973 			    &parms.r_addr, tp);
974 			__rpc_endconf(handle);
975 			tmp_client = TRUE;
976 		}
977 		if (client == NULL) {
978 			/*
979 			 * rpc_createerr. cf_error members were set by
980 			 * creation failure
981 			 */
982 			rpc_createerr.cf_stat = RPC_PROGNOTREGISTERED;
983 			tmp_client = FALSE;
984 			goto error;
985 		}
986 
987 		/*
988 		 * Set version and retry timeout.
989 		 */
990 		CLNT_CONTROL(client, CLSET_RETRY_TIMEOUT, (char *)&rpcbrmttime);
991 		CLNT_CONTROL(client, CLSET_VERS, (char *)&pmapvers);
992 
993 		pmapparms.pm_prog = program;
994 		pmapparms.pm_vers = version;
995 		pmapparms.pm_prot = (strcmp(nconf->nc_proto, NC_TCP) != 0) ?
996 		    IPPROTO_UDP : IPPROTO_TCP;
997 		pmapparms.pm_port = 0;	/* not needed */
998 
999 		/* Sets error structure members in client handle */
1000 		clnt_st = CLNT_CALL(client, PMAPPROC_GETPORT,
1001 		    (xdrproc_t)xdr_pmap, (caddr_t)&pmapparms,
1002 		    (xdrproc_t)xdr_u_short, (caddr_t)&port, *tp);
1003 
1004 		if (clnt_st != RPC_SUCCESS) {
1005 			clnt_geterr(client, &rpc_createerr.cf_error);
1006 			rpc_createerr.cf_stat = RPC_RPCBFAILURE;
1007 			goto error;
1008 		} else if (port == 0) {
1009 			/* Will be NULL universal address */
1010 			/* But client call was successful */
1011 			clnt_geterr(client, &rpc_createerr.cf_error);
1012 			rpc_createerr.cf_stat = RPC_PROGNOTREGISTERED;
1013 			goto error;
1014 		}
1015 		port = htons(port);
1016 		CLNT_CONTROL(client, CLGET_SVC_ADDR, (char *)&remote);
1017 		if (((address = malloc(sizeof (struct netbuf))) == NULL) ||
1018 		    ((address->buf = malloc(remote.len)) == NULL)) {
1019 			/* Construct a system error */
1020 			rpc_createerr.cf_error.re_errno = errno;
1021 			rpc_createerr.cf_error.re_terrno = 0;
1022 			rpc_createerr.cf_stat = RPC_SYSTEMERROR;
1023 			free(address);
1024 			address = NULL;
1025 			goto error;
1026 		}
1027 		(void) memcpy(address->buf, remote.buf, remote.len);
1028 		(void) memcpy(&address->buf[sizeof (short)], &port,
1029 		    sizeof (short));
1030 		address->len = address->maxlen = remote.len;
1031 		goto done;
1032 	} else {
1033 		/*
1034 		 * This is not NC_INET.
1035 		 * Always an error for version 2.
1036 		 */
1037 		if (client != NULL && clnt_st != RPC_SUCCESS) {
1038 			/* There is a client that failed */
1039 			clnt_geterr(client, &rpc_createerr.cf_error);
1040 			rpc_createerr.cf_stat = clnt_st;
1041 		} else {
1042 			/* Something else */
1043 			rpc_createerr.cf_stat = RPC_UNKNOWNPROTO;
1044 			/*
1045 			 * Setting rpc_createerr.cf_stat is sufficient.
1046 			 * No details in rpc_createerr.cf_error needed.
1047 			 */
1048 		}
1049 	}
1050 #endif
1051 
1052 error:
1053 	/* Return NULL address and NULL client */
1054 	address = NULL;
1055 	if (client != NULL) {
1056 		CLNT_DESTROY(client);
1057 		client = NULL;
1058 	}
1059 
1060 done:
1061 	/* Return an address and optional client */
1062 	if (client != NULL && tmp_client) {
1063 		/* This client is the temporary one */
1064 		CLNT_DESTROY(client);
1065 		client = NULL;
1066 	}
1067 	if (clpp != NULL) {
1068 		*clpp = client;
1069 	} else if (client != NULL) {
1070 		CLNT_DESTROY(client);
1071 	}
1072 	free(parms.r_addr);
1073 	return (address);
1074 }
1075 
1076 
1077 /*
1078  * Find the mapped address for program, version.
1079  * Calls the rpcbind service remotely to do the lookup.
1080  * Uses the transport specified in nconf.
1081  * Returns FALSE (0) if no map exists, else returns 1.
1082  *
1083  * Assuming that the address is all properly allocated
1084  */
1085 int
1086 rpcb_getaddr(const rpcprog_t program, const rpcvers_t version,
1087 	const struct netconfig *nconf, struct netbuf *address, const char *host)
1088 {
1089 	struct netbuf *na;
1090 
1091 	if ((na = __rpcb_findaddr_timed(program, version,
1092 	    (struct netconfig *)nconf, (char *)host, NULL, NULL)) == NULL)
1093 		return (FALSE);
1094 
1095 	if (na->len > address->maxlen) {
1096 		/* Too long address */
1097 		netdir_free((char *)na, ND_ADDR);
1098 		rpc_createerr.cf_stat = RPC_FAILED;
1099 		return (FALSE);
1100 	}
1101 	(void) memcpy(address->buf, na->buf, (int)na->len);
1102 	address->len = na->len;
1103 	netdir_free((char *)na, ND_ADDR);
1104 	return (TRUE);
1105 }
1106 
1107 /*
1108  * Get a copy of the current maps.
1109  * Calls the rpcbind service remotely to get the maps.
1110  *
1111  * It returns only a list of the services
1112  * It returns NULL on failure.
1113  */
1114 rpcblist *
1115 rpcb_getmaps(const struct netconfig *nconf, const char *host)
1116 {
1117 	rpcblist_ptr head = NULL;
1118 	CLIENT *client;
1119 	enum clnt_stat clnt_st;
1120 	int vers = 0;
1121 
1122 	client = getclnthandle((char *)host,
1123 	    (struct netconfig *)nconf, NULL);
1124 	if (client == NULL)
1125 		return (NULL);
1126 
1127 	clnt_st = CLNT_CALL(client, RPCBPROC_DUMP,
1128 	    (xdrproc_t)xdr_void, NULL,
1129 	    (xdrproc_t)xdr_rpcblist_ptr,
1130 	    (char *)&head, tottimeout);
1131 	if (clnt_st == RPC_SUCCESS)
1132 		goto done;
1133 
1134 	if ((clnt_st != RPC_PROGVERSMISMATCH) &&
1135 	    (clnt_st != RPC_PROGUNAVAIL)) {
1136 		rpc_createerr.cf_stat = RPC_RPCBFAILURE;
1137 		clnt_geterr(client, &rpc_createerr.cf_error);
1138 		goto done;
1139 	}
1140 
1141 	/* fall back to earlier version */
1142 	CLNT_CONTROL(client, CLGET_VERS, (char *)&vers);
1143 	if (vers == RPCBVERS4) {
1144 		vers = RPCBVERS;
1145 		CLNT_CONTROL(client, CLSET_VERS, (char *)&vers);
1146 		if (CLNT_CALL(client, RPCBPROC_DUMP,
1147 		    (xdrproc_t)xdr_void,
1148 		    NULL, (xdrproc_t)xdr_rpcblist_ptr,
1149 		    (char *)&head, tottimeout) == RPC_SUCCESS)
1150 				goto done;
1151 	}
1152 	rpc_createerr.cf_stat = RPC_RPCBFAILURE;
1153 	clnt_geterr(client, &rpc_createerr.cf_error);
1154 
1155 done:
1156 	CLNT_DESTROY(client);
1157 	return (head);
1158 }
1159 
1160 /*
1161  * rpcbinder remote-call-service interface.
1162  * This routine is used to call the rpcbind remote call service
1163  * which will look up a service program in the address maps, and then
1164  * remotely call that routine with the given parameters. This allows
1165  * programs to do a lookup and call in one step.
1166  */
1167 enum clnt_stat
1168 rpcb_rmtcall(const struct netconfig *nconf, const char *host,
1169 	const rpcprog_t prog, const rpcvers_t vers, const rpcproc_t proc,
1170 	const xdrproc_t xdrargs, const caddr_t argsp, const xdrproc_t xdrres,
1171 	const caddr_t resp, const struct timeval tout, struct netbuf *addr_ptr)
1172 {
1173 	CLIENT *client;
1174 	enum clnt_stat stat;
1175 	struct r_rpcb_rmtcallargs a;
1176 	struct r_rpcb_rmtcallres r;
1177 	int rpcb_vers;
1178 
1179 	client = getclnthandle((char *)host, (struct netconfig *)nconf, NULL);
1180 	if (client == NULL)
1181 		return (RPC_FAILED);
1182 	CLNT_CONTROL(client, CLSET_RETRY_TIMEOUT, (char *)&rmttimeout);
1183 	a.prog = prog;
1184 	a.vers = vers;
1185 	a.proc = proc;
1186 	a.args.args_val = argsp;
1187 	a.xdr_args = xdrargs;
1188 	r.addr = NULL;
1189 	r.results.results_val = resp;
1190 	r.xdr_res = xdrres;
1191 
1192 	for (rpcb_vers = RPCBVERS4; rpcb_vers >= RPCBVERS; rpcb_vers--) {
1193 		CLNT_CONTROL(client, CLSET_VERS, (char *)&rpcb_vers);
1194 		stat = CLNT_CALL(client, RPCBPROC_CALLIT,
1195 		    (xdrproc_t)xdr_rpcb_rmtcallargs, (char *)&a,
1196 		    (xdrproc_t)xdr_rpcb_rmtcallres, (char *)&r, tout);
1197 		if ((stat == RPC_SUCCESS) && (addr_ptr != NULL)) {
1198 			struct netbuf *na;
1199 
1200 			na = uaddr2taddr((struct netconfig *)nconf, r.addr);
1201 			if (!na) {
1202 				stat = RPC_N2AXLATEFAILURE;
1203 				((struct netbuf *)addr_ptr)->len = 0;
1204 				goto error;
1205 			}
1206 			if (na->len > addr_ptr->maxlen) {
1207 				/* Too long address */
1208 				stat = RPC_FAILED; /* XXX A better error no */
1209 				netdir_free((char *)na, ND_ADDR);
1210 				((struct netbuf *)addr_ptr)->len = 0;
1211 				goto error;
1212 			}
1213 			(void) memcpy(addr_ptr->buf, na->buf, (int)na->len);
1214 			((struct netbuf *)addr_ptr)->len = na->len;
1215 			netdir_free((char *)na, ND_ADDR);
1216 			break;
1217 		}
1218 		if ((stat != RPC_PROGVERSMISMATCH) &&
1219 		    (stat != RPC_PROGUNAVAIL))
1220 			goto error;
1221 	}
1222 error:
1223 	CLNT_DESTROY(client);
1224 	if (r.addr)
1225 		xdr_free((xdrproc_t)xdr_wrapstring, (char *)&r.addr);
1226 	return (stat);
1227 }
1228 
1229 /*
1230  * Gets the time on the remote host.
1231  * Returns 1 if succeeds else 0.
1232  */
1233 bool_t
1234 rpcb_gettime(const char *host, time_t *timep)
1235 {
1236 	CLIENT *client = NULL;
1237 	void *handle;
1238 	struct netconfig *nconf;
1239 	int vers;
1240 	enum clnt_stat st;
1241 
1242 	if ((host == NULL) || (host[0] == NULL)) {
1243 		(void) time(timep);
1244 		return (TRUE);
1245 	}
1246 
1247 	if ((handle = __rpc_setconf("netpath")) == NULL) {
1248 		rpc_createerr.cf_stat = RPC_UNKNOWNPROTO;
1249 		return (FALSE);
1250 	}
1251 	rpc_createerr.cf_stat = RPC_SUCCESS;
1252 	while (client == NULL) {
1253 		if ((nconf = __rpc_getconf(handle)) == NULL) {
1254 			if (rpc_createerr.cf_stat == RPC_SUCCESS)
1255 				rpc_createerr.cf_stat = RPC_UNKNOWNPROTO;
1256 			break;
1257 		}
1258 		client = getclnthandle((char *)host, nconf, NULL);
1259 		if (client)
1260 			break;
1261 	}
1262 	__rpc_endconf(handle);
1263 	if (client == NULL)
1264 		return (FALSE);
1265 
1266 	st = CLNT_CALL(client, RPCBPROC_GETTIME,
1267 	    (xdrproc_t)xdr_void, NULL,
1268 	    (xdrproc_t)xdr_time_t, (char *)timep, tottimeout);
1269 
1270 	if ((st == RPC_PROGVERSMISMATCH) || (st == RPC_PROGUNAVAIL)) {
1271 		CLNT_CONTROL(client, CLGET_VERS, (char *)&vers);
1272 		if (vers == RPCBVERS4) {
1273 			/* fall back to earlier version */
1274 			vers = RPCBVERS;
1275 			CLNT_CONTROL(client, CLSET_VERS, (char *)&vers);
1276 			st = CLNT_CALL(client, RPCBPROC_GETTIME,
1277 			    (xdrproc_t)xdr_void, NULL,
1278 			    (xdrproc_t)xdr_time_t, (char *)timep,
1279 			    tottimeout);
1280 		}
1281 	}
1282 	CLNT_DESTROY(client);
1283 	return (st == RPC_SUCCESS? TRUE : FALSE);
1284 }
1285 
1286 /*
1287  * Converts taddr to universal address.  This routine should never
1288  * really be called because local n2a libraries are always provided.
1289  */
1290 char *
1291 rpcb_taddr2uaddr(struct netconfig *nconf, struct netbuf *taddr)
1292 {
1293 	CLIENT *client;
1294 	char *uaddr = NULL;
1295 
1296 	/* parameter checking */
1297 	if (nconf == NULL) {
1298 		rpc_createerr.cf_stat = RPC_UNKNOWNPROTO;
1299 		return (NULL);
1300 	}
1301 	if (taddr == NULL) {
1302 		rpc_createerr.cf_stat = RPC_UNKNOWNADDR;
1303 		return (NULL);
1304 	}
1305 	client = local_rpcb();
1306 	if (!client)
1307 		return (NULL);
1308 
1309 	CLNT_CALL(client, RPCBPROC_TADDR2UADDR, (xdrproc_t)xdr_netbuf,
1310 	    (char *)taddr, (xdrproc_t)xdr_wrapstring, (char *)&uaddr,
1311 	    tottimeout);
1312 	CLNT_DESTROY(client);
1313 	return (uaddr);
1314 }
1315 
1316 /*
1317  * Converts universal address to netbuf.  This routine should never
1318  * really be called because local n2a libraries are always provided.
1319  */
1320 struct netbuf *
1321 rpcb_uaddr2taddr(struct netconfig *nconf, char *uaddr)
1322 {
1323 	CLIENT *client;
1324 	struct netbuf *taddr;
1325 
1326 	/* parameter checking */
1327 	if (nconf == NULL) {
1328 		rpc_createerr.cf_stat = RPC_UNKNOWNPROTO;
1329 		return (NULL);
1330 	}
1331 	if (uaddr == NULL) {
1332 		rpc_createerr.cf_stat = RPC_UNKNOWNADDR;
1333 		return (NULL);
1334 	}
1335 	client = local_rpcb();
1336 	if (!client)
1337 		return (NULL);
1338 
1339 	taddr = calloc(1, sizeof (struct netbuf));
1340 	if (taddr == NULL) {
1341 		CLNT_DESTROY(client);
1342 		return (NULL);
1343 	}
1344 
1345 	if (CLNT_CALL(client, RPCBPROC_UADDR2TADDR, (xdrproc_t)xdr_wrapstring,
1346 	    (char *)&uaddr, (xdrproc_t)xdr_netbuf, (char *)taddr,
1347 	    tottimeout) != RPC_SUCCESS) {
1348 		free(taddr);
1349 		taddr = NULL;
1350 	}
1351 	CLNT_DESTROY(client);
1352 	return (taddr);
1353 }
1354