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