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