1 /*-
2 * SPDX-License-Identifier: BSD-4-Clause
3 *
4 * Copyright (c) 1995
5 * Bill Paul <[email protected]>. 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. All advertising materials mentioning features or use of this software
16 * must display the following acknowledgement:
17 * This product includes software developed by Bill Paul.
18 * 4. Neither the name of the author nor the names of any co-contributors
19 * may be used to endorse or promote products derived from this software
20 * without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED. IN NO EVENT SHALL Bill Paul OR CONTRIBUTORS BE LIABLE
26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 */
34
35 #include <sys/cdefs.h>
36 __FBSDID("$FreeBSD$");
37
38 #include <db.h>
39 #include <errno.h>
40 #include <fcntl.h>
41 #include <limits.h>
42 #include <paths.h>
43 #include <stdio.h>
44 #include <stdlib.h>
45 #include <string.h>
46 #include <unistd.h>
47 #include <sys/stat.h>
48 #include <sys/param.h>
49 #include <rpcsvc/yp.h>
50 #include "yp_extern.h"
51
52 int ypdb_debug = 0;
53 enum ypstat yp_errno = YP_TRUE;
54
55 #define PERM_SECURE (S_IRUSR|S_IWUSR)
56 HASHINFO openinfo = {
57 4096, /* bsize */
58 32, /* ffactor */
59 256, /* nelem */
60 2048 * 512, /* cachesize */
61 NULL, /* hash */
62 0, /* lorder */
63 };
64
65 #ifdef DB_CACHE
66 #include <sys/queue.h>
67
68 #ifndef MAXDBS
69 #define MAXDBS 20
70 #endif
71
72 static int numdbs = 0;
73
74 struct dbent {
75 DB *dbp;
76 char *name;
77 char *key;
78 int size;
79 int flags;
80 };
81
82 static TAILQ_HEAD(circlehead, circleq_entry) qhead;
83
84 struct circleq_entry {
85 struct dbent *dbptr;
86 TAILQ_ENTRY(circleq_entry) links;
87 };
88
89 /*
90 * Initialize the circular queue.
91 */
92 void
yp_init_dbs(void)93 yp_init_dbs(void)
94 {
95 TAILQ_INIT(&qhead);
96 return;
97 }
98
99 /*
100 * Dynamically allocate an entry for the circular queue.
101 * Return a NULL pointer on failure.
102 */
103 static struct circleq_entry *
yp_malloc_qent(void)104 yp_malloc_qent(void)
105 {
106 register struct circleq_entry *q;
107
108 q = malloc(sizeof(struct circleq_entry));
109 if (q == NULL) {
110 yp_error("failed to malloc() circleq entry");
111 return(NULL);
112 }
113 bzero((char *)q, sizeof(struct circleq_entry));
114 q->dbptr = malloc(sizeof(struct dbent));
115 if (q->dbptr == NULL) {
116 yp_error("failed to malloc() circleq entry");
117 free(q);
118 return(NULL);
119 }
120 bzero((char *)q->dbptr, sizeof(struct dbent));
121
122 return(q);
123 }
124
125 /*
126 * Free a previously allocated circular queue
127 * entry.
128 */
129 static void
yp_free_qent(struct circleq_entry * q)130 yp_free_qent(struct circleq_entry *q)
131 {
132 /*
133 * First, close the database. In theory, this is also
134 * supposed to free the resources allocated by the DB
135 * package, including the memory pointed to by q->dbptr->key.
136 * This means we don't have to free q->dbptr->key here.
137 */
138 if (q->dbptr->dbp) {
139 (void)(q->dbptr->dbp->close)(q->dbptr->dbp);
140 q->dbptr->dbp = NULL;
141 }
142 /*
143 * Then free the database name, which was strdup()'ed.
144 */
145 free(q->dbptr->name);
146
147 /*
148 * Free the rest of the dbent struct.
149 */
150 free(q->dbptr);
151 q->dbptr = NULL;
152
153 /*
154 * Free the circleq struct.
155 */
156 free(q);
157 q = NULL;
158
159 return;
160 }
161
162 /*
163 * Zorch a single entry in the dbent queue and release
164 * all its resources. (This always removes the last entry
165 * in the queue.)
166 */
167 static void
yp_flush(void)168 yp_flush(void)
169 {
170 register struct circleq_entry *qptr;
171
172 qptr = TAILQ_LAST(&qhead, circlehead);
173 TAILQ_REMOVE(&qhead, qptr, links);
174 yp_free_qent(qptr);
175 numdbs--;
176
177 return;
178 }
179
180 /*
181 * Close all databases, erase all database names and empty the queue.
182 */
183 void
yp_flush_all(void)184 yp_flush_all(void)
185 {
186 register struct circleq_entry *qptr;
187
188 while (!TAILQ_EMPTY(&qhead)) {
189 qptr = TAILQ_FIRST(&qhead); /* save this */
190 TAILQ_REMOVE(&qhead, qptr, links);
191 yp_free_qent(qptr);
192 }
193 numdbs = 0;
194
195 return;
196 }
197
198 static char *inter_string = "YP_INTERDOMAIN";
199 static char *secure_string = "YP_SECURE";
200 static int inter_sz = sizeof("YP_INTERDOMAIN") - 1;
201 static int secure_sz = sizeof("YP_SECURE") - 1;
202
203 static int
yp_setflags(DB * dbp)204 yp_setflags(DB *dbp)
205 {
206 DBT key = { NULL, 0 }, data = { NULL, 0 };
207 int flags = 0;
208
209 key.data = inter_string;
210 key.size = inter_sz;
211
212 if (!(dbp->get)(dbp, &key, &data, 0))
213 flags |= YP_INTERDOMAIN;
214
215 key.data = secure_string;
216 key.size = secure_sz;
217
218 if (!(dbp->get)(dbp, &key, &data, 0))
219 flags |= YP_SECURE;
220
221 return(flags);
222 }
223
224 int
yp_testflag(char * map,char * domain,int flag)225 yp_testflag(char *map, char *domain, int flag)
226 {
227 char buf[MAXPATHLEN + 2];
228 register struct circleq_entry *qptr;
229
230 if (map == NULL || domain == NULL)
231 return(0);
232
233 strcpy(buf, domain);
234 strcat(buf, "/");
235 strcat(buf, map);
236
237 TAILQ_FOREACH(qptr, &qhead, links) {
238 if (!strcmp(qptr->dbptr->name, buf)) {
239 if (qptr->dbptr->flags & flag)
240 return(1);
241 else
242 return(0);
243 }
244 }
245
246 if (yp_open_db_cache(domain, map, NULL, 0) == NULL)
247 return(0);
248
249 if (TAILQ_FIRST(&qhead)->dbptr->flags & flag)
250 return(1);
251
252 return(0);
253 }
254
255 /*
256 * Add a DB handle and database name to the cache. We only maintain
257 * fixed number of entries in the cache, so if we're asked to store
258 * a new entry when all our slots are already filled, we have to kick
259 * out the entry in the last slot to make room.
260 */
261 static int
yp_cache_db(DB * dbp,char * name,int size)262 yp_cache_db(DB *dbp, char *name, int size)
263 {
264 register struct circleq_entry *qptr;
265
266 if (numdbs == MAXDBS) {
267 if (ypdb_debug)
268 yp_error("queue overflow -- releasing last slot");
269 yp_flush();
270 }
271
272 /*
273 * Allocate a new queue entry.
274 */
275
276 if ((qptr = yp_malloc_qent()) == NULL) {
277 yp_error("failed to allocate a new cache entry");
278 return(1);
279 }
280
281 qptr->dbptr->dbp = dbp;
282 qptr->dbptr->name = strdup(name);
283 qptr->dbptr->size = size;
284 qptr->dbptr->key = NULL;
285
286 qptr->dbptr->flags = yp_setflags(dbp);
287
288 TAILQ_INSERT_HEAD(&qhead, qptr, links);
289 numdbs++;
290
291 return(0);
292 }
293
294 /*
295 * Search the list for a database matching 'name.' If we find it,
296 * move it to the head of the list and return its DB handle. If
297 * not, just fail: yp_open_db_cache() will subsequently try to open
298 * the database itself and call yp_cache_db() to add it to the
299 * list.
300 *
301 * The search works like this:
302 *
303 * - The caller specifies the name of a database to locate. We try to
304 * find an entry in our queue with a matching name.
305 *
306 * - If the caller doesn't specify a key or size, we assume that the
307 * first entry that we encounter with a matching name is returned.
308 * This will result in matches regardless of the key/size values
309 * stored in the queue entry.
310 *
311 * - If the caller also specifies a key and length, we check to see
312 * if the key and length saved in the queue entry also matches.
313 * This lets us return a DB handle that's already positioned at the
314 * correct location within a database.
315 *
316 * - Once we have a match, it gets migrated to the top of the queue
317 * so that it will be easier to find if another request for
318 * the same database comes in later.
319 */
320 static DB *
yp_find_db(const char * name,const char * key,int size)321 yp_find_db(const char *name, const char *key, int size)
322 {
323 register struct circleq_entry *qptr;
324
325 TAILQ_FOREACH(qptr, &qhead, links) {
326 if (!strcmp(qptr->dbptr->name, name)) {
327 if (size) {
328 if (size != qptr->dbptr->size ||
329 strncmp(qptr->dbptr->key, key, size))
330 continue;
331 } else {
332 if (qptr->dbptr->size)
333 continue;
334 }
335 if (qptr != TAILQ_FIRST(&qhead)) {
336 TAILQ_REMOVE(&qhead, qptr, links);
337 TAILQ_INSERT_HEAD(&qhead, qptr, links);
338 }
339 return(qptr->dbptr->dbp);
340 }
341 }
342
343 return(NULL);
344 }
345
346 /*
347 * Open a DB database and cache the handle for later use. We first
348 * check the cache to see if the required database is already open.
349 * If so, we fetch the handle from the cache. If not, we try to open
350 * the database and save the handle in the cache for later use.
351 */
352 DB *
yp_open_db_cache(const char * domain,const char * map,const char * key,const int size)353 yp_open_db_cache(const char *domain, const char *map, const char *key,
354 const int size)
355 {
356 DB *dbp = NULL;
357 char buf[MAXPATHLEN + 2];
358 /*
359 snprintf(buf, sizeof(buf), "%s/%s", domain, map);
360 */
361 yp_errno = YP_TRUE;
362
363 strcpy(buf, domain);
364 strcat(buf, "/");
365 strcat(buf, map);
366
367 if ((dbp = yp_find_db(buf, key, size)) != NULL) {
368 return(dbp);
369 } else {
370 if ((dbp = yp_open_db(domain, map)) != NULL) {
371 if (yp_cache_db(dbp, buf, size)) {
372 (void)(dbp->close)(dbp);
373 yp_errno = YP_YPERR;
374 return(NULL);
375 }
376 }
377 }
378
379 return (dbp);
380 }
381 #endif
382
383 /*
384 * Open a DB database.
385 */
386 DB *
yp_open_db(const char * domain,const char * map)387 yp_open_db(const char *domain, const char *map)
388 {
389 DB *dbp = NULL;
390 char buf[MAXPATHLEN + 2];
391
392 yp_errno = YP_TRUE;
393
394 if (map[0] == '.' || strchr(map, '/')) {
395 yp_errno = YP_BADARGS;
396 return (NULL);
397 }
398
399 #ifdef DB_CACHE
400 if (yp_validdomain(domain)) {
401 yp_errno = YP_NODOM;
402 return(NULL);
403 }
404 #endif
405 snprintf(buf, sizeof(buf), "%s/%s/%s", yp_dir, domain, map);
406
407 #ifdef DB_CACHE
408 again:
409 #endif
410 dbp = dbopen(buf, O_RDONLY, PERM_SECURE, DB_HASH, NULL);
411
412 if (dbp == NULL) {
413 switch (errno) {
414 #ifdef DB_CACHE
415 case ENFILE:
416 /*
417 * We ran out of file descriptors. Nuke an
418 * open one and try again.
419 */
420 yp_error("ran out of file descriptors");
421 yp_flush();
422 goto again;
423 break;
424 #endif
425 case ENOENT:
426 yp_errno = YP_NOMAP;
427 break;
428 case EFTYPE:
429 yp_errno = YP_BADDB;
430 break;
431 default:
432 yp_errno = YP_YPERR;
433 break;
434 }
435 }
436
437 return (dbp);
438 }
439
440 /*
441 * Database access routines.
442 *
443 * - yp_get_record(): retrieve an arbitrary key/data pair given one key
444 * to match against.
445 *
446 * - yp_first_record(): retrieve first key/data base in a database.
447 *
448 * - yp_next_record(): retrieve key/data pair that sequentially follows
449 * the supplied key value in the database.
450 */
451
452 #ifdef DB_CACHE
453 int
yp_get_record(DB * dbp,const DBT * key,DBT * data,int allow)454 yp_get_record(DB *dbp, const DBT *key, DBT *data, int allow)
455 #else
456 int
457 yp_get_record(const char *domain, const char *map,
458 const DBT *key, DBT *data, int allow)
459 #endif
460 {
461 #ifndef DB_CACHE
462 DB *dbp;
463 #endif
464 int rval = 0;
465 #ifndef DB_CACHE
466 static unsigned char buf[YPMAXRECORD];
467 #endif
468
469 if (ypdb_debug)
470 yp_error("looking up key [%.*s]",
471 (int)key->size, (char *)key->data);
472
473 /*
474 * Avoid passing back magic "YP_*" entries unless
475 * the caller specifically requested them by setting
476 * the 'allow' flag.
477 */
478 if (!allow && !strncmp(key->data, "YP_", 3))
479 return(YP_NOKEY);
480
481 #ifndef DB_CACHE
482 if ((dbp = yp_open_db(domain, map)) == NULL) {
483 return(yp_errno);
484 }
485 #endif
486
487 if ((rval = (dbp->get)(dbp, key, data, 0)) != 0) {
488 #ifdef DB_CACHE
489 TAILQ_FIRST(&qhead)->dbptr->size = 0;
490 #else
491 (void)(dbp->close)(dbp);
492 #endif
493 if (rval == 1)
494 return(YP_NOKEY);
495 else
496 return(YP_BADDB);
497 }
498
499 if (ypdb_debug)
500 yp_error("result of lookup: key: [%.*s] data: [%.*s]",
501 (int)key->size, (char *)key->data,
502 (int)data->size, (char *)data->data);
503
504 #ifdef DB_CACHE
505 if (TAILQ_FIRST(&qhead)->dbptr->size) {
506 TAILQ_FIRST(&qhead)->dbptr->key = "";
507 TAILQ_FIRST(&qhead)->dbptr->size = 0;
508 }
509 #else
510 bcopy(data->data, &buf, data->size);
511 data->data = &buf;
512 (void)(dbp->close)(dbp);
513 #endif
514
515 return(YP_TRUE);
516 }
517
518 int
yp_first_record(const DB * dbp,DBT * key,DBT * data,int allow)519 yp_first_record(const DB *dbp, DBT *key, DBT *data, int allow)
520 {
521 int rval;
522 #ifndef DB_CACHE
523 static unsigned char buf[YPMAXRECORD];
524 #endif
525
526 if (ypdb_debug)
527 yp_error("retrieving first key in map");
528
529 if ((rval = (dbp->seq)(dbp,key,data,R_FIRST)) != 0) {
530 #ifdef DB_CACHE
531 TAILQ_FIRST(&qhead)->dbptr->size = 0;
532 #endif
533 if (rval == 1)
534 return(YP_NOKEY);
535 else
536 return(YP_BADDB);
537 }
538
539 /* Avoid passing back magic "YP_*" records. */
540 while (!strncmp(key->data, "YP_", 3) && !allow) {
541 if ((rval = (dbp->seq)(dbp,key,data,R_NEXT)) != 0) {
542 #ifdef DB_CACHE
543 TAILQ_FIRST(&qhead)->dbptr->size = 0;
544 #endif
545 if (rval == 1)
546 return(YP_NOKEY);
547 else
548 return(YP_BADDB);
549 }
550 }
551
552 if (ypdb_debug)
553 yp_error("result of lookup: key: [%.*s] data: [%.*s]",
554 (int)key->size, (char *)key->data,
555 (int)data->size, (char *)data->data);
556
557 #ifdef DB_CACHE
558 if (TAILQ_FIRST(&qhead)->dbptr->size) {
559 TAILQ_FIRST(&qhead)->dbptr->key = key->data;
560 TAILQ_FIRST(&qhead)->dbptr->size = key->size;
561 }
562 #else
563 bcopy(data->data, &buf, data->size);
564 data->data = &buf;
565 #endif
566
567 return(YP_TRUE);
568 }
569
570 int
yp_next_record(const DB * dbp,DBT * key,DBT * data,int all,int allow)571 yp_next_record(const DB *dbp, DBT *key, DBT *data, int all, int allow)
572 {
573 static DBT lkey = { NULL, 0 };
574 static DBT ldata = { NULL, 0 };
575 int rval;
576 #ifndef DB_CACHE
577 static unsigned char keybuf[YPMAXRECORD];
578 static unsigned char datbuf[YPMAXRECORD];
579 #endif
580
581 if (key == NULL || !key->size || key->data == NULL) {
582 rval = yp_first_record(dbp,key,data,allow);
583 if (rval == YP_NOKEY)
584 return(YP_NOMORE);
585 else {
586 #ifdef DB_CACHE
587 TAILQ_FIRST(&qhead)->dbptr->key = key->data;
588 TAILQ_FIRST(&qhead)->dbptr->size = key->size;
589 #endif
590 return(rval);
591 }
592 }
593
594 if (ypdb_debug)
595 yp_error("retrieving next key, previous was: [%.*s]",
596 (int)key->size, (char *)key->data);
597
598 if (!all) {
599 #ifdef DB_CACHE
600 if (TAILQ_FIRST(&qhead)->dbptr->key == NULL) {
601 #endif
602 (dbp->seq)(dbp,&lkey,&ldata,R_FIRST);
603 while (key->size != lkey.size ||
604 strncmp(key->data, lkey.data,
605 (int)key->size))
606 if ((dbp->seq)(dbp,&lkey,&ldata,R_NEXT)) {
607 #ifdef DB_CACHE
608 TAILQ_FIRST(&qhead)->dbptr->size = 0;
609 #endif
610 return(YP_NOKEY);
611 }
612
613 #ifdef DB_CACHE
614 }
615 #endif
616 }
617
618 if ((dbp->seq)(dbp,key,data,R_NEXT)) {
619 #ifdef DB_CACHE
620 TAILQ_FIRST(&qhead)->dbptr->size = 0;
621 #endif
622 return(YP_NOMORE);
623 }
624
625 /* Avoid passing back magic "YP_*" records. */
626 while (!strncmp(key->data, "YP_", 3) && !allow)
627 if ((dbp->seq)(dbp,key,data,R_NEXT)) {
628 #ifdef DB_CACHE
629 TAILQ_FIRST(&qhead)->dbptr->size = 0;
630 #endif
631 return(YP_NOMORE);
632 }
633
634 if (ypdb_debug)
635 yp_error("result of lookup: key: [%.*s] data: [%.*s]",
636 (int)key->size, (char *)key->data,
637 (int)data->size, (char *)data->data);
638
639 #ifdef DB_CACHE
640 if (TAILQ_FIRST(&qhead)->dbptr->size) {
641 TAILQ_FIRST(&qhead)->dbptr->key = key->data;
642 TAILQ_FIRST(&qhead)->dbptr->size = key->size;
643 }
644 #else
645 bcopy(key->data, &keybuf, key->size);
646 lkey.data = &keybuf;
647 lkey.size = key->size;
648 bcopy(data->data, &datbuf, data->size);
649 data->data = &datbuf;
650 #endif
651
652 return(YP_TRUE);
653 }
654
655 #ifdef DB_CACHE
656 /*
657 * Database glue functions.
658 */
659
660 static DB *yp_currmap_db = NULL;
661 static int yp_allow_db = 0;
662
663 ypstat
yp_select_map(char * map,char * domain,keydat * key,int allow)664 yp_select_map(char *map, char *domain, keydat *key, int allow)
665 {
666 if (key == NULL)
667 yp_currmap_db = yp_open_db_cache(domain, map, NULL, 0);
668 else
669 yp_currmap_db = yp_open_db_cache(domain, map,
670 key->keydat_val,
671 key->keydat_len);
672
673 yp_allow_db = allow;
674 return(yp_errno);
675 }
676
677 ypstat
yp_getbykey(keydat * key,valdat * val)678 yp_getbykey(keydat *key, valdat *val)
679 {
680 DBT db_key = { NULL, 0 }, db_val = { NULL, 0 };
681 ypstat rval;
682
683 db_key.data = key->keydat_val;
684 db_key.size = key->keydat_len;
685
686 rval = yp_get_record(yp_currmap_db,
687 &db_key, &db_val, yp_allow_db);
688
689 if (rval == YP_TRUE) {
690 val->valdat_val = db_val.data;
691 val->valdat_len = db_val.size;
692 }
693
694 return(rval);
695 }
696
697 ypstat
yp_firstbykey(keydat * key,valdat * val)698 yp_firstbykey(keydat *key, valdat *val)
699 {
700 DBT db_key = { NULL, 0 }, db_val = { NULL, 0 };
701 ypstat rval;
702
703 rval = yp_first_record(yp_currmap_db, &db_key, &db_val, yp_allow_db);
704
705 if (rval == YP_TRUE) {
706 key->keydat_val = db_key.data;
707 key->keydat_len = db_key.size;
708 val->valdat_val = db_val.data;
709 val->valdat_len = db_val.size;
710 }
711
712 return(rval);
713 }
714
715 ypstat
yp_nextbykey(keydat * key,valdat * val)716 yp_nextbykey(keydat *key, valdat *val)
717 {
718 DBT db_key = { NULL, 0 }, db_val = { NULL, 0 };
719 ypstat rval;
720
721 db_key.data = key->keydat_val;
722 db_key.size = key->keydat_len;
723
724 rval = yp_next_record(yp_currmap_db, &db_key, &db_val, 0, yp_allow_db);
725
726 if (rval == YP_TRUE) {
727 key->keydat_val = db_key.data;
728 key->keydat_len = db_key.size;
729 val->valdat_val = db_val.data;
730 val->valdat_len = db_val.size;
731 }
732
733 return(rval);
734 }
735 #endif
736