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