1 /* ldbm.c - ldap dbm compatibility routines */
3 /* Patched for Berkeley DB version 2.0; /KSp; 98/02/23
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
16 #include <ac/string.h>
20 #include "ldap_pvt_thread.h"
24 ldbm_datum_free( LDBM ldbm, Datum data )
28 memset( &data, 0, sizeof( Datum ));
35 ldbm_datum_dup( LDBM ldbm, Datum data )
39 ldbm_datum_init( dup );
41 if ( data.dsize == 0 ) {
47 dup.dsize = data.dsize;
48 if ( (dup.dptr = (char *) malloc( data.dsize )) != NULL )
49 memcpy( dup.dptr, data.dptr, data.dsize );
54 static int ldbm_initialized = 0;
56 #ifndef HAVE_BERKELEY_DB2
57 /* Everything but DB2 is non-reentrant */
59 static ldap_pvt_thread_mutex_t ldbm_big_mutex;
60 #define LDBM_LOCK (ldap_pvt_thread_mutex_lock(&ldbm_big_mutex))
61 #define LDBM_UNLOCK (ldap_pvt_thread_mutex_unlock(&ldbm_big_mutex))
63 int ldbm_initialize( void )
65 if(ldbm_initialized++) return 1;
67 ldap_pvt_thread_mutex_init( &ldbm_big_mutex );
72 int ldbm_shutdown( void )
74 if( !ldbm_initialized ) return 1;
76 ldap_pvt_thread_mutex_destroy( &ldbm_big_mutex );
84 ldbm_malloc( size_t size )
86 return( calloc( 1, size ));
95 extern int syslog(int, char*, ...);
97 #endif /* HAVE_SYSLOG */
100 ldbm_db_errcall( const char *prefix, char *message )
103 syslog( LOG_INFO, "ldbm_db_errcall(): %s %s", prefix, message );
107 /* a dbEnv for BERKELEYv2 */
108 static DB_ENV ldbm_Env_internal;
109 DB_ENV *ldbm_Env = NULL;
111 /* Berkeley DB 2.x is reentrant */
112 #define LDBM_LOCK ((void)0)
113 #define LDBM_UNLOCK ((void)0)
115 int ldbm_initialize( void )
120 if(ldbm_initialized++) return 1;
122 memset( &ldbm_Env_internal, 0, sizeof( DB_ENV ));
123 ldbm_Env = &ldbm_Env_internal;
125 ldbm_Env->db_errcall = ldbm_db_errcall;
126 ldbm_Env->db_errpfx = "==>";
128 envFlags = DB_CREATE | DB_THREAD;
130 if ( ( err = db_appinit( NULL, NULL, ldbm_Env, envFlags )) ) {
134 sprintf( error, "%ld\n", (long) err );
136 sprintf( error, "%s\n", strerror( err ));
141 "ldbm_initialize(): FATAL error in db_appinit() : %s\n",
150 int ldbm_shutdown( void )
152 if( !ldbm_initialized ) return 1;
154 db_appexit( ldbm_Env );
161 #if defined( LDBM_USE_DBHASH ) || defined( LDBM_USE_DBBTREE )
163 /*****************************************************************
165 * use berkeley db hash or btree package *
167 *****************************************************************/
170 ldbm_open( char *name, int rw, int mode, int dbcachesize )
174 #ifdef HAVE_BERKELEY_DB2
177 memset( &dbinfo, 0, sizeof( dbinfo ));
178 if (( ldbm_Env == NULL ) || ( ldbm_Env->mp_info == NULL ))
179 dbinfo.db_cachesize = dbcachesize;
180 dbinfo.db_pagesize = DEFAULT_DB_PAGE_SIZE;
181 dbinfo.db_malloc = ldbm_malloc;
184 (void) db_open( name, DB_TYPE, rw, mode, ldbm_Env, &dbinfo, &ret );
192 if ( DB_TYPE == DB_HASH ) {
193 memset( (char *) &hinfo, '\0', sizeof(hinfo) );
194 hinfo.cachesize = dbcachesize;
196 } else if ( DB_TYPE == DB_BTREE ) {
197 memset( (char *) &binfo, '\0', sizeof(binfo) );
198 binfo.cachesize = dbcachesize;
205 ret = dbopen( name, rw, mode, DB_TYPE, info );
214 ldbm_close( LDBM ldbm )
217 #ifdef HAVE_BERKELEY_DB2
218 (*ldbm->close)( ldbm, 0 );
220 (*ldbm->close)( ldbm );
226 ldbm_sync( LDBM ldbm )
229 (*ldbm->sync)( ldbm, 0 );
234 ldbm_fetch( LDBM ldbm, Datum key )
241 #ifdef HAVE_BERKELEY_DB2
242 ldbm_datum_init( data );
244 data.flags = DB_DBT_MALLOC;
246 if ( (rc = (*ldbm->get)( ldbm, NULL, &key, &data, 0 )) != 0 ) {
247 ldbm_datum_free( ldbm, data );
249 if ( (rc = (*ldbm->get)( ldbm, &key, &data, 0 )) == 0 ) {
250 /* Berkeley DB 1.85 don't malloc the data for us */
251 /* duplicate it for to ensure reentrancy */
252 data = ldbm_datum_dup( ldbm, data );
265 ldbm_store( LDBM ldbm, Datum key, Datum data, int flags )
271 #ifdef HAVE_BERKELEY_DB2
272 rc = (*ldbm->put)( ldbm, NULL, &key, &data, flags & ~LDBM_SYNC );
275 rc = (*ldbm->put)( ldbm, &key, &data, flags & ~LDBM_SYNC );
278 if ( flags & LDBM_SYNC )
279 (*ldbm->sync)( ldbm, 0 );
287 ldbm_delete( LDBM ldbm, Datum key )
293 #ifdef HAVE_BERKELEY_DB2
294 rc = (*ldbm->del)( ldbm, NULL, &key, 0 );
297 rc = (*ldbm->del)( ldbm, &key, 0 );
299 (*ldbm->sync)( ldbm, 0 );
307 #ifdef HAVE_BERKELEY_DB2
308 ldbm_firstkey( LDBM ldbm, DBC **dbch )
310 ldbm_firstkey( LDBM ldbm )
315 #ifdef HAVE_BERKELEY_DB2
318 ldbm_datum_init( key );
319 ldbm_datum_init( data );
321 key.flags = data.flags = DB_DBT_MALLOC;
325 /* acquire a cursor for the DB */
327 # if defined( DB_VERSION_MAJOR ) && defined( DB_VERSION_MINOR ) && \
328 DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR < 6
330 if ( (*ldbm->cursor)( ldbm, NULL, &dbci ))
333 if ( (*ldbm->cursor)( ldbm, NULL, &dbci, 0 ))
340 if ( (*dbci->c_get)( dbci, &key, &data, DB_NEXT ) == 0 ) {
341 ldbm_datum_free( ldbm, data );
349 if ( (rc = (*ldbm->seq)( ldbm, &key, &data, R_FIRST )) == 0 ) {
350 key = ldbm_datum_dup( ldbm, key );
358 #ifdef HAVE_BERKELEY_DB2
368 #ifdef HAVE_BERKELEY_DB2
369 ldbm_nextkey( LDBM ldbm, Datum key, DBC *dbcp )
371 ldbm_nextkey( LDBM ldbm, Datum key )
376 #ifdef HAVE_BERKELEY_DB2
377 ldbm_datum_init( data );
379 ldbm_datum_free( ldbm, key );
380 key.flags = data.flags = DB_DBT_MALLOC;
384 if ( (*dbcp->c_get)( dbcp, &key, &data, DB_NEXT ) == 0 ) {
385 ldbm_datum_free( ldbm, data );
393 if ( (rc = (*ldbm->seq)( ldbm, &key, &data, R_NEXT )) == 0 ) {
394 key = ldbm_datum_dup( ldbm, key );
408 ldbm_errno( LDBM ldbm )
413 #elif defined( HAVE_GDBM )
415 #ifdef HAVE_ST_BLKSIZE
416 #include <sys/stat.h>
419 /*****************************************************************
423 *****************************************************************/
426 ldbm_open( char *name, int rw, int mode, int dbcachesize )
429 #ifdef HAVE_ST_BLKSIZE
435 if ( (db = gdbm_open( name, 0, rw | GDBM_FAST, mode, 0 )) == NULL ) {
440 #ifdef HAVE_ST_BLKSIZE
441 if ( dbcachesize > 0 && stat( name, &st ) == 0 ) {
442 dbcachesize = (dbcachesize / st.st_blksize);
443 gdbm_setopt( db, GDBM_CACHESIZE, &dbcachesize, sizeof(int) );
446 dbcachesize = (dbcachesize / 4096);
447 gdbm_setopt( db, GDBM_CACHESIZE, &dbcachesize, sizeof(int) );
456 ldbm_close( LDBM ldbm )
464 ldbm_sync( LDBM ldbm )
472 ldbm_fetch( LDBM ldbm, Datum key )
477 d = gdbm_fetch( ldbm, key );
484 ldbm_store( LDBM ldbm, Datum key, Datum data, int flags )
489 rc = gdbm_store( ldbm, key, data, flags & ~LDBM_SYNC );
490 if ( flags & LDBM_SYNC )
498 ldbm_delete( LDBM ldbm, Datum key )
503 rc = gdbm_delete( ldbm, key );
511 ldbm_firstkey( LDBM ldbm )
516 d = gdbm_firstkey( ldbm );
523 ldbm_nextkey( LDBM ldbm, Datum key )
528 d = gdbm_nextkey( ldbm, key );
535 ldbm_errno( LDBM ldbm )
548 /* MMAPED DBM HASHING DATABASE */
553 /* #define MDBM_DEBUG */
560 /* #define MDBM_CHAIN */
567 #define mdbm_store mdbm_chain_store
568 #define mdbm_fetch mdbm_chain_fetch
569 #define mdbm_delete mdbm_chain_delete
570 #define mdbm_first mdbm_chain_first
571 #define mdbm_next mdbm_chain_next
575 #define MDBM_PG_SZ (4*1024)
577 /*****************************************************************
581 *****************************************************************/
584 ldbm_open( char *name, int rw, int mode, int dbcachesize )
590 "==>(mdbm)ldbm_open(name=%s,rw=%x,mode=%x,cachesize=%d)\n",
591 name ? name : "NULL", rw, mode, dbcachesize );
595 LDBM_LOCK; /* We need locking here, this is the only non-thread
596 * safe function we have.
599 if ( (db = mdbm_open( name, rw, mode, MDBM_PG_SZ )) == NULL ) {
603 fprintf( stdout, "<==(mdbm)ldbm_open(db=NULL)\n" );
611 (void)mdbm_set_chain(db);
617 fprintf( stdout, "<==(mdbm)ldbm_open(db=%p)\n", db );
623 }/* LDBM ldbm_open() */
629 ldbm_close( LDBM ldbm )
632 /* Open and close are not reentrant so we need to use locks here */
636 "==>(mdbm)ldbm_close(db=%p)\n", ldbm );
645 fprintf( stdout, "<==(mdbm)ldbm_close()\n" );
649 }/* void ldbm_close() */
655 ldbm_sync( LDBM ldbm )
658 /* XXX: Not sure if this is re-entrant need to check code, if so
659 * you can leave LOCKS out.
666 }/* void ldbm_sync() */
669 #define MAX_MDBM_RETRY 5
672 ldbm_fetch( LDBM ldbm, Datum key )
678 /* This hack is needed because MDBM does not take keys
679 * which begin with NULL when working in the chaining
686 k.key.dsize = key.dsize + 1;
687 k.key.dptr = alloca(k.key.dsize);
689 memcpy( (void *)(k.key.dptr + 1), key.dptr, key.dsize );
699 d = mdbm_fetch( ldbm, k );
703 if ( k.val.dptr != NULL ) {
709 if ( (k.val.dptr = malloc( d.dsize )) != NULL ) {
711 k.val.dsize = d.dsize;
712 d = mdbm_fetch( ldbm, k );
721 }/* if ( d.dsize > 0 ) */
723 } while ((d.dsize > k.val.dsize) && (++retry < MAX_MDBM_RETRY));
729 }/* Datum ldbm_fetch() */
735 ldbm_store( LDBM ldbm, Datum key, Datum data, int flags )
738 Datum int_key; /* Internal key */
742 "==>(mdbm)ldbm_store(db=%p, key(dptr=%p,sz=%d), data(dptr=%p,sz=%d), flags=%x)\n",
743 ldbm, key.dptr, key.dsize, data.dptr, data.dsize, flags );
750 int_key.dsize = key.dsize + 1;
751 int_key.dptr = alloca( int_key.dsize );
752 *(int_key.dptr) = 'l'; /* Must not be NULL !*/
753 memcpy( (void *)(int_key.dptr + 1), key.dptr, key.dsize );
758 rc = mdbm_store( ldbm, int_key, data, flags );
759 if ( flags & LDBM_SYNC ) {
766 fprintf( stdout, "<==(mdbm)ldbm_store(rc=%d)\n", rc );
772 }/* int ldbm_store() */
778 ldbm_delete( LDBM ldbm, Datum key )
786 int_key.dsize = key.dsize + 1;
787 int_key.dptr = alloca(int_key.dsize);
788 *(int_key.dptr) = 'l';
789 memcpy( (void *)(int_key.dptr + 1), key.dptr, key.dsize );
794 rc = mdbm_delete( ldbm, int_key );
800 }/* int ldbm_delete() */
806 ldbm_get_next( LDBM ldbm, kvpair (*fptr)(MDBM *, kvpair) )
812 size_t sz = MDBM_PAGE_SIZE(ldbm);
821 in.key.dsize = sz; /* Assume first key in one pg */
822 in.key.dptr = alloca(sz);
824 in.val.dptr = NULL; /* Don't need data just key */
830 out = fptr( ldbm, in );
832 if (out.key.dsize > 0) {
834 ret.dsize = out.key.dsize - delta;
835 if ((ret.dptr = (char *)malloc(ret.dsize)) == NULL) {
842 memcpy(ret.dptr, (void *)(out.key.dptr + delta),
853 }/* static Datum ldbm_get_next() */
859 ldbm_firstkey( LDBM ldbm )
862 return ldbm_get_next( ldbm, mdbm_first );
864 }/* Datum ldbm_firstkey() */
870 ldbm_nextkey( LDBM ldbm, Datum key )
874 * don't know if this will affect the LDAP server opertaion
875 * but mdbm cannot take and input key.
878 return ldbm_get_next( ldbm, mdbm_next );
880 }/* Datum ldbm_nextkey() */
883 ldbm_errno( LDBM ldbm )
885 /* XXX: best we can do with current mdbm interface */
888 }/* int ldbm_errno() */
893 #elif defined( HAVE_NDBM )
895 /*****************************************************************
897 * if no gdbm or mdbm, fall back to using ndbm, the standard unix thing *
899 *****************************************************************/
903 ldbm_open( char *name, int rw, int mode, int dbcachesize )
908 ldbm = dbm_open( name, rw, mode );
915 ldbm_close( LDBM ldbm )
924 ldbm_sync( LDBM ldbm )
930 ldbm_fetch( LDBM ldbm, Datum key )
935 d = ldbm_datum_dup( ldbm, dbm_fetch( ldbm, key ) );
942 ldbm_store( LDBM ldbm, Datum key, Datum data, int flags )
947 rc = dbm_store( ldbm, key, data, flags );
954 ldbm_delete( LDBM ldbm, Datum key )
959 rc = dbm_delete( ldbm, key );
966 ldbm_firstkey( LDBM ldbm )
971 d = dbm_firstkey( ldbm );
978 ldbm_nextkey( LDBM ldbm, Datum key )
983 d = dbm_nextkey( ldbm );
990 ldbm_errno( LDBM ldbm )
995 err = dbm_error( ldbm );