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 }