/* ldbm.c - ldap dbm compatibility routines */
/* $OpenLDAP$ */
/*
- * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.
+ * Copyright 1998-2002 The OpenLDAP Foundation, All Rights Reserved.
* COPYING RESTRICTIONS APPLY, see COPYRIGHT file
*/
/* Patched for Berkeley DB version 2.0; /KSp; 98/02/23
- *
* - DB version 2.6.4b ; 1998/12/28, /KSp
* - DB_DBT_MALLOC ; 1998/03/22, /KSp
* - basic implementation; 1998/02/23, /KSp
}
}
-
Datum
ldbm_datum_dup( LDBM ldbm, Datum data )
{
static int ldbm_initialized = 0;
-#ifdef HAVE_BERKELEY_DB_THREAD
-#define LDBM_LOCK ((void) 0)
-#define LDBM_UNLOCK ((void) 0)
+#if defined( USE_BERKELEY_CDB )
+ /* not currently supported */
+#define LDBM_RWLOCK_INIT ((void) 0)
+#define LDBM_RWLOCK_DESTROY ((void) 0)
+#define LDBM_WLOCK ((void) 0)
+#define LDBM_WUNLOCK ((void) 0)
+#define LDBM_RLOCK ((void) 0)
+#define LDBM_RUNLOCK ((void) 0)
+
+#elif defined( HAVE_BERKELEY_DB_THREAD )
+static ldap_pvt_thread_rdwr_t ldbm_big_rdwr;
+#define LDBM_RWLOCK_INIT (ldap_pvt_thread_rdwr_init( &ldbm_big_rdwr ))
+#define LDBM_RWLOCK_DESTROY (ldap_pvt_thread_rdwr_destroy( &ldbm_big_rdwr ))
+#define LDBM_WLOCK (ldap_pvt_thread_rdwr_wlock(&ldbm_big_rdwr))
+#define LDBM_WUNLOCK (ldap_pvt_thread_rdwr_wunlock(&ldbm_big_rdwr))
+#define LDBM_RLOCK (ldap_pvt_thread_rdwr_rlock(&ldbm_big_rdwr))
+#define LDBM_RUNLOCK (ldap_pvt_thread_rdwr_runlock(&ldbm_big_rdwr))
+
#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))
+#define LDBM_RWLOCK_INIT (ldap_pvt_thread_mutex_init( &ldbm_big_mutex ))
+#define LDBM_RWLOCK_DESTROY (ldap_pvt_thread_mutex_destroy( &ldbm_big_mutex ))
+#define LDBM_WLOCK (ldap_pvt_thread_mutex_lock(&ldbm_big_mutex))
+#define LDBM_WUNLOCK (ldap_pvt_thread_mutex_unlock(&ldbm_big_mutex))
+#define LDBM_RLOCK LDBM_WLOCK
+#define LDBM_RUNLOCK LDBM_WUNLOCK
#endif
#if !defined( HAVE_BERKELEY_DB ) || (DB_VERSION_MAJOR < 3)
- /* a dbEnv for BERKELEYv2 */
+ /* a dbEnv for BERKELEYv2 */
DB_ENV *ldbm_Env = NULL; /* real or fake, depending on db and version */
#endif
-
/*******************************************************************
* *
* Create some special functions to initialize Berkeley DB for *
void *
ldbm_malloc( size_t size )
{
- return( calloc( 1, size ));
+ /* likely should use ber_mem* routines */
+ return( calloc( 1, size ) );
}
#ifdef LDAP_SYSLOG
#endif
}
-#if DB_VERSION_MAJOR < 3
-
int ldbm_initialize( const char* home )
{
+#if DB_VERSION_MAJOR < 3
int err;
u_int32_t envFlags;
+#endif
if(ldbm_initialized++) return 1;
minor < DB_VERSION_MINOR )
{
#ifdef LDAP_SYSLOG
- char error[BUFSIZ];
-
- sprintf( error, "%s (%d)\n", STRERROR( err ), err );
-
syslog( LOG_INFO,
"ldbm_initialize(): version mismatch\nexpected: %s\ngot: %s\n",
- DB_VERSION_STRING,
- version );
+ DB_VERSION_STRING, version );
#endif
-
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 = "==>";
- envFlags = DB_CREATE;
+ envFlags = DB_CREATE | DB_USE_ENVIRON;
/* 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
+ envFlags |= DB_THREAD;
#endif
- envFlags |= DB_USE_ENVIRON;
err = db_appinit( home, NULL, ldbm_Env, envFlags );
if ( err ) {
#ifdef LDAP_SYSLOG
- char error[BUFSIZ];
-
- sprintf( error, "%s (%d)\n", STRERROR( err ), err );
-
- syslog( LOG_INFO,
- "ldbm_initialize(): FATAL error in db_appinit() : %s\n",
- error );
+ syslog( LOG_INFO, "ldbm_initialize(): "
+ "FATAL error (%d) in db_appinit()\n", err );
#endif
return( 1 );
}
+#endif
+
+ LDBM_RWLOCK_INIT;
return 0;
}
{
if( !ldbm_initialized ) return 1;
+#if DB_VERSION_MAJOR < 3
db_appexit( ldbm_Env );
-
-#ifndef HAVE_BERKELEY_DB_THREAD
- ldap_pvt_thread_mutex_destroy( &ldbm_big_mutex );
#endif
+ LDBM_RWLOCK_DESTROY;
return 0;
}
-#else /* Berkeley v3 or greater */
-
-
-int ldbm_initialize( const char * home )
-{
- /* v3 uses ldbm_initialize_env */
- return 0;
-}
-
-
-int ldbm_shutdown( void )
-{
- 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 );
+ LDBM_RWLOCK_INIT;
return 0;
}
{
if( !ldbm_initialized ) return 1;
- ldap_pvt_thread_mutex_destroy( &ldbm_big_mutex );
+ LDBM_RWLOCK_DESTROY;
return 0;
}
#endif /* HAVE_BERKELEY_DB */
-
#if defined( HAVE_BERKELEY_DB ) && (DB_VERSION_MAJOR >= 3)
-
DB_ENV *ldbm_initialize_env(const char *home, int dbcachesize, int *envdirok)
{
DB_ENV *env = NULL;
int err;
u_int32_t envFlags;
- envFlags =
-#if defined( DB_PRIVATE ) /* comment out DB_PRIVATE setting to use */
- DB_PRIVATE | /* db_stat to view cache behavior */
-#endif
-#if defined( HAVE_BERKELEY_DB_THREAD )
- DB_THREAD |
-#endif
- DB_CREATE;
-
err = db_env_create( &env, 0 );
if ( err ) {
- char error[BUFSIZ];
-
- sprintf( error, "%s (%d)\n", STRERROR( err ), err );
-
#ifdef LDAP_SYSLOG
- syslog( LOG_INFO, "ldbm_initialize_env(): FATAL error in db_env_create() : %s\n", error );
+ syslog( LOG_INFO, "ldbm_initialize_env(): "
+ "FATAL error in db_env_create() : %s (%d)\n",
+ db_strerror( err ), err );
#endif
- return( NULL );
+ return NULL;
}
+#if DB_VERSION_MAJOR > 3 || DB_VERSION_MINOR >= 3
+ /* This interface appeared in 3.3 */
+ env->set_alloc( env, ldbm_malloc, NULL, NULL );
+#endif
+
env->set_errcall( env, ldbm_db_errcall );
env->set_errpfx( env, "==>" );
- if (dbcachesize)
+ if (dbcachesize) {
env->set_cachesize( env, 0, dbcachesize, 0 );
+ }
- envFlags |= DB_INIT_MPOOL | DB_INIT_CDB | DB_USE_ENVIRON;
+ envFlags = DB_CREATE | DB_INIT_MPOOL | DB_USE_ENVIRON;
+#ifdef DB_PRIVATE
+ envFlags |= DB_PRIVATE;
+#endif
+#ifdef DB_MPOOL_PRIVATE
+ envFlags |= DB_MPOOL_PRIVATE;
+#endif
+#ifdef HAVE_BERKELEY_DB_THREAD
+ envFlags |= DB_THREAD;
+#endif
+#if DB_VERSION_MAJOR > 3 || DB_VERSION_MINOR > 0
err = env->open( env, home, envFlags, 0 );
+#else
+ /* 3.0.x requires an extra argument */
+ err = env->open( env, home, NULL, envFlags, 0 );
+#endif
- if ( err != 0 )
- {
- char error[BUFSIZ];
-
- sprintf( error, "%s (%d)\n", STRERROR( err ), err );
-
+ if ( err != 0 ) {
#ifdef LDAP_SYSLOG
- syslog( LOG_INFO,
- "ldbm_initialize_env(): FATAL error in dbEnv->open() : %s\n",
- error );
+ syslog( LOG_INFO, "ldbm_initialize_env(): "
+ "FATAL error in dbEnv->open() : %s (%d)\n",
+ db_strerror( err ), err );
#endif
env->close( env, 0 );
- return( NULL );
+ return NULL;
}
*envdirok = 1;
env->close( env, 0 );
}
-
#else
DB_ENV *ldbm_initialize_env(const char *home, int dbcachesize, int *envdirok)
{
}
-
#endif
-
#if defined( LDBM_USE_DBHASH ) || defined( LDBM_USE_DBBTREE )
/*****************************************************************
ldbm_open( DB_ENV *env, char *name, int rw, int mode, int dbcachesize )
{
LDBM ret = NULL;
+#ifdef HAVE_EBCDIC
+ char n2[2048];
+#endif
#if DB_VERSION_MAJOR >= 3
int err;
- LDBM_LOCK;
+ LDBM_WLOCK;
err = db_create( &ret, env, 0 );
if ( err != 0 ) {
(void)ret->close(ret, 0);
- LDBM_UNLOCK;
+ LDBM_WUNLOCK;
return NULL;
}
- ret->set_pagesize( ret, DEFAULT_DB_PAGE_SIZE );
+#if DB_VERSION_MAJOR == 3 && DB_VERSION_MINOR < 3
ret->set_malloc( ret, ldbm_malloc );
- /* ret->set_cachesize( ret, 0, dbcachesize, 0 ); */
+#endif
+
+ ret->set_pagesize( ret, DEFAULT_DB_PAGE_SIZE );
+ /* likely should use ber_mem* routines */
+
+#ifdef HAVE_EBCDIC
+ strncpy(n2, name, sizeof(n2)-1);
+ n2[sizeof(n2)-1] = '\0';
+ __atoe(n2);
+ name = n2;
+#endif
+#if DB_VERSION_MAJOR >= 4 && DB_VERSION_MINOR > 0 && DB_VERSION_PATCH >= 17
+ err = ret->open( ret, NULL, name, NULL, DB_TYPE, rw, mode);
+#else
err = ret->open( ret, name, NULL, DB_TYPE, rw, mode);
+#endif
if ( err != 0 ) {
int tmp = errno;
(void)ret->close(ret, 0);
errno = tmp;
- LDBM_UNLOCK;
+ LDBM_WUNLOCK;
return NULL;
}
- LDBM_UNLOCK;
+ LDBM_WUNLOCK;
#elif DB_VERSION_MAJOR >= 2
DB_INFO dbinfo;
dbinfo.db_pagesize = DEFAULT_DB_PAGE_SIZE;
dbinfo.db_malloc = ldbm_malloc;
- LDBM_LOCK;
+ LDBM_WLOCK;
(void) db_open( name, DB_TYPE, rw, mode, ldbm_Env, &dbinfo, &ret );
- LDBM_UNLOCK;
+ LDBM_WUNLOCK;
#else
void *info;
info = NULL;
}
- LDBM_LOCK;
+ LDBM_WLOCK;
ret = dbopen( name, rw, mode, DB_TYPE, info );
- LDBM_UNLOCK;
+ LDBM_WUNLOCK;
#endif
return ret;
void
ldbm_close( LDBM ldbm )
{
- LDBM_LOCK;
-#if DB_VERSION_MAJOR >= 3
+ LDBM_WLOCK;
+#if DB_VERSION_MAJOR >= 2
ldbm->close( ldbm, 0 );
-#elif DB_VERSION_MAJOR >= 2
- (*ldbm->close)( ldbm, 0 );
#else
- (*ldbm->close)( ldbm );
+ ldbm->close( ldbm );
#endif
- LDBM_UNLOCK;
+ LDBM_WUNLOCK;
}
void
ldbm_sync( LDBM ldbm )
{
- LDBM_LOCK;
+ LDBM_WLOCK;
(*ldbm->sync)( ldbm, 0 );
- LDBM_UNLOCK;
+ LDBM_WUNLOCK;
}
Datum
Datum data;
int rc;
- LDBM_LOCK;
+ LDBM_RLOCK;
-#if DB_VERSION_MAJOR >= 3
+#if DB_VERSION_MAJOR >= 2
ldbm_datum_init( data );
data.flags = DB_DBT_MALLOC;
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 ) {
+ 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 );
}
#endif
- LDBM_UNLOCK;
+ LDBM_RUNLOCK;
return( data );
}
{
int rc;
- LDBM_LOCK;
+ LDBM_WLOCK;
-#if DB_VERSION_MAJOR >= 3
+#if DB_VERSION_MAJOR >= 2
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;
#else
- rc = (*ldbm->put)( ldbm, &key, &data, flags & ~LDBM_SYNC );
+ rc = ldbm->put( ldbm, &key, &data, flags & ~LDBM_SYNC );
#endif
if ( flags & LDBM_SYNC )
- (*ldbm->sync)( ldbm, 0 );
+ ldbm->sync( ldbm, 0 );
- LDBM_UNLOCK;
+ LDBM_WUNLOCK;
return( rc );
}
{
int rc;
- LDBM_LOCK;
+ LDBM_WLOCK;
-#if DB_VERSION_MAJOR >= 3
+#if DB_VERSION_MAJOR >= 2
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;
#else
- rc = (*ldbm->del)( ldbm, &key, 0 );
+ rc = ldbm->del( ldbm, &key, 0 );
#endif
- (*ldbm->sync)( ldbm, 0 );
+ ldbm->sync( ldbm, 0 );
- LDBM_UNLOCK;
+ LDBM_WUNLOCK;
return( rc );
}
ldbm_firstkey( LDBM ldbm, LDBMCursor **dbch )
{
Datum key, data;
+ int rc;
#if DB_VERSION_MAJOR >= 2
LDBMCursor *dbci;
key.flags = data.flags = DB_DBT_MALLOC;
- LDBM_LOCK;
+ LDBM_RLOCK;
/* 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 ( (*ldbm->cursor)( ldbm, NULL, &dbci ))
+# if DB_VERSION_MAJOR >= 3 || (DB_VERSION_MAJOR == 2 && DB_VERSION_MINOR > 5)
+ rc = ldbm->cursor( ldbm, NULL, &dbci, 0 );
+# else
+ rc = ldbm->cursor( ldbm, NULL, &dbci );
+# endif
-# else
- if ( (*ldbm->cursor)( ldbm, NULL, &dbci, 0 ))
-# endif
- {
+ if( rc ) {
key.dptr = NULL;
- return( key );
} else {
*dbch = dbci;
- if ( (*dbci->c_get)( dbci, &key, &data, DB_NEXT ) == 0 ) {
+ if ( dbci->c_get( dbci, &key, &data, DB_NEXT ) == 0 ) {
ldbm_datum_free( ldbm, data );
+ } else {
+ key.dptr = NULL;
+ key.dsize = 0;
}
- else {
+ }
+
+ LDBM_RUNLOCK;
+
#else
- int rc;
+ LDBM_RLOCK;
- LDBM_LOCK;
+ rc = ldbm->seq( ldbm, &key, &data, R_FIRST );
- if ( (rc = (*ldbm->seq)( ldbm, &key, &data, R_FIRST )) == 0 ) {
+ if ( rc == 0 ) {
key = ldbm_datum_dup( ldbm, key );
- }
- else {
-#endif
+ } else {
key.dptr = NULL;
key.dsize = 0;
}
-#if DB_VERSION_MAJOR >= 2
- }
+ LDBM_RUNLOCK;
#endif
- LDBM_UNLOCK;
-
return( key );
}
Datum
ldbm_nextkey( LDBM ldbm, Datum key, LDBMCursor *dbcp )
{
+ int rc;
Datum data;
+ LDBM_RLOCK;
+
#if DB_VERSION_MAJOR >= 2
ldbm_datum_init( data );
ldbm_datum_free( ldbm, key );
key.flags = data.flags = DB_DBT_MALLOC;
- LDBM_LOCK;
-
- if ( (*dbcp->c_get)( dbcp, &key, &data, DB_NEXT ) == 0 ) {
+ rc = dbcp->c_get( dbcp, &key, &data, DB_NEXT );
+ if ( rc == 0 ) {
ldbm_datum_free( ldbm, data );
- }
- else {
+ } else
#else
- int rc;
-
- LDBM_LOCK;
+ rc = ldbm->seq( ldbm, &key, &data, R_NEXT );
- if ( (rc = (*ldbm->seq)( ldbm, &key, &data, R_NEXT )) == 0 ) {
+ if ( rc == 0 ) {
key = ldbm_datum_dup( ldbm, key );
- }
- else {
+ } else
#endif
+ {
key.dptr = NULL;
key.dsize = 0;
}
- LDBM_UNLOCK;
-
+ LDBM_RUNLOCK;
return( key );
}
#ifdef HAVE_ST_BLKSIZE
struct stat st;
#endif
+#ifdef HAVE_EBCDIC
+ char n2[2048];
- LDBM_LOCK;
+ strncpy(n2, name, sizeof(n2)-1);
+ n2[sizeof(n2)-1] = '\0';
+ __atoe(n2);
+ name = n2;
+#endif
+
+ LDBM_WLOCK;
- if ( (db = gdbm_open( name, 0, rw | GDBM_FAST, mode, 0 )) == NULL ) {
- LDBM_UNLOCK;
+ if ( (db = gdbm_open( name, 0, rw | GDBM_FAST, mode, 0 )) == NULL ) {
+ LDBM_WUNLOCK;
return( NULL );
}
}
#endif
- LDBM_UNLOCK;
+ LDBM_WUNLOCK;
return( db );
}
void
ldbm_close( LDBM ldbm )
{
- LDBM_LOCK;
+ LDBM_WLOCK;
gdbm_close( ldbm );
- LDBM_UNLOCK;
+ LDBM_WUNLOCK;
}
void
ldbm_sync( LDBM ldbm )
{
- LDBM_LOCK;
+ LDBM_WLOCK;
gdbm_sync( ldbm );
- LDBM_UNLOCK;
+ LDBM_WUNLOCK;
}
Datum
{
Datum d;
- LDBM_LOCK;
+ LDBM_RLOCK;
d = gdbm_fetch( ldbm, key );
- LDBM_UNLOCK;
+ LDBM_RUNLOCK;
return d;
}
{
int rc;
- LDBM_LOCK;
+ LDBM_WLOCK;
rc = gdbm_store( ldbm, key, data, flags & ~LDBM_SYNC );
if ( flags & LDBM_SYNC )
gdbm_sync( ldbm );
- LDBM_UNLOCK;
+ LDBM_WUNLOCK;
return( rc );
}
{
int rc;
- LDBM_LOCK;
+ LDBM_WLOCK;
rc = gdbm_delete( ldbm, key );
gdbm_sync( ldbm );
- LDBM_UNLOCK;
+ LDBM_WUNLOCK;
return( rc );
}
{
Datum d;
- LDBM_LOCK;
+ LDBM_RLOCK;
d = gdbm_firstkey( ldbm );
- LDBM_UNLOCK;
+ LDBM_RUNLOCK;
if ( d.dptr != NULL ) {
*dbcp = (Datum *) malloc( sizeof( Datum ) );
{
Datum d;
- LDBM_LOCK;
+ LDBM_RLOCK;
d = gdbm_nextkey( ldbm, *dbcp );
- LDBM_UNLOCK;
+ LDBM_RUNLOCK;
ldbm_datum_free( ldbm, *dbcp );
{
int err;
- LDBM_LOCK;
+ LDBM_WLOCK;
err = gdbm_errno;
- LDBM_UNLOCK;
+ LDBM_WUNLOCK;
return( err );
}
/* Use chaining */
-
#define mdbm_store mdbm_chain_store
#define mdbm_fetch mdbm_chain_fetch
#define mdbm_delete mdbm_chain_delete
fflush( stdout );
#endif
- LDBM_LOCK; /* We need locking here, this is the only non-thread
- * safe function we have.
- */
+ LDBM_WLOCK; /* We need locking here, this is the only non-thread
+ * safe function we have. */
if ( (db = mdbm_open( name, rw, mode, MDBM_PG_SZ )) == NULL ) {
-
- LDBM_UNLOCK;
+ LDBM_WUNLOCK;
#ifdef MDBM_DEBUG
fprintf( stdout, "<==(mdbm)ldbm_open(db=NULL)\n" );
fflush( stdout );
#endif
return( NULL );
-
}
#ifdef MDBM_CHAIN
(void)mdbm_set_chain(db);
#endif
- LDBM_UNLOCK;
+ LDBM_WUNLOCK;
#ifdef MDBM_DEBUG
fprintf( stdout, "<==(mdbm)ldbm_open(db=%p)\n", db );
#endif
return( db );
-
}
-
-
-
void
ldbm_close( LDBM ldbm )
{
-
/* Open and close are not reentrant so we need to use locks here */
#ifdef MDBM_DEBUG
fflush( stdout );
#endif
- LDBM_LOCK;
+ LDBM_WLOCK;
mdbm_close( ldbm );
- LDBM_UNLOCK;
+ LDBM_WUNLOCK;
#ifdef MDBM_DEBUG
fprintf( stdout, "<==(mdbm)ldbm_close()\n" );
fflush( stdout );
#endif
-
}
-
-
-
void
ldbm_sync( LDBM ldbm )
{
* you can leave LOCKS out.
*/
- LDBM_LOCK;
+ LDBM_WLOCK;
mdbm_sync( ldbm );
- LDBM_UNLOCK;
+ LDBM_WUNLOCK;
}
-
#define MAX_MDBM_RETRY 5
Datum
* mode.
*/
- /* LDBM_LOCK; */
-
#ifdef NO_NULL_KEY
k.key.dsize = key.dsize + 1;
k.key.dptr = malloc(k.key.dsize);
k.val.dptr = NULL;
k.val.dsize = 0;
+ /* LDBM_RLOCK; */
do {
-
d = mdbm_fetch( ldbm, k );
if ( d.dsize > 0 ) {
-
if ( k.val.dptr != NULL ) {
free( k.val.dptr );
}
if ( (k.val.dptr = malloc( d.dsize )) != NULL ) {
-
k.val.dsize = d.dsize;
d = mdbm_fetch( ldbm, k );
} else {
-
d.dsize = 0;
break;
-
}
-
}/* if ( d.dsize > 0 ) */
-
} while ((d.dsize > k.val.dsize) && (++retry < MAX_MDBM_RETRY));
-
- /* LDBM_UNLOCK; */
+ /* LDBM_RUNLOCK; */
#ifdef NO_NULL_KEY
free(k.key.dptr);
#endif
return d;
-
}
-
-
-
int
ldbm_store( LDBM ldbm, Datum key, Datum data, int flags )
{
fflush( stdout );
#endif
- /* LDBM_LOCK; */
+ /* LDBM_WLOCK; */
#ifdef NO_NULL_KEY
int_key.dsize = key.dsize + 1;
mdbm_sync( ldbm );
}
- /* LDBM_UNLOCK; */
+ /* LDBM_WUNLOCK; */
#ifdef MDBM_DEBUG
fprintf( stdout, "<==(mdbm)ldbm_store(rc=%d)\n", rc );
#endif
return( rc );
-
}
-
-
int
ldbm_delete( LDBM ldbm, Datum key )
{
int rc;
Datum int_key;
- /* LDBM_LOCK; */
+ /* LDBM_WLOCK; */
#ifdef NO_NULL_KEY
int_key.dsize = key.dsize + 1;
rc = mdbm_delete( ldbm, int_key );
- /* LDBM_UNLOCK; */
+ /* LDBM_WUNLOCK; */
#ifdef NO_NULL_KEY
free(int_key.dptr);
#endif
return( rc );
}
-
-
-
static Datum
ldbm_get_next( LDBM ldbm, kvpair (*fptr)(MDBM *, kvpair) )
{
int delta = 0;
#endif
- /* LDBM_LOCK; */
+ /* LDBM_RLOCK; */
in.key.dsize = sz; /* Assume first key in one pg */
in.key.dptr = malloc(sz);
}
}
- /* LDBM_UNLOCK; */
+ /* LDBM_RUNLOCK; */
free(in.key.dptr);
return ret;
return( errno );
}
-
-
-
#elif defined( HAVE_NDBM )
/*****************************************************************
{
LDBM ldbm;
- LDBM_LOCK;
+ LDBM_WLOCK;
ldbm = dbm_open( name, rw, mode );
- LDBM_UNLOCK;
+ LDBM_WUNLOCK;
return( ldbm );
}
void
ldbm_close( LDBM ldbm )
{
- LDBM_LOCK;
+ LDBM_WLOCK;
dbm_close( ldbm );
- LDBM_UNLOCK;
+ LDBM_WUNLOCK;
}
/* ARGSUSED */
{
Datum d;
- LDBM_LOCK;
+ LDBM_RLOCK;
d = ldbm_datum_dup( ldbm, dbm_fetch( ldbm, key ) );
- LDBM_UNLOCK;
+ LDBM_RUNLOCK;
return d;
}
{
int rc;
- LDBM_LOCK;
+ LDBM_WLOCK;
rc = dbm_store( ldbm, key, data, flags );
- LDBM_UNLOCK;
+ LDBM_WUNLOCK;
return rc;
}
{
int rc;
- LDBM_LOCK;
+ LDBM_WLOCK;
rc = dbm_delete( ldbm, key );
- LDBM_UNLOCK;
+ LDBM_WUNLOCK;
return rc;
}
{
Datum d;
- LDBM_LOCK;
+ LDBM_RLOCK;
d = dbm_firstkey( ldbm );
- LDBM_UNLOCK;
+ LDBM_RUNLOCK;
return d;
}
{
Datum d;
- LDBM_LOCK;
+ LDBM_RLOCK;
d = dbm_nextkey( ldbm );
- LDBM_UNLOCK;
+ LDBM_RUNLOCK;
return d;
}
{
int err;
- LDBM_LOCK;
+ LDBM_WLOCK;
err = dbm_error( ldbm );
- LDBM_UNLOCK;
+ LDBM_WUNLOCK;
return err;
}
projects / openldap / blobdiff