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;
54 if ( (dup.dptr = (char *) malloc( data.dsize )) != NULL ) {
55 AC_MEMCPY( dup.dptr, data.dptr, data.dsize );
61 static int ldbm_initialized = 0;
63 #ifdef HAVE_BERKELEY_DB_THREAD
64 #define LDBM_LOCK ((void) 0)
65 #define LDBM_UNLOCK ((void) 0)
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))
72 #if !defined( HAVE_BERKELEY_DB ) || (DB_VERSION_MAJOR < 3)
73 /* a dbEnv for BERKELEYv2 */
74 DB_ENV *ldbm_Env = NULL; /* real or fake, depending on db and version */
78 /*******************************************************************
80 * Create some special functions to initialize Berkeley DB for *
81 * versions greater than 2. *
83 *******************************************************************/
84 #if defined( HAVE_BERKELEY_DB ) && (DB_VERSION_MAJOR >= 2)
87 ldbm_malloc( size_t size )
89 /* likely should use ber_mem* routines */
90 return( calloc( 1, size ) );
94 #include <ac/syslog.h>
98 ldbm_db_errcall( const char *prefix, char *message )
101 syslog( LOG_INFO, "ldbm: %s %s", prefix, message );
105 #if DB_VERSION_MAJOR < 3
107 int ldbm_initialize( const char* home )
112 if(ldbm_initialized++) return 1;
116 int major, minor, patch;
117 version = db_version( &major, &minor, &patch );
119 if( major != DB_VERSION_MAJOR ||
120 minor < DB_VERSION_MINOR )
125 sprintf( error, "%s (%d)\n", STRERROR( err ), err );
128 "ldbm_initialize(): version mismatch\nexpected: %s\ngot: %s\n",
137 #ifndef HAVE_BERKELEY_DB_THREAD
138 ldap_pvt_thread_mutex_init( &ldbm_big_mutex );
141 ldbm_Env = calloc( 1, sizeof( DB_ENV ));
143 if( ldbm_Env == NULL ) return 1;
145 ldbm_Env->db_errcall = ldbm_db_errcall;
146 ldbm_Env->db_errpfx = "==>";
148 envFlags = DB_CREATE;
150 /* add optional flags */
152 envFlags |= DB_PRIVATE;
155 #ifdef HAVE_BERKELEY_DB_THREAD
156 envFlags |= DB_THREAD | DB_INIT_CDB | DB_INIT_MPOOL;
157 #ifdef DB_MPOOL_PRIVATE
158 envFlags |= DB_MPOOL_PRIVATE;
162 envFlags |= DB_USE_ENVIRON;
163 err = db_appinit( home, NULL, ldbm_Env, envFlags );
169 sprintf( error, "%s (%d)\n", STRERROR( err ), err );
172 "ldbm_initialize(): FATAL error in db_appinit() : %s\n",
181 int ldbm_shutdown( void )
183 if( !ldbm_initialized ) return 1;
185 db_appexit( ldbm_Env );
187 #ifndef HAVE_BERKELEY_DB_THREAD
188 ldap_pvt_thread_mutex_destroy( &ldbm_big_mutex );
194 #else /* Berkeley v3 or greater */
197 int ldbm_initialize( const char * home )
199 /* v3 uses ldbm_initialize_env */
204 int ldbm_shutdown( void )
214 #else /* some DB other than Berkeley V2 or greater */
216 int ldbm_initialize( const char * home )
218 if(ldbm_initialized++) return 1;
220 ldap_pvt_thread_mutex_init( &ldbm_big_mutex );
225 int ldbm_shutdown( void )
227 if( !ldbm_initialized ) return 1;
229 ldap_pvt_thread_mutex_destroy( &ldbm_big_mutex );
234 #endif /* HAVE_BERKELEY_DB */
237 #if defined( HAVE_BERKELEY_DB ) && (DB_VERSION_MAJOR >= 3)
240 DB_ENV *ldbm_initialize_env(const char *home, int dbcachesize, int *envdirok)
247 #if defined( DB_PRIVATE ) /* comment out DB_PRIVATE setting to use */
248 DB_PRIVATE | /* db_stat to view cache behavior */
250 #if defined( HAVE_BERKELEY_DB_THREAD )
255 err = db_env_create( &env, 0 );
260 sprintf( error, "%s (%d)\n", STRERROR( err ), err );
263 syslog( LOG_INFO, "ldbm_initialize_env(): FATAL error in db_env_create() : %s\n", error );
268 env->set_errcall( env, ldbm_db_errcall );
269 env->set_errpfx( env, "==>" );
271 env->set_cachesize( env, 0, dbcachesize, 0 );
273 envFlags |= DB_INIT_MPOOL | DB_INIT_CDB | DB_USE_ENVIRON;
275 err = env->open( env, home, envFlags, 0 );
281 sprintf( error, "%s (%d)\n", STRERROR( err ), err );
285 "ldbm_initialize_env(): FATAL error in dbEnv->open() : %s\n",
288 env->close( env, 0 );
296 void ldbm_shutdown_env(DB_ENV *env)
298 env->close( env, 0 );
304 DB_ENV *ldbm_initialize_env(const char *home, int dbcachesize, int *envdirok)
309 void ldbm_shutdown_env(DB_ENV *env)
317 #if defined( LDBM_USE_DBHASH ) || defined( LDBM_USE_DBBTREE )
319 /*****************************************************************
321 * use berkeley db hash or btree package *
323 *****************************************************************/
326 ldbm_open( DB_ENV *env, char *name, int rw, int mode, int dbcachesize )
330 #if DB_VERSION_MAJOR >= 3
335 err = db_create( &ret, env, 0 );
337 (void)ret->close(ret, 0);
343 ret->set_pagesize( ret, DEFAULT_DB_PAGE_SIZE );
345 /* likely should use ber_mem* routines */
346 #if DB_VERSION_MINOR >= 3
347 ret->set_alloc( ret, ldbm_malloc, NULL, NULL );
349 ret->set_malloc( ret, ldbm_malloc );
352 /* ret->set_cachesize( ret, 0, dbcachesize, 0 ); */
354 err = ret->open( ret, name, NULL, DB_TYPE, rw, mode);
358 (void)ret->close(ret, 0);
367 #elif DB_VERSION_MAJOR >= 2
370 memset( &dbinfo, '\0', sizeof( dbinfo ));
372 #if DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR == 4
374 * BerkeleyDB 2.4 do not allow db_cachesize
375 * to be specified if an DB_ENV is.
378 /* set db_cachesize of MPOOL is NOT being used. */
379 if (( ldbm_Env == NULL ) || ( ldbm_Env->mp_info == NULL )) {
380 dbinfo.db_cachesize = dbcachesize;
384 dbinfo.db_pagesize = DEFAULT_DB_PAGE_SIZE;
385 dbinfo.db_malloc = ldbm_malloc;
388 (void) db_open( name, DB_TYPE, rw, mode, ldbm_Env, &dbinfo, &ret );
396 if ( DB_TYPE == DB_HASH ) {
397 memset( (char *) &hinfo, '\0', sizeof(hinfo) );
398 hinfo.cachesize = dbcachesize;
400 } else if ( DB_TYPE == DB_BTREE ) {
401 memset( (char *) &binfo, '\0', sizeof(binfo) );
402 binfo.cachesize = dbcachesize;
409 ret = dbopen( name, rw, mode, DB_TYPE, info );
417 ldbm_close( LDBM ldbm )
420 #if DB_VERSION_MAJOR >= 3
421 ldbm->close( ldbm, 0 );
422 #elif DB_VERSION_MAJOR >= 2
423 (*ldbm->close)( ldbm, 0 );
425 (*ldbm->close)( ldbm );
431 ldbm_sync( LDBM ldbm )
434 (*ldbm->sync)( ldbm, 0 );
439 ldbm_fetch( LDBM ldbm, Datum key )
446 #if DB_VERSION_MAJOR >= 3
447 ldbm_datum_init( data );
449 data.flags = DB_DBT_MALLOC;
451 if ( (rc = ldbm->get( ldbm, NULL, &key, &data, 0 )) != 0 ) {
452 ldbm_datum_free( ldbm, data );
457 #elif DB_VERSION_MAJOR >= 2
458 ldbm_datum_init( data );
460 data.flags = DB_DBT_MALLOC;
462 if ( (rc = (*ldbm->get)( ldbm, NULL, &key, &data, 0 )) != 0 ) {
463 ldbm_datum_free( ldbm, data );
469 if ( (rc = (*ldbm->get)( ldbm, &key, &data, 0 )) == 0 ) {
470 /* Berkeley DB 1.85 don't malloc the data for us */
471 /* duplicate it for to ensure reentrancy */
472 data = ldbm_datum_dup( ldbm, data );
485 ldbm_store( LDBM ldbm, Datum key, Datum data, int flags )
491 #if DB_VERSION_MAJOR >= 3
492 rc = ldbm->put( ldbm, NULL, &key, &data, flags & ~LDBM_SYNC );
495 #elif DB_VERSION_MAJOR >= 2
496 rc = (*ldbm->put)( ldbm, NULL, &key, &data, flags & ~LDBM_SYNC );
499 rc = (*ldbm->put)( ldbm, &key, &data, flags & ~LDBM_SYNC );
502 if ( flags & LDBM_SYNC )
503 (*ldbm->sync)( ldbm, 0 );
511 ldbm_delete( LDBM ldbm, Datum key )
517 #if DB_VERSION_MAJOR >= 3
518 rc = ldbm->del( ldbm, NULL, &key, 0 );
520 #elif DB_VERSION_MAJOR >= 2
521 rc = (*ldbm->del)( ldbm, NULL, &key, 0 );
524 rc = (*ldbm->del)( ldbm, &key, 0 );
526 (*ldbm->sync)( ldbm, 0 );
534 ldbm_firstkey( LDBM ldbm, LDBMCursor **dbch )
538 #if DB_VERSION_MAJOR >= 2
541 ldbm_datum_init( key );
542 ldbm_datum_init( data );
544 key.flags = data.flags = DB_DBT_MALLOC;
548 /* acquire a cursor for the DB */
549 # if DB_VERSION_MAJOR >= 3
550 if ( ldbm->cursor( ldbm, NULL, &dbci, 0 ) )
551 # elif defined( DB_VERSION_MAJOR ) && defined( DB_VERSION_MINOR ) && \
552 (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR < 6)
554 if ( (*ldbm->cursor)( ldbm, NULL, &dbci ))
557 if ( (*ldbm->cursor)( ldbm, NULL, &dbci, 0 ))
564 if ( (*dbci->c_get)( dbci, &key, &data, DB_NEXT ) == 0 ) {
565 ldbm_datum_free( ldbm, data );
573 if ( (rc = (*ldbm->seq)( ldbm, &key, &data, R_FIRST )) == 0 ) {
574 key = ldbm_datum_dup( ldbm, key );
582 #if DB_VERSION_MAJOR >= 2
592 ldbm_nextkey( LDBM ldbm, Datum key, LDBMCursor *dbcp )
596 #if DB_VERSION_MAJOR >= 2
597 ldbm_datum_init( data );
599 ldbm_datum_free( ldbm, key );
600 key.flags = data.flags = DB_DBT_MALLOC;
604 if ( (*dbcp->c_get)( dbcp, &key, &data, DB_NEXT ) == 0 ) {
605 ldbm_datum_free( ldbm, data );
613 if ( (rc = (*ldbm->seq)( ldbm, &key, &data, R_NEXT )) == 0 ) {
614 key = ldbm_datum_dup( ldbm, key );
628 ldbm_errno( LDBM ldbm )
633 /******************************************************************
635 * END Berkeley section *
637 ******************************************************************/
639 #elif defined( HAVE_GDBM )
641 #ifdef HAVE_ST_BLKSIZE
642 #include <sys/stat.h>
645 /*****************************************************************
649 *****************************************************************/
652 ldbm_open( DB_ENV *env, char *name, int rw, int mode, int dbcachesize )
655 #ifdef HAVE_ST_BLKSIZE
661 if ( (db = gdbm_open( name, 0, rw | GDBM_FAST, mode, 0 )) == NULL ) {
666 #ifdef HAVE_ST_BLKSIZE
667 if ( dbcachesize > 0 && stat( name, &st ) == 0 ) {
668 dbcachesize /= st.st_blksize;
669 if( dbcachesize == 0 ) dbcachesize = 1;
670 gdbm_setopt( db, GDBM_CACHESIZE, &dbcachesize, sizeof(int) );
673 if ( dbcachesize > 0 ) {
675 if( dbcachesize == 0 ) dbcachesize = 1;
676 gdbm_setopt( db, GDBM_CACHESIZE, &dbcachesize, sizeof(int) );
686 ldbm_close( LDBM ldbm )
694 ldbm_sync( LDBM ldbm )
702 ldbm_fetch( LDBM ldbm, Datum key )
707 d = gdbm_fetch( ldbm, key );
714 ldbm_store( LDBM ldbm, Datum key, Datum data, int flags )
719 rc = gdbm_store( ldbm, key, data, flags & ~LDBM_SYNC );
720 if ( flags & LDBM_SYNC )
728 ldbm_delete( LDBM ldbm, Datum key )
733 rc = gdbm_delete( ldbm, key );
741 ldbm_firstkey( LDBM ldbm, LDBMCursor **dbcp )
746 d = gdbm_firstkey( ldbm );
749 if ( d.dptr != NULL ) {
750 *dbcp = (Datum *) malloc( sizeof( Datum ) );
751 **dbcp = ldbm_datum_dup( ldbm, d );
758 ldbm_nextkey( LDBM ldbm, Datum key, LDBMCursor *dbcp )
763 d = gdbm_nextkey( ldbm, *dbcp );
766 ldbm_datum_free( ldbm, *dbcp );
768 if ( d.dptr != NULL ) {
769 *dbcp = ldbm_datum_dup( ldbm, d );
778 ldbm_errno( LDBM ldbm )
791 /* MMAPED DBM HASHING DATABASE */
793 #include <ac/string.h>
795 /* #define MDBM_DEBUG */
802 /* #define MDBM_CHAIN */
809 #define mdbm_store mdbm_chain_store
810 #define mdbm_fetch mdbm_chain_fetch
811 #define mdbm_delete mdbm_chain_delete
812 #define mdbm_first mdbm_chain_first
813 #define mdbm_next mdbm_chain_next
817 #define MDBM_PG_SZ (4*1024)
819 /*****************************************************************
823 *****************************************************************/
826 ldbm_open( DB_ENV *env, char *name, int rw, int mode, int dbcachesize )
832 "==>(mdbm)ldbm_open(name=%s,rw=%x,mode=%x,cachesize=%d)\n",
833 name ? name : "NULL", rw, mode, dbcachesize );
837 LDBM_LOCK; /* We need locking here, this is the only non-thread
838 * safe function we have.
841 if ( (db = mdbm_open( name, rw, mode, MDBM_PG_SZ )) == NULL ) {
845 fprintf( stdout, "<==(mdbm)ldbm_open(db=NULL)\n" );
853 (void)mdbm_set_chain(db);
859 fprintf( stdout, "<==(mdbm)ldbm_open(db=%p)\n", db );
871 ldbm_close( LDBM ldbm )
874 /* Open and close are not reentrant so we need to use locks here */
878 "==>(mdbm)ldbm_close(db=%p)\n", ldbm );
887 fprintf( stdout, "<==(mdbm)ldbm_close()\n" );
897 ldbm_sync( LDBM ldbm )
899 /* XXX: Not sure if this is re-entrant need to check code, if so
900 * you can leave LOCKS out.
909 #define MAX_MDBM_RETRY 5
912 ldbm_fetch( LDBM ldbm, Datum key )
918 /* This hack is needed because MDBM does not take keys
919 * which begin with NULL when working in the chaining
926 k.key.dsize = key.dsize + 1;
927 k.key.dptr = malloc(k.key.dsize);
929 AC_MEMCPY( (void *)(k.key.dptr + 1), key.dptr, key.dsize );
939 d = mdbm_fetch( ldbm, k );
943 if ( k.val.dptr != NULL ) {
947 if ( (k.val.dptr = malloc( d.dsize )) != NULL ) {
949 k.val.dsize = d.dsize;
950 d = mdbm_fetch( ldbm, k );
959 }/* if ( d.dsize > 0 ) */
961 } while ((d.dsize > k.val.dsize) && (++retry < MAX_MDBM_RETRY));
977 ldbm_store( LDBM ldbm, Datum key, Datum data, int flags )
980 Datum int_key; /* Internal key */
984 "==>(mdbm)ldbm_store(db=%p, key(dptr=%p,sz=%d), data(dptr=%p,sz=%d), flags=%x)\n",
985 ldbm, key.dptr, key.dsize, data.dptr, data.dsize, flags );
992 int_key.dsize = key.dsize + 1;
993 int_key.dptr = malloc( int_key.dsize );
994 *(int_key.dptr) = 'l'; /* Must not be NULL !*/
995 AC_MEMCPY( (void *)(int_key.dptr + 1), key.dptr, key.dsize );
1000 rc = mdbm_store( ldbm, int_key, data, flags );
1001 if ( flags & LDBM_SYNC ) {
1008 fprintf( stdout, "<==(mdbm)ldbm_store(rc=%d)\n", rc );
1023 ldbm_delete( LDBM ldbm, Datum key )
1031 int_key.dsize = key.dsize + 1;
1032 int_key.dptr = malloc(int_key.dsize);
1033 *(int_key.dptr) = 'l';
1034 AC_MEMCPY( (void *)(int_key.dptr + 1), key.dptr, key.dsize );
1039 rc = mdbm_delete( ldbm, int_key );
1053 ldbm_get_next( LDBM ldbm, kvpair (*fptr)(MDBM *, kvpair) )
1058 size_t sz = MDBM_PAGE_SIZE(ldbm);
1067 in.key.dsize = sz; /* Assume first key in one pg */
1068 in.key.dptr = malloc(sz);
1070 in.val.dptr = NULL; /* Don't need data just key */
1076 out = fptr( ldbm, in );
1078 if (out.key.dsize > 0) {
1079 ret.dsize = out.key.dsize - delta;
1081 if ((ret.dptr = (char *)malloc(ret.dsize)) == NULL) {
1086 AC_MEMCPY(ret.dptr, (void *)(out.key.dptr + delta),
1098 ldbm_firstkey( LDBM ldbm, LDBMCursor **dbcp )
1100 return ldbm_get_next( ldbm, mdbm_first );
1104 ldbm_nextkey( LDBM ldbm, Datum key, LDBMCursor *dbcp )
1107 * don't know if this will affect the LDAP server operation
1108 * but mdbm cannot take and input key.
1111 return ldbm_get_next( ldbm, mdbm_next );
1115 ldbm_errno( LDBM ldbm )
1117 /* XXX: best we can do with current mdbm interface */
1124 #elif defined( HAVE_NDBM )
1126 /*****************************************************************
1128 * if no gdbm or mdbm, fall back to using ndbm, the standard unix thing *
1130 *****************************************************************/
1134 ldbm_open( DB_ENV *env, char *name, int rw, int mode, int dbcachesize )
1139 ldbm = dbm_open( name, rw, mode );
1146 ldbm_close( LDBM ldbm )
1155 ldbm_sync( LDBM ldbm )
1161 ldbm_fetch( LDBM ldbm, Datum key )
1166 d = ldbm_datum_dup( ldbm, dbm_fetch( ldbm, key ) );
1173 ldbm_store( LDBM ldbm, Datum key, Datum data, int flags )
1178 rc = dbm_store( ldbm, key, data, flags );
1185 ldbm_delete( LDBM ldbm, Datum key )
1190 rc = dbm_delete( ldbm, key );
1197 ldbm_firstkey( LDBM ldbm, LDBMCursor **dbcp )
1202 d = dbm_firstkey( ldbm );
1209 ldbm_nextkey( LDBM ldbm, Datum key, LDBMCursor *dbcp )
1214 d = dbm_nextkey( ldbm );
1221 ldbm_errno( LDBM ldbm )
1226 err = dbm_error( ldbm );