1 /* ldbm.c - ldap dbm compatibility routines */
4 * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.
5 * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
8 /* Patched for Berkeley DB version 2.0; /KSp; 98/02/23
10 * - DB version 2.6.4b ; 1998/12/28, /KSp
11 * - DB_DBT_MALLOC ; 1998/03/22, /KSp
12 * - basic implementation; 1998/02/23, /KSp
21 #include <ac/stdlib.h>
22 #include <ac/string.h>
26 #include "ldap_pvt_thread.h"
29 ldbm_datum_free( LDBM ldbm, Datum data )
33 memset( &data, '\0', sizeof( Datum ));
40 ldbm_datum_dup( LDBM ldbm, Datum data )
44 ldbm_datum_init( dup );
46 if ( data.dsize == 0 ) {
52 dup.dsize = data.dsize;
53 if ( (dup.dptr = (char *) malloc( data.dsize )) != NULL )
54 AC_MEMCPY( dup.dptr, data.dptr, data.dsize );
59 static int ldbm_initialized = 0;
61 #ifdef HAVE_BERKELEY_DB_THREAD
62 #define LDBM_LOCK ((void)0)
63 #define LDBM_UNLOCK ((void)0)
66 /* Only DB2 or DB3 with DB_THREAD is thread-free */
67 static ldap_pvt_thread_mutex_t ldbm_big_mutex;
68 #define LDBM_LOCK (ldap_pvt_thread_mutex_lock(&ldbm_big_mutex))
69 #define LDBM_UNLOCK (ldap_pvt_thread_mutex_unlock(&ldbm_big_mutex))
75 /*******************************************************************
77 * Create some special functions to initialize Berkeley DB for *
78 * versions greater than 2. *
80 *******************************************************************/
81 #if defined( HAVE_BERKELEY_DB ) && (DB_VERSION_MAJOR >= 2)
85 ldbm_malloc( size_t size )
87 return( calloc( 1, size ));
91 #include <ac/syslog.h>
95 ldbm_db_errcall( const char *prefix, char *message )
98 syslog( LOG_INFO, "ldbm_db_errcall(): %s %s", prefix, message );
102 /* a dbEnv for BERKELEYv2 */
103 DB_ENV *ldbm_Env = NULL;
105 int ldbm_initialize( void )
110 if(ldbm_initialized++) return 1;
112 #if DB_VERSION_MAJOR < 3
113 ldbm_Env = calloc( 1, sizeof( DB_ENV ));
115 if( ldbm_Env == NULL ) return 1;
117 ldbm_Env->db_errcall = ldbm_db_errcall;
118 ldbm_Env->db_errpfx = "==>";
124 #if defined( HAVE_BERKELEY_DB_THREAD )
129 #if DB_VERSION_MAJOR >= 3
130 err = db_env_create( &ldbm_Env, 0 );
131 #elif DB_VERSION_MAJOR >= 2
132 err = db_appinit( NULL, NULL, ldbm_Env, envFlags );
138 sprintf( error, "%s (%d)\n", STRERROR( err ), err );
142 "ldbm_initialize(): FATAL error in db_appinit() : %s\n",
148 #if DB_VERSION_MAJOR >= 3
149 ldbm_Env->set_errcall( ldbm_Env, ldbm_db_errcall );
150 ldbm_Env->set_errpfx( ldbm_Env, "==>" );
152 envFlags |= DB_INIT_MPOOL;
153 err = ldbm_Env->open( ldbm_Env, NULL, NULL, envFlags, 0 );
158 sprintf( error, "%s (%d)\n", STRERROR( err ), err );
162 "ldbm_initialize(): FATAL error in db_appinit() : %s\n",
165 ldbm_Env->close( ldbm_Env, 0 );
173 int ldbm_shutdown( void )
175 if( !ldbm_initialized ) return 1;
177 #if DB_VERSION_MAJOR >= 3
178 ldbm_Env->close( ldbm_Env, 0 );
180 db_appexit( ldbm_Env );
186 #else /* some DB other than Berkeley V2 or greater */
188 int ldbm_initialize( void )
190 if(ldbm_initialized++) return 1;
192 ldap_pvt_thread_mutex_init( &ldbm_big_mutex );
197 int ldbm_shutdown( void )
199 if( !ldbm_initialized ) return 1;
201 ldap_pvt_thread_mutex_destroy( &ldbm_big_mutex );
206 #endif /* ifdef HAVE_BERKELEY_DB */
209 #if defined( LDBM_USE_DBHASH ) || defined( LDBM_USE_DBBTREE )
211 /*****************************************************************
213 * use berkeley db hash or btree package *
215 *****************************************************************/
218 ldbm_open( char *name, int rw, int mode, int dbcachesize )
222 #if DB_VERSION_MAJOR >= 3
225 err = db_create( &ret, ldbm_Env, 0 );
230 sprintf( error, "%s (%d)\n", STRERROR( err ), err );
232 (void)ret->close(ret, 0);
236 ret->set_pagesize( ret, DEFAULT_DB_PAGE_SIZE );
237 ret->set_malloc( ret, ldbm_malloc );
238 ret->set_cachesize( ret, 0, dbcachesize, 0 );
239 err = ret->open( ret, name, NULL, DB_TYPE, rw, mode);
245 sprintf( error, "%s (%d)\n", STRERROR( err ), err );
247 (void)ret->close(ret, 0);
251 #elif DB_VERSION_MAJOR >= 2
254 memset( &dbinfo, '\0', sizeof( dbinfo ));
256 #if defined( DB_VERSION_MAJOR ) && defined( DB_VERSION_MINOR ) && \
257 DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR == 4
259 * BerkeleyDB 2.4 do not allow db_cachesize
260 * to be specified if an DB_ENV is.
263 /* set db_cachesize of MPOOL is NOT being used. */
264 if (( ldbm_Env == NULL ) || ( ldbm_Env->mp_info == NULL ))
265 dbinfo.db_cachesize = dbcachesize;
268 dbinfo.db_pagesize = DEFAULT_DB_PAGE_SIZE;
269 dbinfo.db_malloc = ldbm_malloc;
272 (void) db_open( name, DB_TYPE, rw, mode, ldbm_Env, &dbinfo, &ret );
280 if ( DB_TYPE == DB_HASH ) {
281 memset( (char *) &hinfo, '\0', sizeof(hinfo) );
282 hinfo.cachesize = dbcachesize;
284 } else if ( DB_TYPE == DB_BTREE ) {
285 memset( (char *) &binfo, '\0', sizeof(binfo) );
286 binfo.cachesize = dbcachesize;
293 ret = dbopen( name, rw, mode, DB_TYPE, info );
302 ldbm_close( LDBM ldbm )
305 #if DB_VERSION_MAJOR >= 3
306 ldbm->close( ldbm, 0 );
307 #elif DB_VERSION_MAJOR >= 2
308 (*ldbm->close)( ldbm, 0 );
310 (*ldbm->close)( ldbm );
316 ldbm_sync( LDBM ldbm )
319 (*ldbm->sync)( ldbm, 0 );
324 ldbm_fetch( LDBM ldbm, Datum key )
330 #if DB_VERSION_MAJOR >= 3
331 ldbm_datum_init( data );
333 data.flags = DB_DBT_MALLOC;
335 if ( (rc = ldbm->get( ldbm, NULL, &key, &data, 0 )) != 0 ) {
336 ldbm_datum_free( ldbm, data );
338 #elif DB_VERSION_MAJOR >= 2
339 ldbm_datum_init( data );
341 data.flags = DB_DBT_MALLOC;
343 if ( (rc = (*ldbm->get)( ldbm, NULL, &key, &data, 0 )) != 0 ) {
344 ldbm_datum_free( ldbm, data );
346 if ( (rc = (*ldbm->get)( ldbm, &key, &data, 0 )) == 0 ) {
347 /* Berkeley DB 1.85 don't malloc the data for us */
348 /* duplicate it for to ensure reentrancy */
349 data = ldbm_datum_dup( ldbm, data );
362 ldbm_store( LDBM ldbm, Datum key, Datum data, int flags )
368 #if DB_VERSION_MAJOR >= 3
369 rc = ldbm->put( ldbm, NULL, &key, &data, flags & ~LDBM_SYNC );
374 sprintf( error, "%s (%d)\n", STRERROR( rc ), rc );
378 #elif DB_VERSION_MAJOR >= 2
379 rc = (*ldbm->put)( ldbm, NULL, &key, &data, flags & ~LDBM_SYNC );
382 rc = (*ldbm->put)( ldbm, &key, &data, flags & ~LDBM_SYNC );
385 if ( flags & LDBM_SYNC )
386 (*ldbm->sync)( ldbm, 0 );
394 ldbm_delete( LDBM ldbm, Datum key )
400 #if DB_VERSION_MAJOR >= 3
401 rc = ldbm->del( ldbm, NULL, &key, 0 );
403 #elif DB_VERSION_MAJOR >= 2
404 rc = (*ldbm->del)( ldbm, NULL, &key, 0 );
407 rc = (*ldbm->del)( ldbm, &key, 0 );
409 (*ldbm->sync)( ldbm, 0 );
417 ldbm_firstkey( LDBM ldbm, LDBMCursor **dbch )
421 #if DB_VERSION_MAJOR >= 2
424 ldbm_datum_init( key );
425 ldbm_datum_init( data );
427 key.flags = data.flags = DB_DBT_MALLOC;
431 /* acquire a cursor for the DB */
432 # if DB_VERSION_MAJOR >= 3
433 if ( ldbm->cursor( ldbm, NULL, &dbci, 0 ) )
434 # elif defined( DB_VERSION_MAJOR ) && defined( DB_VERSION_MINOR ) && \
435 (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR < 6)
437 if ( (*ldbm->cursor)( ldbm, NULL, &dbci ))
440 if ( (*ldbm->cursor)( ldbm, NULL, &dbci, 0 ))
447 if ( (*dbci->c_get)( dbci, &key, &data, DB_NEXT ) == 0 ) {
448 ldbm_datum_free( ldbm, data );
456 if ( (rc = (*ldbm->seq)( ldbm, &key, &data, R_FIRST )) == 0 ) {
457 key = ldbm_datum_dup( ldbm, key );
465 #if DB_VERSION_MAJOR >= 2
475 ldbm_nextkey( LDBM ldbm, Datum key, LDBMCursor *dbcp )
479 #if DB_VERSION_MAJOR >= 2
480 ldbm_datum_init( data );
482 ldbm_datum_free( ldbm, key );
483 key.flags = data.flags = DB_DBT_MALLOC;
487 if ( (*dbcp->c_get)( dbcp, &key, &data, DB_NEXT ) == 0 ) {
488 ldbm_datum_free( ldbm, data );
496 if ( (rc = (*ldbm->seq)( ldbm, &key, &data, R_NEXT )) == 0 ) {
497 key = ldbm_datum_dup( ldbm, key );
511 ldbm_errno( LDBM ldbm )
516 /******************************************************************
518 * END Berkeley section *
520 ******************************************************************/
522 #elif defined( HAVE_GDBM )
524 #ifdef HAVE_ST_BLKSIZE
525 #include <sys/stat.h>
528 /*****************************************************************
532 *****************************************************************/
535 ldbm_open( char *name, int rw, int mode, int dbcachesize )
538 #ifdef HAVE_ST_BLKSIZE
544 if ( (db = gdbm_open( name, 0, rw | GDBM_FAST, mode, 0 )) == NULL ) {
549 #ifdef HAVE_ST_BLKSIZE
550 if ( dbcachesize > 0 && stat( name, &st ) == 0 ) {
551 dbcachesize /= st.st_blksize;
552 if( dbcachesize == 0 ) dbcachesize = 1;
553 gdbm_setopt( db, GDBM_CACHESIZE, &dbcachesize, sizeof(int) );
556 if ( dbcachesize > 0 ) {
558 if( dbcachesize == 0 ) dbcachesize = 1;
559 gdbm_setopt( db, GDBM_CACHESIZE, &dbcachesize, sizeof(int) );
569 ldbm_close( LDBM ldbm )
577 ldbm_sync( LDBM ldbm )
585 ldbm_fetch( LDBM ldbm, Datum key )
590 d = gdbm_fetch( ldbm, key );
597 ldbm_store( LDBM ldbm, Datum key, Datum data, int flags )
602 rc = gdbm_store( ldbm, key, data, flags & ~LDBM_SYNC );
603 if ( flags & LDBM_SYNC )
611 ldbm_delete( LDBM ldbm, Datum key )
616 rc = gdbm_delete( ldbm, key );
624 ldbm_firstkey( LDBM ldbm, LDBMCursor **dbcp )
629 d = gdbm_firstkey( ldbm );
632 if ( d.dptr != NULL ) {
633 *dbcp = (Datum *) malloc( sizeof( Datum ) );
634 **dbcp = ldbm_datum_dup( ldbm, d );
641 ldbm_nextkey( LDBM ldbm, Datum key, LDBMCursor *dbcp )
646 d = gdbm_nextkey( ldbm, *dbcp );
649 ldbm_datum_free( ldbm, *dbcp );
651 if ( d.dptr != NULL ) {
652 *dbcp = ldbm_datum_dup( ldbm, d );
661 ldbm_errno( LDBM ldbm )
674 /* MMAPED DBM HASHING DATABASE */
676 #include <ac/string.h>
678 /* #define MDBM_DEBUG */
685 /* #define MDBM_CHAIN */
692 #define mdbm_store mdbm_chain_store
693 #define mdbm_fetch mdbm_chain_fetch
694 #define mdbm_delete mdbm_chain_delete
695 #define mdbm_first mdbm_chain_first
696 #define mdbm_next mdbm_chain_next
700 #define MDBM_PG_SZ (4*1024)
702 /*****************************************************************
706 *****************************************************************/
709 ldbm_open( char *name, int rw, int mode, int dbcachesize )
715 "==>(mdbm)ldbm_open(name=%s,rw=%x,mode=%x,cachesize=%d)\n",
716 name ? name : "NULL", rw, mode, dbcachesize );
720 LDBM_LOCK; /* We need locking here, this is the only non-thread
721 * safe function we have.
724 if ( (db = mdbm_open( name, rw, mode, MDBM_PG_SZ )) == NULL ) {
728 fprintf( stdout, "<==(mdbm)ldbm_open(db=NULL)\n" );
736 (void)mdbm_set_chain(db);
742 fprintf( stdout, "<==(mdbm)ldbm_open(db=%p)\n", db );
754 ldbm_close( LDBM ldbm )
757 /* Open and close are not reentrant so we need to use locks here */
761 "==>(mdbm)ldbm_close(db=%p)\n", ldbm );
770 fprintf( stdout, "<==(mdbm)ldbm_close()\n" );
780 ldbm_sync( LDBM ldbm )
783 /* XXX: Not sure if this is re-entrant need to check code, if so
784 * you can leave LOCKS out.
794 #define MAX_MDBM_RETRY 5
797 ldbm_fetch( LDBM ldbm, Datum key )
803 /* This hack is needed because MDBM does not take keys
804 * which begin with NULL when working in the chaining
811 k.key.dsize = key.dsize + 1;
812 k.key.dptr = malloc(k.key.dsize);
814 AC_MEMCPY( (void *)(k.key.dptr + 1), key.dptr, key.dsize );
824 d = mdbm_fetch( ldbm, k );
828 if ( k.val.dptr != NULL ) {
834 if ( (k.val.dptr = malloc( d.dsize )) != NULL ) {
836 k.val.dsize = d.dsize;
837 d = mdbm_fetch( ldbm, k );
846 }/* if ( d.dsize > 0 ) */
848 } while ((d.dsize > k.val.dsize) && (++retry < MAX_MDBM_RETRY));
864 ldbm_store( LDBM ldbm, Datum key, Datum data, int flags )
867 Datum int_key; /* Internal key */
871 "==>(mdbm)ldbm_store(db=%p, key(dptr=%p,sz=%d), data(dptr=%p,sz=%d), flags=%x)\n",
872 ldbm, key.dptr, key.dsize, data.dptr, data.dsize, flags );
879 int_key.dsize = key.dsize + 1;
880 int_key.dptr = malloc( int_key.dsize );
881 *(int_key.dptr) = 'l'; /* Must not be NULL !*/
882 AC_MEMCPY( (void *)(int_key.dptr + 1), key.dptr, key.dsize );
887 rc = mdbm_store( ldbm, int_key, data, flags );
888 if ( flags & LDBM_SYNC ) {
895 fprintf( stdout, "<==(mdbm)ldbm_store(rc=%d)\n", rc );
910 ldbm_delete( LDBM ldbm, Datum key )
918 int_key.dsize = key.dsize + 1;
919 int_key.dptr = malloc(int_key.dsize);
920 *(int_key.dptr) = 'l';
921 AC_MEMCPY( (void *)(int_key.dptr + 1), key.dptr, key.dsize );
926 rc = mdbm_delete( ldbm, int_key );
941 ldbm_get_next( LDBM ldbm, kvpair (*fptr)(MDBM *, kvpair) )
947 size_t sz = MDBM_PAGE_SIZE(ldbm);
956 in.key.dsize = sz; /* Assume first key in one pg */
957 in.key.dptr = malloc(sz);
959 in.val.dptr = NULL; /* Don't need data just key */
965 out = fptr( ldbm, in );
967 if (out.key.dsize > 0) {
969 ret.dsize = out.key.dsize - delta;
970 if ((ret.dptr = (char *)malloc(ret.dsize)) == NULL) {
977 AC_MEMCPY(ret.dptr, (void *)(out.key.dptr + delta),
996 ldbm_firstkey( LDBM ldbm, LDBMCursor **dbcp )
999 return ldbm_get_next( ldbm, mdbm_first );
1007 ldbm_nextkey( LDBM ldbm, Datum key, LDBMCursor *dbcp )
1011 * don't know if this will affect the LDAP server opertaion
1012 * but mdbm cannot take and input key.
1015 return ldbm_get_next( ldbm, mdbm_next );
1020 ldbm_errno( LDBM ldbm )
1022 /* XXX: best we can do with current mdbm interface */
1030 #elif defined( HAVE_NDBM )
1032 /*****************************************************************
1034 * if no gdbm or mdbm, fall back to using ndbm, the standard unix thing *
1036 *****************************************************************/
1040 ldbm_open( char *name, int rw, int mode, int dbcachesize )
1045 ldbm = dbm_open( name, rw, mode );
1052 ldbm_close( LDBM ldbm )
1061 ldbm_sync( LDBM ldbm )
1067 ldbm_fetch( LDBM ldbm, Datum key )
1072 d = ldbm_datum_dup( ldbm, dbm_fetch( ldbm, key ) );
1079 ldbm_store( LDBM ldbm, Datum key, Datum data, int flags )
1084 rc = dbm_store( ldbm, key, data, flags );
1091 ldbm_delete( LDBM ldbm, Datum key )
1096 rc = dbm_delete( ldbm, key );
1103 ldbm_firstkey( LDBM ldbm, LDBMCursor **dbcp )
1108 d = dbm_firstkey( ldbm );
1115 ldbm_nextkey( LDBM ldbm, Datum key, LDBMCursor *dbcp )
1120 d = dbm_nextkey( ldbm );
1127 ldbm_errno( LDBM ldbm )
1132 err = dbm_error( ldbm );