lib/libc/rpc/getrpcent.c

   1 /*      $NetBSD: getrpcent.c,v 1.17 2000/01/22 22:19:17 mycroft Exp $   */
   2
   3 /*-
   4  * SPDX-License-Identifier: BSD-3-Clause
   5  *
   6  * Copyright (c) 2009, Sun Microsystems, Inc.
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions are met:
  11  * - Redistributions of source code must retain the above copyright notice,
  12  *   this list of conditions and the following disclaimer.
  13  * - Redistributions in binary form must reproduce the above copyright notice,
  14  *   this list of conditions and the following disclaimer in the documentation
  15  *   and/or other materials provided with the distribution.
  16  * - Neither the name of Sun Microsystems, Inc. nor the names of its
  17  *   contributors may be used to endorse or promote products derived
  18  *   from this software without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  21  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
  24  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  30  * POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 #if defined(LIBC_SCCS) && !defined(lint)
  34 static char *sccsid = "@(#)getrpcent.c 1.14 91/03/11 Copyr 1984 Sun Micro";
  35 #endif
  36 #include <sys/cdefs.h>
  37 __FBSDID("$FreeBSD$");
  38
  39 /*
  40  * Copyright (c) 1984 by Sun Microsystems, Inc.
  41  */
  42
  43 #include <sys/param.h>
  44 #include <sys/socket.h>
  45 #include <arpa/inet.h>
  46 #include <assert.h>
  47 #include <errno.h>
  48 #include <nsswitch.h>
  49 #include <netinet/in.h>
  50 #include <stdio.h>
  51 #include <string.h>
  52 #include <stdarg.h>
  53 #include <stdlib.h>
  54 #include <rpc/rpc.h>
  55 #ifdef YP
  56 #include <rpcsvc/yp_prot.h>
  57 #include <rpcsvc/ypclnt.h>
  58 #endif
  59 #include <unistd.h>
  60 #include "namespace.h"
  61 #include "reentrant.h"
  62 #include "un-namespace.h"
  63 #include "libc_private.h"
  64 #include "nss_tls.h"
  65 #ifdef NS_CACHING
  66 #include "nscache.h"
  67 #endif
  68
  69 #define RPCDB   "/etc/rpc"
  70
  71 /* nsswitch declarations */
  72 enum constants
  73 {
  74         SETRPCENT = 1,
  75         ENDRPCENT = 2,
  76         RPCENT_STORAGE_INITIAL  = 1 << 10, /* 1 KByte */
  77         RPCENT_STORAGE_MAX      = 1 << 20, /* 1 MByte */
  78 };
  79
  80 static const ns_src defaultsrc[] = {
  81         { NSSRC_FILES, NS_SUCCESS },
  82 #ifdef YP
  83         { NSSRC_NIS, NS_SUCCESS },
  84 #endif
  85         { NULL, 0 }
  86 };
  87
  88 /* files backend declarations */
  89 struct files_state {
  90         FILE    *fp;
  91         int     stayopen;
  92 };
  93
  94 static  int     files_rpcent(void *, void *, va_list);
  95 static  int     files_setrpcent(void *, void *, va_list);
  96
  97 static  void    files_endstate(void *);
  98 NSS_TLS_HANDLING(files);
  99
 100 /* nis backend declarations */
 101 #ifdef YP
 102 struct nis_state {
 103         char    domain[MAXHOSTNAMELEN];
 104         char    *current;
 105         int     currentlen;
 106         int     stepping;
 107         int     no_name_map;
 108 };
 109
 110 static  int     nis_rpcent(void *, void *, va_list);
 111 static  int     nis_setrpcent(void *, void *, va_list);
 112
 113 static  void    nis_endstate(void *);
 114 NSS_TLS_HANDLING(nis);
 115 #endif
 116
 117 /* get** wrappers for get**_r functions declarations */
 118 struct rpcent_state {
 119         struct rpcent   rpc;
 120         char            *buffer;
 121         size_t  bufsize;
 122 };
 123 static  void    rpcent_endstate(void *);
 124 NSS_TLS_HANDLING(rpcent);
 125
 126 union key {
 127         const char      *name;
 128         int             number;
 129 };
 130
 131 static int wrap_getrpcbyname_r(union key, struct rpcent *, char *,
 132                         size_t, struct rpcent **);
 133 static int wrap_getrpcbynumber_r(union key, struct rpcent *, char *,
 134                         size_t, struct rpcent **);
 135 static int wrap_getrpcent_r(union key, struct rpcent *, char *,
 136                         size_t, struct rpcent **);
 137 static struct rpcent *getrpc(int (*fn)(union key, struct rpcent *, char *,
 138                         size_t, struct rpcent **), union key);
 139
 140 #ifdef NS_CACHING
 141 static int rpc_id_func(char *, size_t *, va_list, void *);
 142 static int rpc_marshal_func(char *, size_t *, void *, va_list, void *);
 143 static int rpc_unmarshal_func(char *, size_t, void *, va_list, void *);
 144 #endif
 145
 146 static int
 147 rpcent_unpack(char *p, struct rpcent *rpc, char **r_aliases,
 148         size_t aliases_size, int *errnop)
 149 {
 150         char *cp, **q;
 151
 152         assert(p != NULL);
 153
 154         if (*p == '#')
 155                 return (-1);
 156         cp = strpbrk(p, "#\n");
 157         if (cp == NULL)
 158                 return (-1);
 159         *cp = '\0';
 160         cp = strpbrk(p, " \t");
 161         if (cp == NULL)
 162                 return (-1);
 163         *cp++ = '\0';
 164         /* THIS STUFF IS INTERNET SPECIFIC */
 165         rpc->r_name = p;
 166         while (*cp == ' ' || *cp == '\t')
 167                 cp++;
 168         rpc->r_number = atoi(cp);
 169         q = rpc->r_aliases = r_aliases;
 170         cp = strpbrk(cp, " \t");
 171         if (cp != NULL)
 172                 *cp++ = '\0';
 173         while (cp && *cp) {
 174                 if (*cp == ' ' || *cp == '\t') {
 175                         cp++;
 176                         continue;
 177                 }
 178                 if (q < &(r_aliases[aliases_size - 1]))
 179                         *q++ = cp;
 180                 else {
 181                         *errnop = ERANGE;
 182                         return -1;
 183                 }
 184
 185                 cp = strpbrk(cp, " \t");
 186                 if (cp != NULL)
 187                         *cp++ = '\0';
 188         }
 189         *q = NULL;
 190         return 0;
 191 }
 192
 193 /* files backend implementation */
 194 static  void
 195 files_endstate(void *p)
 196 {
 197         FILE * f;
 198
 199         if (p == NULL)
 200                 return;
 201
 202         f = ((struct files_state *)p)->fp;
 203         if (f != NULL)
 204                 fclose(f);
 205
 206         free(p);
 207 }
 208
 209 static int
 210 files_rpcent(void *retval, void *mdata, va_list ap)
 211 {
 212         char *name;
 213         int number;
 214         struct rpcent *rpc;
 215         char *buffer;
 216         size_t bufsize;
 217         int *errnop;
 218
 219         char *line;
 220         size_t linesize;
 221         char **aliases;
 222         int aliases_size;
 223         char **rp;
 224
 225         struct files_state      *st;
 226         int rv;
 227         int stayopen;
 228         enum nss_lookup_type how;
 229
 230         how = (enum nss_lookup_type)(uintptr_t)mdata;
 231         switch (how)
 232         {
 233         case nss_lt_name:
 234                 name = va_arg(ap, char *);
 235                 break;
 236         case nss_lt_id:
 237                 number = va_arg(ap, int);
 238                 break;
 239         case nss_lt_all:
 240                 break;
 241         default:
 242                 return (NS_NOTFOUND);
 243         }
 244
 245         rpc = va_arg(ap, struct rpcent *);
 246         buffer = va_arg(ap, char *);
 247         bufsize = va_arg(ap, size_t);
 248         errnop = va_arg(ap, int *);
 249
 250         *errnop = files_getstate(&st);
 251         if (*errnop != 0)
 252                 return (NS_UNAVAIL);
 253
 254         if (st->fp == NULL && (st->fp = fopen(RPCDB, "r")) == NULL) {
 255                 *errnop = errno;
 256                 return (NS_UNAVAIL);
 257         }
 258
 259         if (how == nss_lt_all)
 260                 stayopen = 1;
 261         else {
 262                 rewind(st->fp);
 263                 stayopen = st->stayopen;
 264         }
 265
 266         do {
 267                 if ((line = fgetln(st->fp, &linesize)) == NULL) {
 268                         *errnop = errno;
 269                         rv = NS_RETURN;
 270                         break;
 271                 }
 272
 273                 if (bufsize <= linesize + _ALIGNBYTES + sizeof(char *)) {
 274                         *errnop = ERANGE;
 275                         rv = NS_RETURN;
 276                         break;
 277                 }
 278
 279                 aliases = (char **)_ALIGN(&buffer[linesize+1]);
 280                 aliases_size = (buffer + bufsize -
 281                         (char *)aliases)/sizeof(char *);
 282                 if (aliases_size < 1) {
 283                         *errnop = ERANGE;
 284                         rv = NS_RETURN;
 285                         break;
 286                 }
 287
 288                 memcpy(buffer, line, linesize);
 289                 buffer[linesize] = '\0';
 290
 291                 rv = rpcent_unpack(buffer, rpc, aliases, aliases_size, errnop);
 292                 if (rv != 0) {
 293                         if (*errnop == 0) {
 294                                 rv = NS_NOTFOUND;
 295                                 continue;
 296                         }
 297                         else {
 298                                 rv = NS_RETURN;
 299                                 break;
 300                         }
 301                 }
 302
 303                 switch (how)
 304                 {
 305                 case nss_lt_name:
 306                         if (strcmp(rpc->r_name, name) == 0)
 307                                 goto done;
 308                         for (rp = rpc->r_aliases; *rp != NULL; rp++) {
 309                                 if (strcmp(*rp, name) == 0)
 310                                         goto done;
 311                         }
 312                         rv = NS_NOTFOUND;
 313                         continue;
 314 done:
 315                         rv = NS_SUCCESS;
 316                         break;
 317                 case nss_lt_id:
 318                         rv = (rpc->r_number == number) ? NS_SUCCESS :
 319                                 NS_NOTFOUND;
 320                         break;
 321                 case nss_lt_all:
 322                         rv = NS_SUCCESS;
 323                         break;
 324                 }
 325
 326         } while (!(rv & NS_TERMINATE));
 327
 328         if (!stayopen && st->fp!=NULL) {
 329                 fclose(st->fp);
 330                 st->fp = NULL;
 331         }
 332
 333         if ((rv == NS_SUCCESS) && (retval != NULL))
 334                 *((struct rpcent **)retval) = rpc;
 335
 336         return (rv);
 337 }
 338
 339 static int
 340 files_setrpcent(void *retval, void *mdata, va_list ap)
 341 {
 342         struct files_state      *st;
 343         int     rv;
 344         int     f;
 345
 346         rv = files_getstate(&st);
 347         if (rv != 0)
 348                 return (NS_UNAVAIL);
 349
 350         switch ((enum constants)(uintptr_t)mdata)
 351         {
 352         case SETRPCENT:
 353                 f = va_arg(ap,int);
 354                 if (st->fp == NULL)
 355                         st->fp = fopen(RPCDB, "r");
 356                 else
 357                         rewind(st->fp);
 358                 st->stayopen |= f;
 359                 break;
 360         case ENDRPCENT:
 361                 if (st->fp != NULL) {
 362                         fclose(st->fp);
 363                         st->fp = NULL;
 364                 }
 365                 st->stayopen = 0;
 366                 break;
 367         default:
 368                 break;
 369         }
 370
 371         return (NS_UNAVAIL);
 372 }
 373
 374 /* nis backend implementation */
 375 #ifdef YP
 376 static  void
 377 nis_endstate(void *p)
 378 {
 379         if (p == NULL)
 380                 return;
 381
 382         free(((struct nis_state *)p)->current);
 383         free(p);
 384 }
 385
 386 static int
 387 nis_rpcent(void *retval, void *mdata, va_list ap)
 388 {
 389         char            *name;
 390         int             number;
 391         struct rpcent   *rpc;
 392         char            *buffer;
 393         size_t  bufsize;
 394         int             *errnop;
 395
 396         char            **rp;
 397         char            **aliases;
 398         int             aliases_size;
 399
 400         char    *lastkey;
 401         char    *resultbuf;
 402         int     resultbuflen;
 403         char    *buf;
 404
 405         struct nis_state        *st;
 406         int             rv;
 407         enum nss_lookup_type    how;
 408         int     no_name_active;
 409
 410         how = (enum nss_lookup_type)(uintptr_t)mdata;
 411         switch (how)
 412         {
 413         case nss_lt_name:
 414                 name = va_arg(ap, char *);
 415                 break;
 416         case nss_lt_id:
 417                 number = va_arg(ap, int);
 418                 break;
 419         case nss_lt_all:
 420                 break;
 421         default:
 422                 return (NS_NOTFOUND);
 423         }
 424
 425         buf = NULL;
 426         rpc = va_arg(ap, struct rpcent *);
 427         buffer = va_arg(ap, char *);
 428         bufsize = va_arg(ap, size_t);
 429         errnop = va_arg(ap, int *);
 430
 431         *errnop = nis_getstate(&st);
 432         if (*errnop != 0)
 433                 return (NS_UNAVAIL);
 434
 435         if (st->domain[0] == '\0') {
 436                 if (getdomainname(st->domain, sizeof(st->domain)) != 0) {
 437                         *errnop = errno;
 438                         return (NS_UNAVAIL);
 439                 }
 440         }
 441
 442         no_name_active = 0;
 443         do {
 444                 switch (how)
 445                 {
 446                 case nss_lt_name:
 447                         if (!st->no_name_map)
 448                         {
 449                                 free(buf);
 450                                 asprintf(&buf, "%s", name);
 451                                 if (buf == NULL)
 452                                         return (NS_TRYAGAIN);
 453                                 rv = yp_match(st->domain, "rpc.byname", buf,
 454                                         strlen(buf), &resultbuf, &resultbuflen);
 455
 456                                 switch (rv) {
 457                                 case 0:
 458                                         break;
 459                                 case YPERR_MAP:
 460                                         st->stepping = 0;
 461                                         no_name_active = 1;
 462                                         how = nss_lt_all;
 463
 464                                         rv = NS_NOTFOUND;
 465                                         continue;
 466                                 default:
 467                                         rv = NS_NOTFOUND;
 468                                         goto fin;
 469                                 }
 470                         } else {
 471                                 st->stepping = 0;
 472                                 no_name_active = 1;
 473                                 how = nss_lt_all;
 474
 475                                 rv = NS_NOTFOUND;
 476                                 continue;
 477                         }
 478                 break;
 479                 case nss_lt_id:
 480                         free(buf);
 481                         asprintf(&buf, "%d", number);
 482                         if (buf == NULL)
 483                                 return (NS_TRYAGAIN);
 484                         if (yp_match(st->domain, "rpc.bynumber", buf,
 485                                 strlen(buf), &resultbuf, &resultbuflen)) {
 486                                 rv = NS_NOTFOUND;
 487                                 goto fin;
 488                         }
 489                         break;
 490                 case nss_lt_all:
 491                                 if (!st->stepping) {
 492                                         rv = yp_first(st->domain, "rpc.bynumber",
 493                                                 &st->current,
 494                                                 &st->currentlen, &resultbuf,
 495                                                 &resultbuflen);
 496                                         if (rv) {
 497                                                 rv = NS_NOTFOUND;
 498                                                 goto fin;
 499                                         }
 500                                         st->stepping = 1;
 501                                 } else {
 502                                         lastkey = st->current;
 503                                         rv = yp_next(st->domain, "rpc.bynumber",
 504                                                 st->current,
 505                                                 st->currentlen, &st->current,
 506                                                 &st->currentlen,
 507                                                 &resultbuf,     &resultbuflen);
 508                                         free(lastkey);
 509                                         if (rv) {
 510                                                 st->stepping = 0;
 511                                                 rv = NS_NOTFOUND;
 512                                                 goto fin;
 513                                         }
 514                                 }
 515                         break;
 516                 }
 517
 518                 /* we need a room for additional \n symbol */
 519                 if (bufsize <= resultbuflen + 1 + _ALIGNBYTES +
 520                     sizeof(char *)) {
 521                         *errnop = ERANGE;
 522                         rv = NS_RETURN;
 523                         free(resultbuf);
 524                         break;
 525                 }
 526
 527                 aliases=(char **)_ALIGN(&buffer[resultbuflen+2]);
 528                 aliases_size = (buffer + bufsize - (char *)aliases) /
 529                         sizeof(char *);
 530                 if (aliases_size < 1) {
 531                         *errnop = ERANGE;
 532                         rv = NS_RETURN;
 533                         free(resultbuf);
 534                         break;
 535                 }
 536
 537                 /*
 538                  * rpcent_unpack expects lines terminated with \n -- make it happy
 539                  */
 540                 memcpy(buffer, resultbuf, resultbuflen);
 541                 buffer[resultbuflen] = '\n';
 542                 buffer[resultbuflen+1] = '\0';
 543                 free(resultbuf);
 544
 545                 if (rpcent_unpack(buffer, rpc, aliases, aliases_size,
 546                     errnop) != 0) {
 547                         if (*errnop == 0)
 548                                 rv = NS_NOTFOUND;
 549                         else
 550                                 rv = NS_RETURN;
 551                 } else {
 552                         if ((how == nss_lt_all) && (no_name_active != 0)) {
 553                                 if (strcmp(rpc->r_name, name) == 0)
 554                                         goto done;
 555                                 for (rp = rpc->r_aliases; *rp != NULL; rp++) {
 556                                         if (strcmp(*rp, name) == 0)
 557                                                 goto done;
 558                                 }
 559                                 rv = NS_NOTFOUND;
 560                                 continue;
 561 done:
 562                                 rv = NS_SUCCESS;
 563                         } else
 564                                 rv = NS_SUCCESS;
 565                 }
 566
 567         } while (!(rv & NS_TERMINATE) && (how == nss_lt_all));
 568
 569 fin:
 570         free(buf);
 571         if ((rv == NS_SUCCESS) && (retval != NULL))
 572                 *((struct rpcent **)retval) = rpc;
 573
 574         return (rv);
 575 }
 576
 577 static int
 578 nis_setrpcent(void *retval, void *mdata, va_list ap)
 579 {
 580         struct nis_state        *st;
 581         int     rv;
 582
 583         rv = nis_getstate(&st);
 584         if (rv != 0)
 585                 return (NS_UNAVAIL);
 586
 587         switch ((enum constants)(uintptr_t)mdata)
 588         {
 589         case SETRPCENT:
 590         case ENDRPCENT:
 591                 free(st->current);
 592                 st->current = NULL;
 593                 st->stepping = 0;
 594                 break;
 595         default:
 596                 break;
 597         }
 598
 599         return (NS_UNAVAIL);
 600 }
 601 #endif
 602
 603 #ifdef NS_CACHING
 604 static int
 605 rpc_id_func(char *buffer, size_t *buffer_size, va_list ap, void *cache_mdata)
 606 {
 607         char *name;
 608         int rpc;
 609
 610         size_t desired_size, size;
 611         enum nss_lookup_type lookup_type;
 612         int res = NS_UNAVAIL;
 613
 614         lookup_type = (enum nss_lookup_type)(uintptr_t)cache_mdata;
 615         switch (lookup_type) {
 616         case nss_lt_name:
 617                 name = va_arg(ap, char *);
 618
 619                 size = strlen(name);
 620                 desired_size = sizeof(enum nss_lookup_type) + size + 1;
 621                 if (desired_size > *buffer_size) {
 622                         res = NS_RETURN;
 623                         goto fin;
 624                 }
 625
 626                 memcpy(buffer, &lookup_type, sizeof(enum nss_lookup_type));
 627                 memcpy(buffer + sizeof(enum nss_lookup_type), name, size + 1);
 628
 629                 res = NS_SUCCESS;
 630                 break;
 631         case nss_lt_id:
 632                 rpc = va_arg(ap, int);
 633
 634                 desired_size = sizeof(enum nss_lookup_type) + sizeof(int);
 635                 if (desired_size > *buffer_size) {
 636                         res = NS_RETURN;
 637                         goto fin;
 638                 }
 639
 640                 memcpy(buffer, &lookup_type, sizeof(enum nss_lookup_type));
 641                 memcpy(buffer + sizeof(enum nss_lookup_type), &rpc,
 642                     sizeof(int));
 643
 644                 res = NS_SUCCESS;
 645                 break;
 646         default:
 647                 /* should be unreachable */
 648                 return (NS_UNAVAIL);
 649         }
 650
 651 fin:
 652         *buffer_size = desired_size;
 653         return (res);
 654 }
 655
 656 static int
 657 rpc_marshal_func(char *buffer, size_t *buffer_size, void *retval, va_list ap,
 658     void *cache_mdata)
 659 {
 660         char *name;
 661         int num;
 662         struct rpcent *rpc;
 663         char *orig_buf;
 664         size_t orig_buf_size;
 665
 666         struct rpcent new_rpc;
 667         size_t desired_size, size, aliases_size;
 668         char *p;
 669         char **alias;
 670
 671         switch ((enum nss_lookup_type)(uintptr_t)cache_mdata) {
 672         case nss_lt_name:
 673                 name = va_arg(ap, char *);
 674                 break;
 675         case nss_lt_id:
 676                 num = va_arg(ap, int);
 677                 break;
 678         case nss_lt_all:
 679                 break;
 680         default:
 681                 /* should be unreachable */
 682                 return (NS_UNAVAIL);
 683         }
 684
 685         rpc = va_arg(ap, struct rpcent *);
 686         orig_buf = va_arg(ap, char *);
 687         orig_buf_size = va_arg(ap, size_t);
 688
 689         desired_size = _ALIGNBYTES + sizeof(struct rpcent) + sizeof(char *);
 690         if (rpc->r_name != NULL)
 691                 desired_size += strlen(rpc->r_name) + 1;
 692
 693         if (rpc->r_aliases != NULL) {
 694                 aliases_size = 0;
 695                 for (alias = rpc->r_aliases; *alias; ++alias) {
 696                         desired_size += strlen(*alias) + 1;
 697                         ++aliases_size;
 698                 }
 699
 700                 desired_size += _ALIGNBYTES + (aliases_size + 1) *
 701                     sizeof(char *);
 702         }
 703
 704         if (*buffer_size < desired_size) {
 705                 /* this assignment is here for future use */
 706                 *buffer_size = desired_size;
 707                 return (NS_RETURN);
 708         }
 709
 710         new_rpc = *rpc;
 711
 712         *buffer_size = desired_size;
 713         memset(buffer, 0, desired_size);
 714         p = buffer + sizeof(struct rpcent) + sizeof(char *);
 715         memcpy(buffer + sizeof(struct rpcent), &p, sizeof(char *));
 716         p = (char *)_ALIGN(p);
 717
 718         if (new_rpc.r_name != NULL) {
 719                 size = strlen(new_rpc.r_name);
 720                 memcpy(p, new_rpc.r_name, size);
 721                 new_rpc.r_name = p;
 722                 p += size + 1;
 723         }
 724
 725         if (new_rpc.r_aliases != NULL) {
 726                 p = (char *)_ALIGN(p);
 727                 memcpy(p, new_rpc.r_aliases, sizeof(char *) * aliases_size);
 728                 new_rpc.r_aliases = (char **)p;
 729                 p += sizeof(char *) * (aliases_size + 1);
 730
 731                 for (alias = new_rpc.r_aliases; *alias; ++alias) {
 732                         size = strlen(*alias);
 733                         memcpy(p, *alias, size);
 734                         *alias = p;
 735                         p += size + 1;
 736                 }
 737         }
 738
 739         memcpy(buffer, &new_rpc, sizeof(struct rpcent));
 740         return (NS_SUCCESS);
 741 }
 742
 743 static int
 744 rpc_unmarshal_func(char *buffer, size_t buffer_size, void *retval, va_list ap,
 745     void *cache_mdata)
 746 {
 747         char *name;
 748         int num;
 749         struct rpcent *rpc;
 750         char *orig_buf;
 751         size_t orig_buf_size;
 752         int *ret_errno;
 753
 754         char *p;
 755         char **alias;
 756
 757         switch ((enum nss_lookup_type)(uintptr_t)cache_mdata) {
 758         case nss_lt_name:
 759                 name = va_arg(ap, char *);
 760                 break;
 761         case nss_lt_id:
 762                 num = va_arg(ap, int);
 763                 break;
 764         case nss_lt_all:
 765                 break;
 766         default:
 767                 /* should be unreachable */
 768                 return (NS_UNAVAIL);
 769         }
 770
 771         rpc = va_arg(ap, struct rpcent *);
 772         orig_buf = va_arg(ap, char *);
 773         orig_buf_size = va_arg(ap, size_t);
 774         ret_errno = va_arg(ap, int *);
 775
 776         if (orig_buf_size <
 777             buffer_size - sizeof(struct rpcent) - sizeof(char *)) {
 778                 *ret_errno = ERANGE;
 779                 return (NS_RETURN);
 780         }
 781
 782         memcpy(rpc, buffer, sizeof(struct rpcent));
 783         memcpy(&p, buffer + sizeof(struct rpcent), sizeof(char *));
 784
 785         orig_buf = (char *)_ALIGN(orig_buf);
 786         memcpy(orig_buf, buffer + sizeof(struct rpcent) + sizeof(char *) +
 787             _ALIGN(p) - (size_t)p,
 788             buffer_size - sizeof(struct rpcent) - sizeof(char *) -
 789             _ALIGN(p) + (size_t)p);
 790         p = (char *)_ALIGN(p);
 791
 792         NS_APPLY_OFFSET(rpc->r_name, orig_buf, p, char *);
 793         if (rpc->r_aliases != NULL) {
 794                 NS_APPLY_OFFSET(rpc->r_aliases, orig_buf, p, char **);
 795
 796                 for (alias = rpc->r_aliases     ; *alias; ++alias)
 797                         NS_APPLY_OFFSET(*alias, orig_buf, p, char *);
 798         }
 799
 800         if (retval != NULL)
 801                 *((struct rpcent **)retval) = rpc;
 802
 803         return (NS_SUCCESS);
 804 }
 805
 806 NSS_MP_CACHE_HANDLING(rpc);
 807 #endif /* NS_CACHING */
 808
 809
 810 /* get**_r functions implementation */
 811 static int
 812 getrpcbyname_r(const char *name, struct rpcent *rpc, char *buffer,
 813         size_t bufsize, struct rpcent **result)
 814 {
 815 #ifdef NS_CACHING
 816         static const nss_cache_info cache_info =
 817                 NS_COMMON_CACHE_INFO_INITIALIZER(
 818                 rpc, (void *)nss_lt_name,
 819                 rpc_id_func, rpc_marshal_func, rpc_unmarshal_func);
 820 #endif
 821         static const ns_dtab dtab[] = {
 822                 { NSSRC_FILES, files_rpcent, (void *)nss_lt_name },
 823 #ifdef YP
 824                 { NSSRC_NIS, nis_rpcent, (void *)nss_lt_name },
 825 #endif
 826 #ifdef NS_CACHING
 827                 NS_CACHE_CB(&cache_info)
 828 #endif
 829                 { NULL, NULL, NULL }
 830         };
 831         int rv, ret_errno;
 832
 833         ret_errno = 0;
 834         *result = NULL;
 835         rv = nsdispatch(result, dtab, NSDB_RPC, "getrpcbyname_r", defaultsrc,
 836             name, rpc, buffer, bufsize, &ret_errno);
 837
 838         if (rv == NS_SUCCESS)
 839                 return (0);
 840         else
 841                 return (ret_errno);
 842 }
 843
 844 static int
 845 getrpcbynumber_r(int number, struct rpcent *rpc, char *buffer,
 846         size_t bufsize, struct rpcent **result)
 847 {
 848 #ifdef NS_CACHING
 849         static const nss_cache_info cache_info =
 850                 NS_COMMON_CACHE_INFO_INITIALIZER(
 851                 rpc, (void *)nss_lt_id,
 852                 rpc_id_func, rpc_marshal_func, rpc_unmarshal_func);
 853 #endif
 854         static const ns_dtab dtab[] = {
 855                 { NSSRC_FILES, files_rpcent, (void *)nss_lt_id },
 856 #ifdef YP
 857                 { NSSRC_NIS, nis_rpcent, (void *)nss_lt_id },
 858 #endif
 859 #ifdef NS_CACHING
 860                 NS_CACHE_CB(&cache_info)
 861 #endif
 862                 { NULL, NULL, NULL }
 863         };
 864         int rv, ret_errno;
 865
 866         ret_errno = 0;
 867         *result = NULL;
 868         rv = nsdispatch(result, dtab, NSDB_RPC, "getrpcbynumber_r", defaultsrc,
 869             number, rpc, buffer, bufsize, &ret_errno);
 870
 871         if (rv == NS_SUCCESS)
 872                 return (0);
 873         else
 874                 return (ret_errno);
 875 }
 876
 877 static int
 878 getrpcent_r(struct rpcent *rpc, char *buffer, size_t bufsize,
 879         struct rpcent **result)
 880 {
 881 #ifdef NS_CACHING
 882         static const nss_cache_info cache_info = NS_MP_CACHE_INFO_INITIALIZER(
 883                 rpc, (void *)nss_lt_all,
 884                 rpc_marshal_func, rpc_unmarshal_func);
 885 #endif
 886         static const ns_dtab dtab[] = {
 887                 { NSSRC_FILES, files_rpcent, (void *)nss_lt_all },
 888 #ifdef YP
 889                 { NSSRC_NIS, nis_rpcent, (void *)nss_lt_all },
 890 #endif
 891 #ifdef NS_CACHING
 892                 NS_CACHE_CB(&cache_info)
 893 #endif
 894                 { NULL, NULL, NULL }
 895         };
 896         int rv, ret_errno;
 897
 898         ret_errno = 0;
 899         *result = NULL;
 900         rv = nsdispatch(result, dtab, NSDB_RPC, "getrpcent_r", defaultsrc,
 901             rpc, buffer, bufsize, &ret_errno);
 902
 903         if (rv == NS_SUCCESS)
 904                 return (0);
 905         else
 906                 return (ret_errno);
 907 }
 908
 909 /* get** wrappers for get**_r functions implementation */
 910 static  void
 911 rpcent_endstate(void *p)
 912 {
 913         if (p == NULL)
 914                 return;
 915
 916         free(((struct rpcent_state *)p)->buffer);
 917         free(p);
 918 }
 919
 920 static  int
 921 wrap_getrpcbyname_r(union key key, struct rpcent *rpc, char *buffer,
 922     size_t bufsize, struct rpcent **res)
 923 {
 924         return (getrpcbyname_r(key.name, rpc, buffer, bufsize, res));
 925 }
 926
 927 static  int
 928 wrap_getrpcbynumber_r(union key key, struct rpcent *rpc, char *buffer,
 929     size_t bufsize, struct rpcent **res)
 930 {
 931         return (getrpcbynumber_r(key.number, rpc, buffer, bufsize, res));
 932 }
 933
 934 static  int
 935 wrap_getrpcent_r(union key key __unused, struct rpcent *rpc, char *buffer,
 936     size_t bufsize, struct rpcent **res)
 937 {
 938         return (getrpcent_r(rpc, buffer, bufsize, res));
 939 }
 940
 941 static struct rpcent *
 942 getrpc(int (*fn)(union key, struct rpcent *, char *, size_t, struct rpcent **),
 943     union key key)
 944 {
 945         int              rv;
 946         struct rpcent   *res;
 947         struct rpcent_state * st;
 948
 949         rv=rpcent_getstate(&st);
 950         if (rv != 0) {
 951                 errno = rv;
 952                 return NULL;
 953         }
 954
 955         if (st->buffer == NULL) {
 956                 st->buffer = malloc(RPCENT_STORAGE_INITIAL);
 957                 if (st->buffer == NULL)
 958                         return (NULL);
 959                 st->bufsize = RPCENT_STORAGE_INITIAL;
 960         }
 961         do {
 962                 rv = fn(key, &st->rpc, st->buffer, st->bufsize, &res);
 963                 if (res == NULL && rv == ERANGE) {
 964                         free(st->buffer);
 965                         if ((st->bufsize << 1) > RPCENT_STORAGE_MAX) {
 966                                 st->buffer = NULL;
 967                                 errno = ERANGE;
 968                                 return (NULL);
 969                         }
 970                         st->bufsize <<= 1;
 971                         st->buffer = malloc(st->bufsize);
 972                         if (st->buffer == NULL)
 973                                 return (NULL);
 974                 }
 975         } while (res == NULL && rv == ERANGE);
 976         if (rv != 0)
 977                 errno = rv;
 978
 979         return (res);
 980 }
 981
 982 struct rpcent *
 983 getrpcbyname(const char *name)
 984 {
 985         union key key;
 986
 987         key.name = name;
 988
 989         return (getrpc(wrap_getrpcbyname_r, key));
 990 }
 991
 992 struct rpcent *
 993 getrpcbynumber(int number)
 994 {
 995         union key key;
 996
 997         key.number = number;
 998
 999         return (getrpc(wrap_getrpcbynumber_r, key));
1000 }
1001
1002 struct rpcent *
1003 getrpcent(void)
1004 {
1005         union key key;
1006
1007         key.number = 0; /* not used */
1008
1009         return (getrpc(wrap_getrpcent_r, key));
1010 }
1011
1012 void
1013 setrpcent(int stayopen)
1014 {
1015 #ifdef NS_CACHING
1016         static const nss_cache_info cache_info = NS_MP_CACHE_INFO_INITIALIZER(
1017                 rpc, (void *)nss_lt_all,
1018                 NULL, NULL);
1019 #endif
1020
1021         static const ns_dtab dtab[] = {
1022                 { NSSRC_FILES, files_setrpcent, (void *)SETRPCENT },
1023 #ifdef YP
1024                 { NSSRC_NIS, nis_setrpcent, (void *)SETRPCENT },
1025 #endif
1026 #ifdef NS_CACHING
1027                 NS_CACHE_CB(&cache_info)
1028 #endif
1029                 { NULL, NULL, NULL }
1030         };
1031
1032         (void)nsdispatch(NULL, dtab, NSDB_RPC, "setrpcent", defaultsrc,
1033                 stayopen);
1034 }
1035
1036 void
1037 endrpcent(void)
1038 {
1039 #ifdef NS_CACHING
1040         static const nss_cache_info cache_info = NS_MP_CACHE_INFO_INITIALIZER(
1041                 rpc, (void *)nss_lt_all,
1042                 NULL, NULL);
1043 #endif
1044
1045         static const ns_dtab dtab[] = {
1046                 { NSSRC_FILES, files_setrpcent, (void *)ENDRPCENT },
1047 #ifdef YP
1048                 { NSSRC_NIS, nis_setrpcent, (void *)ENDRPCENT },
1049 #endif
1050 #ifdef NS_CACHING
1051                 NS_CACHE_CB(&cache_info)
1052 #endif
1053                 { NULL, NULL, NULL }
1054         };
1055
1056         (void)nsdispatch(NULL, dtab, NSDB_RPC, "endrpcent", defaultsrc);
1057 }