/* $OpenLDAP$ */
/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
*
- * Copyright 2005 The OpenLDAP Foundation.
+ * Copyright 2005-2007 The OpenLDAP Foundation.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
struct berval li_base_path;
enumCookie li_tool_cookie;
ID li_tool_current;
- ldap_pvt_thread_mutex_t li_mutex;
+ ldap_pvt_thread_rdwr_t li_rdwr;
};
#ifdef _WIN32
};
static void
-dn2path(struct berval * dn, struct berval * rootdn, struct berval * base_path,
+dn2path(struct berval * dn, struct berval * suffixdn, struct berval * base_path,
struct berval *res)
{
char *ptr, *sep, *end;
+ struct berval bv;
+
+ assert( dn != NULL );
+ assert( !BER_BVISNULL( dn ) );
+ assert( suffixdn != NULL );
+ assert( !BER_BVISNULL( suffixdn ) );
+ assert( dnIsSuffix( dn, suffixdn ) );
res->bv_len = dn->bv_len + base_path->bv_len + 1 + STRLENOF( LDIF );
res->bv_val = ch_malloc( res->bv_len + 1 );
ptr = lutil_strcopy( res->bv_val, base_path->bv_val );
*ptr++ = LDAP_DIRSEP[0];
- ptr = lutil_strcopy( ptr, rootdn->bv_val );
- end = dn->bv_val + dn->bv_len - rootdn->bv_len - 1;
+ ptr = lutil_strcopy( ptr, suffixdn->bv_val );
+ end = dn->bv_val + dn->bv_len - suffixdn->bv_len - 1;
while ( end > dn->bv_val ) {
for (sep = end-1; sep >=dn->bv_val && !DN_SEPARATOR( *sep ); sep--);
*ptr++ = LDAP_DIRSEP[0];
}
strcpy(ptr, LDIF);
#if IX_FSL != IX_DNL
- ptr = res->bv_val;
- while( ptr=strchr(ptr, IX_DNL) ) {
+ bv = *res;
+ while ( ptr = ber_bvchr( &bv, IX_DNL ) ) {
*ptr++ = IX_FSL;
- ptr = strchr(ptr, IX_DNR);
- if ( ptr )
- *ptr++ = IX_FSR;
- else
+ assert( ( ptr - bv.bv_val ) <= bv.bv_len );
+ bv.bv_len -= ( ptr - bv.bv_val );
+ bv.bv_val = ptr;
+ ptr = ber_bvchr( &bv, IX_DNR );
+ if ( !ptr )
break;
+ *ptr++ = IX_FSR;
+ assert( ( ptr - bv.bv_val ) <= bv.bv_len );
+ bv.bv_len -= ( ptr - bv.bv_val );
+ bv.bv_val = ptr;
}
#endif
}
while(len > 0) {
writeres = write(fd, spew, len);
if(writeres == -1) {
- perror("could not spew write");
+ Debug( LDAP_DEBUG_ANY, "could not spew write: %s\n",
+ STRERROR( errno ), 0, 0 );
return -1;
}
else {
int entry_length;
char * entry_as_string;
- openres = open(path->bv_val, O_WRONLY|O_CREAT|O_TRUNC, S_IRUSR | S_IWUSR);
+ openres = open(path->bv_val, O_WRONLY|O_CREAT|O_TRUNC, S_IREAD | S_IWRITE);
if(openres == -1) {
if(errno == ENOENT)
rs = LDAP_NO_SUCH_OBJECT;
else
rs = LDAP_UNWILLING_TO_PERFORM;
+ Debug( LDAP_DEBUG_ANY, "could not open \"%s\": %s\n",
+ path->bv_val, STRERROR( errno ), 0 );
}
else {
struct berval rdn;
dn2path(&op->o_req_ndn, op->o_bd->be_nsuffix, base_path, &path);
fd = open(path.bv_val, O_RDONLY);
/* error opening file (mebbe should log error) */
- if(fd == -1) {
- perror("failed to open file");
+ if ( fd == -1 && ( errno != ENOENT || op->o_tag != LDAP_REQ_ADD ) ) {
+ Debug( LDAP_DEBUG_ANY, "failed to open file \"%s\": %s\n",
+ path.bv_val, STRERROR(errno), 0 );
}
if(path.bv_val != NULL)
fd = open( path->bv_val, O_RDONLY );
if ( fd < 0 ) {
Debug( LDAP_DEBUG_TRACE,
- "=> ldif_enum_tree: failed to open %s\n",
- path->bv_val, 0, 0 );
+ "=> ldif_enum_tree: failed to open %s: %s\n",
+ path->bv_val, STRERROR(errno), 0 );
return LDAP_NO_SUCH_OBJECT;
}
} else {
/* Queueing up for tool mode */
if(ck->entries == NULL) {
- ck->entries = (Entry **) SLAP_MALLOC(sizeof(Entry *) * ENTRY_BUFF_INCREMENT);
+ ck->entries = (Entry **) ch_malloc(sizeof(Entry *) * ENTRY_BUFF_INCREMENT);
ck->elen = ENTRY_BUFF_INCREMENT;
}
if(ck->eind >= ck->elen) { /* grow entries if necessary */
- ck->entries = (Entry **) SLAP_REALLOC(ck->entries, sizeof(Entry *) * (ck->elen) * 2);
+ ck->entries = (Entry **) ch_realloc(ck->entries, sizeof(Entry *) * (ck->elen) * 2);
ck->elen *= 2;
}
/* it shouldn't be treated as an error
* only if the directory doesn't exist */
rc = LDAP_BUSY;
- Debug( LDAP_DEBUG_TRACE,
+ Debug( LDAP_DEBUG_ANY,
"=> ldif_enum_tree: failed to opendir %s (%d)\n",
path->bv_val, errno, 0 );
}
bvl = ch_malloc( sizeof(bvlist) );
ber_dupbv( &bvl->bv, &fname );
BER_BVZERO( &bvl->num );
- itmp.bv_val = strchr( bvl->bv.bv_val, IX_FSL );
+ itmp.bv_val = ber_bvchr( &bvl->bv, IX_FSL );
if ( itmp.bv_val ) {
char *ptr;
itmp.bv_val++;
- ptr = strchr( itmp.bv_val, IX_FSR );
+ itmp.bv_len = bvl->bv.bv_len
+ - ( itmp.bv_val - bvl->bv.bv_val );
+ ptr = ber_bvchr( &itmp, IX_FSR );
if ( ptr ) {
itmp.bv_len = ptr - itmp.bv_val;
ber_dupbv( &bvl->num, &itmp );
- bvl->inum = strtoul( itmp.bv_val, NULL, 0 );
+ bvl->inum = strtol( itmp.bv_val, NULL, 0 );
itmp.bv_val[0] = '\0';
bvl->off = itmp.bv_val - bvl->bv.bv_val;
}
SlapReply * rs)
{
char textbuf[SLAP_TEXT_BUFLEN];
- int rc = LDAP_UNWILLING_TO_PERFORM;
+ int rc = modlist ? LDAP_UNWILLING_TO_PERFORM : LDAP_SUCCESS;
+ int is_oc = 0;
Modification *mods = NULL;
if (!acl_check_modlist(op, entry, modlist)) {
for (; modlist != NULL; modlist = modlist->sml_next) {
mods = &modlist->sml_mod;
+ if ( mods->sm_desc == slap_schema.si_ad_objectClass ) {
+ is_oc = 1;
+ }
switch (mods->sm_op) {
case LDAP_MOD_ADD:
rc = modify_add_values(entry, mods,
}
if(rc == LDAP_SUCCESS) {
- if ( mods->sm_desc == slap_schema.si_ad_objectClass ) {
+ if ( is_oc ) {
entry->e_ocflags = 0;
}
/* check that the entry still obeys the schema */
- rc = entry_schema_check(op, entry, NULL, 0,
+ rc = entry_schema_check( op, entry, NULL, 0, 0,
&rs->sr_text, textbuf, sizeof( textbuf ) );
}
+
return rc;
}
}
ni = (struct ldif_info *)op->o_bd->be_private;
- ldap_pvt_thread_mutex_lock( &ni->li_mutex );
+ ldap_pvt_thread_rdwr_rlock( &ni->li_rdwr );
entry = (Entry *)get_entry( op, &ni->li_base_path );
/* no object is found for them */
entry = (Entry *)get_entry( op, &ni->li_base_path );
}
- ldap_pvt_thread_mutex_unlock( &ni->li_mutex );
+ ldap_pvt_thread_rdwr_runlock( &ni->li_rdwr );
op->o_req_dn = odn;
op->o_req_ndn = ondn;
return rc;
}
- ldap_pvt_thread_mutex_unlock( &ni->li_mutex );
+ ldap_pvt_thread_rdwr_runlock( &ni->li_rdwr );
if ( is_entry_referral( entry ) ) {
/* entry is a referral */
Entry * entry = NULL;
ni = (struct ldif_info *) op->o_bd->be_private;
- ldap_pvt_thread_mutex_lock(&ni->li_mutex);
+ ldap_pvt_thread_rdwr_rlock(&ni->li_rdwr);
entry = (Entry *) get_entry(op, &ni->li_base_path);
/* no object is found for them */
goto return_result;
return_result:
- ldap_pvt_thread_mutex_unlock(&ni->li_mutex);
+ ldap_pvt_thread_rdwr_runlock(&ni->li_rdwr);
if(return_val != 0)
send_ldap_result( op, rs );
if(entry != NULL)
ck.op = op;
ck.rs = rs;
- ldap_pvt_thread_mutex_lock(&ni->li_mutex);
+ ldap_pvt_thread_rdwr_rlock(&ni->li_rdwr);
rs->sr_err = enum_tree( &ck );
- ldap_pvt_thread_mutex_unlock(&ni->li_mutex);
+ ldap_pvt_thread_rdwr_runlock(&ni->li_rdwr);
send_ldap_result(op, rs);
return rs->sr_err;
int statres;
char textbuf[SLAP_TEXT_BUFLEN];
- slap_add_opattrs( op, &rs->sr_text, textbuf, sizeof( textbuf ), 1 );
+ Debug( LDAP_DEBUG_TRACE, "ldif_back_add: \"%s\"\n", dn.bv_val, 0, 0);
- rs->sr_err = entry_schema_check(op, e, NULL, 0,
+ rs->sr_err = entry_schema_check(op, e, NULL, 0, 1,
&rs->sr_text, textbuf, sizeof( textbuf ) );
if ( rs->sr_err != LDAP_SUCCESS ) goto send_res;
-
- ldap_pvt_thread_mutex_lock(&ni->li_mutex);
+
+ rs->sr_err = slap_add_opattrs( op,
+ &rs->sr_text, textbuf, sizeof( textbuf ), 1 );
+ if ( rs->sr_err != LDAP_SUCCESS ) goto send_res;
+
+ ldap_pvt_thread_rdwr_wlock(&ni->li_rdwr);
dn2path(&dn, &op->o_bd->be_nsuffix[0], &ni->li_base_path, &leaf_path);
base.bv_val[base.bv_len] = '\0';
if(statres == -1 && errno == ENOENT) {
rs->sr_err = LDAP_NO_SUCH_OBJECT; /* parent doesn't exist */
+ rs->sr_text = "Parent does not exist";
}
else if(statres != -1) { /* create parent */
int mkdirres = mkdir(base.bv_val, 0750);
if(mkdirres == -1) {
rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
+ rs->sr_text = "Could not create parent folder";
+ Debug( LDAP_DEBUG_ANY, "could not create folder \"%s\": %s\n",
+ base.bv_val, STRERROR( errno ), 0 );
}
}
else
rs->sr_err = (int) spew_entry(e, &leaf_path);
ldap_pvt_thread_mutex_unlock(&entry2str_mutex);
}
+ else if ( statres == -1 ) {
+ rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
+ Debug( LDAP_DEBUG_ANY, "could not stat file \"%s\": %s\n",
+ leaf_path.bv_val, STRERROR( errno ), 0 );
+ }
else /* it already exists */
rs->sr_err = LDAP_ALREADY_EXISTS;
}
SLAP_FREE(leaf_path.bv_val);
}
- ldap_pvt_thread_mutex_unlock(&ni->li_mutex);
+ ldap_pvt_thread_rdwr_wunlock(&ni->li_rdwr);
send_res:
+ Debug( LDAP_DEBUG_TRACE,
+ "ldif_back_add: err: %d text: %s\n", rs->sr_err, rs->sr_text ?
+ rs->sr_text : "", 0);
send_ldap_result(op, rs);
- if ( !SLAP_SHADOW( op->o_bd ))
- slap_graduate_commit_csn( op );
+ slap_graduate_commit_csn( op );
return 0;
}
Entry * entry = NULL;
int spew_res;
- if ( !SLAP_SHADOW( op->o_bd ))
- slap_mods_opattrs( op, &op->orm_modlist, 1 );
+ slap_mods_opattrs( op, &op->orm_modlist, 1 );
- ldap_pvt_thread_mutex_lock(&ni->li_mutex);
+ ldap_pvt_thread_rdwr_wlock(&ni->li_rdwr);
dn2path(&op->o_req_ndn, &op->o_bd->be_nsuffix[0], &ni->li_base_path,
&path);
entry = (Entry *) get_entry(op, &ni->li_base_path);
if(entry != NULL) {
rs->sr_err = apply_modify_to_entry(entry, modlst, op, rs);
if(rs->sr_err == LDAP_SUCCESS) {
+ int save_errno;
ldap_pvt_thread_mutex_lock(&entry2str_mutex);
spew_res = spew_entry(entry, &path);
+ save_errno = errno;
ldap_pvt_thread_mutex_unlock(&entry2str_mutex);
if(spew_res == -1) {
- perror("could not output entry");
+ Debug( LDAP_DEBUG_ANY,
+ "%s ldif_back_modify: could not output entry \"%s\": %s\n",
+ op->o_log_prefix, entry->e_name.bv_val, STRERROR( save_errno ) );
rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
}
}
if(path.bv_val != NULL)
SLAP_FREE(path.bv_val);
rs->sr_text = NULL;
- ldap_pvt_thread_mutex_unlock(&ni->li_mutex);
+ ldap_pvt_thread_rdwr_wunlock(&ni->li_rdwr);
send_ldap_result(op, rs);
- if ( !SLAP_SHADOW( op->o_bd ))
- slap_graduate_commit_csn( op );
+ slap_graduate_commit_csn( op );
return 0;
}
struct berval path = BER_BVNULL;
int res = 0;
- if ( !SLAP_SHADOW( op->o_bd )) {
+ if ( BER_BVISEMPTY( &op->o_csn )) {
struct berval csn;
char csnbuf[LDAP_LUTIL_CSNSTR_BUFSIZE];
slap_get_csn( op, &csn, 1 );
}
- ldap_pvt_thread_mutex_lock(&ni->li_mutex);
+ ldap_pvt_thread_rdwr_wlock(&ni->li_rdwr);
dn2path(&op->o_req_ndn, &op->o_bd->be_nsuffix[0], &ni->li_base_path, &path);
path.bv_val[path.bv_len - STRLENOF(LDIF)] = '\0';
rs->sr_err = LDAP_SUCCESS;
SLAP_FREE(path.bv_val);
- ldap_pvt_thread_mutex_unlock(&ni->li_mutex);
+ ldap_pvt_thread_rdwr_wunlock(&ni->li_rdwr);
send_ldap_result(op, rs);
- if ( !SLAP_SHADOW( op->o_bd ))
- slap_graduate_commit_csn( op );
+ slap_graduate_commit_csn( op );
return 0;
}
static int move_entry(Entry * entry, struct berval * ndn,
- struct berval * newndn, struct berval * rootdn,
+ struct berval * newndn, struct berval * suffixdn,
struct berval * base_path) {
int res;
int exists_res;
struct berval path;
struct berval newpath;
- dn2path(ndn, rootdn, base_path, &path);
- dn2path(newndn, rootdn, base_path, &newpath);
+ dn2path(ndn, suffixdn, base_path, &path);
+ dn2path(newndn, suffixdn, base_path, &newpath);
if((entry == NULL || path.bv_val == NULL) || newpath.bv_val == NULL) {
/* some object doesn't exist */
else { /* do the modrdn */
exists_res = open(newpath.bv_val, O_RDONLY);
if(exists_res == -1 && errno == ENOENT) {
+ ldap_pvt_thread_mutex_lock( &entry2str_mutex );
res = spew_entry(entry, &newpath);
if(res != -1) {
/* if this fails we should log something bad */
res = unlink(path.bv_val);
+ path.bv_val[path.bv_len - STRLENOF(".ldif")] = '\0';
+ newpath.bv_val[newpath.bv_len - STRLENOF(".ldif")] = '\0';
+ res = rename(path.bv_val, newpath.bv_val);
res = LDAP_SUCCESS;
}
else {
res = LDAP_UNWILLING_TO_PERFORM;
unlink(newpath.bv_val); /* in case file was created */
}
+ ldap_pvt_thread_mutex_unlock( &entry2str_mutex );
}
else if(exists_res) {
int close_res = close(exists_res);
struct berval new_dn = BER_BVNULL, new_ndn = BER_BVNULL;
struct berval p_dn;
Entry * entry = NULL;
- LDAPRDN new_rdn = NULL;
- LDAPRDN old_rdn = NULL;
- Modifications * mods = NULL;
int res;
- ldap_pvt_thread_mutex_lock( &ni->li_mutex );
- ldap_pvt_thread_mutex_lock( &entry2str_mutex );
+ slap_mods_opattrs( op, &op->orr_modlist, 1 );
+
+ ldap_pvt_thread_rdwr_wlock( &ni->li_rdwr );
entry = (Entry *) get_entry( op, &ni->li_base_path );
/* build the mods to the entry */
if ( entry != NULL ) {
- if ( ldap_bv2rdn( &op->oq_modrdn.rs_newrdn, &new_rdn,
- (char **)&rs->sr_text, LDAP_DN_FORMAT_LDAP ) )
- {
- rs->sr_err = LDAP_INVALID_DN_SYNTAX;
- } else if ( op->oq_modrdn.rs_deleteoldrdn &&
- ldap_bv2rdn(&op->o_req_dn, &old_rdn, (char **)&rs->sr_text,
- LDAP_DN_FORMAT_LDAP ) )
- {
- rs->sr_err = LDAP_OTHER;
- } else {
- /* got both rdns successfully, ready to build mods */
- if ( slap_modrdn2mods( op, rs, entry, old_rdn, new_rdn, &mods )
- != LDAP_SUCCESS )
- {
- rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
- } else {
- /* built mods successfully */
-
- /* build new dn, and new ndn for the entry */
- if ( op->oq_modrdn.rs_newSup != NULL ) {
- /* new superior */
- p_dn = *op->oq_modrdn.rs_newSup;
- } else {
- p_dn = slap_empty_bv;
- }
- dnParent( &entry->e_name, &p_dn );
- build_new_dn( &new_dn, &p_dn, &op->oq_modrdn.rs_newrdn, NULL );
- dnNormalize( 0, NULL, NULL, &new_dn, &new_ndn, NULL );
- ber_memfree_x( entry->e_name.bv_val, NULL );
- ber_memfree_x( entry->e_nname.bv_val, NULL );
- entry->e_name = new_dn;
- entry->e_nname = new_ndn;
-
- /* perform the modifications */
- res = apply_modify_to_entry( entry, mods, op, rs );
- slap_modrdn2mods_free( mods );
- if ( res == LDAP_SUCCESS ) {
- rs->sr_err = move_entry( entry, &op->o_req_ndn,
- &new_ndn,
- &op->o_bd->be_nsuffix[0],
- &ni->li_base_path );
- } else {
- rs->sr_err = res;
- }
+ /* build new dn, and new ndn for the entry */
+ if ( op->oq_modrdn.rs_newSup != NULL ) {
+ struct berval op_dn = op->o_req_dn,
+ op_ndn = op->o_req_ndn;
+ Entry *np;
+
+ /* new superior */
+ p_dn = *op->oq_modrdn.rs_newSup;
+ op->o_req_dn = *op->oq_modrdn.rs_newSup;
+ op->o_req_ndn = *op->oq_modrdn.rs_nnewSup;
+ np = (Entry *)get_entry( op, &ni->li_base_path );
+ op->o_req_dn = op_dn;
+ op->o_req_ndn = op_ndn;
+ if ( np == NULL ) {
+ goto no_such_object;
}
+ entry_free( np );
+ } else {
+ dnParent( &entry->e_name, &p_dn );
}
-
- if ( new_rdn != NULL ) {
- ldap_rdnfree( new_rdn );
- }
-
- if ( old_rdn != NULL ) {
- ldap_rdnfree( old_rdn );
+ build_new_dn( &new_dn, &p_dn, &op->oq_modrdn.rs_newrdn, NULL );
+ dnNormalize( 0, NULL, NULL, &new_dn, &new_ndn, NULL );
+ ber_memfree_x( entry->e_name.bv_val, NULL );
+ ber_memfree_x( entry->e_nname.bv_val, NULL );
+ entry->e_name = new_dn;
+ entry->e_nname = new_ndn;
+
+ /* perform the modifications */
+ res = apply_modify_to_entry( entry, op->orr_modlist, op, rs );
+ if ( res == LDAP_SUCCESS ) {
+ rs->sr_err = move_entry( entry, &op->o_req_ndn,
+ &new_ndn,
+ &op->o_bd->be_nsuffix[0],
+ &ni->li_base_path );
+ } else {
+ rs->sr_err = res;
}
} else {
+no_such_object:;
/* entry was null */
rs->sr_err = LDAP_NO_SUCH_OBJECT;
}
entry_free( entry );
}
rs->sr_text = "";
- ldap_pvt_thread_mutex_unlock( &ni->li_mutex );
- ldap_pvt_thread_mutex_unlock( &entry2str_mutex );
+ ldap_pvt_thread_rdwr_wunlock( &ni->li_rdwr );
send_ldap_result( op, rs );
+ slap_graduate_commit_csn( op );
return 0;
}
Entry **ent )
{
struct ldif_info *ni = (struct ldif_info *) op->o_bd->be_private;
+ struct berval op_dn = op->o_req_dn, op_ndn = op->o_req_ndn;
- ldap_pvt_thread_mutex_lock( &ni->li_mutex );
+ assert( ndn != NULL );
+ assert( !BER_BVISNULL( ndn ) );
+ ldap_pvt_thread_rdwr_rlock( &ni->li_rdwr );
+ op->o_req_dn = *ndn;
+ op->o_req_ndn = *ndn;
*ent = (Entry *) get_entry( op, &ni->li_base_path );
+ op->o_req_dn = op_dn;
+ op->o_req_ndn = op_ndn;
+ ldap_pvt_thread_rdwr_runlock( &ni->li_rdwr );
- ldap_pvt_thread_mutex_unlock( &ni->li_mutex );
+ if ( *ent && oc && !is_entry_objectclass_or_sub( *ent, oc ) ) {
+ entry_free( *ent );
+ *ent = NULL;
+ }
return ( *ent == NULL ? 1 : 0 );
}
-static int ldif_tool_entry_open(BackendDB * be, int mode) {
+static int ldif_tool_entry_open(BackendDB *be, int mode) {
struct ldif_info *ni = (struct ldif_info *) be->be_private;
ni->li_tool_current = 0;
return 0;
}
static int
-ldif_back_db_init( BackendDB *be )
+ldif_back_db_init( BackendDB *be, ConfigReply *cr )
{
struct ldif_info *ni;
ni = ch_calloc( 1, sizeof(struct ldif_info) );
be->be_private = ni;
be->be_cf_ocs = ldifocs;
- ldap_pvt_thread_mutex_init(&ni->li_mutex);
+ ldap_pvt_thread_rdwr_init(&ni->li_rdwr);
return 0;
}
static int
-ldif_back_db_destroy(
- Backend *be
- )
+ldif_back_db_destroy( Backend *be, ConfigReply *cr )
{
struct ldif_info *ni = be->be_private;
ch_free(ni->li_base_path.bv_val);
- ldap_pvt_thread_mutex_destroy(&ni->li_mutex);
+ ldap_pvt_thread_rdwr_destroy(&ni->li_rdwr);
free( be->be_private );
return 0;
}
static int
-ldif_back_db_open(
- Backend *be
- )
+ldif_back_db_open( Backend *be, ConfigReply *cr)
{
struct ldif_info *ni = (struct ldif_info *) be->be_private;
if( BER_BVISEMPTY(&ni->li_base_path)) {/* missing base path */
- fprintf(stderr, "missing base path for back-ldif\n");
+ Debug( LDAP_DEBUG_ANY, "missing base path for back-ldif\n", 0, 0, 0);
return 1;
}
return 0;
bi->bi_entry_get_rw = ldif_back_entry_get;
#if 0 /* NOTE: uncomment to completely disable access control */
-#ifdef SLAP_OVERLAY_ACCESS
bi->bi_access_allowed = slap_access_always_allowed;
-#endif /* SLAP_OVERLAY_ACCESS */
#endif
bi->bi_tool_entry_open = ldif_tool_entry_open;