1 /* ldbm.c - ldap dbm compatibility routines */
3 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
5 * Copyright 1998-2005 The OpenLDAP Foundation.
6 * Portions Copyright 1998-2003 Kurt D. Zeilenga.
7 * Portions Copyright 1998-2001 Net Boolean Incorporated.
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted only as authorized by the OpenLDAP
14 * A copy of this license is available in the file LICENSE in the
15 * top-level directory of the distribution or, alternatively, at
16 * <http://www.OpenLDAP.org/license.html>.
19 * This work was originally developed by the University of Michigan
20 * (as part of U-MICH LDAP). Additional significant contributors
37 #include <ac/stdlib.h>
38 #include <ac/string.h>
42 #include "ldap_pvt_thread.h"
45 ldbm_datum_free( LDBM ldbm, Datum data )
49 memset( &data, '\0', sizeof( Datum ));
55 ldbm_datum_dup( LDBM ldbm, Datum data )
59 ldbm_datum_init( dup );
61 if ( data.dsize == 0 ) {
67 dup.dsize = data.dsize;
69 if ( (dup.dptr = (char *) malloc( data.dsize )) != NULL ) {
70 AC_MEMCPY( dup.dptr, data.dptr, data.dsize );
76 static int ldbm_initialized = 0;
78 #if defined( USE_BERKELEY_CDB )
79 /* not currently supported */
80 #define LDBM_RWLOCK_INIT ((void) 0)
81 #define LDBM_RWLOCK_DESTROY ((void) 0)
82 #define LDBM_WLOCK ((void) 0)
83 #define LDBM_WUNLOCK ((void) 0)
84 #define LDBM_RLOCK ((void) 0)
85 #define LDBM_RUNLOCK ((void) 0)
87 #elif defined( HAVE_BERKELEY_DB_THREAD )
88 static ldap_pvt_thread_rdwr_t ldbm_big_rdwr;
89 #define LDBM_RWLOCK_INIT (ldap_pvt_thread_rdwr_init( &ldbm_big_rdwr ))
90 #define LDBM_RWLOCK_DESTROY (ldap_pvt_thread_rdwr_destroy( &ldbm_big_rdwr ))
91 #define LDBM_WLOCK (ldap_pvt_thread_rdwr_wlock(&ldbm_big_rdwr))
92 #define LDBM_WUNLOCK (ldap_pvt_thread_rdwr_wunlock(&ldbm_big_rdwr))
93 #define LDBM_RLOCK (ldap_pvt_thread_rdwr_rlock(&ldbm_big_rdwr))
94 #define LDBM_RUNLOCK (ldap_pvt_thread_rdwr_runlock(&ldbm_big_rdwr))
97 static ldap_pvt_thread_mutex_t ldbm_big_mutex;
98 #define LDBM_RWLOCK_INIT (ldap_pvt_thread_mutex_init( &ldbm_big_mutex ))
99 #define LDBM_RWLOCK_DESTROY (ldap_pvt_thread_mutex_destroy( &ldbm_big_mutex ))
100 #define LDBM_WLOCK (ldap_pvt_thread_mutex_lock(&ldbm_big_mutex))
101 #define LDBM_WUNLOCK (ldap_pvt_thread_mutex_unlock(&ldbm_big_mutex))
102 #define LDBM_RLOCK LDBM_WLOCK
103 #define LDBM_RUNLOCK LDBM_WUNLOCK
106 #if !defined( HAVE_BERKELEY_DB ) || (DB_VERSION_MAJOR < 3)
107 /* a dbEnv for BERKELEYv2 */
108 DB_ENV *ldbm_Env = NULL; /* real or fake, depending on db and version */
111 /* Let's make the version comparisons a little easier... */
113 #ifdef HAVE_BERKELEY_DB
114 #define DB_VERSION_X ((DB_VERSION_MAJOR<<16)|(DB_VERSION_MINOR<<8)|DB_VERSION_PATCH)
117 /*******************************************************************
119 * Create some special functions to initialize Berkeley DB for *
120 * versions greater than 2. *
122 *******************************************************************/
123 #if defined( HAVE_BERKELEY_DB ) && (DB_VERSION_MAJOR >= 2)
126 ldbm_malloc( size_t size )
128 /* likely should use ber_mem* routines */
129 return( calloc( 1, size ) );
133 #include <ac/syslog.h>
137 #if DB_VERSION_X < 0x040300
138 ldbm_db_errcall( const char *prefix, char *message )
140 ldbm_db_errcall( const DB_ENV *env, const char *prefix, char *message )
144 syslog( LOG_INFO, "ldbm: %s %s", prefix, message );
148 int ldbm_initialize( const char* home )
150 #if DB_VERSION_MAJOR < 3
155 if(ldbm_initialized++) return 1;
162 int major, minor, patch;
163 version = db_version( &major, &minor, &patch );
165 strcpy( v2, version );
170 if( major != DB_VERSION_MAJOR ||
171 minor < DB_VERSION_MINOR )
175 "ldbm_initialize(): version mismatch\nexpected: %s\ngot: %s\n",
176 DB_VERSION_STRING, version );
182 #if DB_VERSION_MAJOR < 3
183 ldbm_Env = calloc( 1, sizeof( DB_ENV ));
185 if( ldbm_Env == NULL ) return 1;
187 ldbm_Env->db_errcall = ldbm_db_errcall;
188 ldbm_Env->db_errpfx = "==>";
190 envFlags = DB_CREATE | DB_USE_ENVIRON;
192 /* add optional flags */
194 envFlags |= DB_PRIVATE;
196 #ifdef HAVE_BERKELEY_DB_THREAD
197 envFlags |= DB_THREAD;
200 err = db_appinit( home, NULL, ldbm_Env, envFlags );
204 syslog( LOG_INFO, "ldbm_initialize(): "
205 "FATAL error (%d) in db_appinit()\n", err );
216 int ldbm_shutdown( void )
218 if( !ldbm_initialized ) return 1;
220 #if DB_VERSION_MAJOR < 3
221 db_appexit( ldbm_Env );
228 #else /* some DB other than Berkeley V2 or greater */
230 int ldbm_initialize( const char * home )
232 if(ldbm_initialized++) return 1;
239 int ldbm_shutdown( void )
241 if( !ldbm_initialized ) return 1;
248 #endif /* HAVE_BERKELEY_DB */
250 #if defined( HAVE_BERKELEY_DB ) && (DB_VERSION_MAJOR >= 3)
252 DB_ENV *ldbm_initialize_env(const char *home, int dbcachesize, int *envdirok)
261 err = db_env_create( &env, 0 );
265 syslog( LOG_INFO, "ldbm_initialize_env(): "
266 "FATAL error in db_env_create() : %s (%d)\n",
267 db_strerror( err ), err );
272 #if DB_VERSION_X >= 0x030300
273 /* This interface appeared in 3.3 */
274 env->set_alloc( env, ldbm_malloc, NULL, NULL );
277 env->set_errcall( env, ldbm_db_errcall );
278 env->set_errpfx( env, "==>" );
280 env->set_cachesize( env, 0, dbcachesize, 0 );
283 envFlags = DB_CREATE | DB_INIT_MPOOL | DB_USE_ENVIRON;
285 envFlags |= DB_PRIVATE;
287 #ifdef DB_MPOOL_PRIVATE
288 envFlags |= DB_MPOOL_PRIVATE;
290 #ifdef HAVE_BERKELEY_DB_THREAD
291 envFlags |= DB_THREAD;
295 strncpy(n2, home, sizeof(n2)-1);
296 n2[sizeof(n2)-1] = '\0';
300 #if DB_VERSION_X >= 0x030100
301 err = env->open( env, home, envFlags, 0 );
303 /* 3.0.x requires an extra argument */
304 err = env->open( env, home, NULL, envFlags, 0 );
309 syslog( LOG_INFO, "ldbm_initialize_env(): "
310 "FATAL error in dbEnv->open() : %s (%d)\n",
311 db_strerror( err ), err );
313 env->close( env, 0 );
321 void ldbm_shutdown_env(DB_ENV *env)
323 env->close( env, 0 );
328 DB_ENV *ldbm_initialize_env(const char *home, int dbcachesize, int *envdirok)
333 void ldbm_shutdown_env(DB_ENV *env)
339 #if defined( LDBM_USE_DBHASH ) || defined( LDBM_USE_DBBTREE )
341 /*****************************************************************
343 * use berkeley db hash or btree package *
345 *****************************************************************/
348 ldbm_open( DB_ENV *env, char *name, int rw, int mode, int dbcachesize )
355 #if DB_VERSION_MAJOR >= 3
360 err = db_create( &ret, env, 0 );
362 (void)ret->close(ret, 0);
368 #if DB_VERSION_X < 0x030300
369 ret->set_malloc( ret, ldbm_malloc );
372 ret->set_pagesize( ret, DEFAULT_DB_PAGE_SIZE );
374 /* likely should use ber_mem* routines */
377 strncpy(n2, name, sizeof(n2)-1);
378 n2[sizeof(n2)-1] = '\0';
382 #if DB_VERSION_X >= 0x040111
383 err = ret->open( ret, NULL, name, NULL, DB_TYPE, rw, mode);
385 err = ret->open( ret, name, NULL, DB_TYPE, rw, mode);
390 (void)ret->close(ret, 0);
399 #elif DB_VERSION_MAJOR >= 2
402 memset( &dbinfo, '\0', sizeof( dbinfo ));
404 #if DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR == 4
406 * BerkeleyDB 2.4 do not allow db_cachesize
407 * to be specified if an DB_ENV is.
410 /* set db_cachesize of MPOOL is NOT being used. */
411 if (( ldbm_Env == NULL ) || ( ldbm_Env->mp_info == NULL )) {
412 dbinfo.db_cachesize = dbcachesize;
416 dbinfo.db_pagesize = DEFAULT_DB_PAGE_SIZE;
417 dbinfo.db_malloc = ldbm_malloc;
420 (void) db_open( name, DB_TYPE, rw, mode, ldbm_Env, &dbinfo, &ret );
428 if ( DB_TYPE == DB_HASH ) {
429 memset( (char *) &hinfo, '\0', sizeof(hinfo) );
430 hinfo.cachesize = dbcachesize;
432 } else if ( DB_TYPE == DB_BTREE ) {
433 memset( (char *) &binfo, '\0', sizeof(binfo) );
434 binfo.cachesize = dbcachesize;
441 ret = dbopen( name, rw, mode, DB_TYPE, info );
449 ldbm_close( LDBM ldbm )
452 #if DB_VERSION_MAJOR >= 2
453 ldbm->close( ldbm, 0 );
461 ldbm_sync( LDBM ldbm )
464 (*ldbm->sync)( ldbm, 0 );
469 ldbm_fetch( LDBM ldbm, Datum key )
476 #if DB_VERSION_MAJOR >= 2
477 ldbm_datum_init( data );
479 data.flags = DB_DBT_MALLOC;
481 if ( (rc = ldbm->get( ldbm, NULL, &key, &data, 0 )) != 0 ) {
482 ldbm_datum_free( ldbm, data );
487 if ( (rc = ldbm->get( ldbm, &key, &data, 0 )) == 0 ) {
488 /* Berkeley DB 1.85 don't malloc the data for us */
489 /* duplicate it for to ensure reentrancy */
490 data = ldbm_datum_dup( ldbm, data );
503 ldbm_store( LDBM ldbm, Datum key, Datum data, int flags )
509 #if DB_VERSION_MAJOR >= 2
510 rc = ldbm->put( ldbm, NULL, &key, &data, flags & ~LDBM_SYNC );
513 rc = ldbm->put( ldbm, &key, &data, flags & ~LDBM_SYNC );
516 if ( flags & LDBM_SYNC )
517 ldbm->sync( ldbm, 0 );
525 ldbm_delete( LDBM ldbm, Datum key )
531 #if DB_VERSION_MAJOR >= 2
532 rc = ldbm->del( ldbm, NULL, &key, 0 );
535 rc = ldbm->del( ldbm, &key, 0 );
537 ldbm->sync( ldbm, 0 );
545 ldbm_firstkey( LDBM ldbm, LDBMCursor **dbch )
550 #if DB_VERSION_MAJOR >= 2
553 ldbm_datum_init( key );
554 ldbm_datum_init( data );
556 key.flags = data.flags = DB_DBT_MALLOC;
560 /* acquire a cursor for the DB */
561 # if DB_VERSION_X >= 0x020600
562 rc = ldbm->cursor( ldbm, NULL, &dbci, 0 );
564 rc = ldbm->cursor( ldbm, NULL, &dbci );
571 if ( dbci->c_get( dbci, &key, &data, DB_NEXT ) == 0 ) {
572 ldbm_datum_free( ldbm, data );
584 rc = ldbm->seq( ldbm, &key, &data, R_FIRST );
587 key = ldbm_datum_dup( ldbm, key );
600 ldbm_nextkey( LDBM ldbm, Datum key, LDBMCursor *dbcp )
607 #if DB_VERSION_MAJOR >= 2
608 ldbm_datum_init( data );
610 ldbm_datum_free( ldbm, key );
611 key.flags = data.flags = DB_DBT_MALLOC;
613 rc = dbcp->c_get( dbcp, &key, &data, DB_NEXT );
615 ldbm_datum_free( ldbm, data );
618 rc = ldbm->seq( ldbm, &key, &data, R_NEXT );
621 key = ldbm_datum_dup( ldbm, key );
634 ldbm_errno( LDBM ldbm )
639 /******************************************************************
641 * END Berkeley section *
643 ******************************************************************/
645 #elif defined( HAVE_GDBM )
647 #ifdef HAVE_ST_BLKSIZE
648 #include <sys/stat.h>
651 /*****************************************************************
655 *****************************************************************/
658 ldbm_open( DB_ENV *env, char *name, int rw, int mode, int dbcachesize )
661 #ifdef HAVE_ST_BLKSIZE
667 strncpy(n2, name, sizeof(n2)-1);
668 n2[sizeof(n2)-1] = '\0';
675 if ( (db = gdbm_open( name, 0, rw | GDBM_FAST, mode, 0 )) == NULL ) {
680 #ifdef HAVE_ST_BLKSIZE
681 if ( dbcachesize > 0 && stat( name, &st ) == 0 ) {
682 dbcachesize /= st.st_blksize;
683 if( dbcachesize == 0 ) dbcachesize = 1;
684 gdbm_setopt( db, GDBM_CACHESIZE, &dbcachesize, sizeof(int) );
687 if ( dbcachesize > 0 ) {
689 if( dbcachesize == 0 ) dbcachesize = 1;
690 gdbm_setopt( db, GDBM_CACHESIZE, &dbcachesize, sizeof(int) );
700 ldbm_close( LDBM ldbm )
708 ldbm_sync( LDBM ldbm )
716 ldbm_fetch( LDBM ldbm, Datum key )
721 d = gdbm_fetch( ldbm, key );
728 ldbm_store( LDBM ldbm, Datum key, Datum data, int flags )
733 rc = gdbm_store( ldbm, key, data, flags & ~LDBM_SYNC );
734 if ( flags & LDBM_SYNC )
742 ldbm_delete( LDBM ldbm, Datum key )
747 rc = gdbm_delete( ldbm, key );
755 ldbm_firstkey( LDBM ldbm, LDBMCursor **dbcp )
760 d = gdbm_firstkey( ldbm );
763 if ( d.dptr != NULL ) {
764 *dbcp = (Datum *) malloc( sizeof( Datum ) );
765 **dbcp = ldbm_datum_dup( ldbm, d );
772 ldbm_nextkey( LDBM ldbm, Datum key, LDBMCursor *dbcp )
777 d = gdbm_nextkey( ldbm, *dbcp );
780 ldbm_datum_free( ldbm, *dbcp );
782 if ( d.dptr != NULL ) {
783 *dbcp = ldbm_datum_dup( ldbm, d );
792 ldbm_errno( LDBM ldbm )
805 /* MMAPED DBM HASHING DATABASE */
807 #include <ac/string.h>
809 /* #define MDBM_DEBUG */
816 /* #define MDBM_CHAIN */
822 #define mdbm_store mdbm_chain_store
823 #define mdbm_fetch mdbm_chain_fetch
824 #define mdbm_delete mdbm_chain_delete
825 #define mdbm_first mdbm_chain_first
826 #define mdbm_next mdbm_chain_next
830 #define MDBM_PG_SZ (4*1024)
832 /*****************************************************************
836 *****************************************************************/
839 ldbm_open( DB_ENV *env, char *name, int rw, int mode, int dbcachesize )
845 "==>(mdbm)ldbm_open(name=%s,rw=%x,mode=%x,cachesize=%d)\n",
846 name ? name : "NULL", rw, mode, dbcachesize );
850 LDBM_WLOCK; /* We need locking here, this is the only non-thread
851 * safe function we have. */
853 if ( (db = mdbm_open( name, rw, mode, MDBM_PG_SZ )) == NULL ) {
856 fprintf( stdout, "<==(mdbm)ldbm_open(db=NULL)\n" );
863 (void)mdbm_set_chain(db);
869 fprintf( stdout, "<==(mdbm)ldbm_open(db=%p)\n", db );
877 ldbm_close( LDBM ldbm )
879 /* Open and close are not reentrant so we need to use locks here */
883 "==>(mdbm)ldbm_close(db=%p)\n", ldbm );
892 fprintf( stdout, "<==(mdbm)ldbm_close()\n" );
898 ldbm_sync( LDBM ldbm )
900 /* XXX: Not sure if this is re-entrant need to check code, if so
901 * 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
924 k.key.dsize = key.dsize + 1;
925 k.key.dptr = malloc(k.key.dsize);
927 AC_MEMCPY( (void *)(k.key.dptr + 1), key.dptr, key.dsize );
937 d = mdbm_fetch( ldbm, k );
940 if ( k.val.dptr != NULL ) {
944 if ( (k.val.dptr = malloc( d.dsize )) != NULL ) {
945 k.val.dsize = d.dsize;
946 d = mdbm_fetch( ldbm, k );
952 }/* if ( d.dsize > 0 ) */
953 } while ((d.dsize > k.val.dsize) && (++retry < MAX_MDBM_RETRY));
964 ldbm_store( LDBM ldbm, Datum key, Datum data, int flags )
967 Datum int_key; /* Internal key */
971 "==>(mdbm)ldbm_store(db=%p, key(dptr=%p,sz=%d), data(dptr=%p,sz=%d), flags=%x)\n",
972 ldbm, key.dptr, key.dsize, data.dptr, data.dsize, flags );
979 int_key.dsize = key.dsize + 1;
980 int_key.dptr = malloc( int_key.dsize );
981 *(int_key.dptr) = 'l'; /* Must not be NULL !*/
982 AC_MEMCPY( (void *)(int_key.dptr + 1), key.dptr, key.dsize );
987 rc = mdbm_store( ldbm, int_key, data, flags );
988 if ( flags & LDBM_SYNC ) {
995 fprintf( stdout, "<==(mdbm)ldbm_store(rc=%d)\n", rc );
1007 ldbm_delete( LDBM ldbm, Datum key )
1015 int_key.dsize = key.dsize + 1;
1016 int_key.dptr = malloc(int_key.dsize);
1017 *(int_key.dptr) = 'l';
1018 AC_MEMCPY( (void *)(int_key.dptr + 1), key.dptr, key.dsize );
1023 rc = mdbm_delete( ldbm, int_key );
1034 ldbm_get_next( LDBM ldbm, kvpair (*fptr)(MDBM *, kvpair) )
1039 size_t sz = MDBM_PAGE_SIZE(ldbm);
1048 in.key.dsize = sz; /* Assume first key in one pg */
1049 in.key.dptr = malloc(sz);
1051 in.val.dptr = NULL; /* Don't need data just key */
1057 out = fptr( ldbm, in );
1059 if (out.key.dsize > 0) {
1060 ret.dsize = out.key.dsize - delta;
1062 if ((ret.dptr = (char *)malloc(ret.dsize)) == NULL) {
1067 AC_MEMCPY(ret.dptr, (void *)(out.key.dptr + delta),
1079 ldbm_firstkey( LDBM ldbm, LDBMCursor **dbcp )
1081 return ldbm_get_next( ldbm, mdbm_first );
1085 ldbm_nextkey( LDBM ldbm, Datum key, LDBMCursor *dbcp )
1088 * don't know if this will affect the LDAP server operation
1089 * but mdbm cannot take and input key.
1092 return ldbm_get_next( ldbm, mdbm_next );
1096 ldbm_errno( LDBM ldbm )
1098 /* XXX: best we can do with current mdbm interface */
1102 #elif defined( HAVE_NDBM )
1104 /*****************************************************************
1106 * if no gdbm or mdbm, fall back to using ndbm, the standard unix thing *
1108 *****************************************************************/
1112 ldbm_open( DB_ENV *env, char *name, int rw, int mode, int dbcachesize )
1117 ldbm = dbm_open( name, rw, mode );
1124 ldbm_close( LDBM ldbm )
1133 ldbm_sync( LDBM ldbm )
1139 ldbm_fetch( LDBM ldbm, Datum key )
1144 d = ldbm_datum_dup( ldbm, dbm_fetch( ldbm, key ) );
1151 ldbm_store( LDBM ldbm, Datum key, Datum data, int flags )
1156 rc = dbm_store( ldbm, key, data, flags );
1163 ldbm_delete( LDBM ldbm, Datum key )
1168 rc = dbm_delete( ldbm, key );
1175 ldbm_firstkey( LDBM ldbm, LDBMCursor **dbcp )
1180 d = dbm_firstkey( ldbm );
1187 ldbm_nextkey( LDBM ldbm, Datum key, LDBMCursor *dbcp )
1192 d = dbm_nextkey( ldbm );
1199 ldbm_errno( LDBM ldbm )
1204 err = dbm_error( ldbm );