Diff for /servers/slapd/back-bdb/modrdn.c between versions 1.160 and 1.160.2.15

version 1.160, 2004/12/05 01:00:19 version 1.160.2.15, 2008/02/11 23:20:28
Line 1 Line 1
 /* modrdn.c - bdb backend modrdn routine */  /* modrdn.c - bdb backend modrdn routine */
 /* $OpenLDAP: pkg/ldap/servers/slapd/back-bdb/modrdn.c,v 1.159 2004/11/26 08:39:33 hyc Exp $ */  /* $OpenLDAP: pkg/ldap/servers/slapd/back-bdb/modrdn.c,v 1.160.2.14 2008/02/08 18:18:56 quanah 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-2007 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 29  bdb_modrdn( Operation *op, SlapReply *rs Line 29  bdb_modrdn( Operation *op, SlapReply *rs
         AttributeDescription *entry = slap_schema.si_ad_entry;          AttributeDescription *entry = slap_schema.si_ad_entry;
         struct berval   p_dn, p_ndn;          struct berval   p_dn, p_ndn;
         struct berval   new_dn = {0, NULL}, new_ndn = {0, NULL};          struct berval   new_dn = {0, NULL}, new_ndn = {0, NULL};
         int             isroot = -1;  
         Entry           *e = NULL;          Entry           *e = NULL;
         Entry           *p = NULL;          Entry           *p = NULL;
         EntryInfo       *ei = NULL, *eip = NULL, *nei = NULL, *neip = NULL;          EntryInfo       *ei = NULL, *eip = NULL, *nei = NULL, *neip = NULL;
Line 42  bdb_modrdn( Operation *op, SlapReply *rs Line 41  bdb_modrdn( Operation *op, SlapReply *rs
         struct bdb_op_info opinfo = {0};          struct bdb_op_info opinfo = {0};
         Entry dummy = {0};          Entry dummy = {0};
   
         ID                      id;  
   
         Entry           *np = NULL;                     /* newSuperior Entry */          Entry           *np = NULL;                     /* newSuperior Entry */
         struct berval   *np_dn = NULL;                  /* newSuperior dn */          struct berval   *np_dn = NULL;                  /* newSuperior dn */
         struct berval   *np_ndn = NULL;                 /* newSuperior ndn */          struct berval   *np_ndn = NULL;                 /* newSuperior ndn */
Line 64  bdb_modrdn( Operation *op, SlapReply *rs Line 61  bdb_modrdn( Operation *op, SlapReply *rs
         LDAPControl *ctrls[SLAP_MAX_RESPONSE_CONTROLS];          LDAPControl *ctrls[SLAP_MAX_RESPONSE_CONTROLS];
         int num_ctrls = 0;          int num_ctrls = 0;
   
         Operation *ps_list;  
         struct psid_entry *pm_list, *pm_prev;  
         int     rc;          int     rc;
         EntryInfo       *suffix_ei;  
         Entry           *ctxcsn_e;  
         int                     ctxcsn_added = 0;  
   
         int parent_is_glue = 0;          int parent_is_glue = 0;
         int parent_is_leaf = 0;          int parent_is_leaf = 0;
Line 100  retry: /* transaction retry */ Line 92  retry: /* transaction retry */
                 }                  }
                 Debug( LDAP_DEBUG_TRACE, "==>" LDAP_XSTRING(bdb_modrdn)                  Debug( LDAP_DEBUG_TRACE, "==>" LDAP_XSTRING(bdb_modrdn)
                                 ": retrying...\n", 0, 0, 0 );                                  ": retrying...\n", 0, 0, 0 );
 #ifdef BDB_PSEARCH  
                 pm_list = LDAP_LIST_FIRST(&op->o_pm_list);  
                 while ( pm_list != NULL ) {  
                         LDAP_LIST_REMOVE ( pm_list, ps_link );  
                         pm_prev = pm_list;  
                         pm_list = LDAP_LIST_NEXT ( pm_list, ps_link );  
                         ch_free( pm_prev );  
                 }  
 #endif  
   
                 rs->sr_err = TXN_ABORT( ltid );                  rs->sr_err = TXN_ABORT( ltid );
                 ltid = NULL;                  ltid = NULL;
