static int
alock_query_slot ( alock_info_t * info )
{
- int res;
+ int res, nosave;
alock_slot_t slot_data;
assert (info != NULL);
if (slot_data.al_appname != NULL) free (slot_data.al_appname);
slot_data.al_appname = NULL;
- if (slot_data.al_lock == ALOCK_UNLOCKED) return ALOCK_UNLOCKED;
+ nosave = slot_data.al_lock & ALOCK_NOSAVE;
+
+ if ((slot_data.al_lock & ALOCK_SMASK) == ALOCK_UNLOCKED)
+ return slot_data.al_lock;
res = alock_test_lock (info->al_fd, info->al_slot);
if (res < 0) return -1;
if (res > 0) {
- if (slot_data.al_lock == ALOCK_UNIQUE) {
- return ALOCK_UNIQUE;
+ if ((slot_data.al_lock & ALOCK_SMASK) == ALOCK_UNIQUE) {
+ return slot_data.al_lock;
} else {
- return ALOCK_LOCKED;
+ return ALOCK_LOCKED | nosave;
}
}
- return ALOCK_DIRTY;
+ return ALOCK_DIRTY | nosave;
}
int
alock_slot_t slot_data;
char * filename;
int res, max_slot;
- int dirty_count, live_count;
+ int dirty_count, live_count, nosave;
assert (info != NULL);
assert (appname != NULL);
assert (envdir != NULL);
- assert (locktype >= 1 && locktype <= 2);
+ assert ((locktype & ALOCK_SMASK) >= 1 && (locktype & ALOCK_SMASK) <= 2);
slot_data.al_lock = locktype;
slot_data.al_stamp = time(NULL);
max_slot = (statbuf.st_size + ALOCK_SLOT_SIZE - 1) / ALOCK_SLOT_SIZE;
dirty_count = 0;
live_count = 0;
+ nosave = 0;
scan_info.al_fd = info->al_fd;
for (scan_info.al_slot = 1;
scan_info.al_slot < max_slot;
if (scan_info.al_slot != info->al_slot) {
res = alock_query_slot (&scan_info);
+ if (res & ALOCK_NOSAVE) {
+ nosave = ALOCK_NOSAVE;
+ res ^= ALOCK_NOSAVE;
+ }
if (res == ALOCK_UNLOCKED
&& info->al_slot == 0) {
info->al_slot = scan_info.al_slot;
return ALOCK_UNSTABLE;
}
- if (dirty_count) return ALOCK_RECOVER;
- return ALOCK_CLEAN;
+ if (dirty_count) return ALOCK_RECOVER | nosave;
+ return ALOCK_CLEAN | nosave;
}
int
struct stat statbuf;
alock_info_t scan_info;
int res, max_slot;
- int dirty_count, live_count;
+ int dirty_count, live_count, nosave;
assert (info != NULL);
max_slot = (statbuf.st_size + ALOCK_SLOT_SIZE - 1) / ALOCK_SLOT_SIZE;
dirty_count = 0;
live_count = 0;
+ nosave = 0;
for (scan_info.al_slot = 1;
scan_info.al_slot < max_slot;
++ scan_info.al_slot) {
if (scan_info.al_slot != info->al_slot) {
res = alock_query_slot (&scan_info);
+ if (res & ALOCK_NOSAVE) {
+ nosave = ALOCK_NOSAVE;
+ res ^= ALOCK_NOSAVE;
+ }
+
if (res == ALOCK_LOCKED) {
++live_count;
close (info->al_fd);
return ALOCK_UNSTABLE;
} else {
- return ALOCK_RECOVER;
+ return ALOCK_RECOVER | nosave;
}
}
- return ALOCK_CLEAN;
+ return ALOCK_CLEAN | nosave;
}
int
free (slot_data.al_appname);
return ALOCK_UNSTABLE;
}
- slot_data.al_lock = ALOCK_UNLOCKED;
+ slot_data.al_lock = ALOCK_UNLOCKED | (slot_data.al_lock & ALOCK_NOSAVE);
res = alock_write_slot (info, &slot_data);
if (res == -1) {
close (info->al_fd);
scan_info.al_slot < max_slot;
++ scan_info.al_slot) {
if (scan_info.al_slot != info->al_slot) {
- res = alock_query_slot (&scan_info);
+ res = alock_query_slot (&scan_info) & ~ALOCK_NOSAVE;
if (res == ALOCK_LOCKED
|| res == ALOCK_UNIQUE) {
bdb->bi_dbenv_mode = SLAPD_DEFAULT_DB_MODE;
bdb->bi_cache.c_maxsize = DEFAULT_CACHE_SIZE;
+ bdb->bi_cache.c_minfree = 1;
bdb->bi_lock_detect = DB_LOCK_DEFAULT;
bdb->bi_search_stack_depth = DEFAULT_SEARCH_STACK_DEPTH;
u_int32_t flags;
char path[MAXPATHLEN];
char *dbhome;
- int do_recover = 0, do_alock_recover = 0, open_env = 1, got_env = 0;
+ int do_recover = 0, do_alock_recover = 0, open_env = 1;
+ int alockt, quick = 0;
if ( be->be_suffix == NULL ) {
Debug( LDAP_DEBUG_ANY,
}
/* Perform database use arbitration/recovery logic */
+ alockt = (slapMode & SLAP_TOOL_READONLY) ? ALOCK_LOCKED : ALOCK_UNIQUE;
+ if ( slapMode & SLAP_TOOL_QUICK ) {
+ alockt |= ALOCK_NOSAVE;
+ quick = 1;
+ }
+
rc = alock_open( &bdb->bi_alock_info,
"slapd",
- bdb->bi_dbenv_home,
- slapMode & SLAP_TOOL_READONLY ?
- ALOCK_LOCKED : ALOCK_UNIQUE );
+ bdb->bi_dbenv_home, alockt );
+
+ /* alockt is TRUE if the existing environment was created in Quick mode */
+ alockt = (rc & ALOCK_NOSAVE) ? 1 : 0;
+ rc &= ~ALOCK_NOSAVE;
if( rc == ALOCK_RECOVER ) {
Debug( LDAP_DEBUG_ANY,
" attempting recovery.\n",
0, 0, 0 );
do_alock_recover = 1;
- do_recover = 1;
+ do_recover = DB_RECOVER;
} else if( rc == ALOCK_BUSY ) {
Debug( LDAP_DEBUG_ANY,
"bdb_db_open: database already in use\n",
"bdb_db_open: DB_CONFIG for suffix %s has changed.\n"
"Performing database recovery to activate new settings.\n",
be->be_suffix[0].bv_val, 0, 0 );
- do_recover = 1;
+ do_recover = DB_RECOVER;
}
}
}
bdb->bi_dbenv_home, errno, be->be_suffix[0].bv_val );
}
+ /* Always let slapcat run, regardless of environment state.
+ * This can be used to cause a cache flush after an unclean
+ * shutdown.
+ */
+ if ( do_recover && ( slapMode & SLAP_TOOL_READONLY )) {
+ Debug( LDAP_DEBUG_ANY,
+ "bdb_db_open: Recovery skipped in read-only mode. "
+ "Run manual recovery if errors are encountered.\n",
+ 0, 0, 0 );
+ do_recover = 0;
+ quick = alockt;
+ }
+
+ /* An existing environment in Quick mode has nothing to recover. */
+ if ( alockt && do_recover ) {
+ Debug( LDAP_DEBUG_ANY,
+ "bdb_db_open: cannot recover, database must be reinitialized.\n",
+ 0, 0, 0 );
+ rc = -1;
+ goto fail;
+ }
+
rc = db_env_create( &bdb->bi_dbenv, 0 );
if( rc != 0 ) {
Debug( LDAP_DEBUG_ANY,
goto fail;
}
+ /* If existing environment is clean but doesn't support
+ * currently requested modes, remove it.
+ */
+ if ( !do_recover && ( alockt ^ quick )) {
+ rc = bdb->bi_dbenv->remove( bdb->bi_dbenv, dbhome, DB_FORCE );
+ if ( rc ) {
+ Debug( LDAP_DEBUG_ANY,
+ "bdb_db_open: dbenv remove failed: %s (%d)\n",
+ db_strerror(rc), rc, 0 );
+ bdb->bi_dbenv = NULL;
+ goto fail;
+ }
+ rc = db_env_create( &bdb->bi_dbenv, 0 );
+ if( rc != 0 ) {
+ Debug( LDAP_DEBUG_ANY,
+ "bdb_db_open: db_env_create failed: %s (%d)\n",
+ db_strerror(rc), rc, 0 );
+ goto fail;
+ }
+ }
+
bdb->bi_dbenv->set_errpfx( bdb->bi_dbenv, be->be_suffix[0].bv_val );
bdb->bi_dbenv->set_errcall( bdb->bi_dbenv, bdb_errcall );
"bdb_db_open: dbenv_open(%s)\n",
bdb->bi_dbenv_home, 0, 0);
- /* Check if there is a usable existing environment */
- flags = DB_JOINENV | DB_THREAD;
-
- rc = bdb->bi_dbenv->open( bdb->bi_dbenv, dbhome,
- flags, bdb->bi_dbenv_mode );
- if( rc == 0 ) {
- int flags_ok = 0;
-
- got_env = 1;
-
- rc = bdb->bi_dbenv->get_open_flags( bdb->bi_dbenv, &flags );
- if ( rc == 0 ) {
- int flag2 = flags & BDB_TXN_FLAGS;
-
- /* In quick mode, none of these flags are allowed */
- if ( slapMode & SLAP_TOOL_QUICK ) {
- if ( !flag2 )
- flags_ok = 1;
- } else {
- /* In normal mode, all of these flags are required */
- if ( flag2 == BDB_TXN_FLAGS )
- flags_ok = 1;
- }
- }
-
- /* In Quick mode, we cannot Recover... */
- if ( slapMode & SLAP_TOOL_QUICK ) {
- /* If we need to recover but we had no TXNs, just fail */
- if ( do_recover && flags_ok ) {
- Debug( LDAP_DEBUG_ANY,
- "bdb_db_open: Database cannot be recovered. "
- "Restore from backup!\n", 0, 0, 0);
- rc = -1;
- goto fail;
- }
- /* We need to recover, and we had TXN support before:
- * Close this env, open a new one with recovery flags.
- */
- if ( do_recover ) {
- bdb->bi_dbenv->close( bdb->bi_dbenv, 0 );
- bdb->bi_dbenv = NULL;
- rc = db_env_create( &bdb->bi_dbenv, 0 );
- if( rc != 0 ) {
- Debug( LDAP_DEBUG_ANY,
- "bdb_db_open: db_env_create failed: %s (%d)\n",
- db_strerror(rc), rc, 0 );
- goto fail;
- }
- bdb->bi_dbenv->set_errpfx( bdb->bi_dbenv,
- be->be_suffix[0].bv_val );
- bdb->bi_dbenv->set_errcall( bdb->bi_dbenv, bdb_errcall );
- rc = bdb->bi_dbenv->open( bdb->bi_dbenv, dbhome,
- flags | DB_RECOVER, bdb->bi_dbenv_mode );
- if( rc != 0 ) {
- Debug( LDAP_DEBUG_ANY,
- "bdb_db_open: recovery failed: %s (%d)\n",
- db_strerror(rc), rc, 0 );
- goto fail;
- }
- do_recover = 0;
- }
- /* Prev environment had TXN support, get rid of it */
- if ( !flags_ok ) {
- bdb->bi_dbenv->close( bdb->bi_dbenv, 0 );
- bdb->bi_dbenv = NULL;
- rc = db_env_create( &bdb->bi_dbenv, 0 );
- if( rc != 0 ) {
- Debug( LDAP_DEBUG_ANY,
- "bdb_db_open: db_env_create failed: %s (%d)\n",
- db_strerror(rc), rc, 0 );
- goto fail;
- }
- bdb->bi_dbenv->remove( bdb->bi_dbenv, dbhome, 0 );
- bdb->bi_dbenv = NULL;
- }
- /* Normal TXN mode */
- } else {
- /* If we need to recover but we had no TXNs, just fail */
- if ( do_recover && !flags_ok ) {
- Debug( LDAP_DEBUG_ANY,
- "bdb_db_open: Database cannot be recovered. "
- "Restore from backup!\n", 0, 0, 0);
- rc = -1;
- goto fail;
- }
- /* Prev environment had no TXN support, close it */
- if ( !flags_ok ) {
- bdb->bi_dbenv->close( bdb->bi_dbenv, 0 );
- bdb->bi_dbenv = NULL;
- do_recover = 1;
- }
- }
-
- if ( flags_ok && !do_recover ) {
- /* This environment is fine, don't reopen it */
- open_env = 0;
- } else {
- /* Create a new env that can take the desired settings */
- if ( bdb->bi_dbenv != NULL ) {
- bdb->bi_dbenv->close( bdb->bi_dbenv, 0 );
- bdb->bi_dbenv = NULL;
- }
- rc = db_env_create( &bdb->bi_dbenv, 0 );
- if( rc != 0 ) {
- Debug( LDAP_DEBUG_ANY,
- "bdb_db_open: db_env_create failed: %s (%d)\n",
- db_strerror(rc), rc, 0 );
- goto fail;
- }
+ flags = DB_INIT_MPOOL | DB_CREATE | DB_THREAD;
- bdb->bi_dbenv->set_errpfx( bdb->bi_dbenv, be->be_suffix[0].bv_val );
- bdb->bi_dbenv->set_errcall( bdb->bi_dbenv, bdb_errcall );
- bdb->bi_dbenv->set_lk_detect( bdb->bi_dbenv, bdb->bi_lock_detect );
-
- /* One long-lived TXN per thread, two TXNs per write op */
- bdb->bi_dbenv->set_tx_max( bdb->bi_dbenv, connection_pool_max * 3 );
-
- if( bdb->bi_dbenv_xflags != 0 ) {
- rc = bdb->bi_dbenv->set_flags( bdb->bi_dbenv,
- bdb->bi_dbenv_xflags, 1);
- if( rc != 0 ) {
- Debug( LDAP_DEBUG_ANY,
- "bdb_db_open: dbenv_set_flags failed: %s (%d)\n",
- db_strerror(rc), rc, 0 );
- goto fail;
- }
- }
- }
- }
+ if ( !quick )
+ flags |= BDB_TXN_FLAGS;
- /* If we need to recover but there was no existing environment,
- * then we assume that someone has already manually recovered using
- * db_recover. Just ignore it.
- */
- if ( do_recover && !got_env ) {
- do_recover = 0;
- Debug( LDAP_DEBUG_TRACE,
- "bdb_db_open: Recovery needed but environment is missing - "
- "assuming recovery was done manually...\n", 0, 0, 0 );
+ /* If a key was set, use shared memory for the BDB environment */
+ if ( bdb->bi_shm_key ) {
+ bdb->bi_dbenv->set_shm_key( bdb->bi_dbenv, bdb->bi_shm_key );
+ flags |= DB_SYSTEM_MEM;
}
+ rc = bdb->bi_dbenv->open( bdb->bi_dbenv, dbhome,
+ flags | do_recover, bdb->bi_dbenv_mode );
- if ( open_env ) {
- flags = DB_INIT_MPOOL | DB_THREAD | DB_CREATE;
- if ( !( slapMode & SLAP_TOOL_QUICK ))
- flags |= BDB_TXN_FLAGS;
-
- if ( do_recover ) {
- if ( slapMode & SLAP_TOOL_READONLY ) {
- Debug( LDAP_DEBUG_ANY,
- "bdb_db_open: Recovery skipped in read-only mode. "
- "Run manual recovery if errors are encountered.\n",
- 0, 0, 0 );
- } else {
- flags |= DB_RECOVER;
- }
- }
-
- /* If a key was set, use shared memory for the BDB environment */
- if ( bdb->bi_shm_key ) {
- bdb->bi_dbenv->set_shm_key( bdb->bi_dbenv, bdb->bi_shm_key );
- flags |= DB_SYSTEM_MEM;
- }
-
- rc = bdb->bi_dbenv->open( bdb->bi_dbenv, dbhome,
- flags, bdb->bi_dbenv_mode );
- if( rc != 0 ) {
- Debug( LDAP_DEBUG_ANY,
- "bdb_db_open: dbenv_open failed: %s (%d)\n",
- db_strerror(rc), rc, 0 );
- goto fail;
- }
+ if ( rc ) {
+ Debug( LDAP_DEBUG_ANY,
+ "bdb_db_open: Database cannot be %s, err %d. "
+ "Restore from backup!\n",
+ do_recover ? "recovered" : "opened", rc, 0);
+ goto fail;
}
if ( do_alock_recover && alock_recover (&bdb->bi_alock_info) != 0 ) {
flags = DB_THREAD | bdb->bi_db_opflags;
#ifdef DB_AUTO_COMMIT
- if ( !( slapMode & SLAP_TOOL_QUICK ))
+ if ( !quick )
flags |= DB_AUTO_COMMIT;
#endif
goto fail;
}
- if ( !( slapMode & SLAP_TOOL_QUICK )) {
+ if ( !quick ) {
XLOCK_ID(bdb->bi_dbenv, &bdb->bi_cache.c_locker);
}
m->sml_type = ad_pwdFailureTime->ad_cname;
m->sml_desc = ad_pwdFailureTime;
m->sml_values = ch_calloc( sizeof(struct berval), 2 );
+ m->sml_nvalues = ch_calloc( sizeof(struct berval), 2 );
ber_dupbv( &m->sml_values[0], ×tamp );
+ ber_dupbv( &m->sml_nvalues[0], ×tamp );
m->sml_next = mod;
mod = m;
m->sml_type = ad_pwdAccountLockedTime->ad_cname;
m->sml_desc = ad_pwdAccountLockedTime;
m->sml_values = ch_calloc( sizeof(struct berval), 2 );
+ m->sml_nvalues = ch_calloc( sizeof(struct berval), 2 );
ber_dupbv( &m->sml_values[0], ×tamp );
+ ber_dupbv( &m->sml_nvalues[0], ×tamp );
m->sml_next = mod;
mod = m;
}
m->sml_type = ad_pwdGraceUseTime->ad_cname;
m->sml_desc = ad_pwdGraceUseTime;
m->sml_values = ch_calloc( sizeof(struct berval), 2 );
+ m->sml_nvalues = ch_calloc( sizeof(struct berval), 2 );
ber_dupbv( &m->sml_values[0], ×tamp );
+ ber_dupbv( &m->sml_nvalues[0], ×tamp );
m->sml_next = mod;
mod = m;
timestamp.bv_len = sizeof(timebuf);
slap_timestamp( &now, ×tamp );
- attr_merge_one( op->ora_e, ad_pwdChangedTime, ×tamp, NULL );
+ attr_merge_one( op->ora_e, ad_pwdChangedTime, ×tamp, ×tamp );
}
}
return SLAP_CB_CONTINUE;
if (pwmop != LDAP_MOD_DELETE) {
mods->sml_op = LDAP_MOD_REPLACE;
mods->sml_values = (BerVarray) ch_malloc( 2 * sizeof( struct berval ) );
+ mods->sml_nvalues = (BerVarray) ch_malloc( 2 * sizeof( struct berval ) );
ber_dupbv( &mods->sml_values[0], ×tamp );
+ ber_dupbv( &mods->sml_nvalues[0], ×tamp );
mods->sml_values[1].bv_len = 0;
mods->sml_values[1].bv_val = NULL;
assert( mods->sml_values[0].bv_val != NULL );
int
parse_cr(
- const char *fname,
- int lineno,
- char *line,
- char **argv,
- ContentRule **scr )
+ const char *fname,
+ int lineno,
+ char *line,
+ char **argv,
+ ContentRule **scr )
{
LDAPContentRule *cr;
int code;
const char *err;
- cr = ldap_str2contentrule(line, &code, &err, LDAP_SCHEMA_ALLOW_ALL );
+ cr = ldap_str2contentrule( line, &code, &err, LDAP_SCHEMA_ALLOW_ALL );
if ( !cr ) {
fprintf( stderr, "%s: line %d: %s before %s\n",
fname, lineno, ldap_scherr2str(code), err );
"%s: line %d: Content rule has no OID\n",
fname, lineno );
cr_usage();
- return 1;
+ code = 1;
+ goto done;
}
- code = cr_add(cr,1,scr,&err);
+ code = cr_add( cr, 1, scr, &err );
if ( code ) {
fprintf( stderr, "%s: line %d: %s: \"%s\"\n",
- fname, lineno, scherr2str(code), err);
- return 1;
+ fname, lineno, scherr2str( code ), err );
+ code = 1;
+ goto done;
}
- ldap_memfree(cr);
- return 0;
+done:;
+ if ( code ) {
+ ldap_contentrule_free( cr );
+
+ } else {
+ ldap_memfree( cr );
+ }
+
+ return code;
}
int
parse_oc(
- const char *fname,
- int lineno,
- char *line,
- char **argv,
- ObjectClass **soc )
+ const char *fname,
+ int lineno,
+ char *line,
+ char **argv,
+ ObjectClass **soc )
{
LDAPObjectClass *oc;
int code;
oc = ldap_str2objectclass(line, &code, &err, LDAP_SCHEMA_ALLOW_ALL );
if ( !oc ) {
fprintf( stderr, "%s: line %d: %s before %s\n",
- fname, lineno, ldap_scherr2str(code), err );
+ fname, lineno, ldap_scherr2str( code ), err );
oc_usage();
return 1;
}
"%s: line %d: objectclass has no OID\n",
fname, lineno );
oc_usage();
- return 1;
+ code = 1;
+ goto done;
}
- code = oc_add(oc,1,soc,&err);
+ code = oc_add( oc, 1, soc, &err );
if ( code ) {
fprintf( stderr, "%s: line %d: %s: \"%s\"\n",
- fname, lineno, scherr2str(code), err);
- return 1;
+ fname, lineno, scherr2str( code ), err );
+ code = 1;
+ goto done;
}
- ldap_memfree(oc);
- return 0;
+done:;
+ if ( code ) {
+ ldap_objectclass_free( oc );
+
+ } else {
+ ldap_memfree( oc );
+ }
+
+ return code;
}
static void
int
parse_at(
- const char *fname,
- int lineno,
- char *line,
- char **argv,
- AttributeType **sat )
+ const char *fname,
+ int lineno,
+ char *line,
+ char **argv,
+ AttributeType **sat )
{
LDAPAttributeType *at;
int code;
"%s: line %d: attributeType has no OID\n",
fname, lineno );
at_usage();
- return 1;
+ code = 1;
+ goto done;
}
/* operational attributes should be defined internally */
if ( at->at_usage ) {
fprintf( stderr, "%s: line %d: attribute type \"%s\" is operational\n",
fname, lineno, at->at_oid );
- return 1;
+ code = 1;
+ goto done;
}
- code = at_add(at,1,sat,&err);
+ code = at_add( at, 1, sat, &err);
if ( code ) {
- ldap_attributetype_free( at );
fprintf( stderr, "%s: line %d: %s: \"%s\"\n",
fname, lineno, scherr2str(code), err);
- return 1;
+ code = 1;
+ goto done;
}
- ldap_memfree(at);
- return 0;
+
+done:;
+ if ( code ) {
+ ldap_attributetype_free( at );
+
+ } else {
+ ldap_memfree( at );
+ }
+
+ return code;
}
projects / openldap / commitdiff