/* dn2id.c - routines to deal with the dn2id index */
/* $OpenLDAP$ */
/*
- * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.
+ * Copyright 1998-2003 The OpenLDAP Foundation, All Rights Reserved.
* COPYING RESTRICTIONS APPLY, see COPYRIGHT file
*/
#include "portable.h"
#include <stdio.h>
-
#include <ac/string.h>
-#include <ac/socket.h>
#include "back-bdb.h"
+#include "idl.h"
+#include "lutil.h"
+#ifndef BDB_HIER
int
bdb_dn2id_add(
- Backend *be,
+ Operation *op,
DB_TXN *txn,
- const char *dn,
- ID id
-)
+ EntryInfo *eip,
+ Entry *e )
{
+ struct bdb_info *bdb = (struct bdb_info *) op->o_bd->be_private;
+ DB *db = bdb->bi_dn2id->bdi_db;
int rc;
DBT key, data;
- struct bdb_info *bdb = (struct bdb_info *) be->be_private;
- DB *db = bdb->bi_dn2id->bdi_db;
-
- Debug( LDAP_DEBUG_TRACE, "=> bdb_index_dn_add( \"%s\", %ld )\n", dn, id, 0 );
- assert( id != NOID );
+ char *buf;
+ struct berval ptr, pdn;
+
+#ifdef NEW_LOGGING
+ LDAP_LOG ( INDEX, ARGS, "bdb_dn2id_add( \"%s\", 0x%08lx )\n",
+ e->e_ndn, (long) e->e_id, 0 );
+#else
+ Debug( LDAP_DEBUG_TRACE, "=> bdb_dn2id_add( \"%s\", 0x%08lx )\n",
+ e->e_ndn, (long) e->e_id, 0 );
+#endif
+ assert( e->e_id != NOID );
DBTzero( &key );
- key.size = strlen( dn ) + 2;
- key.data = ch_malloc( key.size );
- ((char *)key.data)[0] = DN_BASE_PREFIX;
- AC_MEMCPY( &((char *)key.data)[1], dn, key.size - 1 );
+ key.size = e->e_nname.bv_len + 2;
+ key.ulen = key.size;
+ key.flags = DB_DBT_USERMEM;
+ buf = op->o_tmpalloc( key.size, op->o_tmpmemctx );
+ key.data = buf;
+ buf[0] = DN_BASE_PREFIX;
+ ptr.bv_val = buf + 1;
+ ptr.bv_len = e->e_nname.bv_len;
+ AC_MEMCPY( ptr.bv_val, e->e_nname.bv_val, e->e_nname.bv_len );
+ ptr.bv_val[ptr.bv_len] = '\0';
DBTzero( &data );
- data.data = (char *) &id;
- data.size = sizeof( id );
+ data.data = (char *) &e->e_id;
+ data.size = sizeof( e->e_id );
/* store it -- don't override */
rc = db->put( db, txn, &key, &data, DB_NOOVERWRITE );
if( rc != 0 ) {
+#ifdef NEW_LOGGING
+ LDAP_LOG ( INDEX, ERR, "bdb_dn2id_add: put failed: %s %d\n",
+ db_strerror(rc), rc, 0 );
+#else
+ Debug( LDAP_DEBUG_ANY, "=> bdb_dn2id_add: put failed: %s %d\n",
+ db_strerror(rc), rc, 0 );
+#endif
goto done;
}
- {
- char *pdn = dn_parent( NULL, dn );
- ((char *)(key.data))[0] = DN_ONE_PREFIX;
-
- if( pdn != NULL ) {
- key.size = strlen( pdn ) + 2;
- AC_MEMCPY( &((char*)key.data)[1],
- pdn, key.size - 1 );
-
- rc = bdb_idl_insert_key( be, db, txn, &key, id );
- free( pdn );
-
- if( rc != 0 ) {
- goto done;
- }
+#ifndef BDB_MULTIPLE_SUFFIXES
+ if( !be_issuffix( op->o_bd, &ptr )) {
+#endif
+ buf[0] = DN_SUBTREE_PREFIX;
+ rc = db->put( db, txn, &key, &data, DB_NOOVERWRITE );
+ if( rc != 0 ) {
+#ifdef NEW_LOGGING
+ LDAP_LOG ( INDEX, ERR,
+ "=> bdb_dn2id_add: subtree (%s) put failed: %d\n",
+ ptr.bv_val, rc, 0 );
+#else
+ Debug( LDAP_DEBUG_ANY,
+ "=> bdb_dn2id_add: subtree (%s) put failed: %d\n",
+ ptr.bv_val, rc, 0 );
+#endif
+ goto done;
}
+
+#ifdef BDB_MULTIPLE_SUFFIXES
+ if( !be_issuffix( op->o_bd, &ptr )) {
+#endif
+ dnParent( &ptr, &pdn );
+
+ key.size = pdn.bv_len + 2;
+ key.ulen = key.size;
+ pdn.bv_val[-1] = DN_ONE_PREFIX;
+ key.data = pdn.bv_val-1;
+ ptr = pdn;
+
+ rc = bdb_idl_insert_key( op->o_bd, db, txn, &key, e->e_id );
+
+ if( rc != 0 ) {
+#ifdef NEW_LOGGING
+ LDAP_LOG ( INDEX, ERR,
+ "=> bdb_dn2id_add: parent (%s) insert failed: %d\n",
+ ptr.bv_val, rc, 0 );
+#else
+ Debug( LDAP_DEBUG_ANY,
+ "=> bdb_dn2id_add: parent (%s) insert failed: %d\n",
+ ptr.bv_val, rc, 0 );
+#endif
+ goto done;
+ }
+#ifndef BDB_MULTIPLE_SUFFIXES
}
- if ( rc != -1 ) {
- char **subtree = dn_subtree( NULL, dn );
-
- if( subtree != NULL ) {
- int i;
- ((char *)key.data)[0] = DN_SUBTREE_PREFIX;
- for( i=0; subtree[i] != NULL; i++ ) {
- key.size = strlen( subtree[i] ) + 2;
- AC_MEMCPY( &((char *)key.data)[1],
- subtree[i], key.size - 1 );
-
- rc = bdb_idl_insert_key( be, db, txn, &key, id );
-
- if( rc != 0 ) {
- goto done;
- }
- }
-
- charray_free( subtree );
+ while( !be_issuffix( op->o_bd, &ptr )) {
+#else
+ for (;;) {
+#endif
+ ptr.bv_val[-1] = DN_SUBTREE_PREFIX;
+
+ rc = bdb_idl_insert_key( op->o_bd, db, txn, &key, e->e_id );
+
+ if( rc != 0 ) {
+#ifdef NEW_LOGGING
+ LDAP_LOG ( INDEX, ERR,
+ "=> bdb_dn2id_add: subtree (%s) insert failed: %d\n",
+ ptr.bv_val, rc, 0 );
+#else
+ Debug( LDAP_DEBUG_ANY,
+ "=> bdb_dn2id_add: subtree (%s) insert failed: %d\n",
+ ptr.bv_val, rc, 0 );
+#endif
+ break;
}
+#ifdef BDB_MULTIPLE_SUFFIXES
+ if( be_issuffix( op->o_bd, &ptr )) break;
+#endif
+ dnParent( &ptr, &pdn );
+
+ key.size = pdn.bv_len + 2;
+ key.ulen = key.size;
+ key.data = pdn.bv_val - 1;
+ ptr = pdn;
+ }
+#ifdef BDB_MULTIPLE_SUFFIXES
}
+#endif
done:
- ch_free( key.data );
- Debug( LDAP_DEBUG_TRACE, "<= bdb_index_dn_add %d\n", rc, 0, 0 );
- return( rc );
+ op->o_tmpfree( buf, op->o_tmpmemctx );
+#ifdef NEW_LOGGING
+ LDAP_LOG ( INDEX, RESULTS, "<= bdb_dn2id_add: %d\n", rc, 0, 0 );
+#else
+ Debug( LDAP_DEBUG_TRACE, "<= bdb_dn2id_add: %d\n", rc, 0, 0 );
+#endif
+ return rc;
}
-#if 0
-ID
-dn2id(
- Backend *be,
- const char *dn
-)
+int
+bdb_dn2id_delete(
+ Operation *op,
+ DB_TXN *txn,
+ EntryInfo *eip,
+ Entry *e )
{
- struct ldbminfo *li = (struct ldbminfo *) be->be_private;
- DBCache *db;
- ID id;
- Datum key, data;
+ struct bdb_info *bdb = (struct bdb_info *) op->o_bd->be_private;
+ DB *db = bdb->bi_dn2id->bdi_db;
+ int rc;
+ DBT key;
+ char *buf;
+ struct berval pdn, ptr;
+
+#ifdef NEW_LOGGING
+ LDAP_LOG ( INDEX, ARGS,
+ "=> bdb_dn2id_delete ( \"%s\", 0x%08lx )\n", e->e_ndn, e->e_id, 0);
+#else
+ Debug( LDAP_DEBUG_TRACE, "=> bdb_dn2id_delete( \"%s\", 0x%08lx )\n",
+ e->e_ndn, e->e_id, 0 );
+#endif
- Debug( LDAP_DEBUG_TRACE, "=> dn2id( \"%s\" )\n", dn, 0, 0 );
+ DBTzero( &key );
+ key.size = e->e_nname.bv_len + 2;
+ buf = op->o_tmpalloc( key.size, op->o_tmpmemctx );
+ key.data = buf;
+ key.flags = DB_DBT_USERMEM;
+ buf[0] = DN_BASE_PREFIX;
+ ptr.bv_val = buf+1;
+ ptr.bv_len = e->e_nname.bv_len;
+ AC_MEMCPY( ptr.bv_val, e->e_nname.bv_val, e->e_nname.bv_len );
+ ptr.bv_val[ptr.bv_len] = '\0';
+
+ /* delete it */
+ rc = db->del( db, txn, &key, 0 );
+ if( rc != 0 ) {
+#ifdef NEW_LOGGING
+ LDAP_LOG ( INDEX, ERR,
+ "=> bdb_dn2id_delete: delete failed: %s %d\n",
+ db_strerror(rc), rc, 0 );
+#else
+ Debug( LDAP_DEBUG_ANY, "=> bdb_dn2id_delete: delete failed: %s %d\n",
+ db_strerror(rc), rc, 0 );
+#endif
+ goto done;
+ }
+
+#ifndef BDB_MULTIPLE_SUFFIXES
+ if( !be_issuffix( op->o_bd, &ptr )) {
+#endif
+ buf[0] = DN_SUBTREE_PREFIX;
+ rc = db->del( db, txn, &key, 0 );
+ if( rc != 0 ) {
+#ifdef NEW_LOGGING
+ LDAP_LOG ( INDEX, ERR,
+ "=> bdb_dn2id_delete: subtree (%s) delete failed: %d\n",
+ ptr.bv_val, rc, 0 );
+#else
+ Debug( LDAP_DEBUG_ANY,
+ "=> bdb_dn2id_delete: subtree (%s) delete failed: %d\n",
+ ptr.bv_val, rc, 0 );
+#endif
+ goto done;
+ }
- /* first check the cache */
- if ( (id = cache_find_entry_dn2id( be, &li->li_cache, dn )) != NOID ) {
- Debug( LDAP_DEBUG_TRACE, "<= dn2id %ld (in cache)\n", id,
- 0, 0 );
- return( id );
+#ifdef BDB_MULTIPLE_SUFFIXES
+ if( !be_issuffix( op->o_bd, &ptr )) {
+#endif
+ dnParent( &ptr, &pdn );
+
+ key.size = pdn.bv_len + 2;
+ key.ulen = key.size;
+ pdn.bv_val[-1] = DN_ONE_PREFIX;
+ key.data = pdn.bv_val - 1;
+ ptr = pdn;
+
+ rc = bdb_idl_delete_key( op->o_bd, db, txn, &key, e->e_id );
+
+ if( rc != 0 ) {
+#ifdef NEW_LOGGING
+ LDAP_LOG ( INDEX, ERR,
+ "=> bdb_dn2id_delete: parent (%s) delete failed: %d\n",
+ ptr.bv_val, rc, 0 );
+#else
+ Debug( LDAP_DEBUG_ANY,
+ "=> bdb_dn2id_delete: parent (%s) delete failed: %d\n",
+ ptr.bv_val, rc, 0 );
+#endif
+ goto done;
+ }
+#ifndef BDB_MULTIPLE_SUFFIXES
}
- if ( (db = ldbm_cache_open( be, "dn2id", LDBM_SUFFIX, LDBM_WRCREAT ))
- == NULL ) {
- Debug( LDAP_DEBUG_ANY, "<= dn2id could not open dn2id%s\n",
- LDBM_SUFFIX, 0, 0 );
- return( NOID );
+ while( !be_issuffix( op->o_bd, &ptr )) {
+#else
+ for (;;) {
+#endif
+ ptr.bv_val[-1] = DN_SUBTREE_PREFIX;
+
+ rc = bdb_idl_delete_key( op->o_bd, db, txn, &key, e->e_id );
+ if( rc != 0 ) {
+#ifdef NEW_LOGGING
+ LDAP_LOG ( INDEX, ERR,
+ "=> bdb_dn2id_delete: subtree (%s) delete failed: %d\n",
+ ptr.bv_val, rc, 0 );
+#else
+ Debug( LDAP_DEBUG_ANY,
+ "=> bdb_dn2id_delete: subtree (%s) delete failed: %d\n",
+ ptr.bv_val, rc, 0 );
+#endif
+ goto done;
+ }
+#ifdef BDB_MULTIPLE_SUFFIXES
+ if( be_issuffix( op->o_bd, &ptr )) break;
+#endif
+ dnParent( &ptr, &pdn );
+
+ key.size = pdn.bv_len + 2;
+ key.ulen = key.size;
+ key.data = pdn.bv_val - 1;
+ ptr = pdn;
}
+#ifdef BDB_MULTIPLE_SUFFIXES
+ }
+#endif
- ldbm_datum_init( key );
+done:
+ op->o_tmpfree( buf, op->o_tmpmemctx );
+#ifdef NEW_LOGGING
+ LDAP_LOG ( INDEX, RESULTS, "<= bdb_dn2id_delete %d\n", rc, 0, 0 );
+#else
+ Debug( LDAP_DEBUG_TRACE, "<= bdb_dn2id_delete %d\n", rc, 0, 0 );
+#endif
+ return rc;
+}
- key.dsize = strlen( dn ) + 2;
- key.dptr = ch_malloc( key.dsize );
- sprintf( key.dptr, "%c%s", DN_BASE_PREFIX, dn );
+int
+bdb_dn2id(
+ Operation *op,
+ DB_TXN *txn,
+ struct berval *dn,
+ EntryInfo *ei )
+{
+ int rc;
+ DBT key, data;
+ struct bdb_info *bdb = (struct bdb_info *) op->o_bd->be_private;
+ DB *db = bdb->bi_dn2id->bdi_db;
- data = ldbm_cache_fetch( db, key );
+#ifdef NEW_LOGGING
+ LDAP_LOG ( INDEX, ARGS, "=> bdb_dn2id( \"%s\" )\n", dn->bv_val, 0, 0 );
+#else
+ Debug( LDAP_DEBUG_TRACE, "=> bdb_dn2id( \"%s\" )\n", dn->bv_val, 0, 0 );
+#endif
+ DBTzero( &key );
+ key.size = dn->bv_len + 2;
+ key.data = op->o_tmpalloc( key.size, op->o_tmpmemctx );
+ ((char *)key.data)[0] = DN_BASE_PREFIX;
+ AC_MEMCPY( &((char *)key.data)[1], dn->bv_val, key.size - 1 );
- ldbm_cache_close( be, db );
+ /* store the ID */
+ DBTzero( &data );
+ data.data = &ei->bei_id;
+ data.ulen = sizeof(ID);
+ data.flags = DB_DBT_USERMEM;
- free( key.dptr );
+ /* fetch it */
+ rc = db->get( db, txn, &key, &data, bdb->bi_db_opflags );
- if ( data.dptr == NULL ) {
- Debug( LDAP_DEBUG_TRACE, "<= dn2id NOID\n", 0, 0, 0 );
- return( NOID );
+ if( rc != 0 ) {
+#ifdef NEW_LOGGING
+ LDAP_LOG ( INDEX, ERR, "<= bdb_dn2id: get failed %s (%d)\n",
+ db_strerror(rc), rc, 0 );
+#else
+ Debug( LDAP_DEBUG_TRACE, "<= bdb_dn2id: get failed: %s (%d)\n",
+ db_strerror( rc ), rc, 0 );
+#endif
+ } else {
+#ifdef NEW_LOGGING
+ LDAP_LOG ( INDEX, RESULTS,
+ "<= bdb_dn2id: got id=0x%08lx\n", ei->bei_id, 0, 0 );
+#else
+ Debug( LDAP_DEBUG_TRACE, "<= bdb_dn2id: got id=0x%08lx\n",
+ ei->bei_id, 0, 0 );
+#endif
}
- AC_MEMCPY( (char *) &id, data.dptr, sizeof(ID) );
-
- assert( id != NOID );
-
- ldbm_datum_free( db->dbc_db, data );
-
- Debug( LDAP_DEBUG_TRACE, "<= dn2id %ld\n", id, 0, 0 );
- return( id );
+ op->o_tmpfree( key.data, op->o_tmpmemctx );
+ return rc;
}
-ID_BLOCK *
-dn2idl(
- Backend *be,
- const char *dn,
- int prefix
-)
+int
+bdb_dn2id_children(
+ Operation *op,
+ DB_TXN *txn,
+ Entry *e )
{
- DBCache *db;
- Datum key;
- ID_BLOCK *idl;
-
- Debug( LDAP_DEBUG_TRACE, "=> dn2idl( \"%c%s\" )\n", prefix, dn, 0 );
+ DBT key, data;
+ struct bdb_info *bdb = (struct bdb_info *) op->o_bd->be_private;
+ DB *db = bdb->bi_dn2id->bdi_db;
+ ID id;
+ int rc;
- if ( (db = ldbm_cache_open( be, "dn2id", LDBM_SUFFIX, LDBM_WRCREAT ))
- == NULL ) {
- Debug( LDAP_DEBUG_ANY, "<= dn2idl could not open dn2id%s\n",
- LDBM_SUFFIX, 0, 0 );
- return NULL;
+#ifdef NEW_LOGGING
+ LDAP_LOG ( INDEX, ARGS,
+ "=> bdb_dn2id_children( %s )\n", e->e_nname.bv_val, 0, 0 );
+#else
+ Debug( LDAP_DEBUG_TRACE, "=> bdb_dn2id_children( %s )\n",
+ e->e_nname.bv_val, 0, 0 );
+#endif
+ DBTzero( &key );
+ key.size = e->e_nname.bv_len + 2;
+ key.data = op->o_tmpalloc( key.size, op->o_tmpmemctx );
+ ((char *)key.data)[0] = DN_ONE_PREFIX;
+ AC_MEMCPY( &((char *)key.data)[1], e->e_nname.bv_val, key.size - 1 );
+
+#ifdef SLAP_IDL_CACHE
+ if ( bdb->bi_idl_cache_size ) {
+ rc = bdb_idl_cache_get( bdb, db, &key, NULL );
+ if ( rc != LDAP_NO_SUCH_OBJECT ) {
+ op->o_tmpfree( key.data, op->o_tmpmemctx );
+ return rc;
+ }
}
+#endif
+ /* we actually could do a empty get... */
+ DBTzero( &data );
+ data.data = &id;
+ data.ulen = sizeof(id);
+ data.flags = DB_DBT_USERMEM;
+ data.doff = 0;
+ data.dlen = sizeof(id);
+
+ rc = db->get( db, txn, &key, &data, bdb->bi_db_opflags );
+ op->o_tmpfree( key.data, op->o_tmpmemctx );
+
+#ifdef NEW_LOGGING
+ LDAP_LOG ( INDEX, DETAIL1,
+ "<= bdb_dn2id_children( %s ): %s (%d)\n",
+ e->e_nname.bv_val, rc == 0 ? "" : ( rc == DB_NOTFOUND ? "no " :
+ db_strerror(rc)), rc );
+#else
+ Debug( LDAP_DEBUG_TRACE, "<= bdb_dn2id_children( %s ): %s (%d)\n",
+ e->e_nname.bv_val,
+ rc == 0 ? "" : ( rc == DB_NOTFOUND ? "no " :
+ db_strerror(rc) ), rc );
+#endif
+
+ return rc;
+}
- ldbm_datum_init( key );
-
- key.dsize = strlen( dn ) + 2;
- key.dptr = ch_malloc( key.dsize );
- sprintf( key.dptr, "%c%s", prefix, dn );
+int
+bdb_dn2idl(
+ Operation *op,
+ Entry *e,
+ ID *ids,
+ ID *stack )
+{
+ int rc;
+ DBT key;
+ struct bdb_info *bdb = (struct bdb_info *) op->o_bd->be_private;
+ DB *db = bdb->bi_dn2id->bdi_db;
+ int prefix = op->ors_scope == LDAP_SCOPE_SUBTREE ? DN_SUBTREE_PREFIX :
+ DN_ONE_PREFIX;
+
+#ifdef NEW_LOGGING
+ LDAP_LOG ( INDEX, ARGS,
+ "=> bdb_dn2ididl( \"%s\" )\n", e->e_nname.bv_val, 0, 0 );
+#else
+ Debug( LDAP_DEBUG_TRACE, "=> bdb_dn2idl( \"%s\" )\n", e->e_nname.bv_val, 0, 0 );
+#endif
+
+#ifndef BDB_MULTIPLE_SUFFIXES
+ if (prefix == DN_SUBTREE_PREFIX && BEI(e)->bei_parent->bei_id == 0 )
+ {
+ BDB_IDL_ALL(bdb, ids);
+ return 0;
+ }
+#endif
- idl = idl_fetch( be, db, key );
+ DBTzero( &key );
+ key.size = e->e_nname.bv_len + 2;
+ key.ulen = key.size;
+ key.flags = DB_DBT_USERMEM;
+ key.data = op->o_tmpalloc( key.size, op->o_tmpmemctx );
+ ((char *)key.data)[0] = prefix;
+ AC_MEMCPY( &((char *)key.data)[1], e->e_nname.bv_val, key.size - 1 );
- ldbm_cache_close( be, db );
+ rc = bdb_idl_fetch_key( op->o_bd, db, NULL, &key, ids );
- free( key.dptr );
+ if( rc != 0 ) {
+#ifdef NEW_LOGGING
+ LDAP_LOG ( INDEX, ERR,
+ "<= bdb_dn2ididl: get failed: %s (%d)\n", db_strerror(rc), rc, 0 );
+#else
+ Debug( LDAP_DEBUG_TRACE,
+ "<= bdb_dn2idl: get failed: %s (%d)\n",
+ db_strerror( rc ), rc, 0 );
+#endif
+
+ } else {
+#ifdef NEW_LOGGING
+ LDAP_LOG ( INDEX, RESULTS,
+ "<= bdb_dn2ididl: id=%ld first=%ld last=%ld\n",
+ (long) ids[0], (long) BDB_IDL_FIRST( ids ),
+ (long) BDB_IDL_LAST( ids ) );
+#else
+ Debug( LDAP_DEBUG_TRACE,
+ "<= bdb_dn2idl: id=%ld first=%ld last=%ld\n",
+ (long) ids[0],
+ (long) BDB_IDL_FIRST( ids ), (long) BDB_IDL_LAST( ids ) );
+#endif
+ }
- return( idl );
+ op->o_tmpfree( key.data, op->o_tmpmemctx );
+ return rc;
}
-
-
+#else /* BDB_HIER */
+
+/* Experimental management routines for a hierarchically structured database.
+ *
+ * Unsupported! Use at your own risk!
+ * -- Howard Chu, Symas Corp. 2003.
+ *
+ * Instead of a ldbm-style dn2id database, we use a hierarchical one. Each
+ * entry in this database is a struct diskNode, keyed by entryID and with
+ * the data containing the RDN and entryID of the node's children. We use
+ * a B-Tree with sorted duplicates to store all the children of a node under
+ * the same key. Also, the first item under the key contains the entry's own
+ * rdn and the ID of the node's parent, to allow bottom-up tree traversal as
+ * well as top-down. To keep this info first in the list, the nrdnlen is set
+ * to the negative of its value.
+ *
+ * The diskNode is a variable length structure. This definition is not
+ * directly usable for in-memory manipulation.
+ */
+typedef struct diskNode {
+ ID entryID;
+ short nrdnlen;
+ char nrdn[1];
+ char rdn[1];
+} diskNode;
+
+/* Sort function for the sorted duplicate data items of a dn2id key.
+ * Sorts based on normalized RDN, in length order.
+ */
int
-dn2id_delete(
- Backend *be,
- const char *dn,
- ID id
+hdb_dup_compare(
+ DB *db,
+ const DBT *usrkey,
+ const DBT *curkey
)
{
- DBCache *db;
- Datum key;
- int rc;
+ char *u = (char *)&(((diskNode *)(usrkey->data))->nrdnlen);
+ char *c = (char *)&(((diskNode *)(curkey->data))->nrdnlen);
+ int rc, i;
+
+ /* data is not aligned, cannot compare directly */
+#ifdef WORDS_BIGENDIAN
+ for( i = 0; i < (int)sizeof(short); i++)
+#else
+ for( i = sizeof(short)-1; i >= 0; i--)
+#endif
+ {
+ rc = u[i] - c[i];
+ if( rc ) return rc;
+ }
+ return strcmp( u+sizeof(short), c+sizeof(short) );
+}
- Debug( LDAP_DEBUG_TRACE, "=> dn2id_delete( \"%s\", %ld )\n", dn, id, 0 );
+/* This function constructs a full DN for a given entry.
+ */
+int hdb_fix_dn(
+ Entry *e,
+ int checkit
+)
+{
+ EntryInfo *ei;
+ int rlen = 0, nrlen = 0;
+ char *ptr, *nptr;
+ int max = 0;
+
+ /* count length of all DN components */
+ for ( ei = BEI(e); ei && ei->bei_id; ei=ei->bei_parent ) {
+ rlen += ei->bei_rdn.bv_len + 1;
+ nrlen += ei->bei_nrdn.bv_len + 1;
+ if (ei->bei_modrdns > max) max = ei->bei_modrdns;
+ }
- assert( id != NOID );
+ /* See if the entry DN was invalidated by a subtree rename */
+ if ( checkit ) {
+ if ( BEI(e)->bei_modrdns >= max ) {
+ return 0;
+ }
+ /* We found a mismatch, tell the caller to lock it */
+ if ( checkit == 1 ) {
+ return 1;
+ }
+ /* checkit == 2. do the fix. */
+ free( e->e_name.bv_val );
+ free( e->e_nname.bv_val );
+ }
- if ( (db = ldbm_cache_open( be, "dn2id", LDBM_SUFFIX, LDBM_WRCREAT ))
- == NULL ) {
- Debug( LDAP_DEBUG_ANY,
- "<= dn2id_delete could not open dn2id%s\n", LDBM_SUFFIX,
- 0, 0 );
- return( -1 );
+ e->e_name.bv_len = rlen - 1;
+ e->e_nname.bv_len = nrlen - 1;
+ e->e_name.bv_val = ch_malloc(rlen);
+ e->e_nname.bv_val = ch_malloc(nrlen);
+ ptr = e->e_name.bv_val;
+ nptr = e->e_nname.bv_val;
+ for ( ei = BEI(e); ei && ei->bei_id; ei=ei->bei_parent ) {
+ ptr = lutil_strcopy(ptr, ei->bei_rdn.bv_val);
+ nptr = lutil_strcopy(nptr, ei->bei_nrdn.bv_val);
+ if ( ei->bei_parent ) {
+ *ptr++ = ',';
+ *nptr++ = ',';
+ }
}
+ BEI(e)->bei_modrdns = max;
+ ptr[-1] = '\0';
+ nptr[-1] = '\0';
+ return 0;
+}
- {
- char *pdn = dn_parent( NULL, dn );
+/* We add two elements to the DN2ID database - a data item under the parent's
+ * entryID containing the child's RDN and entryID, and an item under the
+ * child's entryID containing the parent's entryID.
+ */
+int
+hdb_dn2id_add(
+ Operation *op,
+ DB_TXN *txn,
+ EntryInfo *eip,
+ Entry *e )
+{
+ struct bdb_info *bdb = (struct bdb_info *) op->o_bd->be_private;
+ DB *db = bdb->bi_dn2id->bdi_db;
+ DBT key, data;
+ int rc, rlen, nrlen;
+ diskNode *d;
+ char *ptr;
+
+ nrlen = dn_rdnlen( op->o_bd, &e->e_nname );
+ if (nrlen) {
+ rlen = dn_rdnlen( op->o_bd, &e->e_name );
+ } else {
+ nrlen = e->e_nname.bv_len;
+ rlen = e->e_name.bv_len;
+ }
- if( pdn != NULL ) {
- ldbm_datum_init( key );
- key.dsize = strlen( pdn ) + 2;
- key.dptr = ch_malloc( key.dsize );
- sprintf( key.dptr, "%c%s", DN_ONE_PREFIX, pdn );
+ d = op->o_tmpalloc(sizeof(diskNode) + rlen + nrlen, op->o_tmpmemctx);
+ d->entryID = e->e_id;
+ d->nrdnlen = nrlen;
+ ptr = lutil_strncopy( d->nrdn, e->e_nname.bv_val, nrlen );
+ *ptr++ = '\0';
+ ptr = lutil_strncopy( ptr, e->e_name.bv_val, rlen );
+ *ptr = '\0';
+
+ DBTzero(&key);
+ DBTzero(&data);
+ key.data = &eip->bei_id;
+ key.size = sizeof(ID);
+ key.flags = DB_DBT_USERMEM;
+
+#ifdef SLAP_IDL_CACHE
+ if ( bdb->bi_idl_cache_size ) {
+ bdb_idl_cache_del( bdb, db, &key );
+ }
+#endif
+ data.data = d;
+ data.size = sizeof(diskNode) + rlen + nrlen;
+ data.flags = DB_DBT_USERMEM;
- (void) idl_delete_key( be, db, key, id );
+ rc = db->put( db, txn, &key, &data, DB_NODUPDATA );
- free( key.dptr );
- free( pdn );
- }
+ if (rc == 0) {
+ key.data = &e->e_id;
+ d->entryID = eip->bei_id;
+ d->nrdnlen = 0 - nrlen;
+
+ rc = db->put( db, txn, &key, &data, DB_NODUPDATA );
}
- {
- char **subtree = dn_subtree( NULL, dn );
+ op->o_tmpfree( d, op->o_tmpmemctx );
+
+ return rc;
+}
- if( subtree != NULL ) {
- int i;
- for( i=0; subtree[i] != NULL; i++ ) {
- ldbm_datum_init( key );
- key.dsize = strlen( subtree[i] ) + 2;
- key.dptr = ch_malloc( key.dsize );
- sprintf( key.dptr, "%c%s",
- DN_SUBTREE_PREFIX, subtree[i] );
+int
+hdb_dn2id_delete(
+ Operation *op,
+ DB_TXN *txn,
+ EntryInfo *eip,
+ Entry *e )
+{
+ struct bdb_info *bdb = (struct bdb_info *) op->o_bd->be_private;
+ DB *db = bdb->bi_dn2id->bdi_db;
+ DBT key, data;
+ DBC *cursor;
+ diskNode *d;
+ int rc, nrlen;
+
+ DBTzero(&key);
+ key.size = sizeof(ID);
+ key.ulen = key.size;
+ key.data = &eip->bei_id;
+ key.flags = DB_DBT_USERMEM;
+
+ DBTzero(&data);
+ data.size = sizeof(diskNode) + BEI(e)->bei_nrdn.bv_len;
+ data.ulen = data.size;
+ data.dlen = data.size;
+ data.flags = DB_DBT_USERMEM | DB_DBT_PARTIAL;
+
+#ifdef SLAP_IDL_CACHE
+ if ( bdb->bi_idl_cache_size ) {
+ bdb_idl_cache_del( bdb, db, &key );
+ }
+#endif
+ rc = db->cursor( db, txn, &cursor, bdb->bi_db_opflags );
+ if ( rc ) return rc;
+
+ d = op->o_tmpalloc( data.size, op->o_tmpmemctx );
+ d->entryID = e->e_id;
+ d->nrdnlen = BEI(e)->bei_nrdn.bv_len;
+ strcpy( d->nrdn, BEI(e)->bei_nrdn.bv_val );
+ data.data = d;
+
+ /* Delete our ID from the parent's list */
+ rc = cursor->c_get( cursor, &key, &data, DB_GET_BOTH | DB_RMW );
+ if ( rc == 0 )
+ rc = cursor->c_del( cursor, 0 );
+
+ /* Delete our ID from the tree. With sorted duplicates, this
+ * will leave any child nodes still hanging around. This is OK
+ * for modrdn, which will add our info back in later.
+ */
+ if ( rc == 0 ) {
+ key.data = &e->e_id;
+ rc = cursor->c_get( cursor, &key, &data, DB_SET | DB_RMW );
+ if ( rc == 0 )
+ rc = cursor->c_del( cursor, 0 );
+ }
+ cursor->c_close( cursor );
+ op->o_tmpfree( d, op->o_tmpmemctx );
- (void) idl_delete_key( be, db, key, id );
+ return rc;
+}
- free( key.dptr );
- }
- charray_free( subtree );
+int
+hdb_dn2id(
+ Operation *op,
+ DB_TXN *txn,
+ struct berval *in,
+ EntryInfo *ei )
+{
+ struct bdb_info *bdb = (struct bdb_info *) op->o_bd->be_private;
+ DB *db = bdb->bi_dn2id->bdi_db;
+ DBT key, data;
+ DBC *cursor;
+ int rc = 0, nrlen;
+ diskNode *d;
+ char *ptr;
+ ID idp = ei->bei_parent->bei_id;
+
+ nrlen = dn_rdnlen( op->o_bd, in );
+ if (!nrlen) nrlen = in->bv_len;
+
+ DBTzero(&key);
+ key.size = sizeof(ID);
+ key.data = &idp;
+ key.ulen = sizeof(ID);
+ key.flags = DB_DBT_USERMEM;
+
+ DBTzero(&data);
+ data.size = sizeof(diskNode) + nrlen;
+ data.ulen = data.size * 3;
+ data.flags = DB_DBT_USERMEM;
+
+ rc = db->cursor( db, txn, &cursor, bdb->bi_db_opflags );
+ if ( rc ) return rc;
+
+ d = op->o_tmpalloc( data.size * 3, op->o_tmpmemctx );
+ d->nrdnlen = nrlen;
+ ptr = lutil_strncopy( d->nrdn, in->bv_val, nrlen );
+ *ptr = '\0';
+ data.data = d;
+
+ rc = cursor->c_get( cursor, &key, &data, DB_GET_BOTH );
+ if ( rc == 0 ) {
+ ei->bei_id = d->entryID;
+ ei->bei_rdn.bv_len = data.size - sizeof(diskNode) - nrlen;
+ ptr = d->nrdn + nrlen + 1;
+ ber_str2bv( ptr, ei->bei_rdn.bv_len, 1, &ei->bei_rdn );
+ if ( !ei->bei_parent->bei_dkids ) {
+ db_recno_t dkids;
+ /* How many children does the parent have? */
+ /* FIXME: do we need to lock the parent
+ * entryinfo? Seems safe...
+ */
+ cursor->c_count( cursor, &dkids, 0 );
+ ei->bei_parent->bei_dkids = dkids;
}
}
+ cursor->c_close( cursor );
+ op->o_tmpfree( d, op->o_tmpmemctx );
- ldbm_datum_init( key );
+ return rc;
+}
- key.dsize = strlen( dn ) + 2;
- key.dptr = ch_malloc( key.dsize );
- sprintf( key.dptr, "%c%s", DN_BASE_PREFIX, dn );
+int
+hdb_dn2id_parent(
+ Operation *op,
+ DB_TXN *txn,
+ EntryInfo *ei,
+ ID *idp )
+{
+ struct bdb_info *bdb = (struct bdb_info *) op->o_bd->be_private;
+ DB *db = bdb->bi_dn2id->bdi_db;
+ DBT key, data;
+ DBC *cursor;
+ int rc = 0;
+ diskNode *d;
+ char *ptr;
+ unsigned char *pt2;
+
+ DBTzero(&key);
+ key.size = sizeof(ID);
+ key.data = &ei->bei_id;
+ key.ulen = sizeof(ID);
+ key.flags = DB_DBT_USERMEM;
+
+ DBTzero(&data);
+ data.flags = DB_DBT_USERMEM;
+
+ rc = db->cursor( db, txn, &cursor, bdb->bi_db_opflags );
+ if ( rc ) return rc;
+
+ data.ulen = sizeof(diskNode) + (SLAP_LDAPDN_MAXLEN * 2);
+ d = op->o_tmpalloc( data.ulen, op->o_tmpmemctx );
+ data.data = d;
+
+ rc = cursor->c_get( cursor, &key, &data, DB_SET );
+ if ( rc == 0 ) {
+ if (d->nrdnlen >= 0) {
+ rc = LDAP_OTHER;
+ } else {
+ db_recno_t dkids;
+ *idp = d->entryID;
+ ei->bei_nrdn.bv_len = 0 - d->nrdnlen;
+ ber_str2bv( d->nrdn, ei->bei_nrdn.bv_len, 1, &ei->bei_nrdn );
+ ei->bei_rdn.bv_len = data.size - sizeof(diskNode) -
+ ei->bei_nrdn.bv_len;
+ ptr = d->nrdn + ei->bei_nrdn.bv_len + 1;
+ ber_str2bv( ptr, ei->bei_rdn.bv_len, 1, &ei->bei_rdn );
+ /* How many children does this node have? */
+ cursor->c_count( cursor, &dkids, 0 );
+ ei->bei_dkids = dkids;
+ }
+ }
+ cursor->c_close( cursor );
+ op->o_tmpfree( d, op->o_tmpmemctx );
+ return rc;
+}
- rc = ldbm_cache_delete( db, key );
+int
+hdb_dn2id_children(
+ Operation *op,
+ DB_TXN *txn,
+ Entry *e )
+{
+ struct bdb_info *bdb = (struct bdb_info *) op->o_bd->be_private;
+ DB *db = bdb->bi_dn2id->bdi_db;
+ DBT key, data;
+ DBC *cursor;
+ int rc;
+ ID id;
+ diskNode d;
+
+ DBTzero(&key);
+ key.size = sizeof(ID);
+ key.data = &e->e_id;
+ key.flags = DB_DBT_USERMEM;
+
+#ifdef SLAP_IDL_CACHE
+ if ( bdb->bi_idl_cache_size ) {
+ rc = bdb_idl_cache_get( bdb, db, &key, NULL );
+ if ( rc != LDAP_NO_SUCH_OBJECT ) {
+ return rc;
+ }
+ }
+#endif
+ DBTzero(&data);
+ data.data = &d;
+ data.ulen = sizeof(d);
+ data.flags = DB_DBT_USERMEM | DB_DBT_PARTIAL;
+ data.dlen = sizeof(d);
+
+ rc = db->cursor( db, txn, &cursor, bdb->bi_db_opflags );
+ if ( rc ) return rc;
+
+ rc = cursor->c_get( cursor, &key, &data, DB_SET );
+ if ( rc == 0 ) {
+ db_recno_t dkids;
+ rc = cursor->c_count( cursor, &dkids, 0 );
+ if ( rc == 0 ) {
+ BEI(e)->bei_dkids = dkids;
+ if ( dkids < 2 ) rc = DB_NOTFOUND;
+ }
+ }
+ cursor->c_close( cursor );
+ return rc;
+}
- free( key.dptr );
+/* bdb_dn2idl:
+ * We can't just use bdb_idl_fetch_key because
+ * 1 - our data items are longer than just an entry ID
+ * 2 - our data items are sorted alphabetically by nrdn, not by ID.
+ *
+ * We descend the tree recursively, so we define this cookie
+ * to hold our necessary state information. The bdb_dn2idl_internal
+ * function uses this cookie when calling itself.
+ */
- ldbm_cache_close( be, db );
+struct dn2id_cookie {
+ struct bdb_info *bdb;
+ DB *db;
+ int prefix;
+ int rc;
+ EntryInfo *ei;
+ ID id;
+ ID dbuf;
+ ID *ids;
+ void *ptr;
+ ID tmp[BDB_IDL_DB_SIZE];
+ ID *buf;
+ DBT key;
+ DBT data;
+ DBC *dbc;
+ Operation *op;
+};
+
+/* Stuff for iterating over a bei_kids AVL tree and adding the
+ * IDs to an IDL
+ */
+struct apply_arg {
+ ID *idl;
+ EntryInfo **ei;
+};
+
+static int
+apply_func(
+ void *data,
+ void *arg )
+{
+ EntryInfo *ei = data;
+ struct apply_arg *ap = arg;
- Debug( LDAP_DEBUG_TRACE, "<= dn2id_delete %d\n", rc, 0, 0 );
- return( rc );
+ bdb_idl_insert( ap->idl, ei->bei_id );
+ if ( ap->ei ) {
+ *(ap->ei)++ = ei;
+ }
+ return 0;
}
-/*
- * dn2entry - look up dn in the cache/indexes and return the corresponding
- * entry.
- */
-
-Entry *
-dn2entry_rw(
- Backend *be,
- const char *dn,
- Entry **matched,
- int rw
+static int
+hdb_dn2idl_internal(
+ struct dn2id_cookie *cx
)
{
- ID id;
- Entry *e = NULL;
- char *pdn;
+ EntryInfo **eilist = NULL, **ptr;
+#ifdef SLAP_IDL_CACHE
+ if ( cx->bdb->bi_idl_cache_size ) {
+ cx->rc = bdb_idl_cache_get(cx->bdb, cx->db, &cx->key, cx->tmp);
+ if ( cx->rc == DB_NOTFOUND ) {
+ return cx->rc;
+ }
+ if ( cx->rc == LDAP_SUCCESS ) {
+ goto gotit;
+ }
+ }
+#endif
+ BDB_IDL_ZERO( cx->tmp );
+
+ /* If number of kids in the cache differs from on-disk, load
+ * up all the kids from the database
+ */
+ if ( cx->ei->bei_ckids+1 != cx->ei->bei_dkids ) {
+ EntryInfo ei;
+ ei.bei_parent = cx->ei;
+
+ cx->rc = cx->db->cursor( cx->db, NULL, &cx->dbc,
+ cx->bdb->bi_db_opflags );
+ if ( cx->rc ) return cx->rc;
+
+ cx->data.data = &cx->dbuf;
+ cx->data.ulen = sizeof(ID);
+ cx->data.dlen = sizeof(ID);
+ cx->data.flags = DB_DBT_USERMEM | DB_DBT_PARTIAL;
+
+ /* The first item holds the parent ID. Ignore it. */
+ cx->rc = cx->dbc->c_get( cx->dbc, &cx->key, &cx->data, DB_SET );
+ if ( cx->rc == DB_NOTFOUND ) goto saveit;
+ if ( cx->rc ) return cx->rc;
+
+ /* If the on-disk count is zero we've never checked it.
+ * Count it now.
+ */
+ if ( !cx->ei->bei_dkids ) {
+ db_recno_t dkids;
+ cx->dbc->c_count( cx->dbc, &dkids, 0 );
+ cx->ei->bei_dkids = dkids;
+ }
- Debug(LDAP_DEBUG_TRACE, "dn2entry_%s: dn: \"%s\"\n",
- rw ? "w" : "r", dn, 0);
+ /* If there are kids and this is a subtree search, allocate
+ * temp storage for the list of kids.
+ */
+ if ( cx->prefix == DN_SUBTREE_PREFIX && cx->ei->bei_dkids > 1 ) {
+ eilist = cx->op->o_tmpalloc( sizeof(EntryInfo *) * cx->ei->bei_dkids, cx->op->o_tmpmemctx );
+ eilist[cx->ei->bei_dkids-1] = NULL;
+ ptr = eilist;
+ }
- if( matched != NULL ) {
- /* caller cares about match */
- *matched = NULL;
- }
+ cx->data.data = cx->buf;
+ cx->data.ulen = BDB_IDL_UM_SIZE * sizeof(ID);
+ cx->data.flags = DB_DBT_USERMEM;
+
+ /* Fetch the rest of the IDs in a loop... */
+ while ( (cx->rc = cx->dbc->c_get( cx->dbc, &cx->key, &cx->data,
+ DB_MULTIPLE | DB_NEXT_DUP )) == 0 ) {
+ u_int8_t *j;
+ size_t len;
+ DB_MULTIPLE_INIT( cx->ptr, &cx->data );
+ while (cx->ptr) {
+ DB_MULTIPLE_NEXT( cx->ptr, &cx->data, j, len );
+ if (j) {
+ EntryInfo *ei2;
+ diskNode *d = (diskNode *)j;
+
+ AC_MEMCPY( &ei.bei_id, &d->entryID, sizeof(ID) );
+ AC_MEMCPY( &ei.bei_nrdn.bv_len, &d->nrdnlen, sizeof(d->nrdnlen) );
+ /* nrdn/rdn are set in-place.
+ * hdb_cache_load will copy them as needed
+ */
+ ei.bei_nrdn.bv_val = d->nrdn;
+ ei.bei_rdn.bv_len = len - sizeof(diskNode) - ei.bei_nrdn.bv_len;
+ ei.bei_rdn.bv_val = d->nrdn + ei.bei_nrdn.bv_len + 1;
+ bdb_idl_insert( cx->tmp, ei.bei_id );
+ hdb_cache_load( cx->bdb, &ei, &ei2 );
+ if ( eilist )
+ *ptr++ = ei2;
+ }
+ }
+ }
+ cx->dbc->c_close( cx->dbc );
+ } else {
+ /* The in-memory cache is in sync with the on-disk data.
+ * do we have any kids?
+ */
+ if ( cx->ei->bei_ckids > 0 ) {
+ struct apply_arg ap;
+
+ /* Temp storage for subtree search */
+ if ( cx->prefix == DN_SUBTREE_PREFIX ) {
+ eilist = cx->op->o_tmpalloc( sizeof(EntryInfo *) * cx->ei->bei_dkids, cx->op->o_tmpmemctx );
+ eilist[cx->ei->bei_dkids-1] = NULL;
+ }
- if ( (id = dn2id( be, dn )) != NOID &&
- (e = id2entry_rw( be, id, rw )) != NULL )
- {
- return( e );
+ /* Walk the kids tree; order is irrelevant since bdb_idl_insert
+ * will insert in sorted order.
+ */
+ ap.idl = cx->tmp;
+ ap.ei = eilist;
+ bdb_cache_entryinfo_lock( cx->ei );
+ avl_apply( cx->ei->bei_kids, apply_func, &ap, -1, AVL_POSTORDER );
+ bdb_cache_entryinfo_unlock( cx->ei );
+ }
}
- if ( id != NOID ) {
- Debug(LDAP_DEBUG_ANY,
- "dn2entry_%s: no entry for valid id (%ld), dn \"%s\"\n",
- rw ? "w" : "r", id, dn);
- /* must have been deleted from underneath us */
- /* treat as if NOID was found */
+ /* If we got some records, treat as success */
+ if (!BDB_IDL_IS_ZERO(cx->tmp)) {
+ cx->rc = 0;
}
- /* caller doesn't care about match */
- if( matched == NULL ) return NULL;
-
- /* entry does not exist - see how much of the dn does exist */
- /* dn_parent checks returns NULL if dn is suffix */
- if ( (pdn = dn_parent( be, dn )) != NULL ) {
- /* get entry with reader lock */
- if ( (e = dn2entry_r( be, pdn, matched )) != NULL ) {
- *matched = e;
+saveit:
+#ifdef SLAP_IDL_CACHE
+ if ( cx->bdb->bi_idl_cache_max_size ) {
+ bdb_idl_cache_put( cx->bdb, cx->db, &cx->key, cx->tmp, cx->rc );
+ }
+#endif
+ ;
+gotit:
+ if ( cx->rc == 0 ) {
+ /* If eilist is NULL, cx->tmp is empty... */
+ if ( cx->prefix == DN_SUBTREE_PREFIX && eilist ) {
+ bdb_idl_union( cx->ids, cx->tmp );
+ for (ptr = eilist; *ptr; ptr++) {
+ cx->ei = *ptr;
+ cx->id = cx->ei->bei_id;
+ hdb_dn2idl_internal( cx );
+ }
+ cx->op->o_tmpfree( eilist, cx->op->o_tmpmemctx );
+ cx->rc = 0;
+ } else {
+ BDB_IDL_CPY( cx->ids, cx->tmp );
}
- free( pdn );
}
-
- return NULL;
+ return cx->rc;
}
-#endif
\ No newline at end of file
+int
+hdb_dn2idl(
+ Operation *op,
+ Entry *e,
+ ID *ids,
+ ID *stack )
+{
+ struct bdb_info *bdb = (struct bdb_info *)op->o_bd->be_private;
+ struct dn2id_cookie cx;
+
+#ifdef NEW_LOGGING
+ LDAP_LOG ( INDEX, ARGS,
+ "=> hdb_dn2ididl( \"%s\" )\n", e->e_nname.bv_val, 0, 0 );
+#else
+ Debug( LDAP_DEBUG_TRACE, "=> hdb_dn2idl( \"%s\" )\n", e->e_nname.bv_val, 0, 0 );
+#endif
+
+#ifndef BDB_MULTIPLE_SUFFIXES
+ if ( op->ors_scope == LDAP_SCOPE_SUBTREE &&
+ BEI(e)->bei_parent->bei_id == 0 ) {
+ BDB_IDL_ALL( bdb, ids );
+ return 0;
+ }
+#endif
+
+ cx.id = e->e_id;
+ cx.ei = BEI(e);
+ cx.bdb = bdb;
+ cx.db = cx.bdb->bi_dn2id->bdi_db;
+ cx.prefix = op->ors_scope == LDAP_SCOPE_SUBTREE ? DN_SUBTREE_PREFIX :
+ DN_ONE_PREFIX;
+ cx.ids = ids;
+ cx.buf = stack;
+ cx.op = op;
+
+ BDB_IDL_ZERO( ids );
+ if ( cx.prefix == DN_SUBTREE_PREFIX ) {
+ bdb_idl_insert( ids, cx.id );
+ }
+
+ DBTzero(&cx.key);
+ cx.key.data = &cx.id;
+ cx.key.ulen = sizeof(ID);
+ cx.key.size = sizeof(ID);
+ cx.key.flags = DB_DBT_USERMEM;
+
+ DBTzero(&cx.data);
+
+ return hdb_dn2idl_internal(&cx);
+}
+#endif /* BDB_HIER */
projects / openldap / blobdiff