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