Line 119  retry: /* transaction retry */ Line 102  retry: /* transaction retry */
                         rs->sr_text = "internal error";                          rs->sr_text = "internal error";
                         goto return_results;                          goto return_results;
                 }                  }
                   if ( op->o_abandon ) {
                           rs->sr_err = SLAPD_ABANDON;
                           goto return_results;
                   }
                 parent_is_glue = 0;                  parent_is_glue = 0;
                 parent_is_leaf = 0;                  parent_is_leaf = 0;
                 ldap_pvt_thread_yield();  
                 bdb_trans_backoff( ++num_retries );                  bdb_trans_backoff( ++num_retries );
         }          }
   
Line 172  retry: /* transaction retry */ Line 158  retry: /* transaction retry */
         if (( rs->sr_err == DB_NOTFOUND ) ||          if (( rs->sr_err == DB_NOTFOUND ) ||
                 ( !manageDSAit && e && is_entry_glue( e )))                  ( !manageDSAit && e && is_entry_glue( e )))
         {          {
                 BerVarray deref = NULL;  
                 if( e != NULL ) {                  if( e != NULL ) {
                         rs->sr_matched = ch_strdup( e->e_dn );                          rs->sr_matched = ch_strdup( e->e_dn );
                         rs->sr_ref = is_entry_referral( e )                          rs->sr_ref = is_entry_referral( e )
Line 182  retry: /* transaction retry */ Line 167  retry: /* transaction retry */
                         e = NULL;                          e = NULL;
   
                 } else {                  } else {
                         if ( !LDAP_STAILQ_EMPTY( &op->o_bd->be_syncinfo )) {                          rs->sr_ref = referral_rewrite( default_referral, NULL,
                                 syncinfo_t *si;                                          &op->o_req_dn, LDAP_SCOPE_DEFAULT );
                                 LDAP_STAILQ_FOREACH( si, &op->o_bd->be_syncinfo, si_next ) {  
                                         struct berval tmpbv;  
                                         ber_dupbv( &tmpbv, &si->si_provideruri_bv[0] );  
                                         ber_bvarray_add( &deref, &tmpbv );  
                 }  
                         } else {  
                                 deref = default_referral;  
                         }  
                         rs->sr_ref = referral_rewrite( deref, NULL, &op->o_req_dn,  
                                         LDAP_SCOPE_DEFAULT );  
                 }                  }
   
                 rs->sr_err = LDAP_REFERRAL;                  rs->sr_err = LDAP_REFERRAL;
                 send_ldap_result( op, rs );                  send_ldap_result( op, rs );
   
                 ber_bvarray_free( rs->sr_ref );                  ber_bvarray_free( rs->sr_ref );
                 if ( deref != default_referral ) {  
                         ber_bvarray_free( deref );  
                 }  
                 free( (char *)rs->sr_matched );                  free( (char *)rs->sr_matched );
                 rs->sr_ref = NULL;                  rs->sr_ref = NULL;
                 rs->sr_matched = NULL;                  rs->sr_matched = NULL;
Line 279  retry: /* transaction retry */ Line 251  retry: /* transaction retry */
         }          }
   
         if ( be_issuffix( op->o_bd, &e->e_nname ) ) {          if ( be_issuffix( op->o_bd, &e->e_nname ) ) {
   #ifdef BDB_MULTIPLE_SUFFIXES
                   /* Allow renaming one suffix entry to another */
                 p_ndn = slap_empty_bv;                  p_ndn = slap_empty_bv;
   #else
                   /* There can only be one suffix entry */
                   rs->sr_err = LDAP_NAMING_VIOLATION;
                   rs->sr_text = "cannot rename suffix entry";
                   goto return_results;
   #endif
         } else {          } else {
                 dnParent( &e->e_nname, &p_ndn );                  dnParent( &e->e_nname, &p_ndn );
         }          }
