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
32 * $FreeBSD: src/usr.sbin/ypserv/yp_dblookup.c,v 1.17.2.1 2002/02/15 00:47:00 des Exp $
33 * $DragonFly: src/usr.sbin/ypserv/yp_dblookup.c,v 1.4 2004/12/18 22:48:15 swildner Exp $
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 CIRCLEQ_HEAD(circlehead
, circleq_entry
) qhead
;
82 struct circleq_entry
{
84 CIRCLEQ_ENTRY(circleq_entry
) links
;
88 * Initialize the circular queue.
97 * Dynamically allocate an entry for the circular queue.
98 * Return a NULL pointer on failure.
100 static struct circleq_entry
*
103 struct circleq_entry
*q
;
105 q
= (struct circleq_entry
*)malloc(sizeof(struct circleq_entry
));
107 yp_error("failed to malloc() circleq entry");
110 bzero((char *)q
, sizeof(struct circleq_entry
));
111 q
->dbptr
= (struct dbent
*)malloc(sizeof(struct dbent
));
112 if (q
->dbptr
== NULL
) {
113 yp_error("failed to malloc() circleq entry");
117 bzero((char *)q
->dbptr
, sizeof(struct dbent
));
123 * Free a previously allocated circular queue
127 yp_free_qent(struct circleq_entry
*q
)
130 * First, close the database. In theory, this is also
131 * supposed to free the resources allocated by the DB
132 * package, including the memory pointed to by q->dbptr->key.
133 * This means we don't have to free q->dbptr->key here.
136 q
->dbptr
->dbp
->close(q
->dbptr
->dbp
);
137 q
->dbptr
->dbp
= NULL
;
140 * Then free the database name, which was strdup()'ed.
142 free(q
->dbptr
->name
);
145 * Free the rest of the dbent struct.
151 * Free the circleq struct.
158 * Zorch a single entry in the dbent queue and release
159 * all its resources. (This always removes the last entry
165 struct circleq_entry
*qptr
;
167 qptr
= qhead
.cqh_last
;
168 CIRCLEQ_REMOVE(&qhead
, qptr
, links
);
174 * Close all databases, erase all database names and empty the queue.
179 struct circleq_entry
*qptr
;
181 while (qhead
.cqh_first
!= (void *)&qhead
) {
182 qptr
= qhead
.cqh_first
; /* save this */
183 CIRCLEQ_REMOVE(&qhead
, qhead
.cqh_first
, links
);
189 static char *inter_string
= "YP_INTERDOMAIN";
190 static char *secure_string
= "YP_SECURE";
191 static int inter_sz
= sizeof("YP_INTERDOMAIN") - 1;
192 static int secure_sz
= sizeof("YP_SECURE") - 1;
197 DBT key
= { NULL
, 0 }, data
= { NULL
, 0 };
200 key
.data
= inter_string
;
203 if (!(dbp
->get
)(dbp
, &key
, &data
, 0))
204 flags
|= YP_INTERDOMAIN
;
206 key
.data
= secure_string
;
207 key
.size
= secure_sz
;
209 if (!(dbp
->get
)(dbp
, &key
, &data
, 0))
216 yp_testflag(char *map
, char *domain
, int flag
)
218 char buf
[MAXPATHLEN
+ 2];
219 struct circleq_entry
*qptr
;
221 if (map
== NULL
|| domain
== NULL
)
228 for (qptr
= qhead
.cqh_first
; qptr
!= (void *)&qhead
;
229 qptr
= qptr
->links
.cqe_next
) {
230 if (!strcmp(qptr
->dbptr
->name
, buf
)) {
231 if (qptr
->dbptr
->flags
& flag
)
238 if (yp_open_db_cache(domain
, map
, NULL
, 0) == NULL
)
241 if (qhead
.cqh_first
->dbptr
->flags
& flag
)
248 * Add a DB handle and database name to the cache. We only maintain
249 * fixed number of entries in the cache, so if we're asked to store
250 * a new entry when all our slots are already filled, we have to kick
251 * out the entry in the last slot to make room.
254 yp_cache_db(DB
*dbp
, char *name
, int size
)
256 struct circleq_entry
*qptr
;
258 if (numdbs
== MAXDBS
) {
260 yp_error("queue overflow -- releasing last slot");
265 * Allocate a new queue entry.
268 if ((qptr
= yp_malloc_qent()) == NULL
) {
269 yp_error("failed to allocate a new cache entry");
273 qptr
->dbptr
->dbp
= dbp
;
274 qptr
->dbptr
->name
= strdup(name
);
275 qptr
->dbptr
->size
= size
;
276 qptr
->dbptr
->key
= NULL
;
278 qptr
->dbptr
->flags
= yp_setflags(dbp
);
280 CIRCLEQ_INSERT_HEAD(&qhead
, qptr
, links
);
287 * Search the list for a database matching 'name.' If we find it,
288 * move it to the head of the list and return its DB handle. If
289 * not, just fail: yp_open_db_cache() will subsequently try to open
290 * the database itself and call yp_cache_db() to add it to the
293 * The search works like this:
295 * - The caller specifies the name of a database to locate. We try to
296 * find an entry in our queue with a matching name.
298 * - If the caller doesn't specify a key or size, we assume that the
299 * first entry that we encounter with a matching name is returned.
300 * This will result in matches regardless of the key/size values
301 * stored in the queue entry.
303 * - If the caller also specifies a key and length, we check to see
304 * if the key and length saved in the queue entry also matches.
305 * This lets us return a DB handle that's already positioned at the
306 * correct location within a database.
308 * - Once we have a match, it gets migrated to the top of the queue
309 * so that it will be easier to find if another request for
310 * the same database comes in later.
313 yp_find_db(const char *name
, const char *key
, const int size
)
315 struct circleq_entry
*qptr
;
317 for (qptr
= qhead
.cqh_first
; qptr
!= (void *)&qhead
;
318 qptr
= qptr
->links
.cqe_next
) {
319 if (!strcmp(qptr
->dbptr
->name
, name
)) {
321 if (size
!= qptr
->dbptr
->size
||
322 strncmp(qptr
->dbptr
->key
, key
, size
))
325 if (qptr
->dbptr
->size
)
328 if (qptr
!= qhead
.cqh_first
) {
329 CIRCLEQ_REMOVE(&qhead
, qptr
, links
);
330 CIRCLEQ_INSERT_HEAD(&qhead
, qptr
, links
);
332 return(qptr
->dbptr
->dbp
);
340 * Open a DB database and cache the handle for later use. We first
341 * check the cache to see if the required database is already open.
342 * If so, we fetch the handle from the cache. If not, we try to open
343 * the database and save the handle in the cache for later use.
346 yp_open_db_cache(const char *domain
, const char *map
, const char *key
,
350 char buf
[MAXPATHLEN
+ 2];
352 snprintf(buf, sizeof(buf), "%s/%s", domain, map);
360 if ((dbp
= yp_find_db((char *)&buf
, key
, size
)) != NULL
) {
363 if ((dbp
= yp_open_db(domain
, map
)) != NULL
) {
364 if (yp_cache_db(dbp
, (char *)&buf
, size
)) {
377 * Open a DB database.
380 yp_open_db(const char *domain
, const char *map
)
383 char buf
[MAXPATHLEN
+ 2];
387 if (map
[0] == '.' || strchr(map
, '/')) {
388 yp_errno
= YP_BADARGS
;
393 if (yp_validdomain(domain
)) {
398 snprintf(buf
, sizeof(buf
), "%s/%s/%s", yp_dir
, domain
, map
);
403 dbp
= dbopen(buf
,O_RDONLY
, PERM_SECURE
, DB_HASH
, NULL
);
410 * We ran out of file descriptors. Nuke an
411 * open one and try again.
413 yp_error("ran out of file descriptors");
434 * Database access routines.
436 * - yp_get_record(): retrieve an arbitrary key/data pair given one key
439 * - yp_first_record(): retrieve first key/data base in a database.
441 * - yp_next_record(): retrieve key/data pair that sequentially follows
442 * the supplied key value in the database.
447 yp_get_record(DB
*dbp
, const DBT
*key
, DBT
*data
, int allow
)
450 yp_get_record(const char *domain
, const char *map
, const DBT
*key
,
451 DBT
*data
, int allow
)
459 static unsigned char buf
[YPMAXRECORD
];
463 yp_error("looking up key [%.*s]",
464 key
->size
, key
->data
);
467 * Avoid passing back magic "YP_*" entries unless
468 * the caller specifically requested them by setting
471 if (!allow
&& !strncmp(key
->data
, "YP_", 3))
475 if ((dbp
= yp_open_db(domain
, map
)) == NULL
) {
480 if ((rval
= (dbp
->get
)(dbp
, key
, data
, 0)) != 0) {
482 qhead
.cqh_first
->dbptr
->size
= 0;
493 yp_error("result of lookup: key: [%.*s] data: [%.*s]",
494 key
->size
, key
->data
, data
->size
, data
->data
);
497 if (qhead
.cqh_first
->dbptr
->size
) {
498 qhead
.cqh_first
->dbptr
->key
= "";
499 qhead
.cqh_first
->dbptr
->size
= 0;
502 bcopy((char *)data
->data
, (char *)&buf
, data
->size
);
503 data
->data
= (void *)&buf
;
511 yp_first_record(const DB
*dbp
, DBT
*key
, DBT
*data
, int allow
)
515 static unsigned char buf
[YPMAXRECORD
];
519 yp_error("retrieving first key in map");
521 if ((rval
= (dbp
->seq
)(dbp
,key
,data
,R_FIRST
)) != 0) {
523 qhead
.cqh_first
->dbptr
->size
= 0;
531 /* Avoid passing back magic "YP_*" records. */
532 while (!strncmp(key
->data
, "YP_", 3) && !allow
) {
533 if ((rval
= (dbp
->seq
)(dbp
,key
,data
,R_NEXT
)) != 0) {
535 qhead
.cqh_first
->dbptr
->size
= 0;
545 yp_error("result of lookup: key: [%.*s] data: [%.*s]",
546 key
->size
, key
->data
, data
->size
, data
->data
);
549 if (qhead
.cqh_first
->dbptr
->size
) {
550 qhead
.cqh_first
->dbptr
->key
= key
->data
;
551 qhead
.cqh_first
->dbptr
->size
= key
->size
;
554 bcopy((char *)data
->data
, (char *)&buf
, data
->size
);
555 data
->data
= (void *)&buf
;
562 yp_next_record(const DB
*dbp
, DBT
*key
, DBT
*data
, int all
, int allow
)
564 static DBT lkey
= { NULL
, 0 };
565 static DBT ldata
= { NULL
, 0 };
568 static unsigned char keybuf
[YPMAXRECORD
];
569 static unsigned char datbuf
[YPMAXRECORD
];
572 if (key
== NULL
|| !key
->size
|| key
->data
== NULL
) {
573 rval
= yp_first_record(dbp
,key
,data
,allow
);
574 if (rval
== YP_NOKEY
)
578 qhead
.cqh_first
->dbptr
->key
= key
->data
;
579 qhead
.cqh_first
->dbptr
->size
= key
->size
;
586 yp_error("retrieving next key, previous was: [%.*s]",
587 key
->size
, key
->data
);
591 if (qhead
.cqh_first
->dbptr
->key
== NULL
) {
593 (dbp
->seq
)(dbp
,&lkey
,&ldata
,R_FIRST
);
594 while (key
->size
!= lkey
.size
||
595 strncmp((char *)key
->data
, lkey
.data
,
597 if ((dbp
->seq
)(dbp
,&lkey
,&ldata
,R_NEXT
)) {
599 qhead
.cqh_first
->dbptr
->size
= 0;
609 if ((dbp
->seq
)(dbp
,key
,data
,R_NEXT
)) {
611 qhead
.cqh_first
->dbptr
->size
= 0;
616 /* Avoid passing back magic "YP_*" records. */
617 while (!strncmp(key
->data
, "YP_", 3) && !allow
)
618 if ((dbp
->seq
)(dbp
,key
,data
,R_NEXT
)) {
620 qhead
.cqh_first
->dbptr
->size
= 0;
626 yp_error("result of lookup: key: [%.*s] data: [%.*s]",
627 key
->size
, key
->data
, data
->size
, data
->data
);
630 if (qhead
.cqh_first
->dbptr
->size
) {
631 qhead
.cqh_first
->dbptr
->key
= key
->data
;
632 qhead
.cqh_first
->dbptr
->size
= key
->size
;
635 bcopy((char *)key
->data
, (char *)&keybuf
, key
->size
);
636 lkey
.data
= (void *)&keybuf
;
637 lkey
.size
= key
->size
;
638 bcopy((char *)data
->data
, (char *)&datbuf
, data
->size
);
639 data
->data
= (void *)&datbuf
;
647 * Database glue functions.
650 static DB
*yp_currmap_db
= NULL
;
651 static int yp_allow_db
= 0;
654 yp_select_map(char *map
, char *domain
, keydat
*key
, int allow
)
657 yp_currmap_db
= yp_open_db_cache(domain
, map
, NULL
, 0);
659 yp_currmap_db
= yp_open_db_cache(domain
, map
,
668 yp_getbykey(keydat
*key
, valdat
*val
)
670 DBT db_key
= { NULL
, 0 }, db_val
= { NULL
, 0 };
673 db_key
.data
= key
->keydat_val
;
674 db_key
.size
= key
->keydat_len
;
676 rval
= yp_get_record(yp_currmap_db
,
677 &db_key
, &db_val
, yp_allow_db
);
679 if (rval
== YP_TRUE
) {
680 val
->valdat_val
= db_val
.data
;
681 val
->valdat_len
= db_val
.size
;
688 yp_firstbykey(keydat
*key
, valdat
*val
)
690 DBT db_key
= { NULL
, 0 }, db_val
= { NULL
, 0 };
693 rval
= yp_first_record(yp_currmap_db
, &db_key
, &db_val
, yp_allow_db
);
695 if (rval
== YP_TRUE
) {
696 key
->keydat_val
= db_key
.data
;
697 key
->keydat_len
= db_key
.size
;
698 val
->valdat_val
= db_val
.data
;
699 val
->valdat_len
= db_val
.size
;
706 yp_nextbykey(keydat
*key
, valdat
*val
)
708 DBT db_key
= { NULL
, 0 }, db_val
= { NULL
, 0 };
711 db_key
.data
= key
->keydat_val
;
712 db_key
.size
= key
->keydat_len
;
714 rval
= yp_next_record(yp_currmap_db
, &db_key
, &db_val
, 0, yp_allow_db
);
716 if (rval
== YP_TRUE
) {
717 key
->keydat_val
= db_key
.data
;
718 key
->keydat_len
= db_key
.size
;
719 val
->valdat_val
= db_val
.data
;
720 val
->valdat_len
= db_val
.size
;