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/alloca.h>
 557 #include <ac/string.h>
 558
 559 /* #define MDBM_DEBUG */
 560
 561 #ifdef MDBM_DEBUG
 562 #include <stdio.h>
 563 #endif
 564
 565 #define NO_NULL_KEY
 566 /* #define MDBM_CHAIN */
 567
 568 #ifdef MDBM_CHAIN
 569
 570 /* Use chaining */
 571
 572
 573 #define mdbm_store      mdbm_chain_store
 574 #define mdbm_fetch      mdbm_chain_fetch
 575 #define mdbm_delete     mdbm_chain_delete
 576 #define mdbm_first      mdbm_chain_first
 577 #define mdbm_next       mdbm_chain_next
 578
 579 #endif
 580
 581 #define MDBM_PG_SZ      (4*1024)
 582
 583 /*****************************************************************
 584  *                                                               *
 585  * use mdbm                                                      *
 586  *                                                               *
 587  *****************************************************************/
 588
 589 LDBM
 590 ldbm_open( char *name, int rw, int mode, int dbcachesize )
 591 {
 592         LDBM            db;
 593
 594 #ifdef MDBM_DEBUG
 595         fprintf( stdout,
 596                  "==>(mdbm)ldbm_open(name=%s,rw=%x,mode=%x,cachesize=%d)\n",
 597                  name ? name : "NULL", rw, mode, dbcachesize );
 598         fflush( stdout );
 599 #endif
 600
 601         LDBM_LOCK;      /* We need locking here, this is the only non-thread
 602                          * safe function we have.
 603                          */
 604
 605         if ( (db =  mdbm_open( name, rw, mode, MDBM_PG_SZ )) == NULL ) {
 606
 607                 LDBM_UNLOCK;
 608 #ifdef MDBM_DEBUG
 609                 fprintf( stdout, "<==(mdbm)ldbm_open(db=NULL)\n" );
 610                 fflush( stdout );
 611 #endif
 612                 return( NULL );
 613
 614         }
 615
 616 #ifdef MDBM_CHAIN
 617         (void)mdbm_set_chain(db);
 618 #endif
 619
 620         LDBM_UNLOCK;
 621
 622 #ifdef MDBM_DEBUG
 623         fprintf( stdout, "<==(mdbm)ldbm_open(db=%p)\n", db );
 624         fflush( stdout );
 625 #endif
 626
 627         return( db );
 628
 629 }/* LDBM ldbm_open() */
 630
 631
 632
 633
 634 void
 635 ldbm_close( LDBM ldbm )
 636 {
 637
 638         /* Open and close are not reentrant so we need to use locks here */
 639
 640 #ifdef MDBM_DEBUG
 641         fprintf( stdout,
 642                  "==>(mdbm)ldbm_close(db=%p)\n", ldbm );
 643         fflush( stdout );
 644 #endif
 645
 646         LDBM_LOCK;
 647         mdbm_close( ldbm );
 648         LDBM_UNLOCK;
 649
 650 #ifdef MDBM_DEBUG
 651         fprintf( stdout, "<==(mdbm)ldbm_close()\n" );
 652         fflush( stdout );
 653 #endif
 654
 655 }/* void ldbm_close() */
 656
 657
 658
 659
 660 void
 661 ldbm_sync( LDBM ldbm )
 662 {
 663
 664         /* XXX: Not sure if this is re-entrant need to check code, if so
 665          * you can leave LOCKS out.
 666          */
 667
 668         LDBM_LOCK;
 669         mdbm_sync( ldbm );
 670         LDBM_UNLOCK;
 671
 672 }/* void ldbm_sync() */
 673
 674
 675 #define MAX_MDBM_RETRY  5
 676
 677 Datum
 678 ldbm_fetch( LDBM ldbm, Datum key )
 679 {
 680         Datum   d;
 681         kvpair  k;
 682         int     retry = 0;
 683
 684         /* This hack is needed because MDBM does not take keys
 685          * which begin with NULL when working in the chaining
 686          * mode.
 687          */
 688
 689         /* LDBM_LOCK; */
 690
 691 #ifdef NO_NULL_KEY
 692         k.key.dsize = key.dsize + 1;
 693         k.key.dptr = alloca(k.key.dsize);
 694         *(k.key.dptr) = 'l';
 695         memcpy( (void *)(k.key.dptr + 1), key.dptr, key.dsize );
 696 #else
 697         k.key = key;
 698 #endif
 699
 700         k.val.dptr = NULL;
 701         k.val.dsize = 0;
 702
 703         do {
 704
 705                 d = mdbm_fetch( ldbm, k );
 706
 707                 if ( d.dsize > 0 ) {
 708
 709                         if ( k.val.dptr != NULL ) {
 710
 711                             free( k.val.dptr );
 712
 713                         }
 714
 715                         if ( (k.val.dptr = malloc( d.dsize )) != NULL ) {
 716
 717                                 k.val.dsize = d.dsize;
 718                                 d = mdbm_fetch( ldbm, k );
 719
 720                         } else {
 721
 722                                 d.dsize = 0;
 723                                 break;
 724
 725                         }
 726
 727                 }/* if ( d.dsize > 0 ) */
 728
 729         } while ((d.dsize > k.val.dsize) && (++retry < MAX_MDBM_RETRY));
 730
 731         /* LDBM_UNLOCK; */
 732
 733         return d;
 734
 735 }/* Datum ldbm_fetch() */
 736
 737
 738
 739
 740 int
 741 ldbm_store( LDBM ldbm, Datum key, Datum data, int flags )
 742 {
 743         int     rc;
 744         Datum   int_key;        /* Internal key */
 745
 746 #ifdef MDBM_DEBUG
 747         fprintf( stdout,
 748                  "==>(mdbm)ldbm_store(db=%p, key(dptr=%p,sz=%d), data(dptr=%p,sz=%d), flags=%x)\n",
 749                  ldbm, key.dptr, key.dsize, data.dptr, data.dsize, flags );
 750         fflush( stdout );
 751 #endif
 752
 753         /* LDBM_LOCK; */
 754
 755 #ifdef NO_NULL_KEY
 756         int_key.dsize = key.dsize + 1;
 757         int_key.dptr = alloca( int_key.dsize );
 758         *(int_key.dptr) = 'l';  /* Must not be NULL !*/
 759         memcpy( (void *)(int_key.dptr + 1), key.dptr, key.dsize );
 760 #else
 761         int_key = key;
 762 #endif
 763
 764         rc = mdbm_store( ldbm, int_key, data, flags );
 765         if ( flags & LDBM_SYNC ) {
 766                 mdbm_sync( ldbm );
 767         }
 768
 769         /* LDBM_UNLOCK; */
 770
 771 #ifdef MDBM_DEBUG
 772         fprintf( stdout, "<==(mdbm)ldbm_store(rc=%d)\n", rc );
 773         fflush( stdout );
 774 #endif
 775
 776         return( rc );
 777
 778 }/* int ldbm_store() */
 779
 780
 781
 782
 783 int
 784 ldbm_delete( LDBM ldbm, Datum key )
 785 {
 786         int     rc;
 787         Datum   int_key;
 788
 789         /* LDBM_LOCK; */
 790
 791 #ifdef NO_NULL_KEY
 792         int_key.dsize = key.dsize + 1;
 793         int_key.dptr = alloca(int_key.dsize);
 794         *(int_key.dptr) = 'l';
 795         memcpy( (void *)(int_key.dptr + 1), key.dptr, key.dsize );
 796 #else
 797         int_key = key;
 798 #endif
 799
 800         rc = mdbm_delete( ldbm, int_key );
 801
 802         /* LDBM_UNLOCK; */
 803
 804         return( rc );
 805
 806 }/* int ldbm_delete() */
 807
 808
 809
 810
 811 static Datum
 812 ldbm_get_next( LDBM ldbm, kvpair (*fptr)(MDBM *, kvpair) )
 813 {
 814
 815         kvpair  out;
 816         kvpair  in;
 817         Datum   ret;
 818         size_t  sz = MDBM_PAGE_SIZE(ldbm);
 819 #ifdef NO_NULL_KEY
 820         int     delta = 1;
 821 #else
 822         int     delta = 0;
 823 #endif
 824
 825         /* LDBM_LOCK; */
 826
 827         in.key.dsize = sz;      /* Assume first key in one pg */
 828         in.key.dptr = alloca(sz);
 829
 830         in.val.dptr = NULL;     /* Don't need data just key */
 831         in.val.dsize = 0;
 832
 833         ret.dptr = NULL;
 834         ret.dsize = NULL;
 835
 836         out = fptr( ldbm, in );
 837
 838         if (out.key.dsize > 0) {
 839
 840             ret.dsize = out.key.dsize - delta;
 841             if ((ret.dptr = (char *)malloc(ret.dsize)) == NULL) {
 842
 843                 ret.dsize = 0;
 844                 ret.dptr = NULL;
 845
 846             } else {
 847
 848                 memcpy(ret.dptr, (void *)(out.key.dptr + delta),
 849                        ret.dsize );
 850
 851             }
 852
 853         }
 854
 855         /* LDBM_UNLOCK; */
 856
 857         return ret;
 858
 859 }/* static Datum ldbm_get_next() */
 860
 861
 862
 863
 864 Datum
 865 ldbm_firstkey( LDBM ldbm )
 866 {
 867
 868         return ldbm_get_next( ldbm, mdbm_first );
 869
 870 }/* Datum ldbm_firstkey() */
 871
 872
 873
 874
 875 Datum
 876 ldbm_nextkey( LDBM ldbm, Datum key )
 877 {
 878
 879         /* XXX:
 880          * don't know if this will affect the LDAP server opertaion
 881          * but mdbm cannot take and input key.
 882          */
 883
 884         return ldbm_get_next( ldbm, mdbm_next );
 885
 886 }/* Datum ldbm_nextkey() */
 887
 888 int
 889 ldbm_errno( LDBM ldbm )
 890 {
 891         /* XXX: best we can do with current  mdbm interface */
 892         return( errno );
 893
 894 }/* int ldbm_errno() */
 895
 896
 897
 898
 899 #elif defined( HAVE_NDBM )
 900
 901 /*****************************************************************
 902  *                                                               *
 903  * if no gdbm or mdbm, fall back to using ndbm, the standard unix thing  *
 904  *                                                               *
 905  *****************************************************************/
 906
 907 /* ARGSUSED */
 908 LDBM
 909 ldbm_open( char *name, int rw, int mode, int dbcachesize )
 910 {
 911         LDBM ldbm;
 912
 913         LDBM_LOCK;
 914         ldbm = dbm_open( name, rw, mode );
 915         LDBM_UNLOCK;
 916
 917         return( ldbm );
 918 }
 919
 920 void
 921 ldbm_close( LDBM ldbm )
 922 {
 923         LDBM_LOCK;
 924         dbm_close( ldbm );
 925         LDBM_UNLOCK;
 926 }
 927
 928 /* ARGSUSED */
 929 void
 930 ldbm_sync( LDBM ldbm )
 931 {
 932         return;
 933 }
 934
 935 Datum
 936 ldbm_fetch( LDBM ldbm, Datum key )
 937 {
 938         Datum d;
 939
 940         LDBM_LOCK;
 941         d = ldbm_datum_dup( ldbm, dbm_fetch( ldbm, key ) );
 942         LDBM_UNLOCK;
 943
 944         return d;
 945 }
 946
 947 int
 948 ldbm_store( LDBM ldbm, Datum key, Datum data, int flags )
 949 {
 950         int rc;
 951
 952         LDBM_LOCK;
 953         rc = dbm_store( ldbm, key, data, flags );
 954         LDBM_UNLOCK;
 955
 956         return rc;
 957 }
 958
 959 int
 960 ldbm_delete( LDBM ldbm, Datum key )
 961 {
 962         int rc;
 963
 964         LDBM_LOCK;
 965         rc = dbm_delete( ldbm, key );
 966         LDBM_UNLOCK;
 967
 968         return rc;
 969 }
 970
 971 Datum
 972 ldbm_firstkey( LDBM ldbm )
 973 {
 974         Datum d;
 975
 976         LDBM_LOCK;
 977         d = dbm_firstkey( ldbm );
 978         LDBM_UNLOCK;
 979
 980         return d;
 981 }
 982
 983 Datum
 984 ldbm_nextkey( LDBM ldbm, Datum key )
 985 {
 986         Datum d;
 987
 988         LDBM_LOCK;
 989         d = dbm_nextkey( ldbm );
 990         LDBM_UNLOCK;
 991
 992         return d;
 993 }
 994
 995 int
 996 ldbm_errno( LDBM ldbm )
 997 {
 998         int err;
 999
1000         LDBM_LOCK;
1001         err = dbm_error( ldbm );
1002         LDBM_UNLOCK;
1003
1004         return err;
1005 }
1006
1007 #endif /* ndbm */
1008 #endif /* ldbm */