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