Diff for /servers/slapd/back-bdb/dn2id.c between versions 1.84 and 1.84.2.15

version 1.84, 2003/05/24 22:53:08 version 1.84.2.15, 2005/04/27 19:26:05
Line 1 Line 1
 /* dn2id.c - routines to deal with the dn2id index */  /* dn2id.c - routines to deal with the dn2id index */
 /* $OpenLDAP: pkg/ldap/servers/slapd/back-bdb/dn2id.c,v 1.83 2003/05/23 23:54:03 hyc Exp $ */  /* $OpenLDAP: pkg/ldap/servers/slapd/back-bdb/dn2id.c,v 1.84.2.14 2005/04/21 03:18:41 hyc Exp $ */
 /*  /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
  * Copyright 1998-2003 The OpenLDAP Foundation, All Rights Reserved.   *
  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file   * Copyright 2000-2005 The OpenLDAP Foundation.
    * All rights reserved.
    *
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted only as authorized by the OpenLDAP
    * Public License.
    *
    * A copy of this license is available in the file LICENSE in the
    * top-level directory of the distribution or, alternatively, at
    * <http://www.OpenLDAP.org/license.html>.
  */   */
   
 #include "portable.h"  #include "portable.h"
Line 113  bdb_dn2id_add( Line 122  bdb_dn2id_add(
 #ifndef BDB_MULTIPLE_SUFFIXES  #ifndef BDB_MULTIPLE_SUFFIXES
         }          }
   
         while( !be_issuffix( op->o_bd, &ptr )) {          while( !be_issuffix( op->o_bd, &ptr ))
 #else  #else
         for (;;) {          for (;;)
 #endif  #endif
           {
                 ptr.bv_val[-1] = DN_SUBTREE_PREFIX;                  ptr.bv_val[-1] = DN_SUBTREE_PREFIX;
   
                 rc = bdb_idl_insert_key( op->o_bd, db, txn, &key, e->e_id );                  rc = bdb_idl_insert_key( op->o_bd, db, txn, &key, e->e_id );
Line 372  bdb_dn2id_children( Line 382  bdb_dn2id_children(
         ((char *)key.data)[0] = DN_ONE_PREFIX;          ((char *)key.data)[0] = DN_ONE_PREFIX;
         AC_MEMCPY( &((char *)key.data)[1], e->e_nname.bv_val, key.size - 1 );          AC_MEMCPY( &((char *)key.data)[1], e->e_nname.bv_val, key.size - 1 );
   
 #ifdef SLAP_IDL_CACHE  
         if ( bdb->bi_idl_cache_size ) {          if ( bdb->bi_idl_cache_size ) {
                 rc = bdb_idl_cache_get( bdb, db, &key, NULL );                  rc = bdb_idl_cache_get( bdb, db, &key, NULL );
                 if ( rc != LDAP_NO_SUCH_OBJECT ) {                  if ( rc != LDAP_NO_SUCH_OBJECT ) {
Line 380  bdb_dn2id_children( Line 389  bdb_dn2id_children(
                         return rc;                          return rc;
                 }                  }
         }          }
 #endif  
         /* we actually could do a empty get... */          /* we actually could do a empty get... */
         DBTzero( &data );          DBTzero( &data );
         data.data = &id;          data.data = &id;
Line 418  bdb_dn2idl( Line 426  bdb_dn2idl(
         DBT             key;          DBT             key;
         struct bdb_info *bdb = (struct bdb_info *) op->o_bd->be_private;          struct bdb_info *bdb = (struct bdb_info *) op->o_bd->be_private;
         DB *db = bdb->bi_dn2id->bdi_db;          DB *db = bdb->bi_dn2id->bdi_db;
         int prefix = op->ors_scope == LDAP_SCOPE_SUBTREE ? DN_SUBTREE_PREFIX :          int prefix = ( op->ors_scope == LDAP_SCOPE_ONELEVEL )
                         DN_ONE_PREFIX;                  ? DN_ONE_PREFIX : DN_SUBTREE_PREFIX;
   
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
         LDAP_LOG ( INDEX, ARGS,           LDAP_LOG ( INDEX, ARGS, "=> bdb_dn2ididl( \"%s\" )\n",
                 "=> bdb_dn2ididl( \"%s\" )\n", e->e_nname.bv_val, 0, 0 );                  e->e_nname.bv_val, 0, 0 );
 #else  #else
         Debug( LDAP_DEBUG_TRACE, "=> bdb_dn2idl( \"%s\" )\n", e->e_nname.bv_val, 0, 0 );          Debug( LDAP_DEBUG_TRACE, "=> bdb_dn2idl( \"%s\" )\n",
                   e->e_nname.bv_val, 0, 0 );
 #endif  #endif
   
 #ifndef BDB_MULTIPLE_SUFFIXES  #ifndef BDB_MULTIPLE_SUFFIXES
         if (prefix == DN_SUBTREE_PREFIX && BEI(e)->bei_parent->bei_id == 0 )          if ( prefix == DN_SUBTREE_PREFIX && BEI(e)->bei_parent->bei_id == 0 ) {
         {  
                 BDB_IDL_ALL(bdb, ids);                  BDB_IDL_ALL(bdb, ids);
                 return 0;                  return 0;
         }          }
Line 444  bdb_dn2idl( Line 452  bdb_dn2idl(
         ((char *)key.data)[0] = prefix;          ((char *)key.data)[0] = prefix;
         AC_MEMCPY( &((char *)key.data)[1], e->e_nname.bv_val, key.size - 1 );          AC_MEMCPY( &((char *)key.data)[1], e->e_nname.bv_val, key.size - 1 );
   
           BDB_IDL_ZERO( ids );
         rc = bdb_idl_fetch_key( op->o_bd, db, NULL, &key, ids );          rc = bdb_idl_fetch_key( op->o_bd, db, NULL, &key, ids );
   
         if( rc != 0 ) {          if( rc != 0 ) {
Line 509  hdb_dup_compare( Line 518  hdb_dup_compare(
         const DBT *curkey          const DBT *curkey
 )  )
 {  {
         char *u = (char *)&(((diskNode *)(usrkey->data))->nrdnlen);          signed char *u = (signed char *)&(((diskNode *)(usrkey->data))->nrdnlen);
         char *c = (char *)&(((diskNode *)(curkey->data))->nrdnlen);          signed char *c = (signed char *)&(((diskNode *)(curkey->data))->nrdnlen);
         int rc, i;          int rc, i;
   
         /* data is not aligned, cannot compare directly */          /* data is not aligned, cannot compare directly */
Line 556  int hdb_fix_dn( Line 565  int hdb_fix_dn(
                 }                  }
                 /* checkit == 2. do the fix. */                  /* checkit == 2. do the fix. */
                 free( e->e_name.bv_val );                  free( e->e_name.bv_val );
                   free( e->e_nname.bv_val );
         }          }
   
         e->e_name.bv_len = rlen - 1;          e->e_name.bv_len = rlen - 1;
Line 619  hdb_dn2id_add( Line 629  hdb_dn2id_add(
         key.size = sizeof(ID);          key.size = sizeof(ID);
         key.flags = DB_DBT_USERMEM;          key.flags = DB_DBT_USERMEM;
   
 #ifdef SLAP_IDL_CACHE          /* Delete parent's IDL cache entry */
         if ( bdb->bi_idl_cache_size ) {          if ( bdb->bi_idl_cache_size ) {
                 bdb_idl_cache_del( bdb, db, &key );                  bdb_idl_cache_del( bdb, db, &key );
         }          }
 #endif  
           /* Need to make dummy root node once. Subsequent attempts
            * will fail harmlessly.
            */
           if ( eip->bei_id == 0 ) {
                   diskNode dummy = {0};
                   data.data = &dummy;
                   data.size = sizeof(diskNode);
                   data.flags = DB_DBT_USERMEM;
   
                   db->put( db, txn, &key, &data, DB_NODUPDATA );
           }
   
         data.data = d;          data.data = d;
         data.size = sizeof(diskNode) + rlen + nrlen;          data.size = sizeof(diskNode) + rlen + nrlen;
         data.flags = DB_DBT_USERMEM;          data.flags = DB_DBT_USERMEM;
Line 669  hdb_dn2id_delete( Line 691  hdb_dn2id_delete(
         data.dlen = data.size;          data.dlen = data.size;
         data.flags = DB_DBT_USERMEM | DB_DBT_PARTIAL;          data.flags = DB_DBT_USERMEM | DB_DBT_PARTIAL;
   
 #ifdef SLAP_IDL_CACHE          /* Delete IDL cache entries */
         if ( bdb->bi_idl_cache_size ) {          if ( bdb->bi_idl_cache_size ) {
                   /* Ours */
                   key.data = &e->e_id;
                   bdb_idl_cache_del( bdb, db, &key );
                   /* Parent's */
                   key.data = &eip->bei_id;
                 bdb_idl_cache_del( bdb, db, &key );                  bdb_idl_cache_del( bdb, db, &key );
         }          }
 #endif  
         rc = db->cursor( db, txn, &cursor, bdb->bi_db_opflags );          rc = db->cursor( db, txn, &cursor, bdb->bi_db_opflags );
         if ( rc ) return rc;          if ( rc ) return rc;
   
Line 704  hdb_dn2id_delete( Line 730  hdb_dn2id_delete(
         return rc;          return rc;
 }  }
   
   
 int  int
 hdb_dn2id(  hdb_dn2id(
         Operation       *op,          Operation       *op,
Line 744  hdb_dn2id( Line 771  hdb_dn2id(
         data.data = d;          data.data = d;
   
         rc = cursor->c_get( cursor, &key, &data, DB_GET_BOTH );          rc = cursor->c_get( cursor, &key, &data, DB_GET_BOTH );
         cursor->c_close( cursor );  
   
         if ( rc == 0 ) {          if ( rc == 0 ) {
                 AC_MEMCPY( &ei->bei_id, &d->entryID, sizeof(ID) );                  ei->bei_id = d->entryID;
                 ei->bei_rdn.bv_len = data.size - sizeof(diskNode) - nrlen;                  ei->bei_rdn.bv_len = data.size - sizeof(diskNode) - nrlen;
                 ptr = d->nrdn + nrlen + 1;                  ptr = d->nrdn + nrlen + 1;
                 ei->bei_rdn.bv_val = ch_malloc( ei->bei_rdn.bv_len + 1 );                  ber_str2bv( ptr, ei->bei_rdn.bv_len, 1, &ei->bei_rdn );
                 strcpy( ei->bei_rdn.bv_val, ptr );                  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 );          op->o_tmpfree( d, op->o_tmpmemctx );
   
         return rc;          return rc;
Line 791  hdb_dn2id_parent( Line 825  hdb_dn2id_parent(
         data.data = d;          data.data = d;
   
         rc = cursor->c_get( cursor, &key, &data, DB_SET );          rc = cursor->c_get( cursor, &key, &data, DB_SET );
         cursor->c_close( cursor );  
         if ( rc == 0 ) {          if ( rc == 0 ) {
                 if (d->nrdnlen >= 0) {                  if (d->nrdnlen >= 0) {
                         return LDAP_OTHER;                          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;
                 }                  }
                 AC_MEMCPY( idp, &d->entryID, sizeof(ID) );  
                 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 );  
         }          }
           cursor->c_close( cursor );
         op->o_tmpfree( d, op->o_tmpmemctx );          op->o_tmpfree( d, op->o_tmpmemctx );
         return rc;          return rc;
 }  }
Line 827  hdb_dn2id_children( Line 866  hdb_dn2id_children(
         key.data = &e->e_id;          key.data = &e->e_id;
         key.flags = DB_DBT_USERMEM;          key.flags = DB_DBT_USERMEM;
   
 #ifdef SLAP_IDL_CACHE  
         if ( bdb->bi_idl_cache_size ) {          if ( bdb->bi_idl_cache_size ) {
                 rc = bdb_idl_cache_get( bdb, db, &key, NULL );                  rc = bdb_idl_cache_get( bdb, db, &key, NULL );
                 if ( rc != LDAP_NO_SUCH_OBJECT ) {                  if ( rc != LDAP_NO_SUCH_OBJECT ) {
                         return rc;                          return rc;
                 }                  }
         }          }
 #endif  
         DBTzero(&data);          DBTzero(&data);
         data.data = &d;          data.data = &d;
         data.ulen = sizeof(d);          data.ulen = sizeof(d);
Line 846  hdb_dn2id_children( Line 883  hdb_dn2id_children(
   
         rc = cursor->c_get( cursor, &key, &data, DB_SET );          rc = cursor->c_get( cursor, &key, &data, DB_SET );
         if ( rc == 0 ) {          if ( rc == 0 ) {
                 rc = cursor->c_get( cursor, &key, &data, DB_NEXT_DUP );                  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 );          cursor->c_close( cursor );
         return rc;          return rc;
Line 867  struct dn2id_cookie { Line 909  struct dn2id_cookie {
         DB *db;          DB *db;
         int prefix;          int prefix;
         int rc;          int rc;
           EntryInfo *ei;
         ID id;          ID id;
         ID dbuf;          ID dbuf;
         ID *ids;          ID *ids;
         void *ptr;          void *ptr;
         ID tmp[BDB_IDL_DB_SIZE];          ID tmp[BDB_IDL_UM_SIZE];
         ID *buf;          ID *buf;
         DBT key;          DBT key;
         DBT data;          DBT data;
Line 880  struct dn2id_cookie { Line 923  struct dn2id_cookie {
 };  };
   
 static int  static int
   apply_func(
           void *data,
           void *arg )
   {
           EntryInfo *ei = data;
           ID *idl = arg;
   
           bdb_idl_append_one( idl, ei->bei_id );
           return 0;
   }
   
   static int
 hdb_dn2idl_internal(  hdb_dn2idl_internal(
         struct dn2id_cookie *cx          struct dn2id_cookie *cx
 )  )
 {  {
 #ifdef SLAP_IDL_CACHE          BDB_IDL_ZERO( cx->tmp );
   
           if ( !cx->ei ) {
                   cx->ei = bdb_cache_find_info( cx->bdb, cx->id );
                   if ( !cx->ei ) {
                           cx->rc = DB_NOTFOUND;
                           goto saveit;
                   }
           }
   
         if ( cx->bdb->bi_idl_cache_size ) {          if ( cx->bdb->bi_idl_cache_size ) {
                 cx->rc = bdb_idl_cache_get(cx->bdb, cx->db, &cx->key, cx->tmp);                  cx->rc = bdb_idl_cache_get(cx->bdb, cx->db, &cx->key, cx->tmp);
                 if ( cx->rc == DB_NOTFOUND ) {                  if ( cx->rc == DB_NOTFOUND ) {
Line 894  hdb_dn2idl_internal( Line 958  hdb_dn2idl_internal(
                         goto gotit;                          goto gotit;
                 }                  }
         }          }
 #endif  
   
         cx->rc = cx->db->cursor( cx->db, NULL, &cx->dbc,          bdb_cache_entryinfo_lock( cx->ei );
                 cx->bdb->bi_db_opflags );  
         if ( cx->rc ) return cx->rc;  
         BDB_IDL_ZERO( cx->tmp );  
   
         cx->data.data = &cx->dbuf;          /* If number of kids in the cache differs from on-disk, load
         cx->data.ulen = sizeof(ID);           * up all the kids from the database
         cx->data.dlen = sizeof(ID);           */
         cx->data.flags = DB_DBT_USERMEM | DB_DBT_PARTIAL;          if ( cx->ei->bei_ckids+1 != cx->ei->bei_dkids ) {
                   EntryInfo ei;
         /* The first item holds the parent ID. Ignore it. */                  db_recno_t dkids = cx->ei->bei_dkids;
         cx->rc = cx->dbc->c_get( cx->dbc, &cx->key, &cx->data, DB_SET );                  ei.bei_parent = cx->ei;
         if ( cx->rc == DB_NOTFOUND ) goto saveit;  
         if ( cx->rc ) return cx->rc;                  bdb_cache_entryinfo_unlock( cx->ei );
   
         cx->data.data = cx->buf;                  cx->rc = cx->db->cursor( cx->db, NULL, &cx->dbc,
         cx->data.ulen = BDB_IDL_UM_SIZE * sizeof(ID);                          cx->bdb->bi_db_opflags );
         cx->data.flags = DB_DBT_USERMEM;                  if ( cx->rc ) return cx->rc;
   
         /* Fetch the rest of the IDs in a loop... */                  cx->data.data = &cx->dbuf;
         while ( (cx->rc = cx->dbc->c_get( cx->dbc, &cx->key, &cx->data,                  cx->data.ulen = sizeof(ID);
                 DB_MULTIPLE | DB_NEXT_DUP )) == 0 ) {                  cx->data.dlen = sizeof(ID);
                 u_int8_t *j;                  cx->data.flags = DB_DBT_USERMEM | DB_DBT_PARTIAL;
                 size_t len;  
                 DB_MULTIPLE_INIT( cx->ptr, &cx->data );                  /* The first item holds the parent ID. Ignore it. */
                 while (cx->ptr) {                  cx->rc = cx->dbc->c_get( cx->dbc, &cx->key, &cx->data, DB_SET );
                         DB_MULTIPLE_NEXT( cx->ptr, &cx->data, j, len );                  if ( cx->rc ) {
                         if (j) {                          cx->dbc->c_close( cx->dbc );
                                 AC_MEMCPY( &cx->dbuf, j, sizeof(ID) );                          if ( cx->rc == DB_NOTFOUND ) goto saveit;
                                 bdb_idl_insert( cx->tmp, cx->dbuf );                          return cx->rc;
                         }                  }
   
                   /* If the on-disk count is zero we've never checked it.
                    * Count it now.
                    */
                   if ( !dkids ) {
                           cx->dbc->c_count( cx->dbc, &dkids, 0 );
                           cx->ei->bei_dkids = dkids;
                 }                  }
         }  
         cx->dbc->c_close( cx->dbc );  
   
         /* If we got some records, treat as success */                  cx->data.data = cx->buf;
         if (!BDB_IDL_IS_ZERO(cx->tmp)) {                  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;
                                           short nrlen;
   
                                           AC_MEMCPY( &ei.bei_id, &d->entryID, sizeof(ID) );
                                           AC_MEMCPY( &nrlen, &d->nrdnlen, sizeof(d->nrdnlen) );
                                           ei.bei_nrdn.bv_len = nrlen;
                                           /* 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_append_one( cx->tmp, ei.bei_id );
                                           hdb_cache_load( cx->bdb, &ei, &ei2 );
                                   }
                           }
                   }
                   cx->rc = cx->dbc->c_close( cx->dbc );
           } else {
                   /* The in-memory cache is in sync with the on-disk data.
                    * do we have any kids?
                    */
                 cx->rc = 0;                  cx->rc = 0;
                   if ( cx->ei->bei_ckids > 0 ) {
   
                           /* Walk the kids tree; order is irrelevant since bdb_idl_insert
                            * will insert in sorted order.
                            */
                           avl_apply( cx->ei->bei_kids, apply_func, cx->tmp, -1, AVL_POSTORDER );
                   }
                   bdb_cache_entryinfo_unlock( cx->ei );
         }          }
   
 saveit:  saveit:
 #ifdef SLAP_IDL_CACHE  
         if ( cx->bdb->bi_idl_cache_max_size ) {          if ( cx->bdb->bi_idl_cache_max_size ) {
                 bdb_idl_cache_put( cx->bdb, cx->db, &cx->key, cx->tmp, cx->rc );                  bdb_idl_cache_put( cx->bdb, cx->db, &cx->key, cx->tmp, cx->rc );
         }          }
 #endif  
         ;          ;
 gotit:  gotit:
         if ( cx->rc == 0 ) {          if ( !BDB_IDL_IS_ZERO( cx->tmp )) {
                 if ( cx->prefix == DN_SUBTREE_PREFIX ) {                  if ( cx->prefix == DN_SUBTREE_PREFIX ) {
                         ID *save, idcurs;                          bdb_idl_append( cx->ids, cx->tmp );
                           if ( !(cx->ei->bei_state & CACHE_ENTRY_NO_GRANDKIDS)) {
                         save = cx->op->o_tmpalloc( BDB_IDL_SIZEOF( cx->tmp ),                                  ID *save, idcurs;
                                 cx->op->o_tmpmemctx );                                  EntryInfo *ei = cx->ei;
                         BDB_IDL_CPY( save, cx->tmp );                                  int nokids = 1;
                         bdb_idl_union( cx->ids, cx->tmp );                                  save = cx->op->o_tmpalloc( BDB_IDL_SIZEOF( cx->tmp ),
                                                   cx->op->o_tmpmemctx );
                         idcurs = 0;                                  BDB_IDL_CPY( save, cx->tmp );
                         for ( cx->id = bdb_idl_first( save, &idcurs );  
                                 cx->id != NOID;                                  idcurs = 0;
                                 cx->id = bdb_idl_next( save, &idcurs )) {                                  for ( cx->id = bdb_idl_first( save, &idcurs );
                                 hdb_dn2idl_internal( cx );                                          cx->id != NOID;
                                           cx->id = bdb_idl_next( save, &idcurs )) {
                                           cx->ei = NULL;
                                           hdb_dn2idl_internal( cx );
                                           if ( !BDB_IDL_IS_ZERO( cx->tmp ))
                                                   nokids = 0;
                                   }
                                   cx->op->o_tmpfree( save, cx->op->o_tmpmemctx );
                                   if ( nokids ) ei->bei_state |= CACHE_ENTRY_NO_GRANDKIDS;
                         }                          }
                         cx->op->o_tmpfree( save, cx->op->o_tmpmemctx );                          /* Make sure caller knows it had kids! */
                           cx->tmp[0]=1;
   
                         cx->rc = 0;                          cx->rc = 0;
                 } else {                  } else {
                         BDB_IDL_CPY( cx->ids, cx->tmp );                          BDB_IDL_CPY( cx->ids, cx->tmp );
Line 986  hdb_dn2idl( Line 1101  hdb_dn2idl(
 #endif  #endif
   
 #ifndef BDB_MULTIPLE_SUFFIXES  #ifndef BDB_MULTIPLE_SUFFIXES
         if ( op->ors_scope == LDAP_SCOPE_SUBTREE &&           if ( op->ors_scope != LDAP_SCOPE_ONELEVEL && 
                 BEI(e)->bei_parent->bei_id == 0 ) {                  BEI(e)->bei_parent->bei_id == 0 )
           {
                 BDB_IDL_ALL( bdb, ids );                  BDB_IDL_ALL( bdb, ids );
                 return 0;                  return 0;
         }          }
 #endif  #endif
   
         cx.id = e->e_id;          cx.id = e->e_id;
           cx.ei = e->e_id ? BEI(e) : &bdb->bi_cache.c_dntree;
         cx.bdb = bdb;          cx.bdb = bdb;
         cx.db = cx.bdb->bi_dn2id->bdi_db;          cx.db = cx.bdb->bi_dn2id->bdi_db;
         cx.prefix = op->ors_scope == LDAP_SCOPE_SUBTREE ? DN_SUBTREE_PREFIX :          cx.prefix = (op->ors_scope == LDAP_SCOPE_ONELEVEL) ?
                         DN_ONE_PREFIX;                  DN_ONE_PREFIX : DN_SUBTREE_PREFIX;
         cx.ids = ids;          cx.ids = ids;
         cx.buf = stack;          cx.buf = stack;
         cx.op = op;          cx.op = op;
Line 1015  hdb_dn2idl( Line 1132  hdb_dn2idl(
   
         DBTzero(&cx.data);          DBTzero(&cx.data);
   
         return hdb_dn2idl_internal(&cx);          hdb_dn2idl_internal(&cx);
           if ( !BDB_IDL_IS_ZERO( ids ) && !BDB_IDL_IS_RANGE( ids ))
                   bdb_idl_sort( ids );
   
           return cx.rc;
 }  }
 #endif  /* BDB_HIER */  #endif  /* BDB_HIER */

Removed from v.1.84  
changed lines
  Added in v.1.84.2.15


______________
© Copyright 1998-2020, OpenLDAP Foundation, info@OpenLDAP.org