git.sur5r.net Git - openldap/blob - libraries/libldbm/ldbm.c

   1 /* ldbm.c - ldap dbm compatibility routines */
   2
   3 /* Patched for Berkeley DB version 2.0; /KSp; 98/02/23
   4  *
   5  *   - DB version 2.6.4b   ; 1998/12/28, /KSp
   6  *   - DB_DBT_MALLOC       ; 1998/03/22, /KSp
   7  *   - basic implementation; 1998/02/23, /KSp
   8  */
   9
  10 #include "portable.h"
  11
  12 #ifdef SLAPD_LDBM
  13
  14 #include <stdio.h>
  15
  16 #include <ac/stdlib.h>
  17 #include <ac/string.h>
  18 #include <ac/errno.h>
  19
  20 #include "ldbm.h"
  21 #include "ldap_pvt_thread.h"
  22
  23
  24 void
  25 ldbm_datum_free( LDBM ldbm, Datum data )
  26 {
  27         if ( data.dptr ) {
  28                 free( data.dptr );
  29                 memset( &data, 0, sizeof( Datum ));
  30                 data.dptr = NULL;
  31         }
  32 }
  33
  34
  35 Datum
  36 ldbm_datum_dup( LDBM ldbm, Datum data )
  37 {
  38         Datum   dup;
  39
  40         ldbm_datum_init( dup );
  41
  42         if ( data.dsize == 0 ) {
  43                 dup.dsize = 0;
  44                 dup.dptr = NULL;
  45
  46                 return( dup );
  47         }
  48         dup.dsize = data.dsize;
  49         if ( (dup.dptr = (char *) malloc( data.dsize )) != NULL )
  50                 memcpy( dup.dptr, data.dptr, data.dsize );
  51
  52         return( dup );
  53 }
  54
  55 static int ldbm_initialized = 0;
  56
  57 #ifndef HAVE_BERKELEY_DB2
  58 /* Everything but DB2 is non-reentrant */
  59
  60 static ldap_pvt_thread_mutex_t ldbm_big_mutex;
  61 #define LDBM_LOCK       (ldap_pvt_thread_mutex_lock(&ldbm_big_mutex))
  62 #define LDBM_UNLOCK     (ldap_pvt_thread_mutex_unlock(&ldbm_big_mutex))
  63
  64 int ldbm_initialize( void )
  65 {
  66         if(ldbm_initialized++) return 1;
  67
  68         ldap_pvt_thread_mutex_init( &ldbm_big_mutex );
  69
  70         return 0;
  71 }
  72
  73 int ldbm_shutdown( void )
  74 {
  75         if( !ldbm_initialized ) return 1;
  76
  77         ldap_pvt_thread_mutex_destroy( &ldbm_big_mutex );
  78
  79         return 0;
  80 }
  81
  82 #else
  83
  84 void *
  85 ldbm_malloc( size_t size )
  86 {
  87         return( calloc( 1, size ));
  88 }
  89
  90 #ifdef LDAP_SYSLOG
  91 #include <ac/syslog.h>
  92 #endif
  93
  94 static void
  95 ldbm_db_errcall( const char *prefix, char *message )
  96 {
  97 #ifdef LDAP_SYSLOG
  98         syslog( LOG_INFO, "ldbm_db_errcall(): %s %s", prefix, message );
  99 #endif
 100 }
 101
 102 /*  a dbEnv for BERKELEYv2  */
 103 static DB_ENV    ldbm_Env_internal;
 104 DB_ENV           *ldbm_Env = NULL;
 105
 106 /* Berkeley DB 2.x is reentrant */
 107 #define LDBM_LOCK       ((void)0)
 108 #define LDBM_UNLOCK     ((void)0)
 109
 110 int ldbm_initialize( void )
 111 {
 112         int     err;
 113         int     envFlags;
 114
 115         if(ldbm_initialized++) return 1;
 116
 117         memset( &ldbm_Env_internal, 0, sizeof( DB_ENV ));
 118         ldbm_Env = &ldbm_Env_internal;
 119
 120         ldbm_Env->db_errcall   = ldbm_db_errcall;
 121         ldbm_Env->db_errpfx    = "==>";
 122
 123         envFlags = DB_CREATE | DB_THREAD;
 124
 125         if ( ( err = db_appinit( NULL, NULL, ldbm_Env, envFlags )) ) {
 126                 char  error[BUFSIZ];
 127
 128                 if ( err < 0 ) {
 129                         sprintf( error, "%ld\n", (long) err );
 130                 } else {
 131                         sprintf( error, "%s\n", strerror( err ));
 132                 }
 133
 134 #ifdef LDAP_SYSLOG
 135                 syslog( LOG_INFO,
 136                         "ldbm_initialize(): FATAL error in db_appinit() : %s\n",
 137                         error );
 138 #endif
 139                 return( 1 );
 140         }
 141
 142         return 0;
 143 }
 144
 145 int ldbm_shutdown( void )
 146 {
 147         if( !ldbm_initialized ) return 1;
 148
 149         db_appexit( ldbm_Env );
 150
 151         return 0;
 152 }
 153
 154 #endif
 155
 156 #if defined( LDBM_USE_DBHASH ) || defined( LDBM_USE_DBBTREE )
 157
 158 /*****************************************************************
 159  *                                                               *
 160  * use berkeley db hash or btree package                         *
 161  *                                                               *
 162  *****************************************************************/
 163
 164 LDBM
 165 ldbm_open( char *name, int rw, int mode, int dbcachesize )
 166 {
 167         LDBM            ret = NULL;
 168
 169 #ifdef HAVE_BERKELEY_DB2
 170         DB_INFO dbinfo;
 171
 172         memset( &dbinfo, 0, sizeof( dbinfo ));
 173
 174 #if defined( DB_VERSION_MAJOR ) && defined( DB_VERSION_MINOR ) && \
 175     DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR == 4
 176         /*
 177          * BerkeleyDB 2.4 do not allow db_cachesize
 178          * to be specified if an DB_ENV is.
 179          */
 180 #else
 181         /* set db_cachesize of MPOOL is NOT being used. */
 182         if (( ldbm_Env == NULL ) || ( ldbm_Env->mp_info == NULL ))
 183                 dbinfo.db_cachesize = dbcachesize;
 184 #endif
 185
 186         dbinfo.db_pagesize  = DEFAULT_DB_PAGE_SIZE;
 187         dbinfo.db_malloc    = ldbm_malloc;
 188
 189         LDBM_LOCK;
 190     (void) db_open( name, DB_TYPE, rw, mode, ldbm_Env, &dbinfo, &ret );
 191         LDBM_UNLOCK;
 192
 193 #else
 194         void            *info;
 195         BTREEINFO       binfo;
 196         HASHINFO        hinfo;
 197
 198         if ( DB_TYPE == DB_HASH ) {
 199                 memset( (char *) &hinfo, '\0', sizeof(hinfo) );
 200                 hinfo.cachesize = dbcachesize;
 201                 info = &hinfo;
 202         } else if ( DB_TYPE == DB_BTREE ) {
 203                 memset( (char *) &binfo, '\0', sizeof(binfo) );
 204                 binfo.cachesize = dbcachesize;
 205                 info = &binfo;
 206         } else {
 207                 info = NULL;
 208         }
 209
 210         LDBM_LOCK;
 211         ret = dbopen( name, rw, mode, DB_TYPE, info );
 212         LDBM_UNLOCK;
 213
 214 #endif
 215
 216         return( ret );
 217 }
 218
 219 void
 220 ldbm_close( LDBM ldbm )
 221 {
 222         LDBM_LOCK;
 223 #ifdef HAVE_BERKELEY_DB2
 224         (*ldbm->close)( ldbm, 0 );
 225 #else
 226         (*ldbm->close)( ldbm );
 227 #endif
 228         LDBM_UNLOCK;
 229 }
 230
 231 void
 232 ldbm_sync( LDBM ldbm )
 233 {
 234         LDBM_LOCK;
 235         (*ldbm->sync)( ldbm, 0 );
 236         LDBM_UNLOCK;
 237 }
 238
 239 Datum
 240 ldbm_fetch( LDBM ldbm, Datum key )
 241 {
 242         Datum   data;
 243         int     rc;
 244
 245         LDBM_LOCK;
 246
 247 #ifdef HAVE_BERKELEY_DB2
 248         ldbm_datum_init( data );
 249
 250         data.flags = DB_DBT_MALLOC;
 251
 252         if ( (rc = (*ldbm->get)( ldbm, NULL, &key, &data, 0 )) != 0 ) {
 253                 ldbm_datum_free( ldbm, data );
 254 #else
 255         if ( (rc = (*ldbm->get)( ldbm, &key, &data, 0 )) == 0 ) {
 256                 /* Berkeley DB 1.85 don't malloc the data for us */
 257                 /* duplicate it for to ensure reentrancy */
 258                 data = ldbm_datum_dup( ldbm, data );
 259         } else {
 260 #endif
 261                 data.dptr = NULL;
 262                 data.dsize = 0;
 263         }
 264
 265         LDBM_UNLOCK;
 266
 267         return( data );
 268 }
 269
 270 int
 271 ldbm_store( LDBM ldbm, Datum key, Datum data, int flags )
 272 {
 273         int     rc;
 274
 275         LDBM_LOCK;
 276
 277 #ifdef HAVE_BERKELEY_DB2
 278         rc = (*ldbm->put)( ldbm, NULL, &key, &data, flags & ~LDBM_SYNC );
 279         rc = (-1 ) * rc;
 280 #else
 281         rc = (*ldbm->put)( ldbm, &key, &data, flags & ~LDBM_SYNC );
 282 #endif
 283
 284         if ( flags & LDBM_SYNC )
 285                 (*ldbm->sync)( ldbm, 0 );
 286
 287         LDBM_UNLOCK;
 288
 289         return( rc );
 290 }
 291
 292 int
 293 ldbm_delete( LDBM ldbm, Datum key )
 294 {
 295         int     rc;
 296
 297         LDBM_LOCK;
 298
 299 #ifdef HAVE_BERKELEY_DB2
 300         rc = (*ldbm->del)( ldbm, NULL, &key, 0 );
 301         rc = (-1 ) * rc;
 302 #else
 303         rc = (*ldbm->del)( ldbm, &key, 0 );
 304 #endif
 305         (*ldbm->sync)( ldbm, 0 );
 306
 307         LDBM_UNLOCK;
 308
 309         return( rc );
 310 }
 311
 312 Datum
 313 #ifdef HAVE_BERKELEY_DB2
 314 ldbm_firstkey( LDBM ldbm, DBC **dbch )
 315 #else
 316 ldbm_firstkey( LDBM ldbm )
 317 #endif
 318 {
 319         Datum   key, data;
 320
 321 #ifdef HAVE_BERKELEY_DB2
 322         DBC  *dbci;
 323
 324         ldbm_datum_init( key );
 325         ldbm_datum_init( data );
 326
 327         key.flags = data.flags = DB_DBT_MALLOC;
 328
 329         LDBM_LOCK;
 330
 331         /* acquire a cursor for the DB */
 332
 333 #  if defined( DB_VERSION_MAJOR ) && defined( DB_VERSION_MINOR ) && \
 334     DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR < 6
 335
 336         if ( (*ldbm->cursor)( ldbm, NULL, &dbci ))
 337
 338 #  else
 339         if ( (*ldbm->cursor)( ldbm, NULL, &dbci, 0 ))
 340 #  endif
 341         {
 342                 key.dptr = NULL;
 343                 return( key );
 344         } else {
 345                 *dbch = dbci;
 346                 if ( (*dbci->c_get)( dbci, &key, &data, DB_NEXT ) == 0 ) {
 347                         ldbm_datum_free( ldbm, data );
 348                 }
 349         else {
 350 #else
 351         int     rc;
 352
 353         LDBM_LOCK;
 354
 355         if ( (rc = (*ldbm->seq)( ldbm, &key, &data, R_FIRST )) == 0 ) {
 356                 key = ldbm_datum_dup( ldbm, key );
 357         }
 358         else {
 359 #endif
 360                 key.dptr = NULL;
 361                 key.dsize = 0;
 362         }
 363
 364 #ifdef HAVE_BERKELEY_DB2
 365         }
 366 #endif
 367
 368         LDBM_UNLOCK;
 369
 370         return( key );
 371 }
 372
 373 Datum
 374 #ifdef HAVE_BERKELEY_DB2
 375 ldbm_nextkey( LDBM ldbm, Datum key, DBC *dbcp )
 376 #else
 377 ldbm_nextkey( LDBM ldbm, Datum key )
 378 #endif
 379 {
 380         Datum   data;
 381
 382 #ifdef HAVE_BERKELEY_DB2
 383         ldbm_datum_init( data );
 384
 385         ldbm_datum_free( ldbm, key );
 386         key.flags = data.flags = DB_DBT_MALLOC;
 387
 388         LDBM_LOCK;
 389
 390         if ( (*dbcp->c_get)( dbcp, &key, &data, DB_NEXT ) == 0 ) {
 391                 ldbm_datum_free( ldbm, data );
 392         }
 393         else {
 394 #else
 395         int     rc;
 396
 397         LDBM_LOCK;
 398
 399         if ( (rc = (*ldbm->seq)( ldbm, &key, &data, R_NEXT )) == 0 ) {
 400                 key = ldbm_datum_dup( ldbm, key );
 401         }
 402         else {
 403 #endif
 404                 key.dptr = NULL;
 405                 key.dsize = 0;
 406         }
 407
 408         LDBM_UNLOCK;
 409
 410         return( key );
 411 }
 412
 413 int
 414 ldbm_errno( LDBM ldbm )
 415 {
 416         return( errno );
 417 }
 418
 419 #elif defined( HAVE_GDBM )
 420
 421 #ifdef HAVE_ST_BLKSIZE
 422 #include <sys/stat.h>
 423 #endif
 424
 425 /*****************************************************************
 426  *                                                               *
 427  * use gdbm                                                      *
 428  *                                                               *
 429  *****************************************************************/
 430
 431 LDBM
 432 ldbm_open( char *name, int rw, int mode, int dbcachesize )
 433 {
 434         LDBM            db;
 435 #ifdef HAVE_ST_BLKSIZE
 436                 struct stat     st;
 437 #endif
 438
 439         LDBM_LOCK;
 440
 441         if ( (db =  gdbm_open( name, 0, rw | GDBM_FAST, mode, 0 )) == NULL ) {
 442                 LDBM_UNLOCK;
 443                 return( NULL );
 444         }
 445
 446 #ifdef HAVE_ST_BLKSIZE
 447         if ( dbcachesize > 0 && stat( name, &st ) == 0 ) {
 448                 dbcachesize = (dbcachesize / st.st_blksize);
 449                 gdbm_setopt( db, GDBM_CACHESIZE, &dbcachesize, sizeof(int) );
 450         }
 451 #else
 452         dbcachesize = (dbcachesize / 4096);
 453         gdbm_setopt( db, GDBM_CACHESIZE, &dbcachesize, sizeof(int) );
 454 #endif
 455
 456         LDBM_UNLOCK;
 457
 458         return( db );
 459 }
 460
 461 void
 462 ldbm_close( LDBM ldbm )
 463 {
 464         LDBM_LOCK;
 465         gdbm_close( ldbm );
 466         LDBM_UNLOCK;
 467 }
 468
 469 void
 470 ldbm_sync( LDBM ldbm )
 471 {
 472         LDBM_LOCK;
 473         gdbm_sync( ldbm );
 474         LDBM_UNLOCK;
 475 }
 476
 477 Datum
 478 ldbm_fetch( LDBM ldbm, Datum key )
 479 {
 480         Datum d;
 481
 482         LDBM_LOCK;
 483         d = gdbm_fetch( ldbm, key );
 484         LDBM_UNLOCK;
 485
 486         return d;
 487 }
 488
 489 int
 490 ldbm_store( LDBM ldbm, Datum key, Datum data, int flags )
 491 {
 492         int     rc;
 493
 494         LDBM_LOCK;
 495         rc = gdbm_store( ldbm, key, data, flags & ~LDBM_SYNC );
 496         if ( flags & LDBM_SYNC )
 497                 gdbm_sync( ldbm );
 498         LDBM_UNLOCK;
 499
 500         return( rc );
 501 }
 502
 503 int
 504 ldbm_delete( LDBM ldbm, Datum key )
 505 {
 506         int     rc;
 507
 508         LDBM_LOCK;
 509         rc = gdbm_delete( ldbm, key );
 510         gdbm_sync( ldbm );
 511         LDBM_UNLOCK;
 512
 513         return( rc );
 514 }
 515
 516 Datum
 517 ldbm_firstkey( LDBM ldbm )
 518 {
 519         Datum d;
 520
 521         LDBM_LOCK;
 522         d = gdbm_firstkey( ldbm );
 523         LDBM_UNLOCK;
 524
 525         return d;
 526 }
 527
 528 Datum
 529 ldbm_nextkey( LDBM ldbm, Datum key )
 530 {
 531         Datum d;
 532
 533         LDBM_LOCK;
 534         d = gdbm_nextkey( ldbm, key );
 535         LDBM_UNLOCK;
 536
 537         return d;
 538 }
 539
 540 int
 541 ldbm_errno( LDBM ldbm )
 542 {
 543         int err;
 544
 545         LDBM_LOCK;
 546         err = gdbm_errno;
 547         LDBM_UNLOCK;
 548
 549         return( err );
 550 }
 551
 552 #elif HAVE_MDBM
 553
 554 /* MMAPED DBM HASHING DATABASE */
 555
 556 #include <ac/string.h>
 557
 558 /* #define MDBM_DEBUG */
 559
 560 #ifdef MDBM_DEBUG
 561 #include <stdio.h>
 562 #endif
 563
 564 #define NO_NULL_KEY
 565 /* #define MDBM_CHAIN */
 566
 567 #ifdef MDBM_CHAIN
 568
 569 /* Use chaining */
 570
 571
 572 #define mdbm_store      mdbm_chain_store
 573 #define mdbm_fetch      mdbm_chain_fetch
 574 #define mdbm_delete     mdbm_chain_delete
 575 #define mdbm_first      mdbm_chain_first
 576 #define mdbm_next       mdbm_chain_next
 577
 578 #endif
 579
 580 #define MDBM_PG_SZ      (4*1024)
 581
 582 /*****************************************************************
 583  *                                                               *
 584  * use mdbm                                                      *
 585  *                                                               *
 586  *****************************************************************/
 587
 588 LDBM
 589 ldbm_open( char *name, int rw, int mode, int dbcachesize )
 590 {
 591         LDBM            db;
 592
 593 #ifdef MDBM_DEBUG
 594         fprintf( stdout,
 595                  "==>(mdbm)ldbm_open(name=%s,rw=%x,mode=%x,cachesize=%d)\n",
 596                  name ? name : "NULL", rw, mode, dbcachesize );
 597         fflush( stdout );
 598 #endif
 599
 600         LDBM_LOCK;      /* We need locking here, this is the only non-thread
 601                          * safe function we have.
 602                          */
 603
 604         if ( (db =  mdbm_open( name, rw, mode, MDBM_PG_SZ )) == NULL ) {
 605
 606                 LDBM_UNLOCK;
 607 #ifdef MDBM_DEBUG
 608                 fprintf( stdout, "<==(mdbm)ldbm_open(db=NULL)\n" );
 609                 fflush( stdout );
 610 #endif
 611                 return( NULL );
 612
 613         }
 614
 615 #ifdef MDBM_CHAIN
 616         (void)mdbm_set_chain(db);
 617 #endif
 618
 619         LDBM_UNLOCK;
 620
 621 #ifdef MDBM_DEBUG
 622         fprintf( stdout, "<==(mdbm)ldbm_open(db=%p)\n", db );
 623         fflush( stdout );
 624 #endif
 625
 626         return( db );
 627
 628 }/* LDBM ldbm_open() */
 629
 630
 631
 632
 633 void
 634 ldbm_close( LDBM ldbm )
 635 {
 636
 637         /* Open and close are not reentrant so we need to use locks here */
 638
 639 #ifdef MDBM_DEBUG
 640         fprintf( stdout,
 641                  "==>(mdbm)ldbm_close(db=%p)\n", ldbm );
 642         fflush( stdout );
 643 #endif
 644
 645         LDBM_LOCK;
 646         mdbm_close( ldbm );
 647         LDBM_UNLOCK;
 648
 649 #ifdef MDBM_DEBUG
 650         fprintf( stdout, "<==(mdbm)ldbm_close()\n" );
 651         fflush( stdout );
 652 #endif
 653
 654 }/* void ldbm_close() */
 655
 656
 657
 658
 659 void
 660 ldbm_sync( LDBM ldbm )
 661 {
 662
 663         /* XXX: Not sure if this is re-entrant need to check code, if so
 664          * you can leave LOCKS out.
 665          */
 666
 667         LDBM_LOCK;
 668         mdbm_sync( ldbm );
 669         LDBM_UNLOCK;
 670
 671 }/* void ldbm_sync() */
 672
 673
 674 #define MAX_MDBM_RETRY  5
 675
 676 Datum
 677 ldbm_fetch( LDBM ldbm, Datum key )
 678 {
 679         Datum   d;
 680         kvpair  k;
 681         int     retry = 0;
 682
 683         /* This hack is needed because MDBM does not take keys
 684          * which begin with NULL when working in the chaining
 685          * mode.
 686          */
 687
 688         /* LDBM_LOCK; */
 689
 690 #ifdef NO_NULL_KEY
 691         k.key.dsize = key.dsize + 1;
 692         k.key.dptr = malloc(k.key.dsize);
 693         *(k.key.dptr) = 'l';
 694         memcpy( (void *)(k.key.dptr + 1), key.dptr, key.dsize );
 695 #else
 696         k.key = key;
 697 #endif
 698
 699         k.val.dptr = NULL;
 700         k.val.dsize = 0;
 701
 702         do {
 703
 704                 d = mdbm_fetch( ldbm, k );
 705
 706                 if ( d.dsize > 0 ) {
 707
 708                         if ( k.val.dptr != NULL ) {
 709
 710                             free( k.val.dptr );
 711
 712                         }
 713
 714                         if ( (k.val.dptr = malloc( d.dsize )) != NULL ) {
 715
 716                                 k.val.dsize = d.dsize;
 717                                 d = mdbm_fetch( ldbm, k );
 718
 719                         } else {
 720
 721                                 d.dsize = 0;
 722                                 break;
 723
 724                         }
 725
 726                 }/* if ( d.dsize > 0 ) */
 727
 728         } while ((d.dsize > k.val.dsize) && (++retry < MAX_MDBM_RETRY));
 729
 730         /* LDBM_UNLOCK; */
 731
 732 #ifdef NO_NULL_KEY
 733         free(k.key.dptr);
 734 #endif
 735
 736         return d;
 737
 738 }/* Datum ldbm_fetch() */
 739
 740
 741
 742
 743 int
 744 ldbm_store( LDBM ldbm, Datum key, Datum data, int flags )
 745 {
 746         int     rc;
 747         Datum   int_key;        /* Internal key */
 748
 749 #ifdef MDBM_DEBUG
 750         fprintf( stdout,
 751                  "==>(mdbm)ldbm_store(db=%p, key(dptr=%p,sz=%d), data(dptr=%p,sz=%d), flags=%x)\n",
 752                  ldbm, key.dptr, key.dsize, data.dptr, data.dsize, flags );
 753         fflush( stdout );
 754 #endif
 755
 756         /* LDBM_LOCK; */
 757
 758 #ifdef NO_NULL_KEY
 759         int_key.dsize = key.dsize + 1;
 760         int_key.dptr = malloc( int_key.dsize );
 761         *(int_key.dptr) = 'l';  /* Must not be NULL !*/
 762         memcpy( (void *)(int_key.dptr + 1), key.dptr, key.dsize );
 763 #else
 764         int_key = key;
 765 #endif
 766
 767         rc = mdbm_store( ldbm, int_key, data, flags );
 768         if ( flags & LDBM_SYNC ) {
 769                 mdbm_sync( ldbm );
 770         }
 771
 772         /* LDBM_UNLOCK; */
 773
 774 #ifdef MDBM_DEBUG
 775         fprintf( stdout, "<==(mdbm)ldbm_store(rc=%d)\n", rc );
 776         fflush( stdout );
 777 #endif
 778
 779 #ifdef NO_NULL_KEY
 780         free(int_key.dptr);
 781 #endif
 782
 783         return( rc );
 784
 785 }/* int ldbm_store() */
 786
 787
 788
 789
 790 int
 791 ldbm_delete( LDBM ldbm, Datum key )
 792 {
 793         int     rc;
 794         Datum   int_key;
 795
 796         /* LDBM_LOCK; */
 797
 798 #ifdef NO_NULL_KEY
 799         int_key.dsize = key.dsize + 1;
 800         int_key.dptr = malloc(int_key.dsize);
 801         *(int_key.dptr) = 'l';
 802         memcpy( (void *)(int_key.dptr + 1), key.dptr, key.dsize );
 803 #else
 804         int_key = key;
 805 #endif
 806
 807         rc = mdbm_delete( ldbm, int_key );
 808
 809         /* LDBM_UNLOCK; */
 810 #ifdef NO_NULL_KEY
 811         free(int_key.dptr);
 812 #endif
 813
 814         return( rc );
 815
 816 }/* int ldbm_delete() */
 817
 818
 819
 820
 821 static Datum
 822 ldbm_get_next( LDBM ldbm, kvpair (*fptr)(MDBM *, kvpair) )
 823 {
 824
 825         kvpair  out;
 826         kvpair  in;
 827         Datum   ret;
 828         size_t  sz = MDBM_PAGE_SIZE(ldbm);
 829 #ifdef NO_NULL_KEY
 830         int     delta = 1;
 831 #else
 832         int     delta = 0;
 833 #endif
 834
 835         /* LDBM_LOCK; */
 836
 837         in.key.dsize = sz;      /* Assume first key in one pg */
 838         in.key.dptr = malloc(sz);
 839
 840         in.val.dptr = NULL;     /* Don't need data just key */
 841         in.val.dsize = 0;
 842
 843         ret.dptr = NULL;
 844         ret.dsize = NULL;
 845
 846         out = fptr( ldbm, in );
 847
 848         if (out.key.dsize > 0) {
 849
 850             ret.dsize = out.key.dsize - delta;
 851             if ((ret.dptr = (char *)malloc(ret.dsize)) == NULL) {
 852
 853                 ret.dsize = 0;
 854                 ret.dptr = NULL;
 855
 856             } else {
 857
 858                 memcpy(ret.dptr, (void *)(out.key.dptr + delta),
 859                        ret.dsize );
 860
 861             }
 862
 863         }
 864
 865         /* LDBM_UNLOCK; */
 866
 867         free(in.key.dptr);
 868
 869         return ret;
 870
 871 }/* static Datum ldbm_get_next() */
 872
 873
 874
 875
 876 Datum
 877 ldbm_firstkey( LDBM ldbm )
 878 {
 879
 880         return ldbm_get_next( ldbm, mdbm_first );
 881
 882 }/* Datum ldbm_firstkey() */
 883
 884
 885
 886
 887 Datum
 888 ldbm_nextkey( LDBM ldbm, Datum key )
 889 {
 890
 891         /* XXX:
 892          * don't know if this will affect the LDAP server opertaion
 893          * but mdbm cannot take and input key.
 894          */
 895
 896         return ldbm_get_next( ldbm, mdbm_next );
 897
 898 }/* Datum ldbm_nextkey() */
 899
 900 int
 901 ldbm_errno( LDBM ldbm )
 902 {
 903         /* XXX: best we can do with current  mdbm interface */
 904         return( errno );
 905
 906 }/* int ldbm_errno() */
 907
 908
 909
 910
 911 #elif defined( HAVE_NDBM )
 912
 913 /*****************************************************************
 914  *                                                               *
 915  * if no gdbm or mdbm, fall back to using ndbm, the standard unix thing  *
 916  *                                                               *
 917  *****************************************************************/
 918
 919 /* ARGSUSED */
 920 LDBM
 921 ldbm_open( char *name, int rw, int mode, int dbcachesize )
 922 {
 923         LDBM ldbm;
 924
 925         LDBM_LOCK;
 926         ldbm = dbm_open( name, rw, mode );
 927         LDBM_UNLOCK;
 928
 929         return( ldbm );
 930 }
 931
 932 void
 933 ldbm_close( LDBM ldbm )
 934 {
 935         LDBM_LOCK;
 936         dbm_close( ldbm );
 937         LDBM_UNLOCK;
 938 }
 939
 940 /* ARGSUSED */
 941 void
 942 ldbm_sync( LDBM ldbm )
 943 {
 944         return;
 945 }
 946
 947 Datum
 948 ldbm_fetch( LDBM ldbm, Datum key )
 949 {
 950         Datum d;
 951
 952         LDBM_LOCK;
 953         d = ldbm_datum_dup( ldbm, dbm_fetch( ldbm, key ) );
 954         LDBM_UNLOCK;
 955
 956         return d;
 957 }
 958
 959 int
 960 ldbm_store( LDBM ldbm, Datum key, Datum data, int flags )
 961 {
 962         int rc;
 963
 964         LDBM_LOCK;
 965         rc = dbm_store( ldbm, key, data, flags );
 966         LDBM_UNLOCK;
 967
 968         return rc;
 969 }
 970
 971 int
 972 ldbm_delete( LDBM ldbm, Datum key )
 973 {
 974         int rc;
 975
 976         LDBM_LOCK;
 977         rc = dbm_delete( ldbm, key );
 978         LDBM_UNLOCK;
 979
 980         return rc;
 981 }
 982
 983 Datum
 984 ldbm_firstkey( LDBM ldbm )
 985 {
 986         Datum d;
 987
 988         LDBM_LOCK;
 989         d = dbm_firstkey( ldbm );
 990         LDBM_UNLOCK;
 991
 992         return d;
 993 }
 994
 995 Datum
 996 ldbm_nextkey( LDBM ldbm, Datum key )
 997 {
 998         Datum d;
 999
1000         LDBM_LOCK;
1001         d = dbm_nextkey( ldbm );
1002         LDBM_UNLOCK;
1003
1004         return d;
1005 }
1006
1007 int
1008 ldbm_errno( LDBM ldbm )
1009 {
1010         int err;
1011
1012         LDBM_LOCK;
1013         err = dbm_error( ldbm );
1014         LDBM_UNLOCK;
1015
1016         return err;
1017 }
1018
1019 #endif /* ndbm */
1020 #endif /* ldbm */