3 * Bill Paul <wpaul@ctr.columbia.edu>. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by Bill Paul.
16 * 4. Neither the name of the author nor the names of any co-contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
20 * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL Bill Paul OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 #include <sys/cdefs.h>
34 __FBSDID("$FreeBSD$");
46 #include <sys/param.h>
47 #include <rpcsvc/yp.h>
48 #include "yp_extern.h"
51 enum ypstat yp_errno = YP_TRUE;
53 #define PERM_SECURE (S_IRUSR|S_IWUSR)
58 2048 * 512, /* cachesize */
64 #include <sys/queue.h>
70 static int numdbs = 0;
80 static TAILQ_HEAD(circlehead, circleq_entry) qhead;
82 struct circleq_entry {
84 TAILQ_ENTRY(circleq_entry) links;
88 * Initialize the circular queue.
98 * Dynamically allocate an entry for the circular queue.
99 * Return a NULL pointer on failure.
101 static struct circleq_entry *
104 register struct circleq_entry *q;
106 q = (struct circleq_entry *)malloc(sizeof(struct circleq_entry));
108 yp_error("failed to malloc() circleq entry");
111 bzero((char *)q, sizeof(struct circleq_entry));
112 q->dbptr = (struct dbent *)malloc(sizeof(struct dbent));
113 if (q->dbptr == NULL) {
114 yp_error("failed to malloc() circleq entry");
118 bzero((char *)q->dbptr, sizeof(struct dbent));
124 * Free a previously allocated circular queue
128 yp_free_qent(struct circleq_entry *q)
131 * First, close the database. In theory, this is also
132 * supposed to free the resources allocated by the DB
133 * package, including the memory pointed to by q->dbptr->key.
134 * This means we don't have to free q->dbptr->key here.
137 (void)(q->dbptr->dbp->close)(q->dbptr->dbp);
138 q->dbptr->dbp = NULL;
141 * Then free the database name, which was strdup()'ed.
143 free(q->dbptr->name);
146 * Free the rest of the dbent struct.
152 * Free the circleq struct.
161 * Zorch a single entry in the dbent queue and release
162 * all its resources. (This always removes the last entry
168 register struct circleq_entry *qptr;
170 qptr = TAILQ_LAST(&qhead, circlehead);
171 TAILQ_REMOVE(&qhead, qptr, links);
179 * Close all databases, erase all database names and empty the queue.
184 register struct circleq_entry *qptr;
186 while (!TAILQ_EMPTY(&qhead)) {
187 qptr = TAILQ_FIRST(&qhead); /* save this */
188 TAILQ_REMOVE(&qhead, qptr, links);
196 static char *inter_string = "YP_INTERDOMAIN";
197 static char *secure_string = "YP_SECURE";
198 static int inter_sz = sizeof("YP_INTERDOMAIN") - 1;
199 static int secure_sz = sizeof("YP_SECURE") - 1;
204 DBT key = { NULL, 0 }, data = { NULL, 0 };
207 key.data = inter_string;
210 if (!(dbp->get)(dbp, &key, &data, 0))
211 flags |= YP_INTERDOMAIN;
213 key.data = secure_string;
214 key.size = secure_sz;
216 if (!(dbp->get)(dbp, &key, &data, 0))
223 yp_testflag(char *map, char *domain, int flag)
225 char buf[MAXPATHLEN + 2];
226 register struct circleq_entry *qptr;
228 if (map == NULL || domain == NULL)
235 TAILQ_FOREACH(qptr, &qhead, links) {
236 if (!strcmp(qptr->dbptr->name, buf)) {
237 if (qptr->dbptr->flags & flag)
244 if (yp_open_db_cache(domain, map, NULL, 0) == NULL)
247 if (TAILQ_FIRST(&qhead)->dbptr->flags & flag)
254 * Add a DB handle and database name to the cache. We only maintain
255 * fixed number of entries in the cache, so if we're asked to store
256 * a new entry when all our slots are already filled, we have to kick
257 * out the entry in the last slot to make room.
260 yp_cache_db(DB *dbp, char *name, int size)
262 register struct circleq_entry *qptr;
264 if (numdbs == MAXDBS) {
266 yp_error("queue overflow -- releasing last slot");
271 * Allocate a new queue entry.
274 if ((qptr = yp_malloc_qent()) == NULL) {
275 yp_error("failed to allocate a new cache entry");
279 qptr->dbptr->dbp = dbp;
280 qptr->dbptr->name = strdup(name);
281 qptr->dbptr->size = size;
282 qptr->dbptr->key = NULL;
284 qptr->dbptr->flags = yp_setflags(dbp);
286 TAILQ_INSERT_HEAD(&qhead, qptr, links);
293 * Search the list for a database matching 'name.' If we find it,
294 * move it to the head of the list and return its DB handle. If
295 * not, just fail: yp_open_db_cache() will subsequently try to open
296 * the database itself and call yp_cache_db() to add it to the
299 * The search works like this:
301 * - The caller specifies the name of a database to locate. We try to
302 * find an entry in our queue with a matching name.
304 * - If the caller doesn't specify a key or size, we assume that the
305 * first entry that we encounter with a matching name is returned.
306 * This will result in matches regardless of the key/size values
307 * stored in the queue entry.
309 * - If the caller also specifies a key and length, we check to see
310 * if the key and length saved in the queue entry also matches.
311 * This lets us return a DB handle that's already positioned at the
312 * correct location within a database.
314 * - Once we have a match, it gets migrated to the top of the queue
315 * so that it will be easier to find if another request for
316 * the same database comes in later.
319 yp_find_db(const char *name, const char *key, int size)
321 register struct circleq_entry *qptr;
323 TAILQ_FOREACH(qptr, &qhead, links) {
324 if (!strcmp(qptr->dbptr->name, name)) {
326 if (size != qptr->dbptr->size ||
327 strncmp(qptr->dbptr->key, key, size))
330 if (qptr->dbptr->size)
333 if (qptr != TAILQ_FIRST(&qhead)) {
334 TAILQ_REMOVE(&qhead, qptr, links);
335 TAILQ_INSERT_HEAD(&qhead, qptr, links);
337 return(qptr->dbptr->dbp);
345 * Open a DB database and cache the handle for later use. We first
346 * check the cache to see if the required database is already open.
347 * If so, we fetch the handle from the cache. If not, we try to open
348 * the database and save the handle in the cache for later use.
351 yp_open_db_cache(const char *domain, const char *map, const char *key,
355 char buf[MAXPATHLEN + 2];
357 snprintf(buf, sizeof(buf), "%s/%s", domain, map);
365 if ((dbp = yp_find_db(buf, key, size)) != NULL) {
368 if ((dbp = yp_open_db(domain, map)) != NULL) {
369 if (yp_cache_db(dbp, buf, size)) {
370 (void)(dbp->close)(dbp);
382 * Open a DB database.
385 yp_open_db(const char *domain, const char *map)
388 char buf[MAXPATHLEN + 2];
392 if (map[0] == '.' || strchr(map, '/')) {
393 yp_errno = YP_BADARGS;
398 if (yp_validdomain(domain)) {
403 snprintf(buf, sizeof(buf), "%s/%s/%s", yp_dir, domain, map);
408 dbp = dbopen(buf,O_RDONLY, PERM_SECURE, DB_HASH, NULL);
415 * We ran out of file descriptors. Nuke an
416 * open one and try again.
418 yp_error("ran out of file descriptors");
439 * Database access routines.
441 * - yp_get_record(): retrieve an arbitrary key/data pair given one key
444 * - yp_first_record(): retrieve first key/data base in a database.
446 * - yp_next_record(): retrieve key/data pair that sequentially follows
447 * the supplied key value in the database.
452 yp_get_record(DB *dbp, const DBT *key, DBT *data, int allow)
455 yp_get_record(const char *domain, const char *map,
456 const DBT *key, DBT *data, int allow)
464 static unsigned char buf[YPMAXRECORD];
468 yp_error("looking up key [%.*s]",
469 (int)key->size, (char *)key->data);
472 * Avoid passing back magic "YP_*" entries unless
473 * the caller specifically requested them by setting
476 if (!allow && !strncmp(key->data, "YP_", 3))
480 if ((dbp = yp_open_db(domain, map)) == NULL) {
485 if ((rval = (dbp->get)(dbp, key, data, 0)) != 0) {
487 TAILQ_FIRST(&qhead)->dbptr->size = 0;
489 (void)(dbp->close)(dbp);
498 yp_error("result of lookup: key: [%.*s] data: [%.*s]",
499 (int)key->size, (char *)key->data,
500 (int)data->size, (char *)data->data);
503 if (TAILQ_FIRST(&qhead)->dbptr->size) {
504 TAILQ_FIRST(&qhead)->dbptr->key = "";
505 TAILQ_FIRST(&qhead)->dbptr->size = 0;
508 bcopy(data->data, &buf, data->size);
510 (void)(dbp->close)(dbp);
517 yp_first_record(const DB *dbp, DBT *key, DBT *data, int allow)
521 static unsigned char buf[YPMAXRECORD];
525 yp_error("retrieving first key in map");
527 if ((rval = (dbp->seq)(dbp,key,data,R_FIRST)) != 0) {
529 TAILQ_FIRST(&qhead)->dbptr->size = 0;
537 /* Avoid passing back magic "YP_*" records. */
538 while (!strncmp(key->data, "YP_", 3) && !allow) {
539 if ((rval = (dbp->seq)(dbp,key,data,R_NEXT)) != 0) {
541 TAILQ_FIRST(&qhead)->dbptr->size = 0;
551 yp_error("result of lookup: key: [%.*s] data: [%.*s]",
552 (int)key->size, (char *)key->data,
553 (int)data->size, (char *)data->data);
556 if (TAILQ_FIRST(&qhead)->dbptr->size) {
557 TAILQ_FIRST(&qhead)->dbptr->key = key->data;
558 TAILQ_FIRST(&qhead)->dbptr->size = key->size;
561 bcopy(data->data, &buf, data->size);
569 yp_next_record(const DB *dbp, DBT *key, DBT *data, int all, int allow)
571 static DBT lkey = { NULL, 0 };
572 static DBT ldata = { NULL, 0 };
575 static unsigned char keybuf[YPMAXRECORD];
576 static unsigned char datbuf[YPMAXRECORD];
579 if (key == NULL || !key->size || key->data == NULL) {
580 rval = yp_first_record(dbp,key,data,allow);
581 if (rval == YP_NOKEY)
585 TAILQ_FIRST(&qhead)->dbptr->key = key->data;
586 TAILQ_FIRST(&qhead)->dbptr->size = key->size;
593 yp_error("retrieving next key, previous was: [%.*s]",
594 (int)key->size, (char *)key->data);
598 if (TAILQ_FIRST(&qhead)->dbptr->key == NULL) {
600 (dbp->seq)(dbp,&lkey,&ldata,R_FIRST);
601 while (key->size != lkey.size ||
602 strncmp(key->data, lkey.data,
604 if ((dbp->seq)(dbp,&lkey,&ldata,R_NEXT)) {
606 TAILQ_FIRST(&qhead)->dbptr->size = 0;
616 if ((dbp->seq)(dbp,key,data,R_NEXT)) {
618 TAILQ_FIRST(&qhead)->dbptr->size = 0;
623 /* Avoid passing back magic "YP_*" records. */
624 while (!strncmp(key->data, "YP_", 3) && !allow)
625 if ((dbp->seq)(dbp,key,data,R_NEXT)) {
627 TAILQ_FIRST(&qhead)->dbptr->size = 0;
633 yp_error("result of lookup: key: [%.*s] data: [%.*s]",
634 (int)key->size, (char *)key->data,
635 (int)data->size, (char *)data->data);
638 if (TAILQ_FIRST(&qhead)->dbptr->size) {
639 TAILQ_FIRST(&qhead)->dbptr->key = key->data;
640 TAILQ_FIRST(&qhead)->dbptr->size = key->size;
643 bcopy(key->data, &keybuf, key->size);
645 lkey.size = key->size;
646 bcopy(data->data, &datbuf, data->size);
647 data->data = &datbuf;
655 * Database glue functions.
658 static DB *yp_currmap_db = NULL;
659 static int yp_allow_db = 0;
662 yp_select_map(char *map, char *domain, keydat *key, int allow)
665 yp_currmap_db = yp_open_db_cache(domain, map, NULL, 0);
667 yp_currmap_db = yp_open_db_cache(domain, map,
676 yp_getbykey(keydat *key, valdat *val)
678 DBT db_key = { NULL, 0 }, db_val = { NULL, 0 };
681 db_key.data = key->keydat_val;
682 db_key.size = key->keydat_len;
684 rval = yp_get_record(yp_currmap_db,
685 &db_key, &db_val, yp_allow_db);
687 if (rval == YP_TRUE) {
688 val->valdat_val = db_val.data;
689 val->valdat_len = db_val.size;
696 yp_firstbykey(keydat *key, valdat *val)
698 DBT db_key = { NULL, 0 }, db_val = { NULL, 0 };
701 rval = yp_first_record(yp_currmap_db, &db_key, &db_val, yp_allow_db);
703 if (rval == YP_TRUE) {
704 key->keydat_val = db_key.data;
705 key->keydat_len = db_key.size;
706 val->valdat_val = db_val.data;
707 val->valdat_len = db_val.size;
714 yp_nextbykey(keydat *key, valdat *val)
716 DBT db_key = { NULL, 0 }, db_val = { NULL, 0 };
719 db_key.data = key->keydat_val;
720 db_key.size = key->keydat_len;
722 rval = yp_next_record(yp_currmap_db, &db_key, &db_val, 0, yp_allow_db);
724 if (rval == YP_TRUE) {
725 key->keydat_val = db_key.data;
726 key->keydat_len = db_key.size;
727 val->valdat_val = db_val.data;
728 val->valdat_len = db_val.size;