usr.sbin/ypserv/yp_dblookup.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-4-Clause
   3  *
   4  * Copyright (c) 1995
   5  *      Bill Paul <wpaul@ctr.columbia.edu>.  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
  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 *
 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
 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
 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
 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
 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
 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
 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 *
 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 *
 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 *
 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
 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
 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
 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
 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
 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
 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
 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