Line 316  retry: /* transaction retry */ Line 296  retry: /* transaction retry */
                         rs->sr_text = "old entry's parent does not exist";                          rs->sr_text = "old entry's parent does not exist";
                         goto return_results;                          goto return_results;
                 }                  }
           } else {
                   p = (Entry *)&slap_entry_root;
           }
   
                 /* check parent for "children" acl */          /* check parent for "children" acl */
                 rs->sr_err = access_allowed( op, p,          rs->sr_err = access_allowed( op, p,
                         children, NULL, ACL_WRITE, NULL );                  children, NULL,
                   op->oq_modrdn.rs_newSup == NULL ?
                 if ( ! rs->sr_err ) {                          ACL_WRITE : ACL_WDEL,
                         switch( opinfo.boi_err ) {                  NULL );
                         case DB_LOCK_DEADLOCK:  
                         case DB_LOCK_NOTGRANTED:  
                                 goto retry;  
                         }  
   
                         rs->sr_err = LDAP_INSUFFICIENT_ACCESS;          if ( !p_ndn.bv_len )
                         Debug( LDAP_DEBUG_TRACE, "no access to parent\n", 0,                  p = NULL;
                                 0, 0 );  
                         rs->sr_text = "no write access to old parent's children";  
                         goto return_results;  
                 }  
   
                 Debug( LDAP_DEBUG_TRACE,          if ( ! rs->sr_err ) {
                         LDAP_XSTRING(bdb_modrdn) ": wr to children "                  switch( opinfo.boi_err ) {
                         "of entry %s OK\n", p_ndn.bv_val, 0, 0 );                  case DB_LOCK_DEADLOCK:
                                   case DB_LOCK_NOTGRANTED:
                 if ( p_ndn.bv_val == slap_empty_bv.bv_val ) {                          goto retry;
                         p_dn = slap_empty_bv;  
                 } else {  
                         dnParent( &e->e_name, &p_dn );  
                 }                  }
   
                 Debug( LDAP_DEBUG_TRACE,                  rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
                         LDAP_XSTRING(bdb_modrdn) ": parent dn=%s\n",                  Debug( LDAP_DEBUG_TRACE, "no access to parent\n", 0,
                         p_dn.bv_val, 0, 0 );                          0, 0 );
                   rs->sr_text = "no write access to old parent's children";
                   goto return_results;
           }
   
           Debug( LDAP_DEBUG_TRACE,
                   LDAP_XSTRING(bdb_modrdn) ": wr to children "
                   "of entry %s OK\n", p_ndn.bv_val, 0, 0 );
           
           if ( p_ndn.bv_val == slap_empty_bv.bv_val ) {
                   p_dn = slap_empty_bv;
         } else {          } else {
                 /* no parent, modrdn entry directly under root */                  dnParent( &e->e_name, &p_dn );
                 isroot = be_isroot( op );  
                 if ( ! isroot ) {  
                         if ( be_issuffix( op->o_bd, (struct berval *)&slap_empty_bv )  
                                 || be_shadow_update( op ) ) {  
   
                                 p = (Entry *)&slap_entry_root;  
   
                                 /* check parent for "children" acl */  
                                 rs->sr_err = access_allowed( op, p,  
                                         children, NULL, ACL_WRITE, NULL );  
   
                                 p = NULL;  
   
                                 if ( ! rs->sr_err ) {  
                                         switch( opinfo.boi_err ) {  
                                         case DB_LOCK_DEADLOCK:  
                                         case DB_LOCK_NOTGRANTED:  
                                                 goto retry;  
                                         }  
   
                                         rs->sr_err = LDAP_INSUFFICIENT_ACCESS;  
                                         Debug( LDAP_DEBUG_TRACE,   
                                                 "no access to parent\n",   
                                                 0, 0, 0 );  
                                         rs->sr_text = "no write access to old parent";  
                                         goto return_results;  
                                 }  
   
                                 Debug( LDAP_DEBUG_TRACE,  
                                         LDAP_XSTRING(bdb_modrdn)  
                                         ": wr to children of entry \"\" OK\n",  
                                         0, 0, 0 );  
                   
                                 p_dn.bv_val = "";  
                                 p_dn.bv_len = 0;  
   
                                 Debug( LDAP_DEBUG_TRACE,  
                                         LDAP_XSTRING(bdb_modrdn)  
                                         ": parent dn=\"\"\n",  
                                         0, 0, 0 );  
   
                         } else {  
                                 Debug( LDAP_DEBUG_TRACE,  
                                         LDAP_XSTRING(bdb_modrdn)  
                                         ": no parent, not root "  
                                         "& \"\" is not suffix\n",  
                                         0, 0, 0);  
                                 rs->sr_text = "no write access to old parent";  
                                 rs->sr_err = LDAP_INSUFFICIENT_ACCESS;  
                                 goto return_results;  
                         }  
                 }  
         }          }
   
           Debug( LDAP_DEBUG_TRACE,
                   LDAP_XSTRING(bdb_modrdn) ": parent dn=%s\n",
                   p_dn.bv_val, 0, 0 );
   
         new_parent_dn = &p_dn;  /* New Parent unless newSuperior given */          new_parent_dn = &p_dn;  /* New Parent unless newSuperior given */
   
         if ( op->oq_modrdn.rs_newSup != NULL ) {          if ( op->oq_modrdn.rs_newSup != NULL ) {
Line 422  retry: /* transaction retry */ Line 355  retry: /* transaction retry */
                 }                  }
         }          }
   
           /* There's a BDB_MULTIPLE_SUFFIXES case here that this code doesn't
            * support. E.g., two suffixes dc=foo,dc=com and dc=bar,dc=net.
            * We do not allow modDN
            *   dc=foo,dc=com
            *    newrdn dc=bar
            *    newsup dc=net
            * and we probably should. But since MULTIPLE_SUFFIXES is deprecated
            * I'm ignoring this problem for now.
            */
         if ( op->oq_modrdn.rs_newSup != NULL ) {          if ( op->oq_modrdn.rs_newSup != NULL ) {
                 if ( op->oq_modrdn.rs_newSup->bv_len ) {                  if ( op->oq_modrdn.rs_newSup->bv_len ) {
                         np_dn = op->oq_modrdn.rs_newSup;                          np_dn = op->oq_modrdn.rs_newSup;
                         np_ndn = op->oq_modrdn.rs_nnewSup;                          np_ndn = op->oq_modrdn.rs_nnewSup;
   
                         /* newSuperior == oldParent?, if so ==> ERROR */                          /* newSuperior == oldParent? - checked above */
                         /* newSuperior == entry being moved?, if so ==> ERROR */                          /* newSuperior == entry being moved?, if so ==> ERROR */
                           if ( dnIsSuffix( np_ndn, &e->e_nname )) {
                                   rs->sr_err = LDAP_NO_SUCH_OBJECT;
                                   rs->sr_text = "new superior not found";
                                   goto return_results;
                           }
                         /* Get Entry with dn=newSuperior. Does newSuperior exist? */                          /* Get Entry with dn=newSuperior. Does newSuperior exist? */
   
                         rs->sr_err = bdb_dn2entry( op, ltid, np_ndn,                          rs->sr_err = bdb_dn2entry( op, ltid, np_ndn,
Line 456  retry: /* transaction retry */ Line 403  retry: /* transaction retry */
                                         ": newSup(ndn=%s) not here!\n",                                          ": newSup(ndn=%s) not here!\n",
                                         np_ndn->bv_val, 0, 0);                                          np_ndn->bv_val, 0, 0);
                                 rs->sr_text = "new superior not found";                                  rs->sr_text = "new superior not found";
                                 rs->sr_err = LDAP_OTHER;                                  rs->sr_err = LDAP_NO_SUCH_OBJECT;
                                 goto return_results;                                  goto return_results;
                         }                          }
   
Line 467  retry: /* transaction retry */ Line 414  retry: /* transaction retry */
   
                         /* check newSuperior for "children" acl */                          /* check newSuperior for "children" acl */
                         rs->sr_err = access_allowed( op, np, children,                          rs->sr_err = access_allowed( op, np, children,
                                 NULL, ACL_WRITE, NULL );                                  NULL, ACL_WADD, NULL );
   
                         if( ! rs->sr_err ) {                          if( ! rs->sr_err ) {
                                 switch( opinfo.boi_err ) {                                  switch( opinfo.boi_err ) {
Line 508  retry: /* transaction retry */ Line 455  retry: /* transaction retry */
                         }                          }
   
                 } else {                  } else {
                         if ( isroot == -1 ) {  
                                 isroot = be_isroot( op );  
                         }  
                           
                         np_dn = NULL;                          np_dn = NULL;
   
                         /* no parent, modrdn entry directly under root */                          /* no parent, modrdn entry directly under root */
                         if ( ! isroot ) {                          if ( be_issuffix( op->o_bd, (struct berval *)&slap_empty_bv )
                                 if ( be_issuffix( op->o_bd, (struct berval *)&slap_empty_bv )                                  || be_isupdate( op ) ) {
                                         || be_isupdate( op ) ) {                                  np = (Entry *)&slap_entry_root;
                                         np = (Entry *)&slap_entry_root;  
                                   /* check parent for "children" acl */
                                         /* check parent for "children" acl */                                  rs->sr_err = access_allowed( op, np,
                                         rs->sr_err = access_allowed( op, np,                                          children, NULL, ACL_WADD, NULL );
                                                 children, NULL, ACL_WRITE, NULL );  
                                   np = NULL;
                                         np = NULL;  
                                   if ( ! rs->sr_err ) {
                                         if ( ! rs->sr_err ) {                                          switch( opinfo.boi_err ) {
                                                 switch( opinfo.boi_err ) {                                          case DB_LOCK_DEADLOCK:
                                                 case DB_LOCK_DEADLOCK:                                          case DB_LOCK_NOTGRANTED:
                                                 case DB_LOCK_NOTGRANTED:                                                  goto retry;
                                                         goto retry;  
                                                 }  
   
                                                 rs->sr_err = LDAP_INSUFFICIENT_ACCESS;  
                                                 Debug( LDAP_DEBUG_TRACE,   
                                                         "no access to new superior\n",   
                                                         0, 0, 0 );  
                                                 rs->sr_text =  
                                                         "no write access to new superior's children";  
                                                 goto return_results;  
                                         }                                          }
   
                                         Debug( LDAP_DEBUG_TRACE,  
                                                 LDAP_XSTRING(bdb_modrdn)  
                                                 ": wr to children "  
                                                 "of entry \"\" OK\n",  
                                                 0, 0, 0 );  
                   
                                 } else {  
                                         Debug( LDAP_DEBUG_TRACE,  
                                                 LDAP_XSTRING(bdb_modrdn)  
                                                 ": new superior=\"\", not root "  
                                                 "& \"\" is not suffix\n",  
                                                 0, 0, 0 );  
                                         rs->sr_text = "no write access to new superior's children";  
                                         rs->sr_err = LDAP_INSUFFICIENT_ACCESS;                                          rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
                                           Debug( LDAP_DEBUG_TRACE, 
                                                   "no access to new superior\n", 
                                                   0, 0, 0 );
                                           rs->sr_text =
                                                   "no write access to new superior's children";
                                         goto return_results;                                          goto return_results;
                                 }                                  }
                         }                          }
   
                         Debug( LDAP_DEBUG_TRACE,  
                                 LDAP_XSTRING(bdb_modrdn)  
                                 ": new superior=\"\"\n",  
                                 0, 0, 0 );  
                 }                  }
   
                 Debug( LDAP_DEBUG_TRACE,                  Debug( LDAP_DEBUG_TRACE,
Line 590  retry: /* transaction retry */ Line 510  retry: /* transaction retry */
   
         /* Shortcut the search */          /* Shortcut the search */
         nei = neip ? neip : eip;          nei = neip ? neip : eip;
         rs->sr_err = bdb_cache_find_ndn ( op, ltid, &new_ndn, &nei );          rs->sr_err = bdb_cache_find_ndn ( op, locker, &new_ndn, &nei );
         if ( nei ) bdb_cache_entryinfo_unlock( nei );          if ( nei ) bdb_cache_entryinfo_unlock( nei );
         switch( rs->sr_err ) {          switch( rs->sr_err ) {
         case DB_LOCK_DEADLOCK:          case DB_LOCK_DEADLOCK:
Line 599  retry: /* transaction retry */ Line 519  retry: /* transaction retry */
         case DB_NOTFOUND:          case DB_NOTFOUND:
                 break;                  break;
         case 0:          case 0:
                   /* Allow rename to same DN */
                   if ( nei == ei )
                           break;
                 rs->sr_err = LDAP_ALREADY_EXISTS;                  rs->sr_err = LDAP_ALREADY_EXISTS;
                 goto return_results;                  goto return_results;
         default:          default:
Line 720  retry: /* transaction retry */ Line 643  retry: /* transaction retry */
   
         dummy.e_attrs = e->e_attrs;          dummy.e_attrs = e->e_attrs;
   
 #ifdef BDB_PSEARCH  
         if ( rs->sr_err == LDAP_SUCCESS && !op->o_noop && !op->o_no_psearch ) {  
                 ldap_pvt_thread_rdwr_wlock( &bdb->bi_pslist_rwlock );  
                 LDAP_LIST_FOREACH ( ps_list, &bdb->bi_psearch_list, o_ps_link ) {  
                         rc = bdb_psearch( op, rs, ps_list, &dummy, LDAP_PSEARCH_BY_PREMODIFY );  
                         if ( rc ) {  
                                 Debug( LDAP_DEBUG_TRACE,  
                                         LDAP_XSTRING(bdb_modrdn)  
                                         ": persistent search failed (%d,%d)\n",  
                                         rc, rs->sr_err, 0 );  
                         }  
                 }  
                 ldap_pvt_thread_rdwr_wunlock( &bdb->bi_pslist_rwlock );  
         }  
 #endif  
   
   
         /* modify entry */          /* modify entry */
         rs->sr_err = bdb_modify_internal( op, lt2, &mod[0], &dummy,          rs->sr_err = bdb_modify_internal( op, lt2, &mod[0], &dummy,
                 &rs->sr_text, textbuf, textlen );                  &rs->sr_text, textbuf, textlen );
Line 805  retry: /* transaction retry */ Line 711  retry: /* transaction retry */
                 goto return_results;                  goto return_results;
         }          }
   
 #ifdef BDB_PSEARCH  
         if ( LDAP_STAILQ_EMPTY( &op->o_bd->be_syncinfo )) {  
                 rc = bdb_csn_commit( op, rs, ltid, ei, &suffix_ei,  
                         &ctxcsn_e, &ctxcsn_added, locker );  
                 switch ( rc ) {  
                 case BDB_CSN_ABORT :  
                         goto return_results;  
                 case BDB_CSN_RETRY :  
                         goto retry;  
                 }  
         }  
 #endif  
   
         if( op->o_postread ) {          if( op->o_postread ) {
                 if( postread_ctrl == NULL ) {                  if( postread_ctrl == NULL ) {
                         postread_ctrl = &ctrls[num_ctrls++];                          postread_ctrl = &ctrls[num_ctrls++];
Line 837  retry: /* transaction retry */ Line 730  retry: /* transaction retry */
                 if(( rs->sr_err=TXN_ABORT( ltid )) != 0 ) {                  if(( rs->sr_err=TXN_ABORT( ltid )) != 0 ) {
                         rs->sr_text = "txn_abort (no-op) failed";                          rs->sr_text = "txn_abort (no-op) failed";
                 } else {                  } else {
                         rs->sr_err = LDAP_SUCCESS;                          rs->sr_err = LDAP_X_NO_OPERATION;
                           ltid = NULL;
                           /* Only free attrs if they were dup'd.  */
                           if ( dummy.e_attrs == e->e_attrs ) dummy.e_attrs = NULL;
                         goto return_results;                          goto return_results;
                 }                  }
   
         } else {          } else {
                 rc = bdb_cache_modrdn( e, &op->orr_nnewrdn, &dummy, neip,                  rc = bdb_cache_modrdn( bdb, e, &op->orr_nnewrdn, &dummy, neip,
                         bdb->bi_dbenv, locker, &lock );                          locker, &lock );
                 switch( rc ) {                  switch( rc ) {
                 case DB_LOCK_DEADLOCK:                  case DB_LOCK_DEADLOCK:
                 case DB_LOCK_NOTGRANTED:                  case DB_LOCK_NOTGRANTED:
Line 853  retry: /* transaction retry */ Line 749  retry: /* transaction retry */
                 new_dn.bv_val = NULL;                  new_dn.bv_val = NULL;
                 new_ndn.bv_val = NULL;                  new_ndn.bv_val = NULL;
   
 #ifdef BDB_PSEARCH  
                 if ( LDAP_STAILQ_EMPTY( &op->o_bd->be_syncinfo )) {  
                         if ( ctxcsn_added ) {  
                                 bdb_cache_add( bdb, suffix_ei, ctxcsn_e,  
                                         (struct berval *)&slap_ldapsync_cn_bv, locker );  
                         }  
                 }  
   
                 if ( rs->sr_err == LDAP_SUCCESS ) {  
                         /* Loop through in-scope entries for each psearch spec */  
                         ldap_pvt_thread_rdwr_wlock( &bdb->bi_pslist_rwlock );  
                         LDAP_LIST_FOREACH ( ps_list, &bdb->bi_psearch_list, o_ps_link ) {  
                                 rc = bdb_psearch( op, rs, ps_list, e, LDAP_PSEARCH_BY_MODIFY );  
                                 if ( rc ) {  
                                         Debug( LDAP_DEBUG_TRACE,  
                                                 LDAP_XSTRING(bdb_modrdn)  
                                                 ": persistent search failed "  
                                                 "(%d,%d)\n",  
                                                 rc, rs->sr_err, 0 );  
                         }  
                         }  
                         pm_list = LDAP_LIST_FIRST(&op->o_pm_list);  
                         while ( pm_list != NULL ) {  
                                 rc = bdb_psearch(op, rs, pm_list->ps_op,  
                                                         e, LDAP_PSEARCH_BY_SCOPEOUT);  
                                 if ( rc ) {  
                                         Debug( LDAP_DEBUG_TRACE,  
                                                 LDAP_XSTRING(bdb_modrdn)  
                                                 ": persistent search failed "  
                                                 "(%d,%d)\n",  
                                                 rc, rs->sr_err, 0 );  
                                 }  
                                 pm_prev = pm_list;  
                                 LDAP_LIST_REMOVE ( pm_list, ps_link );  
                                 pm_list = LDAP_LIST_NEXT ( pm_list, ps_link );  
                                 ch_free( pm_prev );  
                         }  
                         ldap_pvt_thread_rdwr_wunlock( &bdb->bi_pslist_rwlock );  
                 }  
 #endif  
   
                 if(( rs->sr_err=TXN_COMMIT( ltid, 0 )) != 0 ) {                  if(( rs->sr_err=TXN_COMMIT( ltid, 0 )) != 0 ) {
                         rs->sr_text = "txn_commit failed";                          rs->sr_text = "txn_commit failed";
                 } else {                  } else {
Line 928  return_results: Line 783  return_results:
         send_ldap_result( op, rs );          send_ldap_result( op, rs );
   
         if( rs->sr_err == LDAP_SUCCESS && bdb->bi_txn_cp ) {          if( rs->sr_err == LDAP_SUCCESS && bdb->bi_txn_cp ) {
                 ldap_pvt_thread_yield();  
                 TXN_CHECKPOINT( bdb->bi_dbenv,                  TXN_CHECKPOINT( bdb->bi_dbenv,
                         bdb->bi_txn_cp_kbyte, bdb->bi_txn_cp_min, 0 );                          bdb->bi_txn_cp_kbyte, bdb->bi_txn_cp_min, 0 );
         }          }
Line 938  return_results: Line 792  return_results:
         }          }
   
 done:  done:
           slap_graduate_commit_csn( op );
   
         if( new_dn.bv_val != NULL ) free( new_dn.bv_val );          if( new_dn.bv_val != NULL ) free( new_dn.bv_val );
         if( new_ndn.bv_val != NULL ) free( new_ndn.bv_val );          if( new_ndn.bv_val != NULL ) free( new_ndn.bv_val );
   
Line 945  done: Line 801  done:
         if ( new_rdn != NULL ) {          if ( new_rdn != NULL ) {
                 ldap_rdnfree_x( new_rdn, op->o_tmpmemctx );                  ldap_rdnfree_x( new_rdn, op->o_tmpmemctx );
         }          }
   
         if ( old_rdn != NULL ) {          if ( old_rdn != NULL ) {
                 ldap_rdnfree_x( old_rdn, op->o_tmpmemctx );                  ldap_rdnfree_x( old_rdn, op->o_tmpmemctx );
         }          }
   
         if( mod != NULL ) {          if( mod != NULL ) {
                 Modifications *tmp;                  slap_modrdn2mods_free( mod );
                 for (; mod; mod=tmp ) {  
                         tmp = mod->sml_next;  
                         /* slap_modrdn2mods does things one way,  
                          * slap_mods_opattrs does it differently  
                          */  
                         if ( mod->sml_op != SLAP_MOD_SOFTADD &&  
                                 mod->sml_op != LDAP_MOD_DELETE ) break;  
                         if ( mod->sml_nvalues ) free( mod->sml_nvalues[0].bv_val );  
                         free( mod );  
                 }  
                 slap_mods_free( mod );  
         }          }
   
         /* LDAP v3 Support */          /* LDAP v3 Support */
Line 980  done: Line 827  done:
         }          }
   
         if( ltid != NULL ) {          if( ltid != NULL ) {
 #ifdef BDB_PSEARCH  
                 pm_list = LDAP_LIST_FIRST(&op->o_pm_list);  
                 while ( pm_list != NULL ) {  
                         LDAP_LIST_REMOVE ( pm_list, ps_link );  
                         pm_prev = pm_list;  
                         pm_list = LDAP_LIST_NEXT ( pm_list, ps_link );  
                         ch_free( pm_prev );  
                 }  
 #endif  
                 TXN_ABORT( ltid );                  TXN_ABORT( ltid );
                 op->o_private = NULL;  
         }          }
           op->o_private = NULL;
   
         if( preread_ctrl != NULL ) {          if( preread_ctrl != NULL && (*preread_ctrl) != NULL ) {
                 slap_sl_free( (*preread_ctrl)->ldctl_value.bv_val, op->o_tmpmemctx );                  slap_sl_free( (*preread_ctrl)->ldctl_value.bv_val, op->o_tmpmemctx );
                 slap_sl_free( *preread_ctrl, op->o_tmpmemctx );                  slap_sl_free( *preread_ctrl, op->o_tmpmemctx );
         }          }
         if( postread_ctrl != NULL ) {          if( postread_ctrl != NULL && (*postread_ctrl) != NULL ) {
                 slap_sl_free( (*postread_ctrl)->ldctl_value.bv_val, op->o_tmpmemctx );                  slap_sl_free( (*postread_ctrl)->ldctl_value.bv_val, op->o_tmpmemctx );
                 slap_sl_free( *postread_ctrl, op->o_tmpmemctx );                  slap_sl_free( *postread_ctrl, op->o_tmpmemctx );
         }          }

Removed from v.1.160  
changed lines
  Added in v.1.160.2.15


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