Diff for /servers/slapd/back-bdb/modrdn.c between versions 1.63 and 1.63.2.18

version 1.63, 2002/02/13 10:46:34 version 1.63.2.18, 2003/05/16 02:53:02
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.62 2002/02/11 20:07:55 kurt Exp $ */  /* $OpenLDAP: pkg/ldap/servers/slapd/back-bdb/modrdn.c,v 1.63.2.17 2003/03/26 17:56:38 kurt Exp $ */
 /*  /*
  * Copyright 1998-2002 The OpenLDAP Foundation, All Rights Reserved.   * Copyright 1998-2003 The OpenLDAP Foundation, All Rights Reserved.
  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file   * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
  */   */
   
Line 28  bdb_modrdn( Line 28  bdb_modrdn(
 {  {
         struct bdb_info *bdb = (struct bdb_info *) be->be_private;          struct bdb_info *bdb = (struct bdb_info *) be->be_private;
         AttributeDescription *children = slap_schema.si_ad_children;          AttributeDescription *children = slap_schema.si_ad_children;
           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;          int             isroot = -1;
         Entry           *e, *p = NULL;          Entry           *e = NULL;
           Entry           *p = NULL;
         Entry           *matched;          Entry           *matched;
         int                     rc;          /* LDAP v2 supporting correct attribute handling. */
           LDAPRDN         *new_rdn = NULL;
           LDAPRDN         *old_rdn = NULL;
           int             rc;
         const char *text;          const char *text;
         char textbuf[SLAP_TEXT_BUFLEN];          char textbuf[SLAP_TEXT_BUFLEN];
         size_t textlen = sizeof textbuf;          size_t textlen = sizeof textbuf;
Line 41  bdb_modrdn( Line 46  bdb_modrdn(
         struct bdb_op_info opinfo;          struct bdb_op_info opinfo;
   
         ID                      id;          ID                      id;
         int             a_cnt, d_cnt;  
         LDAPRDN         *new_rdn = NULL;  
         LDAPRDN         *old_rdn = NULL;  
   
         Entry           *np = NULL;                     /* newSuperior Entry */          Entry           *np = NULL;                     /* newSuperior Entry */
         struct berval   *np_dn = NULL;                  /* newSuperior dn */          struct berval   *np_dn = NULL;                  /* newSuperior dn */
Line 55  bdb_modrdn( Line 57  bdb_modrdn(
   
         int             manageDSAit = get_manageDSAit( op );          int             manageDSAit = get_manageDSAit( op );
   
           u_int32_t       locker = 0;
           DB_LOCK         lock;
   
           int             noop = 0;
   
   #if defined(LDAP_CLIENT_UPDATE) || defined(LDAP_SYNC)
           Operation* ps_list;
           struct psid_entry* pm_list;
           struct psid_entry* pm_prev;
   #endif
   
   #ifdef NEW_LOGGING
           LDAP_LOG ( OPERATION, ENTRY, "==>bdb_modrdn(%s,%s,%s)\n", 
                   dn->bv_val,newrdn->bv_val, newSuperior ? newSuperior->bv_val : "NULL" );
   #else
         Debug( LDAP_DEBUG_TRACE, "==>bdb_modrdn(%s,%s,%s)\n",          Debug( LDAP_DEBUG_TRACE, "==>bdb_modrdn(%s,%s,%s)\n",
                 dn->bv_val, newrdn->bv_val,                  dn->bv_val, newrdn->bv_val,
                 newSuperior ? newSuperior->bv_val : "NULL" );                  newSuperior ? newSuperior->bv_val : "NULL" );
   
 #if 0  
         if( newSuperior != NULL ) {  
                 rc = LDAP_UNWILLING_TO_PERFORM;  
                 text = "newSuperior not implemented (yet)";  
                 goto return_results;  
         }  
 #endif  #endif
   
         if( 0 ) {          if( 0 ) {
 retry:  /* transaction retry */  retry:  /* transaction retry */
                 if (e != NULL) {                  if (e != NULL) {
                         bdb_cache_delete_entry(&bdb->bi_cache, e);                          bdb_cache_delete_entry(&bdb->bi_cache, e);
                         bdb_cache_return_entry_w(&bdb->bi_cache, e);                          bdb_unlocked_cache_return_entry_w(&bdb->bi_cache, e);
                           e = NULL;
                 }                  }
                 if (p != NULL) {                  if (p != NULL) {
                         bdb_cache_return_entry_r(&bdb->bi_cache, p);                          bdb_unlocked_cache_return_entry_r(&bdb->bi_cache, p);
                           p = NULL;
                 }                  }
                 if (np != NULL) {                  if (np != NULL) {
                         bdb_cache_return_entry_r(&bdb->bi_cache, np);                          bdb_unlocked_cache_return_entry_r(&bdb->bi_cache, np);
                           np = NULL;
                 }                  }
   #ifdef NEW_LOGGING
                   LDAP_LOG ( OPERATION, DETAIL1, "==>bdb_modrdn: retrying...\n", 0, 0, 0);
   #else
                 Debug( LDAP_DEBUG_TRACE, "==>bdb_modrdn: retrying...\n", 0, 0, 0 );                  Debug( LDAP_DEBUG_TRACE, "==>bdb_modrdn: retrying...\n", 0, 0, 0 );
   #endif
   
   #if defined(LDAP_CLIENT_UPDATE) || defined(LDAP_SYNC)
                   pm_list = LDAP_LIST_FIRST(&op->premodify_list);
                   while ( pm_list != NULL ) {
                           LDAP_LIST_REMOVE ( pm_list, link );
                           pm_prev = pm_list;
                           pm_list = LDAP_LIST_NEXT ( pm_list, link );
                           free (pm_prev);
                   }
   #endif
   
                 rc = TXN_ABORT( ltid );                  rc = TXN_ABORT( ltid );
                 ltid = NULL;                  ltid = NULL;
                 op->o_private = NULL;                  op->o_private = NULL;
                   op->o_do_not_cache = opinfo.boi_acl_cache;
                 if( rc != 0 ) {                  if( rc != 0 ) {
                         rc = LDAP_OTHER;                          rc = LDAP_OTHER;
                         text = "internal error";                          text = "internal error";
Line 96  retry: /* transaction retry */ Line 125  retry: /* transaction retry */
                 bdb->bi_db_opflags );                  bdb->bi_db_opflags );
         text = NULL;          text = NULL;
         if( rc != 0 ) {          if( rc != 0 ) {
   #ifdef NEW_LOGGING
                   LDAP_LOG ( OPERATION, ERR, 
                           "==>bdb_modrdn: txn_begin failed: %s (%d)\n", 
                           db_strerror(rc), rc, 0 );
   #else
                 Debug( LDAP_DEBUG_TRACE,                  Debug( LDAP_DEBUG_TRACE,
                         "bdb_delete: txn_begin failed: %s (%d)\n",                          "bdb_modrdn: txn_begin failed: %s (%d)\n",
                         db_strerror(rc), rc, 0 );                          db_strerror(rc), rc, 0 );
   #endif
                 rc = LDAP_OTHER;                  rc = LDAP_OTHER;
                 text = "internal error";                  text = "internal error";
                 goto return_results;                  goto return_results;
         }          }
   
           locker = TXN_ID ( ltid );
   
         opinfo.boi_bdb = be;          opinfo.boi_bdb = be;
         opinfo.boi_txn = ltid;          opinfo.boi_txn = ltid;
           opinfo.boi_locker = locker;
         opinfo.boi_err = 0;          opinfo.boi_err = 0;
           opinfo.boi_acl_cache = op->o_do_not_cache;
         op->o_private = &opinfo;          op->o_private = &opinfo;
   
         /* get entry */          /* get entry */
         rc = bdb_dn2entry_w( be, ltid, ndn, &e, &matched, 0 );          rc = bdb_dn2entry_w( be, ltid, ndn, &e, &matched, DB_RMW, locker, &lock );
   
         switch( rc ) {          switch( rc ) {
         case 0:          case 0:
Line 119  retry: /* transaction retry */ Line 158  retry: /* transaction retry */
         case DB_LOCK_DEADLOCK:          case DB_LOCK_DEADLOCK:
         case DB_LOCK_NOTGRANTED:          case DB_LOCK_NOTGRANTED:
                 goto retry;                  goto retry;
           case LDAP_BUSY:
                   text = "ldap server busy";
                   goto return_results;
         default:          default:
                 rc = LDAP_OTHER;                  rc = LDAP_OTHER;
                 text = "internal error";                  text = "internal error";
Line 134  retry: /* transaction retry */ Line 176  retry: /* transaction retry */
                         refs = is_entry_referral( matched )                          refs = is_entry_referral( matched )
                                 ? get_entry_referrals( be, conn, op, matched )                                  ? get_entry_referrals( be, conn, op, matched )
                                 : NULL;                                  : NULL;
                         bdb_cache_return_entry_r( &bdb->bi_cache, matched );                          bdb_unlocked_cache_return_entry_r( &bdb->bi_cache, matched);
                         matched = NULL;                          matched = NULL;
   
                 } else {                  } else {
Line 151  retry: /* transaction retry */ Line 193  retry: /* transaction retry */
                 goto done;                  goto done;
         }          }
   
           /* check write on old entry */
           rc = access_allowed( be, conn, op, e, entry, NULL, ACL_WRITE, NULL );
   
           if ( ! rc ) {
                   switch( opinfo.boi_err ) {
                   case DB_LOCK_DEADLOCK:
                   case DB_LOCK_NOTGRANTED:
                           goto retry;
                   }
   
   #ifdef NEW_LOGGING
                   LDAP_LOG ( OPERATION, ERR, 
                           "==>bdb_modrdn: no access to entry\n", 0, 0, 0 );
   #else
                   Debug( LDAP_DEBUG_TRACE, "no access to entry\n", 0,
                           0, 0 );
   #endif
                   text = "no write access to old entry";
                   rc = LDAP_INSUFFICIENT_ACCESS;
                   goto return_results;
           }
   
   #ifndef BDB_HIER
           rc = bdb_dn2id_children( be, ltid, &e->e_nname, 0 );
           if ( rc != DB_NOTFOUND ) {
                   switch( rc ) {
                   case DB_LOCK_DEADLOCK:
                   case DB_LOCK_NOTGRANTED:
                           goto retry;
                   case 0:
   #ifdef NEW_LOGGING
                           LDAP_LOG ( OPERATION, DETAIL1, 
                                   "<=- bdb_modrdn: non-leaf %s\n", dn->bv_val, 0, 0 );
   #else
                           Debug(LDAP_DEBUG_ARGS,
                                   "<=- bdb_modrdn: non-leaf %s\n",
                                   dn->bv_val, 0, 0);
   #endif
                           rc = LDAP_NOT_ALLOWED_ON_NONLEAF;
                           text = "subtree rename not supported";
                           break;
                   default:
   #ifdef NEW_LOGGING
                           LDAP_LOG ( OPERATION, ERR, 
                                   "<=- bdb_modrdn: has_children failed %s (%d)\n",
                                   db_strerror(rc), rc, 0 );
   #else
                           Debug(LDAP_DEBUG_ARGS,
                                   "<=- bdb_modrdn: has_children failed: %s (%d)\n",
                                   db_strerror(rc), rc, 0 );
   #endif
                           rc = LDAP_OTHER;
                           text = "internal error";
                   }
                   goto return_results;
           }
   #endif
         if (!manageDSAit && is_entry_referral( e ) ) {          if (!manageDSAit && is_entry_referral( e ) ) {
                 /* parent is a referral, don't allow add */                  /* parent is a referral, don't allow add */
                 /* parent is an alias, don't allow add */                  /* parent is an alias, don't allow add */
                 BerVarray refs = get_entry_referrals( be,                  BerVarray refs = get_entry_referrals( be,
                         conn, op, e );                          conn, op, e );
   
   #ifdef NEW_LOGGING
                   LDAP_LOG ( OPERATION, DETAIL1, 
                           "==>bdb_modrdn: entry %s is referral \n", e->e_dn, 0, 0 );
   #else
                 Debug( LDAP_DEBUG_TRACE, "bdb_modrdn: entry %s is referral\n",                  Debug( LDAP_DEBUG_TRACE, "bdb_modrdn: entry %s is referral\n",
                         e->e_dn, 0, 0 );                          e->e_dn, 0, 0 );
   #endif
   
                 send_ldap_result( conn, op, rc = LDAP_REFERRAL,                  send_ldap_result( conn, op, rc = LDAP_REFERRAL,
                         e->e_dn, NULL, refs, NULL );                          e->e_dn, NULL, refs, NULL );
Line 177  retry: /* transaction retry */ Line 281  retry: /* transaction retry */
                 /* Make sure parent entry exist and we can write its                   /* Make sure parent entry exist and we can write its 
                  * children.                   * children.
                  */                   */
                 rc = bdb_dn2entry_r( be, ltid, &p_ndn, &p, NULL, 0 );                  rc = bdb_dn2entry_r( be, ltid, &p_ndn, &p, NULL, 0, locker, &lock );
   
                 switch( rc ) {                  switch( rc ) {
                 case 0:                  case 0:
Line 186  retry: /* transaction retry */ Line 290  retry: /* transaction retry */
                 case DB_LOCK_DEADLOCK:                  case DB_LOCK_DEADLOCK:
                 case DB_LOCK_NOTGRANTED:                  case DB_LOCK_NOTGRANTED:
                         goto retry;                          goto retry;
                   case LDAP_BUSY:
                           text = "ldap server busy";
                           goto return_results;
                 default:                  default:
                         rc = LDAP_OTHER;                          rc = LDAP_OTHER;
                         text = "internal error";                          text = "internal error";
Line 193  retry: /* transaction retry */ Line 300  retry: /* transaction retry */
                 }                  }
   
                 if( p == NULL) {                  if( p == NULL) {
   #ifdef NEW_LOGGING
                           LDAP_LOG ( OPERATION, ERR, 
                                   "==>bdb_modrdn: parent does not exist\n", 0, 0, 0 );
   #else
                         Debug( LDAP_DEBUG_TRACE, "bdb_modrdn: parent does not exist\n",                          Debug( LDAP_DEBUG_TRACE, "bdb_modrdn: parent does not exist\n",
                                 0, 0, 0);                                  0, 0, 0);
   #endif
                         rc = LDAP_OTHER;                          rc = LDAP_OTHER;
                           text = "old entry's parent does not exist";
                         goto return_results;                          goto return_results;
                 }                  }
   
                 /* check parent for "children" acl */                  /* check parent for "children" acl */
                 if ( ! access_allowed( be, conn, op, p,                  rc = access_allowed( be, conn, op, p,
                         children, NULL, ACL_WRITE, NULL ) )                          children, NULL, ACL_WRITE, NULL );
                 {  
                   if ( ! rc ) {
                           switch( opinfo.boi_err ) {
                           case DB_LOCK_DEADLOCK:
                           case DB_LOCK_NOTGRANTED:
                                   goto retry;
                           }
   
                           rc = LDAP_INSUFFICIENT_ACCESS;
   #ifdef NEW_LOGGING
                           LDAP_LOG ( OPERATION, ERR, 
                                   "==>bdb_modrdn: no access to parent\n", 0, 0, 0 );
   #else
                         Debug( LDAP_DEBUG_TRACE, "no access to parent\n", 0,                          Debug( LDAP_DEBUG_TRACE, "no access to parent\n", 0,
                                 0, 0 );                                  0, 0 );
                         send_ldap_result( conn, op, LDAP_INSUFFICIENT_ACCESS,  #endif
                                 NULL, NULL, NULL, NULL );                          text = "no write access to old parent's children";
                         goto return_results;                          goto return_results;
                 }                  }
   
   #ifdef NEW_LOGGING
                   LDAP_LOG ( OPERATION, DETAIL1, 
                           "==>bdb_modrdn: wr to children %s is OK\n", p_ndn.bv_val, 0, 0 );
   #else
                 Debug( LDAP_DEBUG_TRACE,                  Debug( LDAP_DEBUG_TRACE,
                         "bdb_modrdn: wr to children of entry %s OK\n",                          "bdb_modrdn: wr to children of entry %s OK\n",
                         p_ndn.bv_val, 0, 0 );                          p_ndn.bv_val, 0, 0 );
   #endif
                                   
                 if ( p_ndn.bv_val == slap_empty_bv.bv_val ) {                  if ( p_ndn.bv_val == slap_empty_bv.bv_val ) {
                         p_dn = slap_empty_bv;                          p_dn = slap_empty_bv;
Line 220  retry: /* transaction retry */ Line 350  retry: /* transaction retry */
                         dnParent( &e->e_name, &p_dn );                          dnParent( &e->e_name, &p_dn );
                 }                  }
   
   #ifdef NEW_LOGGING
                   LDAP_LOG ( OPERATION, DETAIL1, 
                           "==>bdb_modrdn: parent dn=%s\n", p_dn.bv_val, 0, 0 );
   #else
                 Debug( LDAP_DEBUG_TRACE,                  Debug( LDAP_DEBUG_TRACE,
                         "bdb_modrdn: parent dn=%s\n",                          "bdb_modrdn: parent dn=%s\n",
                         p_dn.bv_val, 0, 0 );                          p_dn.bv_val, 0, 0 );
   #endif
   
         } else {          } else {
                 /* no parent, modrdn entry directly under root */                  /* no parent, modrdn entry directly under root */
Line 239  retry: /* transaction retry */ Line 374  retry: /* transaction retry */
   
                                 p = NULL;                                  p = NULL;
   
                                 if ( ! rc )                                  if ( ! rc ) {
                                 {                                          switch( opinfo.boi_err ) {
                                           case DB_LOCK_DEADLOCK:
                                           case DB_LOCK_NOTGRANTED:
                                                   goto retry;
                                           }
   
                                           rc = LDAP_INSUFFICIENT_ACCESS;
   #ifdef NEW_LOGGING
                                           LDAP_LOG ( OPERATION, ERR, 
                                                   "==>bdb_modrdn: no access to parent\n", 0, 0, 0 );
   #else
                                         Debug( LDAP_DEBUG_TRACE,                                           Debug( LDAP_DEBUG_TRACE, 
                                                 "no access to parent\n",                                                   "no access to parent\n", 
                                                 0, 0, 0 );                                                  0, 0, 0 );
                                         send_ldap_result( conn, op,   #endif
                                                 LDAP_INSUFFICIENT_ACCESS,                                          text = "no write access to old parent";
                                                 NULL, NULL, NULL, NULL );  
                                         goto return_results;                                          goto return_results;
                                 }                                  }
   
   #ifdef NEW_LOGGING
                                   LDAP_LOG ( OPERATION, DETAIL1, 
                                           "==>bdb_modrdn: wr to children of entry \"%s\" OK\n", 
                                           p_dn.bv_val, 0, 0 );
   #else
                                 Debug( LDAP_DEBUG_TRACE,                                  Debug( LDAP_DEBUG_TRACE,
                                         "bdb_modrdn: wr to children of entry \"\" OK\n",                                          "bdb_modrdn: wr to children of entry \"\" OK\n",
                                         0, 0, 0 );                                          0, 0, 0 );
   #endif
                                   
                                 p_dn.bv_val = "";                                  p_dn.bv_val = "";
                                 p_dn.bv_len = 0;                                  p_dn.bv_len = 0;
   
   #ifdef NEW_LOGGING
                                   LDAP_LOG ( OPERATION, DETAIL1, 
                                           "==>bdb_modrdn: parent dn=\"\" \n", 0, 0, 0 );
   #else
                                 Debug( LDAP_DEBUG_TRACE,                                  Debug( LDAP_DEBUG_TRACE,
                                         "bdb_modrdn: parent dn=\"\"\n",                                          "bdb_modrdn: parent dn=\"\"\n",
                                         0, 0, 0 );                                          0, 0, 0 );
   #endif
   
                         } else {                          } else {
   #ifdef NEW_LOGGING
                                   LDAP_LOG ( OPERATION, ERR, 
                                           "==>bdb_modrdn: no parent, not root &\"\" is not "
                                           "suffix\n", 0, 0, 0 );
   #else
                                 Debug( LDAP_DEBUG_TRACE,                                  Debug( LDAP_DEBUG_TRACE,
                                         "bdb_modrdn: no parent, not root "                                          "bdb_modrdn: no parent, not root "
                                         "& \"\" is not suffix\n",                                          "& \"\" is not suffix\n",
                                         0, 0, 0);                                          0, 0, 0);
   #endif
                                   text = "no write access to old parent";
                                 rc = LDAP_INSUFFICIENT_ACCESS;                                  rc = LDAP_INSUFFICIENT_ACCESS;
                                 goto return_results;                                  goto return_results;
                         }                          }
Line 275  retry: /* transaction retry */ Line 437  retry: /* transaction retry */
         new_parent_dn = &p_dn;  /* New Parent unless newSuperior given */          new_parent_dn = &p_dn;  /* New Parent unless newSuperior given */
   
         if ( newSuperior != NULL ) {          if ( newSuperior != NULL ) {
   #ifdef NEW_LOGGING
                   LDAP_LOG ( OPERATION, DETAIL1, 
                           "==>bdb_modrdn: new parent \"%s\" requested...\n", 
                           newSuperior->bv_val, 0, 0 );
   #else
                 Debug( LDAP_DEBUG_TRACE,                   Debug( LDAP_DEBUG_TRACE, 
                         "bdb_modrdn: new parent \"%s\" requested...\n",                          "bdb_modrdn: new parent \"%s\" requested...\n",
                         newSuperior->bv_val, 0, 0 );                          newSuperior->bv_val, 0, 0 );
   #endif
   
                   /*  newSuperior == oldParent? */
                   if( dn_match( &p_ndn, nnewSuperior ) ) {
   #ifdef NEW_LOGGING
                           LDAP_LOG( BACK_BDB, INFO, "bdb_back_modrdn: "
                                   "new parent \"%s\" same as the old parent \"%s\"\n",
                                   newSuperior->bv_val, p_dn.bv_val, 0 );
   #else
                           Debug( LDAP_DEBUG_TRACE, "bdb_back_modrdn: "
                                   "new parent \"%s\" same as the old parent \"%s\"\n",
                                   newSuperior->bv_val, p_dn.bv_val, 0 );
   #endif      
                           newSuperior = NULL; /* ignore newSuperior */
                   }
           }
   
           if ( newSuperior != NULL ) {
                 if ( newSuperior->bv_len ) {                  if ( newSuperior->bv_len ) {
                         np_dn = newSuperior;                          np_dn = newSuperior;
                         np_ndn = nnewSuperior;                          np_ndn = nnewSuperior;
Line 287  retry: /* transaction retry */ Line 471  retry: /* transaction retry */
                         /* newSuperior == entry being moved?, if so ==> ERROR */                          /* newSuperior == entry being moved?, if so ==> ERROR */
                         /* Get Entry with dn=newSuperior. Does newSuperior exist? */                          /* Get Entry with dn=newSuperior. Does newSuperior exist? */
   
                         rc = bdb_dn2entry_r( be, ltid, nnewSuperior, &np, NULL, 0 );                          rc = bdb_dn2entry_r( be,
                                   ltid, nnewSuperior, &np, NULL, 0, locker, &lock );
   
                         switch( rc ) {                          switch( rc ) {
                         case 0:                          case 0:
Line 296  retry: /* transaction retry */ Line 481  retry: /* transaction retry */
                         case DB_LOCK_DEADLOCK:                          case DB_LOCK_DEADLOCK:
                         case DB_LOCK_NOTGRANTED:                          case DB_LOCK_NOTGRANTED:
                                 goto retry;                                  goto retry;
                           case LDAP_BUSY:
                                   text = "ldap server busy";
                                   goto return_results;
                         default:                          default:
                                 rc = LDAP_OTHER;                                  rc = LDAP_OTHER;
                                 text = "internal error";                                  text = "internal error";
Line 303  retry: /* transaction retry */ Line 491  retry: /* transaction retry */
                         }                          }
   
                         if( np == NULL) {                          if( np == NULL) {
   #ifdef NEW_LOGGING
                                   LDAP_LOG ( OPERATION, DETAIL1, 
                                           "==>bdb_modrdn: newSup(ndn=%s) not here!\n", 
                                           np_ndn->bv_val, 0, 0 );
   #else
                                 Debug( LDAP_DEBUG_TRACE,                                  Debug( LDAP_DEBUG_TRACE,
                                         "bdb_modrdn: newSup(ndn=%s) not here!\n",                                          "bdb_modrdn: newSup(ndn=%s) not here!\n",
                                         np_ndn->bv_val, 0, 0);                                          np_ndn->bv_val, 0, 0);
   #endif
                                   text = "new superior not found";
                                 rc = LDAP_OTHER;                                  rc = LDAP_OTHER;
                                 goto return_results;                                  goto return_results;
                         }                          }
   
   #ifdef NEW_LOGGING
                           LDAP_LOG ( OPERATION, DETAIL1, 
                                   "==>bdb_modrdn: wr to new parent OK np=%p, id=%ld\n", 
                                   np, (long) np->e_id, 0 );
   #else
                         Debug( LDAP_DEBUG_TRACE,                          Debug( LDAP_DEBUG_TRACE,
                                 "bdb_modrdn: wr to new parent OK np=%p, id=%ld\n",                                  "bdb_modrdn: wr to new parent OK np=%p, id=%ld\n",
                                 np, (long) np->e_id, 0 );                                  np, (long) np->e_id, 0 );
   #endif
   
                         /* check newSuperior for "children" acl */                          /* check newSuperior for "children" acl */
                         if ( !access_allowed( be, conn, op, np, children, NULL, ACL_WRITE, NULL ) ) {                          rc = access_allowed( be, conn, op, np, children,
                                   NULL, ACL_WRITE, NULL );
   
                           if( ! rc ) {
                                   switch( opinfo.boi_err ) {
                                   case DB_LOCK_DEADLOCK:
                                   case DB_LOCK_NOTGRANTED:
                                           goto retry;
                                   }
   
   #ifdef NEW_LOGGING
                                   LDAP_LOG ( OPERATION, DETAIL1, 
                                           "==>bdb_modrdn: no wr to newSup children\n", 0, 0, 0 );
   #else
                                 Debug( LDAP_DEBUG_TRACE,                                  Debug( LDAP_DEBUG_TRACE,
                                         "bdb_modrdn: no wr to newSup children\n",                                          "bdb_modrdn: no wr to newSup children\n",
                                         0, 0, 0 );                                          0, 0, 0 );
   #endif
                                   text = "no write access to new superior's children";
                                 rc = LDAP_INSUFFICIENT_ACCESS;                                  rc = LDAP_INSUFFICIENT_ACCESS;
                                 goto return_results;                                  goto return_results;
                         }                          }
Line 326  retry: /* transaction retry */ Line 542  retry: /* transaction retry */
 #ifdef BDB_ALIASES  #ifdef BDB_ALIASES
                         if ( is_entry_alias( np ) ) {                          if ( is_entry_alias( np ) ) {
                                 /* parent is an alias, don't allow add */                                  /* parent is an alias, don't allow add */
   #ifdef NEW_LOGGING
                                   LDAP_LOG ( OPERATION, DETAIL1, 
                                           "==>bdb_modrdn: entry is alias\n", 0, 0, 0 );
   #else
                                 Debug( LDAP_DEBUG_TRACE, "bdb_modrdn: entry is alias\n",                                  Debug( LDAP_DEBUG_TRACE, "bdb_modrdn: entry is alias\n",
                                         0, 0, 0 );                                          0, 0, 0 );
   #endif
                                   text = "new superior is an alias";
                                 rc = LDAP_ALIAS_PROBLEM;                                  rc = LDAP_ALIAS_PROBLEM;
                                 goto return_results;                                  goto return_results;
                         }                          }
Line 336  retry: /* transaction retry */ Line 557  retry: /* transaction retry */
   
                         if ( is_entry_referral( np ) ) {                          if ( is_entry_referral( np ) ) {
                                 /* parent is a referral, don't allow add */                                  /* parent is a referral, don't allow add */
   #ifdef NEW_LOGGING
                                   LDAP_LOG ( OPERATION, DETAIL1, 
                                           "==>bdb_modrdn: entry is referral\n", 0, 0, 0 );
   #else
                                 Debug( LDAP_DEBUG_TRACE, "bdb_modrdn: entry is referral\n",                                  Debug( LDAP_DEBUG_TRACE, "bdb_modrdn: entry is referral\n",
                                         0, 0, 0 );                                          0, 0, 0 );
   #endif
                                 rc = LDAP_OPERATIONS_ERROR;                                  text = "new superior is a referral";
                                   rc = LDAP_OTHER;
                                 goto return_results;                                  goto return_results;
                         }                          }
   
Line 362  retry: /* transaction retry */ Line 588  retry: /* transaction retry */
   
                                         np = NULL;                                          np = NULL;
   
                                         if ( ! rc )                                          if ( ! rc ) {
                                         {                                                  switch( opinfo.boi_err ) {
                                                   case DB_LOCK_DEADLOCK:
                                                   case DB_LOCK_NOTGRANTED:
                                                           goto retry;
                                                   }
   
                                                   rc = LDAP_INSUFFICIENT_ACCESS;
   #ifdef NEW_LOGGING
                                                   LDAP_LOG ( OPERATION, ERR, 
                                                           "==>bdb_modrdn: no access to superior\n", 0, 0, 0 );
   #else
                                                 Debug( LDAP_DEBUG_TRACE,                                                   Debug( LDAP_DEBUG_TRACE, 
                                                         "no access to new superior\n",                                                           "no access to new superior\n", 
                                                         0, 0, 0 );                                                          0, 0, 0 );
                                                 send_ldap_result( conn, op,   #endif
                                                         LDAP_INSUFFICIENT_ACCESS,                                                  text = "no write access to new superior's children";
                                                         NULL, NULL, NULL, NULL );  
                                                 goto return_results;                                                  goto return_results;
                                         }                                          }
   
   #ifdef NEW_LOGGING
                                           LDAP_LOG ( OPERATION, DETAIL1, 
                                                   "bdb_modrdn: wr to children entry \"\" OK\n", 0, 0, 0 );
   #else
                                         Debug( LDAP_DEBUG_TRACE,                                          Debug( LDAP_DEBUG_TRACE,
                                                 "bdb_modrdn: wr to children of entry \"\" OK\n",                                                  "bdb_modrdn: wr to children of entry \"\" OK\n",
                                                 0, 0, 0 );                                                  0, 0, 0 );
   #endif
                                   
                                 } else {                                  } else {
   #ifdef NEW_LOGGING
                                           LDAP_LOG ( OPERATION, ERR, 
                                                   "bdb_modrdn: new superior=\"\", not root & \"\" "
                                                   "is not suffix\n", 0, 0, 0 );
   #else
                                         Debug( LDAP_DEBUG_TRACE,                                          Debug( LDAP_DEBUG_TRACE,
                                                 "bdb_modrdn: new superior=\"\", not root "                                                  "bdb_modrdn: new superior=\"\", not root "
                                                 "& \"\" is not suffix\n",                                                  "& \"\" is not suffix\n",
                                                 0, 0, 0);                                                  0, 0, 0);
   #endif
                                           text = "no write access to new superior's children";
                                         rc = LDAP_INSUFFICIENT_ACCESS;                                          rc = LDAP_INSUFFICIENT_ACCESS;
                                         goto return_results;                                          goto return_results;
                                 }                                  }
                         }                          }
   
   #ifdef NEW_LOGGING
                           LDAP_LOG ( OPERATION, DETAIL1, 
                                   "bdb_modrdn: new superior=\"\"\n", 0, 0, 0 );
   #else
                         Debug( LDAP_DEBUG_TRACE,                          Debug( LDAP_DEBUG_TRACE,
                                 "bdb_modrdn: new superior=\"\"\n",                                  "bdb_modrdn: new superior=\"\"\n",
                                 0, 0, 0 );                                  0, 0, 0 );
   #endif
                 }                  }
   
   #ifdef NEW_LOGGING
                   LDAP_LOG ( OPERATION, DETAIL1, 
                           "bdb_modrdn: wr to new parent's children OK\n", 0, 0, 0 );
   #else
                 Debug( LDAP_DEBUG_TRACE,                  Debug( LDAP_DEBUG_TRACE,
                         "bdb_modrdn: wr to new parent's children OK\n",                          "bdb_modrdn: wr to new parent's children OK\n",
                         0, 0, 0 );                          0, 0, 0 );
   #endif
   
                 new_parent_dn = np_dn;                  new_parent_dn = np_dn;
         }          }
           
         /* Build target dn and make sure target entry doesn't exist already. */          /* Build target dn and make sure target entry doesn't exist already. */
         build_new_dn( &new_dn, new_parent_dn, newrdn );           if (!new_dn.bv_val) build_new_dn( &new_dn, new_parent_dn, newrdn ); 
   
         dnNormalize2( NULL, &new_dn, &new_ndn );          if (!new_ndn.bv_val) dnNormalize2( NULL, &new_dn, &new_ndn );
   
   #ifdef NEW_LOGGING
           LDAP_LOG ( OPERATION, RESULTS, 
                   "bdb_modrdn: new ndn=%s\n", new_ndn.bv_val, 0, 0 );
   #else
         Debug( LDAP_DEBUG_TRACE, "bdb_modrdn: new ndn=%s\n",          Debug( LDAP_DEBUG_TRACE, "bdb_modrdn: new ndn=%s\n",
                 new_ndn.bv_val, 0, 0 );                  new_ndn.bv_val, 0, 0 );
   #endif
   
         rc = bdb_dn2id ( be, ltid, &new_ndn, &id );          rc = bdb_dn2id ( be, ltid, &new_ndn, &id, 0 );
         switch( rc ) {          switch( rc ) {
         case DB_LOCK_DEADLOCK:          case DB_LOCK_DEADLOCK:
         case DB_LOCK_NOTGRANTED:          case DB_LOCK_NOTGRANTED:
Line 423  retry: /* transaction retry */ Line 685  retry: /* transaction retry */
                 goto return_results;                  goto return_results;
         }          }
   
         Debug( LDAP_DEBUG_TRACE,  
                 "bdb_modrdn: new ndn=%s does not exist\n",  
                 new_ndn.bv_val, 0, 0 );  
   
         /* Get attribute type and attribute value of our new rdn, we will          /* Get attribute type and attribute value of our new rdn, we will
          * need to add that to our new entry           * need to add that to our new entry
          */           */
         if ( ldap_bv2rdn( newrdn, &new_rdn, (char **)&text,          if ( !new_rdn && ldap_bv2rdn( newrdn, &new_rdn, (char **)&text,
                 LDAP_DN_FORMAT_LDAP ) )                  LDAP_DN_FORMAT_LDAP ) )
         {          {
   #ifdef NEW_LOGGING
                   LDAP_LOG ( OPERATION, ERR, 
                           "bdb_modrdn: can't figure out "
                           "type(s)/values(s) of newrdn\n", 
                           0, 0, 0 );
   #else
                 Debug( LDAP_DEBUG_TRACE,                  Debug( LDAP_DEBUG_TRACE,
                         "bdb_modrdn: can't figure out type(s)/values(s) "                          "bdb_modrdn: can't figure out "
                         "of newrdn\n", 0, 0, 0 );                          "type(s)/values(s) of newrdn\n", 
                 rc = LDAP_OPERATIONS_ERROR;                          0, 0, 0 );
   #endif
                   rc = LDAP_INVALID_DN_SYNTAX;
                 text = "unknown type(s) used in RDN";                  text = "unknown type(s) used in RDN";
                 goto return_results;                              goto return_results;
         }          }
   
   #ifdef NEW_LOGGING
           LDAP_LOG ( OPERATION, RESULTS, 
                   "bdb_modrdn: new_rdn_type=\"%s\", "
                   "new_rdn_val=\"%s\"\n",
                   new_rdn[ 0 ][ 0 ]->la_attr.bv_val, 
                   new_rdn[ 0 ][ 0 ]->la_value.bv_val, 0 );
   #else
         Debug( LDAP_DEBUG_TRACE,          Debug( LDAP_DEBUG_TRACE,
                 "bdb_modrdn: new_rdn_type=\"%s\", new_rdn_val=\"%s\"\n",                  "bdb_modrdn: new_rdn_type=\"%s\", "
                 new_rdn[0][0]->la_attr.bv_val, new_rdn[0][0]->la_value.bv_val, 0 );                  "new_rdn_val=\"%s\"\n",
                   new_rdn[ 0 ][ 0 ]->la_attr.bv_val,
         if ( ldap_bv2rdn( dn, &old_rdn, (char **)&text,                  new_rdn[ 0 ][ 0 ]->la_value.bv_val, 0 );
                 LDAP_DN_FORMAT_LDAP ) )  
         {  
                 Debug( LDAP_DEBUG_TRACE,  
                         "bdb_back_modrdn: can't figure out the old_rdn "  
                         "type(s)/value(s)\n", 0, 0, 0 );  
                 rc = LDAP_OTHER;  
                 text = "cannot parse RDN from old DN";  
                 goto return_results;              
         }  
   
 #if 0  
         if ( newSuperior == NULL  
                 && charray_strcasecmp( ( const char ** )old_rdn_types,   
                                 ( const char ** )new_rdn_types ) != 0 ) {  
                 /* Not a big deal but we may say something */  
                 Debug( LDAP_DEBUG_TRACE,  
                         "bdb_modrdn: old_rdn_type(s)=%s, new_rdn_type(s)=%s "  
                         "do not match\n",   
                         old_rdn_types[ 0 ], new_rdn_types[ 0 ], 0 );  
         }                 
 #endif  #endif
   
         /* Add new attribute values to the entry */  
         for ( a_cnt = 0; new_rdn[0][ a_cnt ]; a_cnt++ ) {  
                 int                     rc;  
                 AttributeDescription    *desc = NULL;  
                 Modifications           *mod_tmp;  
   
                 rc = slap_bv2ad( &new_rdn[0][ a_cnt ]->la_attr, &desc, &text );  
   
                 if ( rc != LDAP_SUCCESS ) {  
                         Debug( LDAP_DEBUG_TRACE,  
                                 "bdb_modrdn: %s: %s (new)\n",  
                                 text, new_rdn[0][ a_cnt ]->la_attr.bv_val, 0 );  
                         goto return_results;              
                 }  
   
                 /* ACL check of newly added attrs */  
                 if ( !access_allowed( be, conn, op, e, desc,  
                         &new_rdn[0][ a_cnt ]->la_value, ACL_WRITE, NULL ) ) {  
                         Debug( LDAP_DEBUG_TRACE,  
                                 "bdb_modrdn: access to attr \"%s\" "  
                                 "(new) not allowed\n",   
                                 new_rdn[0][ a_cnt ]->la_attr.bv_val, 0, 0 );  
                         rc = LDAP_INSUFFICIENT_ACCESS;  
                         goto return_results;  
                 }  
   
                 /* Apply modification */  
                 mod_tmp = ( Modifications * )ch_malloc( sizeof( Modifications )  
                         + 2 * sizeof( struct berval ) );  
                 mod_tmp->sml_desc = desc;  
                 mod_tmp->sml_bvalues = ( BerVarray )( mod_tmp + 1 );  
                 mod_tmp->sml_bvalues[ 0 ] = new_rdn[0][ a_cnt ]->la_value;  
                 mod_tmp->sml_bvalues[ 1 ].bv_val = NULL;  
                 mod_tmp->sml_op = SLAP_MOD_SOFTADD;  
                 mod_tmp->sml_next = mod;  
                 mod = mod_tmp;  
         }  
   
         /* Remove old rdn value if required */  
         if ( deleteoldrdn ) {          if ( deleteoldrdn ) {
                 /* Get value of old rdn */                  if ( !old_rdn && ldap_bv2rdn( dn, &old_rdn, (char **)&text,
                 if ( old_rdn == NULL) {                          LDAP_DN_FORMAT_LDAP ) )
                   {
   #ifdef NEW_LOGGING
                           LDAP_LOG ( OPERATION, ERR, 
                                   "bdb_modrdn: can't figure out "
                                   "type(s)/values(s) of old_rdn\n", 
                                   0, 0, 0 );
   #else
                         Debug( LDAP_DEBUG_TRACE,                          Debug( LDAP_DEBUG_TRACE,
                                 "bdb_modrdn: can't figure out old RDN value(s) "                                  "bdb_modrdn: can't figure out "
                                 "from old RDN\n", 0, 0, 0 );                                  "the old_rdn type(s)/value(s)\n", 
                                   0, 0, 0 );
   #endif
                         rc = LDAP_OTHER;                          rc = LDAP_OTHER;
                         text = "could not parse value(s) from old RDN";                          text = "cannot parse RDN from old DN";
                         goto return_results;                                      goto return_results;            
                 }                  }
           }
   
                 for ( d_cnt = 0; old_rdn[0][ d_cnt ]; d_cnt++ ) {          /* prepare modlist of modifications from old/new rdn */
                         int                     rc;          if (!mod) {
                         AttributeDescription    *desc = NULL;                  rc = slap_modrdn2mods( be, conn, op, e, old_rdn, new_rdn, 
                         Modifications           *mod_tmp;                          deleteoldrdn, &mod );
                   if ( rc != LDAP_SUCCESS ) {
                         rc = slap_bv2ad( &old_rdn[0][ d_cnt ]->la_attr,                          goto return_results;
                                         &desc, &text );  
   
                         if ( rc != LDAP_SUCCESS ) {  
                                 Debug( LDAP_DEBUG_TRACE,  
                                         "bdb_modrdn: %s: %s (old)\n",  
                                         text, old_rdn[0][ d_cnt ]->la_attr.bv_val, 0 );  
                                 goto return_results;              
                         }  
   
                         /* ACL check of newly added attrs */  
                         if ( !access_allowed( be, conn, op, e, desc,  
                                 &old_rdn[0][d_cnt]->la_value, ACL_WRITE, NULL ) ) {  
                                 Debug( LDAP_DEBUG_TRACE,  
                                         "bdb_modrdn: access to attr \"%s\" "  
                                         "(old) not allowed\n",   
                                         old_rdn[0][ d_cnt ]->la_attr.bv_val, 0, 0 );  
                                 rc = LDAP_INSUFFICIENT_ACCESS;  
                                 goto return_results;  
                         }  
   
                         /* Apply modification */  
                         mod_tmp = ( Modifications * )ch_malloc( sizeof( Modifications )  
                                 + 2 * sizeof ( struct berval ) );  
                         mod_tmp->sml_desc = desc;  
                         mod_tmp->sml_bvalues = ( BerVarray )(mod_tmp+1);  
                         mod_tmp->sml_bvalues[ 0 ] = old_rdn[0][ d_cnt ]->la_value;  
                         mod_tmp->sml_bvalues[ 1 ].bv_val = NULL;  
                         mod_tmp->sml_op = LDAP_MOD_DELETE;  
                         mod_tmp->sml_next = mod;  
                         mod = mod_tmp;  
                 }                  }
         }          }
                   
Line 573  retry: /* transaction retry */ Line 767  retry: /* transaction retry */
         (void) bdb_cache_delete_entry(&bdb->bi_cache, e);          (void) bdb_cache_delete_entry(&bdb->bi_cache, e);
   
         /* Binary format uses a single contiguous block, cannot          /* Binary format uses a single contiguous block, cannot
          * free individual fields. Leave new_dn/new_ndn set so           * free individual fields. But if a previous modrdn has
          * they can be individually freed later.           * already happened, must free the names.
          */           */
           if( e->e_nname.bv_val < e->e_bv.bv_val || e->e_nname.bv_val >
                   e->e_bv.bv_val + e->e_bv.bv_len ) {
                   ch_free(e->e_name.bv_val);
                   ch_free(e->e_nname.bv_val);
                   e->e_name.bv_val = NULL;
                   e->e_nname.bv_val = NULL;
           }
         e->e_name = new_dn;          e->e_name = new_dn;
         e->e_nname = new_ndn;          e->e_nname = new_ndn;
   
Line 595  retry: /* transaction retry */ Line 796  retry: /* transaction retry */
                 goto return_results;                  goto return_results;
         }          }
   
   #if defined(LDAP_CLIENT_UPDATE) || defined(LDAP_SYNC)
           if ( rc == LDAP_SUCCESS && !op->o_noop ) {
                   LDAP_LIST_FOREACH ( ps_list, &bdb->psearch_list, link ) {
                           bdb_psearch(be, conn, op, ps_list, e, LDAP_PSEARCH_BY_PREMODIFY );
                   }
           }
   #endif
   
         /* modify entry */          /* modify entry */
         rc = bdb_modify_internal( be, conn, op, ltid, &mod[0], e,          rc = bdb_modify_internal( be, conn, op, ltid, &mod[0], e,
                 &text, textbuf, textlen );                  &text, textbuf, textlen );
   
         if( rc != LDAP_SUCCESS ) {          if( rc != LDAP_SUCCESS ) {
                   if ( ( rc == LDAP_INSUFFICIENT_ACCESS ) && opinfo.boi_err ) {
                           rc = opinfo.boi_err;
                   }
                 switch( rc ) {                  switch( rc ) {
                 case DB_LOCK_DEADLOCK:                  case DB_LOCK_DEADLOCK:
                 case DB_LOCK_NOTGRANTED:                  case DB_LOCK_NOTGRANTED:
Line 625  retry: /* transaction retry */ Line 837  retry: /* transaction retry */
                 if(( rc=TXN_ABORT( ltid )) != 0 ) {                  if(( rc=TXN_ABORT( ltid )) != 0 ) {
                         text = "txn_abort (no-op) failed";                          text = "txn_abort (no-op) failed";
                 } else {                  } else {
                           noop = 1;
                         rc = LDAP_SUCCESS;                          rc = LDAP_SUCCESS;
                 }                  }
   
Line 646  retry: /* transaction retry */ Line 859  retry: /* transaction retry */
                                 }                                  }
   
                         } else {                          } else {
                                   bdb_cache_entry_commit( e );
                                 if(( rc=TXN_COMMIT( ltid, 0 )) != 0 ) {                                  if(( rc=TXN_COMMIT( ltid, 0 )) != 0 ) {
                                         text = "txn_commit failed";                                          text = "txn_commit failed";
                                 } else {                                  } else {
Line 659  retry: /* transaction retry */ Line 873  retry: /* transaction retry */
         op->o_private = NULL;          op->o_private = NULL;
     
         if( rc == LDAP_SUCCESS ) {          if( rc == LDAP_SUCCESS ) {
   #ifdef NEW_LOGGING
                   LDAP_LOG ( OPERATION, RESULTS, 
                           "bdb_modrdn: rdn modified%s id=%08lx dn=\"%s\"\n", 
                           op->o_noop ? " (no-op)" : "", e->e_id, e->e_dn );
   #else
                 Debug(LDAP_DEBUG_TRACE,                  Debug(LDAP_DEBUG_TRACE,
                         "bdb_modrdn: rdn modified%s id=%08lx dn=\"%s\"\n",                          "bdb_modrdn: rdn modified%s id=%08lx dn=\"%s\"\n",
                         op->o_noop ? " (no-op)" : "", e->e_id, e->e_dn );                          op->o_noop ? " (no-op)" : "", e->e_id, e->e_dn );
   #endif
                 text = NULL;                  text = NULL;
                 bdb_cache_entry_commit( e );  
   
         } else {          } else {
   #ifdef NEW_LOGGING
                   LDAP_LOG ( OPERATION, RESULTS, "bdb_modrdn: %s : %s (%d)\n", 
                           text, db_strerror(rc), rc );
   #else
                 Debug( LDAP_DEBUG_TRACE, "bdb_add: %s : %s (%d)\n",                  Debug( LDAP_DEBUG_TRACE, "bdb_add: %s : %s (%d)\n",
                         text, db_strerror(rc), rc );                          text, db_strerror(rc), rc );
   #endif
                 rc = LDAP_OTHER;                  rc = LDAP_OTHER;
         }          }
   
Line 675  return_results: Line 898  return_results:
         send_ldap_result( conn, op, rc,          send_ldap_result( conn, op, rc,
                 NULL, text, NULL, NULL );                  NULL, text, NULL, NULL );
   
   #if defined(LDAP_CLIENT_UPDATE) || defined(LDAP_SYNC)
           if ( rc == LDAP_SUCCESS && !op->o_noop ) {
                   /* Loop through in-scope entries for each psearch spec */
                   LDAP_LIST_FOREACH ( ps_list, &bdb->psearch_list, link ) {
                           bdb_psearch( be, conn, op, ps_list, e, LDAP_PSEARCH_BY_MODIFY );
                   }
                   pm_list = LDAP_LIST_FIRST(&op->premodify_list);
                   while ( pm_list != NULL ) {
                           bdb_psearch(be, conn, op, pm_list->ps->op,
                                                   e, LDAP_PSEARCH_BY_SCOPEOUT);
                           LDAP_LIST_REMOVE ( pm_list, link );
                           pm_prev = pm_list;
                           pm_list = LDAP_LIST_NEXT ( pm_list, link );
                           free (pm_prev);
                   }
           }
   #endif
   
         if( rc == LDAP_SUCCESS && bdb->bi_txn_cp ) {          if( rc == LDAP_SUCCESS && bdb->bi_txn_cp ) {
                 ldap_pvt_thread_yield();                  ldap_pvt_thread_yield();
                 TXN_CHECKPOINT( bdb->bi_dbenv,                  TXN_CHECKPOINT( bdb->bi_dbenv,
Line 686  done: Line 927  done:
         if( new_ndn.bv_val != NULL ) free( new_ndn.bv_val );          if( new_ndn.bv_val != NULL ) free( new_ndn.bv_val );
   
         /* LDAP v2 supporting correct attribute handling. */          /* LDAP v2 supporting correct attribute handling. */
         if( new_rdn != NULL ) ldap_rdnfree( new_rdn );          if ( new_rdn != NULL ) {
         if( old_rdn != NULL ) ldap_rdnfree( old_rdn );                  ldap_rdnfree( new_rdn );
           }
           if ( old_rdn != NULL ) {
                   ldap_rdnfree( old_rdn );
           }
         if( mod != NULL ) {          if( mod != NULL ) {
                 Modifications *tmp;                  Modifications *tmp;
                 for (; mod; mod=tmp ) {                  for (; mod; mod=tmp ) {
Line 699  done: Line 944  done:
         /* LDAP v3 Support */          /* LDAP v3 Support */
         if( np != NULL ) {          if( np != NULL ) {
                 /* free new parent and reader lock */                  /* free new parent and reader lock */
                 bdb_cache_return_entry_r(&bdb->bi_cache, np);                  bdb_unlocked_cache_return_entry_r(&bdb->bi_cache, np);
         }          }
   
         if( p != NULL ) {          if( p != NULL ) {
                 /* free parent and reader lock */                  /* free parent and reader lock */
                 bdb_cache_return_entry_r(&bdb->bi_cache, p);                  bdb_unlocked_cache_return_entry_r(&bdb->bi_cache, p);
         }          }
   
         /* free entry */          /* free entry */
         if( e != NULL ) {          if( e != NULL ) {
                 bdb_cache_return_entry_w( &bdb->bi_cache, e );                  bdb_unlocked_cache_return_entry_w( &bdb->bi_cache, e);
         }          }
   
         if( ltid != NULL ) {          if( ltid != NULL ) {
   #if defined(LDAP_CLIENT_UPDATE) || defined(LDAP_SYNC)
                   pm_list = LDAP_LIST_FIRST(&op->premodify_list);
                   while ( pm_list != NULL ) {
                           LDAP_LIST_REMOVE ( pm_list, link );
                           pm_prev = pm_list;
                           pm_list = LDAP_LIST_NEXT ( pm_list, link );
                           free (pm_prev);
                   }
   #endif
                 TXN_ABORT( ltid );                  TXN_ABORT( ltid );
                 op->o_private = NULL;                  op->o_private = NULL;
         }          }
   
         return rc;          return ( ( rc == LDAP_SUCCESS ) ? noop : rc );
 }  }

Removed from v.1.63  
changed lines
  Added in v.1.63.2.18


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