Diff for /servers/slapd/back-bdb/dn2id.c between versions 1.106 and 1.106.2.5

version 1.106, 2004/12/08 19:55:35 version 1.106.2.5, 2005/06/13 19:44:18
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.105 2004/12/06 06:28:47 hyc Exp $ */  /* $OpenLDAP: pkg/ldap/servers/slapd/back-bdb/dn2id.c,v 1.118 2005/06/13 19:25:51 hyc Exp $ */
 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.  /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
  *   *
  * Copyright 2000-2004 The OpenLDAP Foundation.   * Copyright 2000-2005 The OpenLDAP Foundation.
  * All rights reserved.   * All rights reserved.
  *   *
  * Redistribution and use in source and binary forms, with or without   * Redistribution and use in source and binary forms, with or without
Line 361  bdb_dn2idl( Line 361  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, NULL, 0 );          rc = bdb_idl_fetch_key( op->o_bd, db, NULL, &key, ids, NULL, 0 );
   
         if( rc != 0 ) {          if( rc != 0 ) {
Line 391  bdb_dn2idl( Line 392  bdb_dn2idl(
  * a B-Tree with sorted duplicates to store all the children of a node under   * 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   * 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   * 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   * well as top-down. To keep this info first in the list, the high bit of all
  * to the negative of its value.   * subsequent nrdnlen's is always set. This means we can only accomodate
    * RDNs up to length 32767, but that's fine since full DNs are already
    * restricted to 8192.
  *   *
  * The diskNode is a variable length structure. This definition is not   * The diskNode is a variable length structure. This definition is not
  * directly usable for in-memory manipulation.   * directly usable for in-memory manipulation.
  */   */
 typedef struct diskNode {  typedef struct diskNode {
         ID entryID;          unsigned char nrdnlen[2];
         short nrdnlen;          unsigned char nrdn[1];
         char nrdn[1];          unsigned char rdn[1];
         char rdn[1];          unsigned char entryID[sizeof(ID)];
 } diskNode;  } diskNode;
   
 /* Sort function for the sorted duplicate data items of a dn2id key.  
  * Sorts based on normalized RDN, in length order.  
  */  
 int  
 hdb_dup_compare(  
         DB *db,   
         const DBT *usrkey,  
         const DBT *curkey )  
 {  
         signed char *u = (signed char *)&(((diskNode *)(usrkey->data))->nrdnlen);  
         signed char *c = (signed 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) );  
 }  
   
 /* This function constructs a full DN for a given entry.  /* This function constructs a full DN for a given entry.
  */   */
 int hdb_fix_dn(  int hdb_fix_dn(
Line 441  int hdb_fix_dn( Line 418  int hdb_fix_dn(
         char *ptr, *nptr;          char *ptr, *nptr;
         int max = 0;          int max = 0;
   
           if ( !e->e_id )
                   return 0;
   
         /* count length of all DN components */          /* count length of all DN components */
         for ( ei = BEI(e); ei && ei->bei_id; ei=ei->bei_parent ) {          for ( ei = BEI(e); ei && ei->bei_id; ei=ei->bei_parent ) {
                 rlen += ei->bei_rdn.bv_len + 1;                  rlen += ei->bei_rdn.bv_len + 1;
Line 497  hdb_dn2id_add( Line 477  hdb_dn2id_add(
         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;
         DBT             key, data;          DBT             key, data;
           ID              nid;
         int             rc, rlen, nrlen;          int             rc, rlen, nrlen;
         diskNode *d;          diskNode *d;
         char *ptr;          char *ptr;
Line 510  hdb_dn2id_add( Line 491  hdb_dn2id_add(
         }          }
   
         d = op->o_tmpalloc(sizeof(diskNode) + rlen + nrlen, op->o_tmpmemctx);          d = op->o_tmpalloc(sizeof(diskNode) + rlen + nrlen, op->o_tmpmemctx);
         d->entryID = e->e_id;          d->nrdnlen[1] = nrlen & 0xff;
         d->nrdnlen = nrlen;          d->nrdnlen[0] = (nrlen >> 8) | 0x80;
         ptr = lutil_strncopy( d->nrdn, e->e_nname.bv_val, nrlen );          ptr = lutil_strncopy( d->nrdn, e->e_nname.bv_val, nrlen );
         *ptr++ = '\0';          *ptr++ = '\0';
         ptr = lutil_strncopy( ptr, e->e_name.bv_val, rlen );          ptr = lutil_strncopy( ptr, e->e_name.bv_val, rlen );
         *ptr = '\0';          *ptr++ = '\0';
           BDB_ID2DISK( e->e_id, ptr );
   
         DBTzero(&key);          DBTzero(&key);
         DBTzero(&data);          DBTzero(&data);
         key.data = &eip->bei_id;  
         key.size = sizeof(ID);          key.size = sizeof(ID);
         key.flags = DB_DBT_USERMEM;          key.flags = DB_DBT_USERMEM;
           BDB_ID2DISK( eip->bei_id, &nid );
   
           /* Delete parent's IDL cache entry */
           if ( bdb->bi_idl_cache_size ) {
                   key.data = &eip->bei_id;
                   bdb_idl_cache_del( bdb, db, &key );
           }
           key.data = &nid;
   
         /* Need to make dummy root node once. Subsequent attempts          /* Need to make dummy root node once. Subsequent attempts
          * will fail harmlessly.           * will fail harmlessly.
Line 535  hdb_dn2id_add( Line 524  hdb_dn2id_add(
                 db->put( db, txn, &key, &data, DB_NODUPDATA );                  db->put( db, txn, &key, &data, DB_NODUPDATA );
         }          }
   
         if ( bdb->bi_idl_cache_size ) {  
                 bdb_idl_cache_del( bdb, db, &key );  
         }  
         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 545  hdb_dn2id_add( Line 531  hdb_dn2id_add(
         rc = db->put( db, txn, &key, &data, DB_NODUPDATA );          rc = db->put( db, txn, &key, &data, DB_NODUPDATA );
   
         if (rc == 0) {          if (rc == 0) {
                 key.data = &e->e_id;                  BDB_ID2DISK( e->e_id, &nid );
                 d->entryID = eip->bei_id;                  BDB_ID2DISK( eip->bei_id, ptr );
                 d->nrdnlen = 0 - nrlen;                  d->nrdnlen[0] ^= 0x80;
   
                 rc = db->put( db, txn, &key, &data, DB_NODUPDATA );                  rc = db->put( db, txn, &key, &data, DB_NODUPDATA );
         }          }
Line 570  hdb_dn2id_delete( Line 556  hdb_dn2id_delete(
         DBC     *cursor;          DBC     *cursor;
         diskNode *d;          diskNode *d;
         int rc, nrlen;          int rc, nrlen;
           ID      nid;
           unsigned char dlen[2];
   
         DBTzero(&key);          DBTzero(&key);
         key.size = sizeof(ID);          key.size = sizeof(ID);
         key.ulen = key.size;          key.ulen = key.size;
         key.data = &eip->bei_id;  
         key.flags = DB_DBT_USERMEM;          key.flags = DB_DBT_USERMEM;
           BDB_ID2DISK( eip->bei_id, &nid );
   
         DBTzero(&data);          DBTzero(&data);
         data.size = sizeof(diskNode) + BEI(e)->bei_nrdn.bv_len;          data.size = sizeof(diskNode) + BEI(e)->bei_nrdn.bv_len - sizeof(ID) - 1;
         data.ulen = data.size;          data.ulen = data.size;
         data.dlen = data.size;          data.dlen = data.size;
         data.flags = DB_DBT_USERMEM | DB_DBT_PARTIAL;          data.flags = DB_DBT_USERMEM | DB_DBT_PARTIAL;
   
           /* 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 );
         }          }
           key.data = &nid;
         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;
   
         d = op->o_tmpalloc( data.size, op->o_tmpmemctx );          d = op->o_tmpalloc( data.size, op->o_tmpmemctx );
         d->entryID = e->e_id;          d->nrdnlen[1] = BEI(e)->bei_nrdn.bv_len & 0xff;
         d->nrdnlen = BEI(e)->bei_nrdn.bv_len;          d->nrdnlen[0] = (BEI(e)->bei_nrdn.bv_len >> 8) | 0x80;
           dlen[0] = d->nrdnlen[0];
           dlen[1] = d->nrdnlen[1];
         strcpy( d->nrdn, BEI(e)->bei_nrdn.bv_val );          strcpy( d->nrdn, BEI(e)->bei_nrdn.bv_val );
         data.data = d;          data.data = d;
   
         /* Delete our ID from the parent's list */          /* Delete our ID from the parent's list */
         rc = cursor->c_get( cursor, &key, &data, DB_GET_BOTH | DB_RMW );          rc = cursor->c_get( cursor, &key, &data, DB_GET_BOTH_RANGE );
         if ( rc == 0 )          if ( rc == 0 ) {
                 rc = cursor->c_del( cursor, 0 );                  if ( dlen[1] == d->nrdnlen[1] && dlen[0] != d->nrdnlen[0] &&
                           !strcmp( d->nrdn, BEI(e)->bei_nrdn.bv_val ))
                           rc = cursor->c_del( cursor, 0 );
                   else
                           rc = DB_NOTFOUND;
           }
   
         /* Delete our ID from the tree. With sorted duplicates, this          /* Delete our ID from the tree. With sorted duplicates, this
          * will leave any child nodes still hanging around. This is OK           * will leave any child nodes still hanging around. This is OK
          * for modrdn, which will add our info back in later.           * for modrdn, which will add our info back in later.
          */           */
         if ( rc == 0 ) {          if ( rc == 0 ) {
                 key.data = &e->e_id;                  BDB_ID2DISK( e->e_id, &nid );
                 rc = cursor->c_get( cursor, &key, &data, DB_SET | DB_RMW );                  rc = cursor->c_get( cursor, &key, &data, DB_SET );
                 if ( rc == 0 )                  if ( rc == 0 )
                         rc = cursor->c_del( cursor, 0 );                          rc = cursor->c_del( cursor, 0 );
         }          }
Line 631  hdb_dn2id( Line 633  hdb_dn2id(
         int             rc = 0, nrlen;          int             rc = 0, nrlen;
         diskNode *d;          diskNode *d;
         char    *ptr;          char    *ptr;
         ID idp = ei->bei_parent->bei_id;          unsigned char dlen[2];
           ID idp;
   
         nrlen = dn_rdnlen( op->o_bd, in );          nrlen = dn_rdnlen( op->o_bd, in );
         if (!nrlen) nrlen = in->bv_len;          if (!nrlen) nrlen = in->bv_len;
Line 641  hdb_dn2id( Line 644  hdb_dn2id(
         key.data = &idp;          key.data = &idp;
         key.ulen = sizeof(ID);          key.ulen = sizeof(ID);
         key.flags = DB_DBT_USERMEM;          key.flags = DB_DBT_USERMEM;
           BDB_ID2DISK( ei->bei_parent->bei_id, &idp );
   
         DBTzero(&data);          DBTzero(&data);
         data.size = sizeof(diskNode) + nrlen;          data.size = sizeof(diskNode) + nrlen - sizeof(ID) - 1;
         data.ulen = data.size * 3;          data.ulen = data.size * 3;
         data.flags = DB_DBT_USERMEM;          data.dlen = data.ulen;
           data.flags = DB_DBT_USERMEM | DB_DBT_PARTIAL;
   
         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;
   
         d = op->o_tmpalloc( data.size * 3, op->o_tmpmemctx );          d = op->o_tmpalloc( data.size * 3, op->o_tmpmemctx );
         d->nrdnlen = nrlen;          d->nrdnlen[1] = nrlen & 0xff;
           d->nrdnlen[0] = (nrlen >> 8) | 0x80;
           dlen[0] = d->nrdnlen[0];
           dlen[1] = d->nrdnlen[1];
         ptr = lutil_strncopy( d->nrdn, in->bv_val, nrlen );          ptr = lutil_strncopy( d->nrdn, in->bv_val, nrlen );
         *ptr = '\0';          *ptr = '\0';
         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_RANGE );
           if ( rc == 0 && (dlen[1] != d->nrdnlen[1] || dlen[0] != d->nrdnlen[0] ||
                   strncmp( d->nrdn, in->bv_val, nrlen ))) {
                   rc = DB_NOTFOUND;
           }
         if ( rc == 0 ) {          if ( rc == 0 ) {
                 ei->bei_id = d->entryID;                  ptr = data.data + data.size - sizeof(ID);
                   BDB_DISK2ID( ptr, &ei->bei_id );
                 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;
                 ber_str2bv( ptr, ei->bei_rdn.bv_len, 1, &ei->bei_rdn );                  ber_str2bv( ptr, ei->bei_rdn.bv_len, 1, &ei->bei_rdn );
Line 693  hdb_dn2id_parent( Line 706  hdb_dn2id_parent(
         diskNode *d;          diskNode *d;
         char    *ptr;          char    *ptr;
         unsigned char *pt2;          unsigned char *pt2;
           ID      nid;
   
         DBTzero(&key);          DBTzero(&key);
         key.size = sizeof(ID);          key.size = sizeof(ID);
         key.data = &ei->bei_id;          key.data = &nid;
         key.ulen = sizeof(ID);          key.ulen = sizeof(ID);
         key.flags = DB_DBT_USERMEM;          key.flags = DB_DBT_USERMEM;
           BDB_ID2DISK( ei->bei_id, &nid );
   
         DBTzero(&data);          DBTzero(&data);
         data.flags = DB_DBT_USERMEM;          data.flags = DB_DBT_USERMEM;
Line 712  hdb_dn2id_parent( Line 727  hdb_dn2id_parent(
   
         rc = cursor->c_get( cursor, &key, &data, DB_SET );          rc = cursor->c_get( cursor, &key, &data, DB_SET );
         if ( rc == 0 ) {          if ( rc == 0 ) {
                 if (d->nrdnlen >= 0) {                  if (d->nrdnlen[0] & 0x80) {
                         rc = LDAP_OTHER;                          rc = LDAP_OTHER;
                 } else {                  } else {
                         db_recno_t dkids;                          db_recno_t dkids;
                         *idp = d->entryID;                          ptr = data.data + data.size - sizeof(ID);
                         ei->bei_nrdn.bv_len = 0 - d->nrdnlen;                          BDB_DISK2ID( ptr, idp );
                           ei->bei_nrdn.bv_len = (d->nrdnlen[0] << 8) | d->nrdnlen[1];
                         ber_str2bv( d->nrdn, ei->bei_nrdn.bv_len, 1, &ei->bei_nrdn );                          ber_str2bv( d->nrdn, ei->bei_nrdn.bv_len, 1, &ei->bei_nrdn );
                         ei->bei_rdn.bv_len = data.size - sizeof(diskNode) -                          ei->bei_rdn.bv_len = data.size - sizeof(diskNode) -
                                 ei->bei_nrdn.bv_len;                                  ei->bei_nrdn.bv_len;
Line 751  hdb_dn2id_children( Line 767  hdb_dn2id_children(
         key.size = sizeof(ID);          key.size = sizeof(ID);
         key.data = &e->e_id;          key.data = &e->e_id;
         key.flags = DB_DBT_USERMEM;          key.flags = DB_DBT_USERMEM;
           BDB_ID2DISK( e->e_id, &id );
   
           /* IDL cache is in host byte order */
         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;
                 }                  }
         }          }
   
           key.data = &id;
         DBTzero(&data);          DBTzero(&data);
         data.data = &d;          data.data = &d;
         data.ulen = sizeof(d);          data.ulen = sizeof(d);
Line 797  struct dn2id_cookie { Line 817  struct dn2id_cookie {
         int rc;          int rc;
         EntryInfo *ei;          EntryInfo *ei;
         ID id;          ID id;
           ID nid;
         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 816  apply_func( Line 837  apply_func(
         EntryInfo *ei = data;          EntryInfo *ei = data;
         ID *idl = arg;          ID *idl = arg;
   
         bdb_idl_insert( idl, ei->bei_id );          bdb_idl_append_one( idl, ei->bei_id );
         return 0;          return 0;
 }  }
   
Line 825  hdb_dn2idl_internal( Line 846  hdb_dn2idl_internal(
         struct dn2id_cookie *cx          struct dn2id_cookie *cx
 )  )
 {  {
         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;  
                 }  
         }  
         BDB_IDL_ZERO( cx->tmp );          BDB_IDL_ZERO( cx->tmp );
   
         if ( !cx->ei ) {          if ( !cx->ei ) {
Line 844  hdb_dn2idl_internal( Line 856  hdb_dn2idl_internal(
                 }                  }
         }          }
   
           if ( cx->bdb->bi_idl_cache_size ) {
                   cx->key.data = &cx->id;
                   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;
                   }
           }
   
         bdb_cache_entryinfo_lock( cx->ei );          bdb_cache_entryinfo_lock( cx->ei );
   
         /* If number of kids in the cache differs from on-disk, load          /* If number of kids in the cache differs from on-disk, load
Line 866  hdb_dn2idl_internal( Line 889  hdb_dn2idl_internal(
                 cx->data.flags = DB_DBT_USERMEM | DB_DBT_PARTIAL;                  cx->data.flags = DB_DBT_USERMEM | DB_DBT_PARTIAL;
   
                 /* The first item holds the parent ID. Ignore it. */                  /* The first item holds the parent ID. Ignore it. */
                   cx->key.data = &cx->nid;
                 cx->rc = cx->dbc->c_get( cx->dbc, &cx->key, &cx->data, DB_SET );                  cx->rc = cx->dbc->c_get( cx->dbc, &cx->key, &cx->data, DB_SET );
                 if ( cx->rc ) {                  if ( cx->rc ) {
                         cx->dbc->c_close( cx->dbc );                          cx->dbc->c_close( cx->dbc );
Line 898  hdb_dn2idl_internal( Line 922  hdb_dn2idl_internal(
                                         diskNode *d = (diskNode *)j;                                          diskNode *d = (diskNode *)j;
                                         short nrlen;                                          short nrlen;
   
                                         AC_MEMCPY( &ei.bei_id, &d->entryID, sizeof(ID) );                                          BDB_DISK2ID( j + len - sizeof(ID), &ei.bei_id );
                                         AC_MEMCPY( &nrlen, &d->nrdnlen, sizeof(d->nrdnlen) );                                          nrlen = ((d->nrdnlen[0] ^ 0x80) << 8) | d->nrdnlen[1];
                                         ei.bei_nrdn.bv_len = nrlen;                                          ei.bei_nrdn.bv_len = nrlen;
                                         /* nrdn/rdn are set in-place.                                          /* nrdn/rdn are set in-place.
                                          * hdb_cache_load will copy them as needed                                           * hdb_cache_load will copy them as needed
Line 908  hdb_dn2idl_internal( Line 932  hdb_dn2idl_internal(
                                         ei.bei_rdn.bv_len = len - sizeof(diskNode)                                          ei.bei_rdn.bv_len = len - sizeof(diskNode)
                                                 - ei.bei_nrdn.bv_len;                                                  - ei.bei_nrdn.bv_len;
                                         ei.bei_rdn.bv_val = d->nrdn + ei.bei_nrdn.bv_len + 1;                                          ei.bei_rdn.bv_val = d->nrdn + ei.bei_nrdn.bv_len + 1;
                                         bdb_idl_insert( cx->tmp, ei.bei_id );                                          bdb_idl_append_one( cx->tmp, ei.bei_id );
                                         hdb_cache_load( cx->bdb, &ei, &ei2 );                                          hdb_cache_load( cx->bdb, &ei, &ei2 );
                                 }                                  }
                         }                          }
Line 931  hdb_dn2idl_internal( Line 955  hdb_dn2idl_internal(
   
 saveit:  saveit:
         if ( cx->bdb->bi_idl_cache_max_size ) {          if ( cx->bdb->bi_idl_cache_max_size ) {
                   cx->key.data = &cx->id;
                 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 );
         }          }
         ;          ;
 gotit:  gotit:
         if ( !BDB_IDL_IS_ZERO( cx->tmp )) {          if ( !BDB_IDL_IS_ZERO( cx->tmp )) {
                 if ( cx->prefix == DN_SUBTREE_PREFIX ) {                  if ( cx->prefix == DN_SUBTREE_PREFIX ) {
                         if (cx->ei->bei_state & CACHE_ENTRY_NO_GRANDKIDS) {                          bdb_idl_append( cx->ids, cx->tmp );
                                 bdb_idl_union( cx->ids, cx->tmp );                          if ( !(cx->ei->bei_state & CACHE_ENTRY_NO_GRANDKIDS)) {
                         } else {  
                                 ID *save, idcurs;                                  ID *save, idcurs;
                                 EntryInfo *ei = cx->ei;                                  EntryInfo *ei = cx->ei;
                                 int nokids = 1;                                  int nokids = 1;
                                 save = cx->op->o_tmpalloc( BDB_IDL_SIZEOF( cx->tmp ),                                  save = cx->op->o_tmpalloc( BDB_IDL_SIZEOF( cx->tmp ),
                                         cx->op->o_tmpmemctx );                                          cx->op->o_tmpmemctx );
                                 BDB_IDL_CPY( save, cx->tmp );                                  BDB_IDL_CPY( save, cx->tmp );
                                 bdb_idl_union( cx->ids, cx->tmp );  
   
                                 idcurs = 0;                                  idcurs = 0;
                                 for ( cx->id = bdb_idl_first( save, &idcurs );                                  for ( cx->id = bdb_idl_first( save, &idcurs );
                                         cx->id != NOID;                                          cx->id != NOID;
                                         cx->id = bdb_idl_next( save, &idcurs )) {                                          cx->id = bdb_idl_next( save, &idcurs )) {
                                           BDB_ID2DISK( cx->id, &cx->nid );
                                         cx->ei = NULL;                                          cx->ei = NULL;
                                         hdb_dn2idl_internal( cx );                                          hdb_dn2idl_internal( cx );
                                         if ( !BDB_IDL_IS_ZERO( cx->tmp ))                                          if ( !BDB_IDL_IS_ZERO( cx->tmp ))
Line 994  hdb_dn2idl( Line 1018  hdb_dn2idl(
 #endif  #endif
   
         cx.id = e->e_id;          cx.id = e->e_id;
           BDB_ID2DISK( cx.id, &cx.nid );
         cx.ei = e->e_id ? BEI(e) : &bdb->bi_cache.c_dntree;          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_ONELEVEL          cx.prefix = (op->ors_scope == LDAP_SCOPE_ONELEVEL) ?
                 ? DN_ONE_PREFIX : DN_SUBTREE_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 1009  hdb_dn2idl( Line 1034  hdb_dn2idl(
         }          }
   
         DBTzero(&cx.key);          DBTzero(&cx.key);
         cx.key.data = &cx.id;  
         cx.key.ulen = sizeof(ID);          cx.key.ulen = sizeof(ID);
         cx.key.size = sizeof(ID);          cx.key.size = sizeof(ID);
         cx.key.flags = DB_DBT_USERMEM;          cx.key.flags = DB_DBT_USERMEM;
   
         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.106  
changed lines
  Added in v.1.106.2.5


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