1 /*- 2 * SPDX-License-Identifier: BSD-3-Clause 3 * 4 * Copyright (c) 1983, 1993 5 * The Regents of the University of California. 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 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the name of the University nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 */ 31 32 #if defined(LIBC_SCCS) && !defined(lint) 33 static char sccsid[] = "@(#)getservent.c 8.1 (Berkeley) 6/4/93"; 34 #endif /* LIBC_SCCS and not lint */ 35 #include <sys/cdefs.h> 36 __FBSDID("$FreeBSD$"); 37 38 #include <sys/param.h> 39 #include <sys/socket.h> 40 #include <arpa/inet.h> 41 #include <db.h> 42 #include <errno.h> 43 #include <fcntl.h> 44 #include <limits.h> 45 #include <netdb.h> 46 #include <nsswitch.h> 47 #include <stdio.h> 48 #include <string.h> 49 #include <stdlib.h> 50 #include <unistd.h> 51 #ifdef YP 52 #include <rpc/rpc.h> 53 #include <rpcsvc/yp_prot.h> 54 #include <rpcsvc/ypclnt.h> 55 #endif 56 #include "namespace.h" 57 #include "reentrant.h" 58 #include "un-namespace.h" 59 #include "netdb_private.h" 60 #ifdef NS_CACHING 61 #include "nscache.h" 62 #endif 63 #include "nss_tls.h" 64 65 enum constants 66 { 67 SETSERVENT = 1, 68 ENDSERVENT = 2, 69 SERVENT_STORAGE_INITIAL = 1 << 10, /* 1 KByte */ 70 SERVENT_STORAGE_MAX = 1 << 20, /* 1 MByte */ 71 }; 72 73 struct servent_mdata 74 { 75 enum nss_lookup_type how; 76 int compat_mode; 77 }; 78 79 static const ns_src defaultsrc[] = { 80 { NSSRC_COMPAT, NS_SUCCESS }, 81 { NULL, 0 } 82 }; 83 84 static int servent_unpack(char *, struct servent *, char **, size_t, int *); 85 86 /* files backend declarations */ 87 struct files_state 88 { 89 FILE *fp; 90 int stayopen; 91 92 int compat_mode_active; 93 }; 94 static void files_endstate(void *); 95 NSS_TLS_HANDLING(files); 96 97 static int files_servent(void *, void *, va_list); 98 static int files_setservent(void *, void *, va_list); 99 100 /* db backend declarations */ 101 struct db_state 102 { 103 DB *db; 104 int stayopen; 105 int keynum; 106 }; 107 static void db_endstate(void *); 108 NSS_TLS_HANDLING(db); 109 110 static int db_servent(void *, void *, va_list); 111 static int db_setservent(void *, void *, va_list); 112 113 #ifdef YP 114 /* nis backend declarations */ 115 static int nis_servent(void *, void *, va_list); 116 static int nis_setservent(void *, void *, va_list); 117 118 struct nis_state 119 { 120 int yp_stepping; 121 char yp_domain[MAXHOSTNAMELEN]; 122 char *yp_key; 123 int yp_keylen; 124 }; 125 static void nis_endstate(void *); 126 NSS_TLS_HANDLING(nis); 127 128 static int nis_servent(void *, void *, va_list); 129 static int nis_setservent(void *, void *, va_list); 130 #endif 131 132 /* compat backend declarations */ 133 static int compat_setservent(void *, void *, va_list); 134 135 /* get** wrappers for get**_r functions declarations */ 136 struct servent_state { 137 struct servent serv; 138 char *buffer; 139 size_t bufsize; 140 }; 141 static void servent_endstate(void *); 142 NSS_TLS_HANDLING(servent); 143 144 struct key { 145 const char *proto; 146 union { 147 const char *name; 148 int port; 149 }; 150 }; 151 152 static int wrap_getservbyname_r(struct key, struct servent *, char *, size_t, 153 struct servent **); 154 static int wrap_getservbyport_r(struct key, struct servent *, char *, size_t, 155 struct servent **); 156 static int wrap_getservent_r(struct key, struct servent *, char *, size_t, 157 struct servent **); 158 static struct servent *getserv(int (*fn)(struct key, struct servent *, char *, 159 size_t, struct servent **), struct key); 160 161 #ifdef NS_CACHING 162 static int serv_id_func(char *, size_t *, va_list, void *); 163 static int serv_marshal_func(char *, size_t *, void *, va_list, void *); 164 static int serv_unmarshal_func(char *, size_t, void *, va_list, void *); 165 #endif 166 167 static int 168 servent_unpack(char *p, struct servent *serv, char **aliases, 169 size_t aliases_size, int *errnop) 170 { 171 char *cp, **q, *endp; 172 long l; 173 174 if (*p == '#') 175 return -1; 176 177 memset(serv, 0, sizeof(struct servent)); 178 179 cp = strpbrk(p, "#\n"); 180 if (cp != NULL) 181 *cp = '\0'; 182 serv->s_name = p; 183 184 p = strpbrk(p, " \t"); 185 if (p == NULL) 186 return -1; 187 *p++ = '\0'; 188 while (*p == ' ' || *p == '\t') 189 p++; 190 cp = strpbrk(p, ",/"); 191 if (cp == NULL) 192 return -1; 193 194 *cp++ = '\0'; 195 l = strtol(p, &endp, 10); 196 if (endp == p || *endp != '\0' || l < 0 || l > USHRT_MAX) 197 return -1; 198 serv->s_port = htons((in_port_t)l); 199 serv->s_proto = cp; 200 201 q = serv->s_aliases = aliases; 202 cp = strpbrk(cp, " \t"); 203 if (cp != NULL) 204 *cp++ = '\0'; 205 while (cp && *cp) { 206 if (*cp == ' ' || *cp == '\t') { 207 cp++; 208 continue; 209 } 210 if (q < &aliases[aliases_size - 1]) { 211 *q++ = cp; 212 } else { 213 *q = NULL; 214 *errnop = ERANGE; 215 return -1; 216 } 217 cp = strpbrk(cp, " \t"); 218 if (cp != NULL) 219 *cp++ = '\0'; 220 } 221 *q = NULL; 222 223 return 0; 224 } 225 226 static int 227 parse_result(struct servent *serv, char *buffer, size_t bufsize, 228 char *resultbuf, size_t resultbuflen, int *errnop) 229 { 230 char **aliases; 231 int aliases_size; 232 233 if (bufsize <= resultbuflen + _ALIGNBYTES + sizeof(char *)) { 234 *errnop = ERANGE; 235 return (NS_RETURN); 236 } 237 aliases = (char **)_ALIGN(&buffer[resultbuflen + 1]); 238 aliases_size = (buffer + bufsize - (char *)aliases) / sizeof(char *); 239 if (aliases_size < 1) { 240 *errnop = ERANGE; 241 return (NS_RETURN); 242 } 243 244 memcpy(buffer, resultbuf, resultbuflen); 245 buffer[resultbuflen] = '\0'; 246 247 if (servent_unpack(buffer, serv, aliases, aliases_size, errnop) != 0) 248 return ((*errnop == 0) ? NS_NOTFOUND : NS_RETURN); 249 return (NS_SUCCESS); 250 } 251 252 /* files backend implementation */ 253 static void 254 files_endstate(void *p) 255 { 256 FILE * f; 257 258 if (p == NULL) 259 return; 260 261 f = ((struct files_state *)p)->fp; 262 if (f != NULL) 263 fclose(f); 264 265 free(p); 266 } 267 268 /* 269 * compat structures. compat and files sources functionalities are almost 270 * equal, so they all are managed by files_servent function 271 */ 272 static int 273 files_servent(void *retval, void *mdata, va_list ap) 274 { 275 static const ns_src compat_src[] = { 276 #ifdef YP 277 { NSSRC_NIS, NS_SUCCESS }, 278 #endif 279 { NULL, 0 } 280 }; 281 ns_dtab compat_dtab[] = { 282 { NSSRC_DB, db_servent, 283 (void *)((struct servent_mdata *)mdata)->how }, 284 #ifdef YP 285 { NSSRC_NIS, nis_servent, 286 (void *)((struct servent_mdata *)mdata)->how }, 287 #endif 288 { NULL, NULL, NULL } 289 }; 290 291 struct files_state *st; 292 int rv; 293 int stayopen; 294 295 struct servent_mdata *serv_mdata; 296 char *name; 297 char *proto; 298 int port; 299 300 struct servent *serv; 301 char *buffer; 302 size_t bufsize; 303 int *errnop; 304 305 size_t linesize; 306 char *line; 307 char **cp; 308 309 name = NULL; 310 proto = NULL; 311 serv_mdata = (struct servent_mdata *)mdata; 312 switch (serv_mdata->how) { 313 case nss_lt_name: 314 name = va_arg(ap, char *); 315 proto = va_arg(ap, char *); 316 break; 317 case nss_lt_id: 318 port = va_arg(ap, int); 319 proto = va_arg(ap, char *); 320 break; 321 case nss_lt_all: 322 break; 323 default: 324 return NS_NOTFOUND; 325 } 326 327 serv = va_arg(ap, struct servent *); 328 buffer = va_arg(ap, char *); 329 bufsize = va_arg(ap, size_t); 330 errnop = va_arg(ap,int *); 331 332 *errnop = files_getstate(&st); 333 if (*errnop != 0) 334 return (NS_UNAVAIL); 335 336 if (st->fp == NULL) 337 st->compat_mode_active = 0; 338 339 if (st->fp == NULL && (st->fp = fopen(_PATH_SERVICES, "re")) == NULL) { 340 *errnop = errno; 341 return (NS_UNAVAIL); 342 } 343 344 if (serv_mdata->how == nss_lt_all) 345 stayopen = 1; 346 else { 347 rewind(st->fp); 348 stayopen = st->stayopen; 349 } 350 351 rv = NS_NOTFOUND; 352 do { 353 if (!st->compat_mode_active) { 354 if ((line = fgetln(st->fp, &linesize)) == NULL) { 355 *errnop = errno; 356 rv = NS_RETURN; 357 break; 358 } 359 360 if (*line=='+' && serv_mdata->compat_mode != 0) 361 st->compat_mode_active = 1; 362 } 363 364 if (st->compat_mode_active != 0) { 365 switch (serv_mdata->how) { 366 case nss_lt_name: 367 rv = nsdispatch(retval, compat_dtab, 368 NSDB_SERVICES_COMPAT, "getservbyname_r", 369 compat_src, name, proto, serv, buffer, 370 bufsize, errnop); 371 break; 372 case nss_lt_id: 373 rv = nsdispatch(retval, compat_dtab, 374 NSDB_SERVICES_COMPAT, "getservbyport_r", 375 compat_src, port, proto, serv, buffer, 376 bufsize, errnop); 377 break; 378 case nss_lt_all: 379 rv = nsdispatch(retval, compat_dtab, 380 NSDB_SERVICES_COMPAT, "getservent_r", 381 compat_src, serv, buffer, bufsize, errnop); 382 break; 383 } 384 385 if (!(rv & NS_TERMINATE) || 386 serv_mdata->how != nss_lt_all) 387 st->compat_mode_active = 0; 388 389 continue; 390 } 391 392 rv = parse_result(serv, buffer, bufsize, line, linesize, 393 errnop); 394 if (rv == NS_NOTFOUND) 395 continue; 396 if (rv == NS_RETURN) 397 break; 398 399 rv = NS_NOTFOUND; 400 switch (serv_mdata->how) { 401 case nss_lt_name: 402 if (strcmp(name, serv->s_name) == 0) 403 goto gotname; 404 for (cp = serv->s_aliases; *cp; cp++) 405 if (strcmp(name, *cp) == 0) 406 goto gotname; 407 408 continue; 409 gotname: 410 if (proto == NULL || strcmp(serv->s_proto, proto) == 0) 411 rv = NS_SUCCESS; 412 break; 413 case nss_lt_id: 414 if (port != serv->s_port) 415 continue; 416 417 if (proto == NULL || strcmp(serv->s_proto, proto) == 0) 418 rv = NS_SUCCESS; 419 break; 420 case nss_lt_all: 421 rv = NS_SUCCESS; 422 break; 423 } 424 425 } while (!(rv & NS_TERMINATE)); 426 427 if (!stayopen && st->fp != NULL) { 428 fclose(st->fp); 429 st->fp = NULL; 430 } 431 432 if ((rv == NS_SUCCESS) && (retval != NULL)) 433 *(struct servent **)retval=serv; 434 435 return (rv); 436 } 437 438 static int 439 files_setservent(void *retval, void *mdata, va_list ap) 440 { 441 struct files_state *st; 442 int rv; 443 int f; 444 445 rv = files_getstate(&st); 446 if (rv != 0) 447 return (NS_UNAVAIL); 448 449 switch ((enum constants)mdata) { 450 case SETSERVENT: 451 f = va_arg(ap,int); 452 if (st->fp == NULL) 453 st->fp = fopen(_PATH_SERVICES, "re"); 454 else 455 rewind(st->fp); 456 st->stayopen |= f; 457 break; 458 case ENDSERVENT: 459 if (st->fp != NULL) { 460 fclose(st->fp); 461 st->fp = NULL; 462 } 463 st->stayopen = 0; 464 break; 465 default: 466 break; 467 } 468 469 st->compat_mode_active = 0; 470 return (NS_UNAVAIL); 471 } 472 473 /* db backend implementation */ 474 static void 475 db_endstate(void *p) 476 { 477 DB *db; 478 479 if (p == NULL) 480 return; 481 482 db = ((struct db_state *)p)->db; 483 if (db != NULL) 484 db->close(db); 485 486 free(p); 487 } 488 489 static int 490 db_servent(void *retval, void *mdata, va_list ap) 491 { 492 char buf[BUFSIZ]; 493 DBT key, data, *result; 494 DB *db; 495 496 struct db_state *st; 497 int rv; 498 int stayopen; 499 500 enum nss_lookup_type how; 501 char *name; 502 char *proto; 503 int port; 504 505 struct servent *serv; 506 char *buffer; 507 size_t bufsize; 508 int *errnop; 509 510 name = NULL; 511 proto = NULL; 512 how = (enum nss_lookup_type)mdata; 513 switch (how) { 514 case nss_lt_name: 515 name = va_arg(ap, char *); 516 proto = va_arg(ap, char *); 517 break; 518 case nss_lt_id: 519 port = va_arg(ap, int); 520 proto = va_arg(ap, char *); 521 break; 522 case nss_lt_all: 523 break; 524 default: 525 return NS_NOTFOUND; 526 } 527 528 serv = va_arg(ap, struct servent *); 529 buffer = va_arg(ap, char *); 530 bufsize = va_arg(ap, size_t); 531 errnop = va_arg(ap,int *); 532 533 *errnop = db_getstate(&st); 534 if (*errnop != 0) 535 return (NS_UNAVAIL); 536 537 if (how == nss_lt_all && st->keynum < 0) 538 return (NS_NOTFOUND); 539 540 if (st->db == NULL) { 541 st->db = dbopen(_PATH_SERVICES_DB, O_RDONLY, 0, DB_HASH, NULL); 542 if (st->db == NULL) { 543 *errnop = errno; 544 return (NS_UNAVAIL); 545 } 546 } 547 548 stayopen = (how == nss_lt_all) ? 1 : st->stayopen; 549 db = st->db; 550 551 do { 552 switch (how) { 553 case nss_lt_name: 554 key.data = buf; 555 if (proto == NULL) 556 key.size = snprintf(buf, sizeof(buf), 557 "\376%s", name); 558 else 559 key.size = snprintf(buf, sizeof(buf), 560 "\376%s/%s", name, proto); 561 key.size++; 562 if (db->get(db, &key, &data, 0) != 0 || 563 db->get(db, &data, &key, 0) != 0) { 564 rv = NS_NOTFOUND; 565 goto db_fin; 566 } 567 result = &key; 568 break; 569 case nss_lt_id: 570 key.data = buf; 571 port = htons(port); 572 if (proto == NULL) 573 key.size = snprintf(buf, sizeof(buf), 574 "\377%d", port); 575 else 576 key.size = snprintf(buf, sizeof(buf), 577 "\377%d/%s", port, proto); 578 key.size++; 579 if (db->get(db, &key, &data, 0) != 0 || 580 db->get(db, &data, &key, 0) != 0) { 581 rv = NS_NOTFOUND; 582 goto db_fin; 583 } 584 result = &key; 585 break; 586 case nss_lt_all: 587 key.data = buf; 588 key.size = snprintf(buf, sizeof(buf), "%d", 589 st->keynum++); 590 key.size++; 591 if (db->get(db, &key, &data, 0) != 0) { 592 st->keynum = -1; 593 rv = NS_NOTFOUND; 594 goto db_fin; 595 } 596 result = &data; 597 break; 598 } 599 600 rv = parse_result(serv, buffer, bufsize, result->data, 601 result->size - 1, errnop); 602 603 } while (!(rv & NS_TERMINATE) && how == nss_lt_all); 604 605 db_fin: 606 if (!stayopen && st->db != NULL) { 607 db->close(db); 608 st->db = NULL; 609 } 610 611 if (rv == NS_SUCCESS && retval != NULL) 612 *(struct servent **)retval = serv; 613 614 return (rv); 615 } 616 617 static int 618 db_setservent(void *retval, void *mdata, va_list ap) 619 { 620 DB *db; 621 struct db_state *st; 622 int rv; 623 int f; 624 625 rv = db_getstate(&st); 626 if (rv != 0) 627 return (NS_UNAVAIL); 628 629 switch ((enum constants)mdata) { 630 case SETSERVENT: 631 f = va_arg(ap, int); 632 st->stayopen |= f; 633 st->keynum = 0; 634 break; 635 case ENDSERVENT: 636 db = st->db; 637 if (db != NULL) { 638 db->close(db); 639 st->db = NULL; 640 } 641 st->stayopen = 0; 642 break; 643 default: 644 break; 645 } 646 647 return (NS_UNAVAIL); 648 } 649 650 /* nis backend implementation */ 651 #ifdef YP 652 static void 653 nis_endstate(void *p) 654 { 655 if (p == NULL) 656 return; 657 658 free(((struct nis_state *)p)->yp_key); 659 free(p); 660 } 661 662 static int 663 nis_servent(void *retval, void *mdata, va_list ap) 664 { 665 char *resultbuf, *lastkey; 666 int resultbuflen; 667 char *buf; 668 669 struct nis_state *st; 670 int rv; 671 672 enum nss_lookup_type how; 673 char *name; 674 char *proto; 675 int port; 676 677 struct servent *serv; 678 char *buffer; 679 size_t bufsize; 680 int *errnop; 681 682 name = NULL; 683 proto = NULL; 684 buf = NULL; 685 how = (enum nss_lookup_type)mdata; 686 switch (how) { 687 case nss_lt_name: 688 name = va_arg(ap, char *); 689 proto = va_arg(ap, char *); 690 break; 691 case nss_lt_id: 692 port = va_arg(ap, int); 693 proto = va_arg(ap, char *); 694 break; 695 case nss_lt_all: 696 break; 697 default: 698 return NS_NOTFOUND; 699 } 700 701 serv = va_arg(ap, struct servent *); 702 buffer = va_arg(ap, char *); 703 bufsize = va_arg(ap, size_t); 704 errnop = va_arg(ap, int *); 705 706 *errnop = nis_getstate(&st); 707 if (*errnop != 0) 708 return (NS_UNAVAIL); 709 710 if (st->yp_domain[0] == '\0') { 711 if (getdomainname(st->yp_domain, sizeof st->yp_domain)) { 712 *errnop = errno; 713 return (NS_UNAVAIL); 714 } 715 } 716 717 do { 718 switch (how) { 719 case nss_lt_name: 720 free(buf); 721 asprintf(&buf, "%s/%s", name, proto); 722 if (buf == NULL) 723 return (NS_TRYAGAIN); 724 if (yp_match(st->yp_domain, "services.byname", buf, 725 strlen(buf), &resultbuf, &resultbuflen)) { 726 rv = NS_NOTFOUND; 727 goto fin; 728 } 729 break; 730 case nss_lt_id: 731 free(buf); 732 asprintf(&buf, "%d/%s", ntohs(port), proto); 733 if (buf == NULL) 734 return (NS_TRYAGAIN); 735 736 /* 737 * We have to be a little flexible 738 * here. Ideally you're supposed to have both 739 * a services.byname and a services.byport 740 * map, but some systems have only 741 * services.byname. FreeBSD cheats a little by 742 * putting the services.byport information in 743 * the same map as services.byname so that 744 * either case will work. We allow for both 745 * possibilities here: if there is no 746 * services.byport map, we try services.byname 747 * instead. 748 */ 749 rv = yp_match(st->yp_domain, "services.byport", buf, 750 strlen(buf), &resultbuf, &resultbuflen); 751 if (rv) { 752 if (rv == YPERR_MAP) { 753 if (yp_match(st->yp_domain, 754 "services.byname", buf, 755 strlen(buf), &resultbuf, 756 &resultbuflen)) { 757 rv = NS_NOTFOUND; 758 goto fin; 759 } 760 } else { 761 rv = NS_NOTFOUND; 762 goto fin; 763 } 764 } 765 766 break; 767 case nss_lt_all: 768 if (!st->yp_stepping) { 769 free(st->yp_key); 770 rv = yp_first(st->yp_domain, "services.byname", 771 &st->yp_key, &st->yp_keylen, &resultbuf, 772 &resultbuflen); 773 if (rv) { 774 rv = NS_NOTFOUND; 775 goto fin; 776 } 777 st->yp_stepping = 1; 778 } else { 779 lastkey = st->yp_key; 780 rv = yp_next(st->yp_domain, "services.byname", 781 st->yp_key, st->yp_keylen, &st->yp_key, 782 &st->yp_keylen, &resultbuf, &resultbuflen); 783 free(lastkey); 784 if (rv) { 785 st->yp_stepping = 0; 786 rv = NS_NOTFOUND; 787 goto fin; 788 } 789 } 790 break; 791 } 792 793 rv = parse_result(serv, buffer, bufsize, resultbuf, 794 resultbuflen, errnop); 795 free(resultbuf); 796 797 } while (!(rv & NS_TERMINATE) && how == nss_lt_all); 798 799 fin: 800 free(buf); 801 if (rv == NS_SUCCESS && retval != NULL) 802 *(struct servent **)retval = serv; 803 804 return (rv); 805 } 806 807 static int 808 nis_setservent(void *result, void *mdata, va_list ap) 809 { 810 struct nis_state *st; 811 int rv; 812 813 rv = nis_getstate(&st); 814 if (rv != 0) 815 return (NS_UNAVAIL); 816 817 switch ((enum constants)mdata) { 818 case SETSERVENT: 819 case ENDSERVENT: 820 free(st->yp_key); 821 st->yp_key = NULL; 822 st->yp_stepping = 0; 823 break; 824 default: 825 break; 826 } 827 828 return (NS_UNAVAIL); 829 } 830 #endif 831 832 /* compat backend implementation */ 833 static int 834 compat_setservent(void *retval, void *mdata, va_list ap) 835 { 836 static const ns_src compat_src[] = { 837 #ifdef YP 838 { NSSRC_NIS, NS_SUCCESS }, 839 #endif 840 { NULL, 0 } 841 }; 842 ns_dtab compat_dtab[] = { 843 { NSSRC_DB, db_setservent, mdata }, 844 #ifdef YP 845 { NSSRC_NIS, nis_setservent, mdata }, 846 #endif 847 { NULL, NULL, NULL } 848 }; 849 int f; 850 851 (void)files_setservent(retval, mdata, ap); 852 853 switch ((enum constants)mdata) { 854 case SETSERVENT: 855 f = va_arg(ap,int); 856 (void)nsdispatch(retval, compat_dtab, NSDB_SERVICES_COMPAT, 857 "setservent", compat_src, f); 858 break; 859 case ENDSERVENT: 860 (void)nsdispatch(retval, compat_dtab, NSDB_SERVICES_COMPAT, 861 "endservent", compat_src); 862 break; 863 default: 864 break; 865 } 866 867 return (NS_UNAVAIL); 868 } 869 870 #ifdef NS_CACHING 871 static int 872 serv_id_func(char *buffer, size_t *buffer_size, va_list ap, void *cache_mdata) 873 { 874 char *name; 875 char *proto; 876 int port; 877 878 size_t desired_size, size, size2; 879 enum nss_lookup_type lookup_type; 880 int res = NS_UNAVAIL; 881 882 lookup_type = (enum nss_lookup_type)cache_mdata; 883 switch (lookup_type) { 884 case nss_lt_name: 885 name = va_arg(ap, char *); 886 proto = va_arg(ap, char *); 887 888 size = strlen(name); 889 desired_size = sizeof(enum nss_lookup_type) + size + 1; 890 if (proto != NULL) { 891 size2 = strlen(proto); 892 desired_size += size2 + 1; 893 } else 894 size2 = 0; 895 896 if (desired_size > *buffer_size) { 897 res = NS_RETURN; 898 goto fin; 899 } 900 901 memcpy(buffer, &lookup_type, sizeof(enum nss_lookup_type)); 902 memcpy(buffer + sizeof(enum nss_lookup_type), name, size + 1); 903 904 if (proto != NULL) 905 memcpy(buffer + sizeof(enum nss_lookup_type) + size + 1, 906 proto, size2 + 1); 907 908 res = NS_SUCCESS; 909 break; 910 case nss_lt_id: 911 port = va_arg(ap, int); 912 proto = va_arg(ap, char *); 913 914 desired_size = sizeof(enum nss_lookup_type) + sizeof(int); 915 if (proto != NULL) { 916 size = strlen(proto); 917 desired_size += size + 1; 918 } else 919 size = 0; 920 921 if (desired_size > *buffer_size) { 922 res = NS_RETURN; 923 goto fin; 924 } 925 926 memcpy(buffer, &lookup_type, sizeof(enum nss_lookup_type)); 927 memcpy(buffer + sizeof(enum nss_lookup_type), &port, 928 sizeof(int)); 929 930 if (proto != NULL) 931 memcpy(buffer + sizeof(enum nss_lookup_type) + 932 sizeof(int), proto, size + 1); 933 934 res = NS_SUCCESS; 935 break; 936 default: 937 /* should be unreachable */ 938 return (NS_UNAVAIL); 939 } 940 941 fin: 942 *buffer_size = desired_size; 943 return (res); 944 } 945 946 int 947 serv_marshal_func(char *buffer, size_t *buffer_size, void *retval, va_list ap, 948 void *cache_mdata) 949 { 950 char *name; 951 char *proto; 952 int port; 953 struct servent *serv; 954 char *orig_buf; 955 size_t orig_buf_size; 956 957 struct servent new_serv; 958 size_t desired_size; 959 char **alias; 960 char *p; 961 size_t size; 962 size_t aliases_size; 963 964 switch ((enum nss_lookup_type)cache_mdata) { 965 case nss_lt_name: 966 name = va_arg(ap, char *); 967 proto = va_arg(ap, char *); 968 break; 969 case nss_lt_id: 970 port = va_arg(ap, int); 971 proto = va_arg(ap, char *); 972 break; 973 case nss_lt_all: 974 break; 975 default: 976 /* should be unreachable */ 977 return (NS_UNAVAIL); 978 } 979 980 serv = va_arg(ap, struct servent *); 981 orig_buf = va_arg(ap, char *); 982 orig_buf_size = va_arg(ap, size_t); 983 984 desired_size = _ALIGNBYTES + sizeof(struct servent) + sizeof(char *); 985 if (serv->s_name != NULL) 986 desired_size += strlen(serv->s_name) + 1; 987 if (serv->s_proto != NULL) 988 desired_size += strlen(serv->s_proto) + 1; 989 990 aliases_size = 0; 991 if (serv->s_aliases != NULL) { 992 for (alias = serv->s_aliases; *alias; ++alias) { 993 desired_size += strlen(*alias) + 1; 994 ++aliases_size; 995 } 996 997 desired_size += _ALIGNBYTES + 998 sizeof(char *) * (aliases_size + 1); 999 } 1000 1001 if (*buffer_size < desired_size) { 1002 /* this assignment is here for future use */ 1003 *buffer_size = desired_size; 1004 return (NS_RETURN); 1005 } 1006 1007 memcpy(&new_serv, serv, sizeof(struct servent)); 1008 memset(buffer, 0, desired_size); 1009 1010 *buffer_size = desired_size; 1011 p = buffer + sizeof(struct servent) + sizeof(char *); 1012 memcpy(buffer + sizeof(struct servent), &p, sizeof(char *)); 1013 p = (char *)_ALIGN(p); 1014 1015 if (new_serv.s_name != NULL) { 1016 size = strlen(new_serv.s_name); 1017 memcpy(p, new_serv.s_name, size); 1018 new_serv.s_name = p; 1019 p += size + 1; 1020 } 1021 1022 if (new_serv.s_proto != NULL) { 1023 size = strlen(new_serv.s_proto); 1024 memcpy(p, new_serv.s_proto, size); 1025 new_serv.s_proto = p; 1026 p += size + 1; 1027 } 1028 1029 if (new_serv.s_aliases != NULL) { 1030 p = (char *)_ALIGN(p); 1031 memcpy(p, new_serv.s_aliases, sizeof(char *) * aliases_size); 1032 new_serv.s_aliases = (char **)p; 1033 p += sizeof(char *) * (aliases_size + 1); 1034 1035 for (alias = new_serv.s_aliases; *alias; ++alias) { 1036 size = strlen(*alias); 1037 memcpy(p, *alias, size); 1038 *alias = p; 1039 p += size + 1; 1040 } 1041 } 1042 1043 memcpy(buffer, &new_serv, sizeof(struct servent)); 1044 return (NS_SUCCESS); 1045 } 1046 1047 int 1048 serv_unmarshal_func(char *buffer, size_t buffer_size, void *retval, va_list ap, 1049 void *cache_mdata) 1050 { 1051 char *name; 1052 char *proto; 1053 int port; 1054 struct servent *serv; 1055 char *orig_buf; 1056 char *p; 1057 char **alias; 1058 size_t orig_buf_size; 1059 int *ret_errno; 1060 1061 switch ((enum nss_lookup_type)cache_mdata) { 1062 case nss_lt_name: 1063 name = va_arg(ap, char *); 1064 proto = va_arg(ap, char *); 1065 break; 1066 case nss_lt_id: 1067 port = va_arg(ap, int); 1068 proto = va_arg(ap, char *); 1069 break; 1070 case nss_lt_all: 1071 break; 1072 default: 1073 /* should be unreachable */ 1074 return (NS_UNAVAIL); 1075 } 1076 1077 serv = va_arg(ap, struct servent *); 1078 orig_buf = va_arg(ap, char *); 1079 orig_buf_size = va_arg(ap, size_t); 1080 ret_errno = va_arg(ap, int *); 1081 1082 if (orig_buf_size < 1083 buffer_size - sizeof(struct servent) - sizeof(char *)) { 1084 *ret_errno = ERANGE; 1085 return (NS_RETURN); 1086 } 1087 1088 memcpy(serv, buffer, sizeof(struct servent)); 1089 memcpy(&p, buffer + sizeof(struct servent), sizeof(char *)); 1090 1091 orig_buf = (char *)_ALIGN(orig_buf); 1092 memcpy(orig_buf, buffer + sizeof(struct servent) + sizeof(char *) + 1093 (_ALIGN(p) - (size_t)p), 1094 buffer_size - sizeof(struct servent) - sizeof(char *) - 1095 (_ALIGN(p) - (size_t)p)); 1096 p = (char *)_ALIGN(p); 1097 1098 NS_APPLY_OFFSET(serv->s_name, orig_buf, p, char *); 1099 NS_APPLY_OFFSET(serv->s_proto, orig_buf, p, char *); 1100 if (serv->s_aliases != NULL) { 1101 NS_APPLY_OFFSET(serv->s_aliases, orig_buf, p, char **); 1102 1103 for (alias = serv->s_aliases; *alias; ++alias) 1104 NS_APPLY_OFFSET(*alias, orig_buf, p, char *); 1105 } 1106 1107 if (retval != NULL) 1108 *((struct servent **)retval) = serv; 1109 return (NS_SUCCESS); 1110 } 1111 1112 NSS_MP_CACHE_HANDLING(services); 1113 #endif /* NS_CACHING */ 1114 1115 /* get**_r functions implementation */ 1116 int 1117 getservbyname_r(const char *name, const char *proto, struct servent *serv, 1118 char *buffer, size_t bufsize, struct servent **result) 1119 { 1120 static const struct servent_mdata mdata = { nss_lt_name, 0 }; 1121 static const struct servent_mdata compat_mdata = { nss_lt_name, 1 }; 1122 #ifdef NS_CACHING 1123 static const nss_cache_info cache_info = 1124 NS_COMMON_CACHE_INFO_INITIALIZER( 1125 services, (void *)nss_lt_name, 1126 serv_id_func, serv_marshal_func, serv_unmarshal_func); 1127 #endif /* NS_CACHING */ 1128 static const ns_dtab dtab[] = { 1129 { NSSRC_FILES, files_servent, (void *)&mdata }, 1130 { NSSRC_DB, db_servent, (void *)nss_lt_name }, 1131 #ifdef YP 1132 { NSSRC_NIS, nis_servent, (void *)nss_lt_name }, 1133 #endif 1134 { NSSRC_COMPAT, files_servent, (void *)&compat_mdata }, 1135 #ifdef NS_CACHING 1136 NS_CACHE_CB(&cache_info) 1137 #endif 1138 { NULL, NULL, NULL } 1139 }; 1140 int rv, ret_errno; 1141 1142 ret_errno = 0; 1143 *result = NULL; 1144 rv = nsdispatch(result, dtab, NSDB_SERVICES, "getservbyname_r", 1145 defaultsrc, name, proto, serv, buffer, bufsize, &ret_errno); 1146 1147 if (rv == NS_SUCCESS) 1148 return (0); 1149 else 1150 return (ret_errno); 1151 } 1152 1153 int 1154 getservbyport_r(int port, const char *proto, struct servent *serv, 1155 char *buffer, size_t bufsize, struct servent **result) 1156 { 1157 static const struct servent_mdata mdata = { nss_lt_id, 0 }; 1158 static const struct servent_mdata compat_mdata = { nss_lt_id, 1 }; 1159 #ifdef NS_CACHING 1160 static const nss_cache_info cache_info = 1161 NS_COMMON_CACHE_INFO_INITIALIZER( 1162 services, (void *)nss_lt_id, 1163 serv_id_func, serv_marshal_func, serv_unmarshal_func); 1164 #endif 1165 static const ns_dtab dtab[] = { 1166 { NSSRC_FILES, files_servent, (void *)&mdata }, 1167 { NSSRC_DB, db_servent, (void *)nss_lt_id }, 1168 #ifdef YP 1169 { NSSRC_NIS, nis_servent, (void *)nss_lt_id }, 1170 #endif 1171 { NSSRC_COMPAT, files_servent, (void *)&compat_mdata }, 1172 #ifdef NS_CACHING 1173 NS_CACHE_CB(&cache_info) 1174 #endif 1175 { NULL, NULL, NULL } 1176 }; 1177 int rv, ret_errno; 1178 1179 ret_errno = 0; 1180 *result = NULL; 1181 rv = nsdispatch(result, dtab, NSDB_SERVICES, "getservbyport_r", 1182 defaultsrc, port, proto, serv, buffer, bufsize, &ret_errno); 1183 1184 if (rv == NS_SUCCESS) 1185 return (0); 1186 else 1187 return (ret_errno); 1188 } 1189 1190 int 1191 getservent_r(struct servent *serv, char *buffer, size_t bufsize, 1192 struct servent **result) 1193 { 1194 static const struct servent_mdata mdata = { nss_lt_all, 0 }; 1195 static const struct servent_mdata compat_mdata = { nss_lt_all, 1 }; 1196 #ifdef NS_CACHING 1197 static const nss_cache_info cache_info = NS_MP_CACHE_INFO_INITIALIZER( 1198 services, (void *)nss_lt_all, 1199 serv_marshal_func, serv_unmarshal_func); 1200 #endif 1201 static const ns_dtab dtab[] = { 1202 { NSSRC_FILES, files_servent, (void *)&mdata }, 1203 { NSSRC_DB, db_servent, (void *)nss_lt_all }, 1204 #ifdef YP 1205 { NSSRC_NIS, nis_servent, (void *)nss_lt_all }, 1206 #endif 1207 { NSSRC_COMPAT, files_servent, (void *)&compat_mdata }, 1208 #ifdef NS_CACHING 1209 NS_CACHE_CB(&cache_info) 1210 #endif 1211 { NULL, NULL, NULL } 1212 }; 1213 int rv, ret_errno; 1214 1215 ret_errno = 0; 1216 *result = NULL; 1217 rv = nsdispatch(result, dtab, NSDB_SERVICES, "getservent_r", 1218 defaultsrc, serv, buffer, bufsize, &ret_errno); 1219 1220 if (rv == NS_SUCCESS) 1221 return (0); 1222 else 1223 return (ret_errno); 1224 } 1225 1226 void 1227 setservent(int stayopen) 1228 { 1229 #ifdef NS_CACHING 1230 static const nss_cache_info cache_info = NS_MP_CACHE_INFO_INITIALIZER( 1231 services, (void *)nss_lt_all, 1232 NULL, NULL); 1233 #endif 1234 static const ns_dtab dtab[] = { 1235 { NSSRC_FILES, files_setservent, (void *)SETSERVENT }, 1236 { NSSRC_DB, db_setservent, (void *)SETSERVENT }, 1237 #ifdef YP 1238 { NSSRC_NIS, nis_setservent, (void *)SETSERVENT }, 1239 #endif 1240 { NSSRC_COMPAT, compat_setservent, (void *)SETSERVENT }, 1241 #ifdef NS_CACHING 1242 NS_CACHE_CB(&cache_info) 1243 #endif 1244 { NULL, NULL, NULL } 1245 }; 1246 1247 (void)nsdispatch(NULL, dtab, NSDB_SERVICES, "setservent", defaultsrc, 1248 stayopen); 1249 } 1250 1251 void 1252 endservent(void) 1253 { 1254 #ifdef NS_CACHING 1255 static const nss_cache_info cache_info = NS_MP_CACHE_INFO_INITIALIZER( 1256 services, (void *)nss_lt_all, 1257 NULL, NULL); 1258 #endif 1259 static const ns_dtab dtab[] = { 1260 { NSSRC_FILES, files_setservent, (void *)ENDSERVENT }, 1261 { NSSRC_DB, db_setservent, (void *)ENDSERVENT }, 1262 #ifdef YP 1263 { NSSRC_NIS, nis_setservent, (void *)ENDSERVENT }, 1264 #endif 1265 { NSSRC_COMPAT, compat_setservent, (void *)ENDSERVENT }, 1266 #ifdef NS_CACHING 1267 NS_CACHE_CB(&cache_info) 1268 #endif 1269 { NULL, NULL, NULL } 1270 }; 1271 1272 (void)nsdispatch(NULL, dtab, NSDB_SERVICES, "endservent", defaultsrc); 1273 } 1274 1275 /* get** wrappers for get**_r functions implementation */ 1276 static void 1277 servent_endstate(void *p) 1278 { 1279 if (p == NULL) 1280 return; 1281 1282 free(((struct servent_state *)p)->buffer); 1283 free(p); 1284 } 1285 1286 static int 1287 wrap_getservbyname_r(struct key key, struct servent *serv, char *buffer, 1288 size_t bufsize, struct servent **res) 1289 { 1290 return (getservbyname_r(key.name, key.proto, serv, buffer, bufsize, 1291 res)); 1292 } 1293 1294 static int 1295 wrap_getservbyport_r(struct key key, struct servent *serv, char *buffer, 1296 size_t bufsize, struct servent **res) 1297 { 1298 return (getservbyport_r(key.port, key.proto, serv, buffer, bufsize, 1299 res)); 1300 } 1301 1302 static int 1303 wrap_getservent_r(struct key key, struct servent *serv, char *buffer, 1304 size_t bufsize, struct servent **res) 1305 { 1306 return (getservent_r(serv, buffer, bufsize, res)); 1307 } 1308 1309 static struct servent * 1310 getserv(int (*fn)(struct key, struct servent *, char *, size_t, 1311 struct servent **), struct key key) 1312 { 1313 int rv; 1314 struct servent *res; 1315 struct servent_state * st; 1316 1317 rv = servent_getstate(&st); 1318 if (rv != 0) { 1319 errno = rv; 1320 return NULL; 1321 } 1322 1323 if (st->buffer == NULL) { 1324 st->buffer = malloc(SERVENT_STORAGE_INITIAL); 1325 if (st->buffer == NULL) 1326 return (NULL); 1327 st->bufsize = SERVENT_STORAGE_INITIAL; 1328 } 1329 do { 1330 rv = fn(key, &st->serv, st->buffer, st->bufsize, &res); 1331 if (res == NULL && rv == ERANGE) { 1332 free(st->buffer); 1333 if ((st->bufsize << 1) > SERVENT_STORAGE_MAX) { 1334 st->buffer = NULL; 1335 errno = ERANGE; 1336 return (NULL); 1337 } 1338 st->bufsize <<= 1; 1339 st->buffer = malloc(st->bufsize); 1340 if (st->buffer == NULL) 1341 return (NULL); 1342 } 1343 } while (res == NULL && rv == ERANGE); 1344 if (rv != 0) 1345 errno = rv; 1346 1347 return (res); 1348 } 1349 1350 struct servent * 1351 getservbyname(const char *name, const char *proto) 1352 { 1353 struct key key; 1354 1355 key.name = name; 1356 key.proto = proto; 1357 1358 return (getserv(wrap_getservbyname_r, key)); 1359 } 1360 1361 struct servent * 1362 getservbyport(int port, const char *proto) 1363 { 1364 struct key key; 1365 1366 key.port = port; 1367 key.proto = proto; 1368 1369 return (getserv(wrap_getservbyport_r, key)); 1370 } 1371 1372 struct servent * 1373 getservent(void) 1374 { 1375 struct key key; 1376 1377 key.proto = NULL; 1378 key.port = 0; 1379 1380 return (getserv(wrap_getservent_r, key)); 1381 } 1382