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