/* ldbm.c - ldap dbm compatibility routines */
+/* $OpenLDAP$ */
/*
- * Copyright 1998-1999 The OpenLDAP Foundation, All Rights Reserved.
+ * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.
* COPYING RESTRICTIONS APPLY, see COPYRIGHT file
*/
#include "ldbm.h"
#include "ldap_pvt_thread.h"
-
void
ldbm_datum_free( LDBM ldbm, Datum data )
{
if ( data.dptr ) {
free( data.dptr );
- memset( &data, 0, sizeof( Datum ));
+ memset( &data, '\0', sizeof( Datum ));
data.dptr = NULL;
}
}
return( dup );
}
dup.dsize = data.dsize;
- if ( (dup.dptr = (char *) malloc( data.dsize )) != NULL )
- memcpy( dup.dptr, data.dptr, data.dsize );
+
+ if ( (dup.dptr = (char *) malloc( data.dsize )) != NULL ) {
+ AC_MEMCPY( dup.dptr, data.dptr, data.dsize );
+ }
return( dup );
}
static int ldbm_initialized = 0;
-#ifndef HAVE_BERKELEY_DB2
-/* Everything but DB2 is non-reentrant */
-
+#ifdef HAVE_BERKELEY_DB_THREAD
+#define LDBM_LOCK ((void) 0)
+#define LDBM_UNLOCK ((void) 0)
+#else
static ldap_pvt_thread_mutex_t ldbm_big_mutex;
#define LDBM_LOCK (ldap_pvt_thread_mutex_lock(&ldbm_big_mutex))
#define LDBM_UNLOCK (ldap_pvt_thread_mutex_unlock(&ldbm_big_mutex))
+#endif
-int ldbm_initialize( void )
-{
- if(ldbm_initialized++) return 1;
-
- ldap_pvt_thread_mutex_init( &ldbm_big_mutex );
-
- return 0;
-}
-
-int ldbm_shutdown( void )
-{
- if( !ldbm_initialized ) return 1;
-
- ldap_pvt_thread_mutex_destroy( &ldbm_big_mutex );
-
- return 0;
-}
-#else
+/*******************************************************************
+ * *
+ * Create some special functions to initialize Berkeley DB for *
+ * versions greater than 2. *
+ * *
+ *******************************************************************/
+#if defined( HAVE_BERKELEY_DB ) && (DB_VERSION_MAJOR >= 2)
void *
ldbm_malloc( size_t size )
ldbm_db_errcall( const char *prefix, char *message )
{
#ifdef LDAP_SYSLOG
- syslog( LOG_INFO, "ldbm_db_errcall(): %s %s", prefix, message );
+ syslog( LOG_INFO, "ldbm: %s %s", prefix, message );
#endif
}
/* a dbEnv for BERKELEYv2 */
-static DB_ENV ldbm_Env_internal;
-DB_ENV *ldbm_Env = NULL;
+DB_ENV *ldbm_Env = NULL;
-/* Berkeley DB 2.x is reentrant */
-#define LDBM_LOCK ((void)0)
-#define LDBM_UNLOCK ((void)0)
-
-int ldbm_initialize( void )
+int ldbm_initialize( const char* home )
{
- int err;
- int envFlags;
+ int err;
+ u_int32_t envFlags;
if(ldbm_initialized++) return 1;
- memset( &ldbm_Env_internal, 0, sizeof( DB_ENV ));
- ldbm_Env = &ldbm_Env_internal;
+ {
+ char *version;
+ int major, minor, patch;
+ version = db_version( &major, &minor, &patch );
- ldbm_Env->db_errcall = ldbm_db_errcall;
- ldbm_Env->db_errpfx = "==>";
+ if( major != DB_VERSION_MAJOR ||
+ minor < DB_VERSION_MINOR )
+ {
+#ifdef LDAP_SYSLOG
+ char error[BUFSIZ];
- envFlags = DB_CREATE | DB_THREAD;
+ sprintf( error, "%s (%d)\n", STRERROR( err ), err );
- if ( ( err = db_appinit( NULL, NULL, ldbm_Env, envFlags )) ) {
- char error[BUFSIZ];
+ syslog( LOG_INFO,
+ "ldbm_initialize(): version mismatch\nexpected: %s\ngot: %s\n",
+ DB_VERSION_STRING,
+ version );
+#endif
- if ( err < 0 ) {
- sprintf( error, "%ld\n", (long) err );
- } else {
- sprintf( error, "%s\n", strerror( err ));
+ return 1;
}
+ }
+
+#ifndef HAVE_BERKELEY_DB_THREAD
+ ldap_pvt_thread_mutex_init( &ldbm_big_mutex );
+#endif
+
+#if DB_VERSION_MAJOR < 3
+ ldbm_Env = calloc( 1, sizeof( DB_ENV ));
+
+ if( ldbm_Env == NULL ) return 1;
+
+ ldbm_Env->db_errcall = ldbm_db_errcall;
+ ldbm_Env->db_errpfx = "==>";
+#else
+ ldbm_Env = NULL;
+#endif
+
+ envFlags = DB_CREATE;
+
+ /* add optional flags */
+#ifdef DB_PRIVATE
+ envFlags |= DB_PRIVATE;
+#endif
+#ifdef HAVE_BERKELEY_DB_THREAD
+ envFlags |= DB_THREAD | DB_INIT_CDB | DB_INIT_MPOOL;
+#ifdef DB_MPOOL_PRIVATE
+ envFlags |= DB_MPOOL_PRIVATE;
+#endif
+#endif
+
+#if DB_VERSION_MAJOR >= 3
+ err = db_env_create( &ldbm_Env, 0 );
+#else
+ envFlags |= DB_USE_ENVIRON;
+ err = db_appinit( home, NULL, ldbm_Env, envFlags );
+#endif
+
+ if ( err ) {
#ifdef LDAP_SYSLOG
+ char error[BUFSIZ];
+
+ sprintf( error, "%s (%d)\n", STRERROR( err ), err );
+
syslog( LOG_INFO,
+#if DB_VERSION_MAJOR >= 3
+ "ldbm_initialize(): FATAL error in db_env_create() : %s\n",
+#else
"ldbm_initialize(): FATAL error in db_appinit() : %s\n",
+#endif
error );
#endif
return( 1 );
}
+#if DB_VERSION_MAJOR > 2
+ ldbm_Env->set_errcall( ldbm_Env, ldbm_db_errcall );
+ ldbm_Env->set_errpfx( ldbm_Env, "==>" );
+
+#ifdef HAVE_BERKELEY_DB_THREAD
+ envFlags |= DB_INIT_CDB | DB_INIT_MPOOL;
+#endif
+ envFlags |= DB_USE_ENVIRON;
+
+#if (DB_VERSION_MAJOR > 3) || (DB_VERSION_MINOR >= 1)
+ err = ldbm_Env->open( ldbm_Env, home, envFlags, 0 );
+#else
+ err = ldbm_Env->open( ldbm_Env, home, NULL, envFlags, 0 );
+#endif
+
+ if ( err != 0 ) {
+#ifdef LDAP_SYSLOG
+ char error[BUFSIZ];
+
+ sprintf( error, "%s (%d)\n", STRERROR( err ), err );
+ syslog( LOG_INFO,
+ "ldbm_initialize(): FATAL error in dbEnv->open() : %s\n",
+ error );
+#endif
+ ldbm_Env->close( ldbm_Env, 0 );
+ return( 1 );
+ }
+#endif
+
return 0;
}
{
if( !ldbm_initialized ) return 1;
+#if DB_VERSION_MAJOR >= 3
+ ldbm_Env->close( ldbm_Env, 0 );
+#else
db_appexit( ldbm_Env );
+#endif
+
+#ifndef HAVE_BERKELEY_DB_THREAD
+ ldap_pvt_thread_mutex_destroy( &ldbm_big_mutex );
+#endif
return 0;
}
-#endif
+#else /* some DB other than Berkeley V2 or greater */
+
+int ldbm_initialize( const char * home )
+{
+ if(ldbm_initialized++) return 1;
+
+ ldap_pvt_thread_mutex_init( &ldbm_big_mutex );
+
+ return 0;
+}
+
+int ldbm_shutdown( void )
+{
+ if( !ldbm_initialized ) return 1;
+
+ ldap_pvt_thread_mutex_destroy( &ldbm_big_mutex );
+
+ return 0;
+}
+
+#endif /* HAVE_BERKELEY_DB */
+
#if defined( LDBM_USE_DBHASH ) || defined( LDBM_USE_DBBTREE )
{
LDBM ret = NULL;
-#ifdef HAVE_BERKELEY_DB2
+#if DB_VERSION_MAJOR >= 3
+ int err;
+
+ LDBM_LOCK;
+
+ err = db_create( &ret, ldbm_Env, 0 );
+ if ( err != 0 ) {
+ (void)ret->close(ret, 0);
+ LDBM_UNLOCK;
+
+ return NULL;
+ }
+
+ ret->set_pagesize( ret, DEFAULT_DB_PAGE_SIZE );
+ ret->set_malloc( ret, ldbm_malloc );
+
+ err = ret->open( ret, name, NULL, DB_TYPE, rw, mode);
+
+ if ( err != 0 ) {
+ int tmp = errno;
+ (void)ret->close(ret, 0);
+ errno = tmp;
+
+ LDBM_UNLOCK;
+ return NULL;
+ }
+
+ LDBM_UNLOCK;
+
+#elif DB_VERSION_MAJOR >= 2
DB_INFO dbinfo;
- memset( &dbinfo, 0, sizeof( dbinfo ));
+ memset( &dbinfo, '\0', sizeof( dbinfo ));
-#if defined( DB_VERSION_MAJOR ) && defined( DB_VERSION_MINOR ) && \
- DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR == 4
+#if DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR == 4
/*
* BerkeleyDB 2.4 do not allow db_cachesize
* to be specified if an DB_ENV is.
*/
#else
/* set db_cachesize of MPOOL is NOT being used. */
- if (( ldbm_Env == NULL ) || ( ldbm_Env->mp_info == NULL ))
+ if (( ldbm_Env == NULL ) || ( ldbm_Env->mp_info == NULL )) {
dbinfo.db_cachesize = dbcachesize;
+ }
#endif
- dbinfo.db_pagesize = DEFAULT_DB_PAGE_SIZE;
- dbinfo.db_malloc = ldbm_malloc;
+ dbinfo.db_pagesize = DEFAULT_DB_PAGE_SIZE;
+ dbinfo.db_malloc = ldbm_malloc;
LDBM_LOCK;
- (void) db_open( name, DB_TYPE, rw, mode, ldbm_Env, &dbinfo, &ret );
+ (void) db_open( name, DB_TYPE, rw, mode, ldbm_Env, &dbinfo, &ret );
LDBM_UNLOCK;
#else
LDBM_LOCK;
ret = dbopen( name, rw, mode, DB_TYPE, info );
LDBM_UNLOCK;
-
#endif
- return( ret );
+ return ret;
}
void
ldbm_close( LDBM ldbm )
{
LDBM_LOCK;
-#ifdef HAVE_BERKELEY_DB2
+#if DB_VERSION_MAJOR >= 3
+ ldbm->close( ldbm, 0 );
+#elif DB_VERSION_MAJOR >= 2
(*ldbm->close)( ldbm, 0 );
#else
(*ldbm->close)( ldbm );
LDBM_LOCK;
-#ifdef HAVE_BERKELEY_DB2
+#if DB_VERSION_MAJOR >= 3
+ ldbm_datum_init( data );
+
+ data.flags = DB_DBT_MALLOC;
+
+ if ( (rc = ldbm->get( ldbm, NULL, &key, &data, 0 )) != 0 ) {
+ ldbm_datum_free( ldbm, data );
+ data.dptr = NULL;
+ data.dsize = 0;
+ }
+
+#elif DB_VERSION_MAJOR >= 2
ldbm_datum_init( data );
data.flags = DB_DBT_MALLOC;
if ( (rc = (*ldbm->get)( ldbm, NULL, &key, &data, 0 )) != 0 ) {
ldbm_datum_free( ldbm, data );
+ data.dptr = NULL;
+ data.dsize = 0;
+ }
#else
+
if ( (rc = (*ldbm->get)( ldbm, &key, &data, 0 )) == 0 ) {
/* Berkeley DB 1.85 don't malloc the data for us */
/* duplicate it for to ensure reentrancy */
data = ldbm_datum_dup( ldbm, data );
} else {
-#endif
data.dptr = NULL;
data.dsize = 0;
}
+#endif
LDBM_UNLOCK;
LDBM_LOCK;
-#ifdef HAVE_BERKELEY_DB2
+#if DB_VERSION_MAJOR >= 3
+ rc = ldbm->put( ldbm, NULL, &key, &data, flags & ~LDBM_SYNC );
+ rc = (-1) * rc;
+
+#elif DB_VERSION_MAJOR >= 2
rc = (*ldbm->put)( ldbm, NULL, &key, &data, flags & ~LDBM_SYNC );
- rc = (-1 ) * rc;
+ rc = (-1) * rc;
#else
rc = (*ldbm->put)( ldbm, &key, &data, flags & ~LDBM_SYNC );
#endif
LDBM_LOCK;
-#ifdef HAVE_BERKELEY_DB2
+#if DB_VERSION_MAJOR >= 3
+ rc = ldbm->del( ldbm, NULL, &key, 0 );
+ rc = (-1) * rc;
+#elif DB_VERSION_MAJOR >= 2
rc = (*ldbm->del)( ldbm, NULL, &key, 0 );
- rc = (-1 ) * rc;
+ rc = (-1) * rc;
#else
rc = (*ldbm->del)( ldbm, &key, 0 );
#endif
{
Datum key, data;
-#ifdef HAVE_BERKELEY_DB2
+#if DB_VERSION_MAJOR >= 2
LDBMCursor *dbci;
ldbm_datum_init( key );
LDBM_LOCK;
/* acquire a cursor for the DB */
+# if DB_VERSION_MAJOR >= 3
+ if ( ldbm->cursor( ldbm, NULL, &dbci, 0 ) )
+# elif defined( DB_VERSION_MAJOR ) && defined( DB_VERSION_MINOR ) && \
+ (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR < 6)
-# if defined( DB_VERSION_MAJOR ) && defined( DB_VERSION_MINOR ) && \
- DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR < 6
-
- if ( (*ldbm->cursor)( ldbm, NULL, &dbci ))
+ if ( (*ldbm->cursor)( ldbm, NULL, &dbci ))
# else
if ( (*ldbm->cursor)( ldbm, NULL, &dbci, 0 ))
key.dsize = 0;
}
-#ifdef HAVE_BERKELEY_DB2
+#if DB_VERSION_MAJOR >= 2
}
#endif
{
Datum data;
-#ifdef HAVE_BERKELEY_DB2
+#if DB_VERSION_MAJOR >= 2
ldbm_datum_init( data );
ldbm_datum_free( ldbm, key );
return( errno );
}
+/******************************************************************
+ * *
+ * END Berkeley section *
+ * *
+ ******************************************************************/
+
#elif defined( HAVE_GDBM )
#ifdef HAVE_ST_BLKSIZE
#ifdef HAVE_ST_BLKSIZE
if ( dbcachesize > 0 && stat( name, &st ) == 0 ) {
- dbcachesize = (dbcachesize / st.st_blksize);
+ dbcachesize /= st.st_blksize;
+ if( dbcachesize == 0 ) dbcachesize = 1;
gdbm_setopt( db, GDBM_CACHESIZE, &dbcachesize, sizeof(int) );
}
#else
- dbcachesize = (dbcachesize / 4096);
- gdbm_setopt( db, GDBM_CACHESIZE, &dbcachesize, sizeof(int) );
+ if ( dbcachesize > 0 ) {
+ dbcachesize /= 4096;
+ if( dbcachesize == 0 ) dbcachesize = 1;
+ gdbm_setopt( db, GDBM_CACHESIZE, &dbcachesize, sizeof(int) );
+ }
#endif
LDBM_UNLOCK;
d = gdbm_firstkey( ldbm );
LDBM_UNLOCK;
+ if ( d.dptr != NULL ) {
+ *dbcp = (Datum *) malloc( sizeof( Datum ) );
+ **dbcp = ldbm_datum_dup( ldbm, d );
+ }
+
return d;
}
Datum d;
LDBM_LOCK;
- d = gdbm_nextkey( ldbm, key );
+ d = gdbm_nextkey( ldbm, *dbcp );
LDBM_UNLOCK;
+ ldbm_datum_free( ldbm, *dbcp );
+
+ if ( d.dptr != NULL ) {
+ *dbcp = ldbm_datum_dup( ldbm, d );
+ } else {
+ free( dbcp );
+ }
+
return d;
}
void
ldbm_sync( LDBM ldbm )
{
-
/* XXX: Not sure if this is re-entrant need to check code, if so
* you can leave LOCKS out.
*/
LDBM_LOCK;
mdbm_sync( ldbm );
- LDBM_UNLOCK;
-
+ LDBM_UNLOCK;
}
k.key.dsize = key.dsize + 1;
k.key.dptr = malloc(k.key.dsize);
*(k.key.dptr) = 'l';
- memcpy( (void *)(k.key.dptr + 1), key.dptr, key.dsize );
+ AC_MEMCPY( (void *)(k.key.dptr + 1), key.dptr, key.dsize );
#else
k.key = key;
#endif
if ( d.dsize > 0 ) {
if ( k.val.dptr != NULL ) {
-
- free( k.val.dptr );
-
+ free( k.val.dptr );
}
if ( (k.val.dptr = malloc( d.dsize )) != NULL ) {
int_key.dsize = key.dsize + 1;
int_key.dptr = malloc( int_key.dsize );
*(int_key.dptr) = 'l'; /* Must not be NULL !*/
- memcpy( (void *)(int_key.dptr + 1), key.dptr, key.dsize );
+ AC_MEMCPY( (void *)(int_key.dptr + 1), key.dptr, key.dsize );
#else
int_key = key;
#endif
int_key.dsize = key.dsize + 1;
int_key.dptr = malloc(int_key.dsize);
*(int_key.dptr) = 'l';
- memcpy( (void *)(int_key.dptr + 1), key.dptr, key.dsize );
+ AC_MEMCPY( (void *)(int_key.dptr + 1), key.dptr, key.dsize );
#else
int_key = key;
#endif
#endif
return( rc );
-
}
static Datum
ldbm_get_next( LDBM ldbm, kvpair (*fptr)(MDBM *, kvpair) )
{
-
kvpair out;
kvpair in;
Datum ret;
out = fptr( ldbm, in );
if (out.key.dsize > 0) {
+ ret.dsize = out.key.dsize - delta;
- ret.dsize = out.key.dsize - delta;
- if ((ret.dptr = (char *)malloc(ret.dsize)) == NULL) {
-
- ret.dsize = 0;
- ret.dptr = NULL;
-
- } else {
-
- memcpy(ret.dptr, (void *)(out.key.dptr + delta),
- ret.dsize );
+ if ((ret.dptr = (char *)malloc(ret.dsize)) == NULL) {
+ ret.dsize = 0;
+ ret.dptr = NULL;
+ } else {
+ AC_MEMCPY(ret.dptr, (void *)(out.key.dptr + delta),
+ ret.dsize );
}
-
}
/* LDBM_UNLOCK; */
free(in.key.dptr);
-
return ret;
-
}
-
-
-
Datum
ldbm_firstkey( LDBM ldbm, LDBMCursor **dbcp )
{
-
return ldbm_get_next( ldbm, mdbm_first );
-
}
-
-
-
Datum
ldbm_nextkey( LDBM ldbm, Datum key, LDBMCursor *dbcp )
{
-
/* XXX:
- * don't know if this will affect the LDAP server opertaion
+ * don't know if this will affect the LDAP server operation
* but mdbm cannot take and input key.
*/
return ldbm_get_next( ldbm, mdbm_next );
-
}
int
{
/* XXX: best we can do with current mdbm interface */
return( errno );
-
}
projects / openldap / blobdiff