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

version 1.63.2.18, 2003/05/16 02:53:02 version 1.64, 2002/03/14 21:23:44
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.63.2.17 2003/03/26 17:56:38 kurt Exp $ */  /* $OpenLDAP: pkg/ldap/servers/slapd/back-bdb/modrdn.c,v 1.63 2002/02/13 10:46:34 ando Exp $ */
 /*  /*
  * Copyright 1998-2003 The OpenLDAP Foundation, All Rights Reserved.   * Copyright 1998-2002 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 = NULL;          Entry           *e, *p = NULL;
         Entry           *p = NULL;  
         Entry           *matched;          Entry           *matched;
         /* LDAP v2 supporting correct attribute handling. */          int                     rc;
         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 46  bdb_modrdn( Line 41  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 57  bdb_modrdn( Line 55  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  #ifdef NEW_LOGGING
         LDAP_LOG ( OPERATION, ENTRY, "==>bdb_modrdn(%s,%s,%s)\n",           LDAP_LOG (( "modrdn", LDAP_LEVEL_ENTRY, "==>bdb_modrdn(%s,%s,%s)\n",
                 dn->bv_val,newrdn->bv_val, newSuperior ? newSuperior->bv_val : "NULL" );                  dn->bv_val,newrdn->bv_val,
                   newSuperior ? newSuperior->bv_val : "NULL" ));
 #else  #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" );
 #endif  #endif
   
   #if 0
           if( newSuperior != NULL ) {
                   rc = LDAP_UNWILLING_TO_PERFORM;
                   text = "newSuperior not implemented (yet)";
                   goto return_results;
           }
   #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_unlocked_cache_return_entry_w(&bdb->bi_cache, e);                          bdb_cache_return_entry_w(&bdb->bi_cache, e);
                         e = NULL;  
                 }                  }
                 if (p != NULL) {                  if (p != NULL) {
                         bdb_unlocked_cache_return_entry_r(&bdb->bi_cache, p);                          bdb_cache_return_entry_r(&bdb->bi_cache, p);
                         p = NULL;  
                 }                  }
                 if (np != NULL) {                  if (np != NULL) {
                         bdb_unlocked_cache_return_entry_r(&bdb->bi_cache, np);                          bdb_cache_return_entry_r(&bdb->bi_cache, np);
                         np = NULL;  
                 }                  }
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                 LDAP_LOG ( OPERATION, DETAIL1, "==>bdb_modrdn: retrying...\n", 0, 0, 0);                  LDAP_LOG (( "modrdn", LDAP_LEVEL_DETAIL1, "==>bdb_modrdn: retrying...\n"));
 #else  #else
                 Debug( LDAP_DEBUG_TRACE, "==>bdb_modrdn: retrying...\n", 0, 0, 0 );                  Debug( LDAP_DEBUG_TRACE, "==>bdb_modrdn: retrying...\n", 0, 0, 0 );
 #endif  #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 126  retry: /* transaction retry */ Line 107  retry: /* transaction retry */
         text = NULL;          text = NULL;
         if( rc != 0 ) {          if( rc != 0 ) {
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                 LDAP_LOG ( OPERATION, ERR,                   LDAP_LOG (( "modrdn", LDAP_LEVEL_ERR, "==>bdb_modrdn: txn_begin failed: %s (%d)\n", db_strerror(rc), rc ));
                         "==>bdb_modrdn: txn_begin failed: %s (%d)\n",   
                         db_strerror(rc), rc, 0 );  
 #else  #else
                 Debug( LDAP_DEBUG_TRACE,                  Debug( LDAP_DEBUG_TRACE,
                         "bdb_modrdn: txn_begin failed: %s (%d)\n",                          "bdb_delete: txn_begin failed: %s (%d)\n",
                         db_strerror(rc), rc, 0 );                          db_strerror(rc), rc, 0 );
 #endif  #endif
                 rc = LDAP_OTHER;                  rc = LDAP_OTHER;
Line 139  retry: /* transaction retry */ Line 118  retry: /* transaction retry */
                 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, DB_RMW, locker, &lock );          rc = bdb_dn2entry_w( be, ltid, ndn, &e, &matched, 0 );
   
         switch( rc ) {          switch( rc ) {
         case 0:          case 0:
Line 158  retry: /* transaction retry */ Line 133  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 176  retry: /* transaction retry */ Line 148  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_unlocked_cache_return_entry_r( &bdb->bi_cache, matched);                          bdb_cache_return_entry_r( &bdb->bi_cache, matched );
                         matched = NULL;                          matched = NULL;
   
                 } else {                  } else {
Line 193  retry: /* transaction retry */ Line 165  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 */
Line 257  retry: /* transaction retry */ Line 172  retry: /* transaction retry */
                         conn, op, e );                          conn, op, e );
   
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                 LDAP_LOG ( OPERATION, DETAIL1,                   LDAP_LOG (( "modrdn", LDAP_LEVEL_DETAIL1, "==>bdb_modrdn: entry %s is referral \n", e->e_dn ));
                         "==>bdb_modrdn: entry %s is referral \n", e->e_dn, 0, 0 );  
 #else  #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 );
Line 281  retry: /* transaction retry */ Line 195  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, locker, &lock );                  rc = bdb_dn2entry_r( be, ltid, &p_ndn, &p, NULL, 0 );
   
                 switch( rc ) {                  switch( rc ) {
                 case 0:                  case 0:
Line 290  retry: /* transaction retry */ Line 204  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 301  retry: /* transaction retry */ Line 212  retry: /* transaction retry */
   
                 if( p == NULL) {                  if( p == NULL) {
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                         LDAP_LOG ( OPERATION, ERR,                           LDAP_LOG (( "modrdn", LDAP_LEVEL_ERR, "==>bdb_modrdn: parent does not exist\n" ));
                                 "==>bdb_modrdn: parent does not exist\n", 0, 0, 0 );  
 #else  #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  #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 */
                 rc = access_allowed( be, conn, op, p,                  if ( ! 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  #ifdef NEW_LOGGING
                         LDAP_LOG ( OPERATION, ERR,                           LDAP_LOG (( "modrdn", LDAP_LEVEL_ERR, "==>bdb_modrdn: no access to parent\n" ));
                                 "==>bdb_modrdn: no access to parent\n", 0, 0, 0 );  
 #else  #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 );
 #endif  #endif
                         text = "no write access to old parent's children";                          send_ldap_result( conn, op, LDAP_INSUFFICIENT_ACCESS,
                                   NULL, NULL, NULL, NULL );
                         goto return_results;                          goto return_results;
                 }                  }
   
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                 LDAP_LOG ( OPERATION, DETAIL1,                   LDAP_LOG (( "modrdn", LDAP_LEVEL_DETAIL1, "==>bdb_modrdn: wr to children %s is OK\n", p_ndn.bv_val ));
                         "==>bdb_modrdn: wr to children %s is OK\n", p_ndn.bv_val, 0, 0 );  
 #else  #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",
Line 351  retry: /* transaction retry */ Line 251  retry: /* transaction retry */
                 }                  }
   
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                 LDAP_LOG ( OPERATION, DETAIL1,                   LDAP_LOG (( "modrdn", LDAP_LEVEL_DETAIL1, "==>bdb_modrdn: parent dn=%s\n", p_dn.bv_val ));
                         "==>bdb_modrdn: parent dn=%s\n", p_dn.bv_val, 0, 0 );  
 #else  #else
                 Debug( LDAP_DEBUG_TRACE,                  Debug( LDAP_DEBUG_TRACE,
                         "bdb_modrdn: parent dn=%s\n",                          "bdb_modrdn: parent dn=%s\n",
Line 374  retry: /* transaction retry */ Line 273  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  #ifdef NEW_LOGGING
                                         LDAP_LOG ( OPERATION, ERR,                                           LDAP_LOG (( "modrdn", LDAP_LEVEL_ERR, "==>bdb_modrdn: no access to parent\n" ));
                                                 "==>bdb_modrdn: no access to parent\n", 0, 0, 0 );  
 #else  #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 );
 #endif  #endif
                                         text = "no write access to old parent";                                          send_ldap_result( conn, op, 
                                                   LDAP_INSUFFICIENT_ACCESS,
                                                   NULL, NULL, NULL, NULL );
                                         goto return_results;                                          goto return_results;
                                 }                                  }
   
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                                 LDAP_LOG ( OPERATION, DETAIL1,                                   LDAP_LOG (( "modrdn", LDAP_LEVEL_DETAIL1, "==>bdb_modrdn: wr to children of entry \"\" OK\n", p_dn.bv_val ));
                                         "==>bdb_modrdn: wr to children of entry \"%s\" OK\n",   
                                         p_dn.bv_val, 0, 0 );  
 #else  #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",
Line 408  retry: /* transaction retry */ Line 300  retry: /* transaction retry */
                                 p_dn.bv_len = 0;                                  p_dn.bv_len = 0;
   
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                                 LDAP_LOG ( OPERATION, DETAIL1,                                   LDAP_LOG (( "modrdn", LDAP_LEVEL_DETAIL1, "==>bdb_modrdn: parent dn=\"\" \n" ));
                                         "==>bdb_modrdn: parent dn=\"\" \n", 0, 0, 0 );  
 #else  #else
                                 Debug( LDAP_DEBUG_TRACE,                                  Debug( LDAP_DEBUG_TRACE,
                                         "bdb_modrdn: parent dn=\"\"\n",                                          "bdb_modrdn: parent dn=\"\"\n",
Line 418  retry: /* transaction retry */ Line 309  retry: /* transaction retry */
   
                         } else {                          } else {
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                                 LDAP_LOG ( OPERATION, ERR,                                   LDAP_LOG (( "modrdn", LDAP_LEVEL_ERR, "==>bdb_modrdn: no parent, not root &\"\" is not suffix\n" ));
                                         "==>bdb_modrdn: no parent, not root &\"\" is not "  
                                         "suffix\n", 0, 0, 0 );  
 #else  #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  #endif
                                 text = "no write access to old parent";  
                                 rc = LDAP_INSUFFICIENT_ACCESS;                                  rc = LDAP_INSUFFICIENT_ACCESS;
                                 goto return_results;                                  goto return_results;
                         }                          }
Line 438  retry: /* transaction retry */ Line 326  retry: /* transaction retry */
   
         if ( newSuperior != NULL ) {          if ( newSuperior != NULL ) {
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                 LDAP_LOG ( OPERATION, DETAIL1,                   LDAP_LOG (( "modrdn", LDAP_LEVEL_DETAIL1, "==>bdb_modrdn: new parent \"%s\" requested...\n", newSuperior->bv_val ));
                         "==>bdb_modrdn: new parent \"%s\" requested...\n",   
                         newSuperior->bv_val, 0, 0 );  
 #else  #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  #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 471  retry: /* transaction retry */ Line 341  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,                          rc = bdb_dn2entry_r( be, ltid, nnewSuperior, &np, NULL, 0 );
                                 ltid, nnewSuperior, &np, NULL, 0, locker, &lock );  
   
                         switch( rc ) {                          switch( rc ) {
                         case 0:                          case 0:
Line 481  retry: /* transaction retry */ Line 350  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 492  retry: /* transaction retry */ Line 358  retry: /* transaction retry */
   
                         if( np == NULL) {                          if( np == NULL) {
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                                 LDAP_LOG ( OPERATION, DETAIL1,                                   LDAP_LOG (( "modrdn", LDAP_LEVEL_DETAIL1, "==>bdb_modrdn: newSup(ndn=%s) not here!\n", np_ndn->bv_val ));
                                         "==>bdb_modrdn: newSup(ndn=%s) not here!\n",   
                                         np_ndn->bv_val, 0, 0 );  
 #else  #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  #endif
                                 text = "new superior not found";  
                                 rc = LDAP_OTHER;                                  rc = LDAP_OTHER;
                                 goto return_results;                                  goto return_results;
                         }                          }
   
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                         LDAP_LOG ( OPERATION, DETAIL1,                           LDAP_LOG (( "modrdn", LDAP_LEVEL_DETAIL1, "==>bdb_modrdn: wr to new parent OK np=%p, id=%ld\n", np, (long) np->e_id ));
                                 "==>bdb_modrdn: wr to new parent OK np=%p, id=%ld\n",   
                                 np, (long) np->e_id, 0 );  
 #else  #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",
Line 516  retry: /* transaction retry */ Line 377  retry: /* transaction retry */
 #endif  #endif
   
                         /* check newSuperior for "children" acl */                          /* check newSuperior for "children" acl */
                         rc = access_allowed( be, conn, op, np, children,                          if ( !access_allowed( be, conn, op, np, children, NULL, ACL_WRITE, NULL ) ) {
                                 NULL, ACL_WRITE, NULL );  
   
                         if( ! rc ) {  
                                 switch( opinfo.boi_err ) {  
                                 case DB_LOCK_DEADLOCK:  
                                 case DB_LOCK_NOTGRANTED:  
                                         goto retry;  
                                 }  
   
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                                 LDAP_LOG ( OPERATION, DETAIL1,                                   LDAP_LOG (( "modrdn", LDAP_LEVEL_DETAIL1, "==>bdb_modrdn: no wr to newSup children\n" ));
                                         "==>bdb_modrdn: no wr to newSup children\n", 0, 0, 0 );  
 #else  #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  #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 543  retry: /* transaction retry */ Line 393  retry: /* transaction retry */
                         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  #ifdef NEW_LOGGING
                                 LDAP_LOG ( OPERATION, DETAIL1,                                   LDAP_LOG (( "modrdn", LDAP_LEVEL_DETAIL1, "==>bdb_modrdn: entry is alias\n" ));
                                         "==>bdb_modrdn: entry is alias\n", 0, 0, 0 );  
 #else  #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  #endif
                                 text = "new superior is an alias";  
                                 rc = LDAP_ALIAS_PROBLEM;                                  rc = LDAP_ALIAS_PROBLEM;
                                 goto return_results;                                  goto return_results;
                         }                          }
Line 558  retry: /* transaction retry */ Line 407  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  #ifdef NEW_LOGGING
                                 LDAP_LOG ( OPERATION, DETAIL1,                                   LDAP_LOG (( "modrdn", LDAP_LEVEL_DETAIL1, "==>bdb_modrdn: entry is referral\n" ));
                                         "==>bdb_modrdn: entry is referral\n", 0, 0, 0 );  
 #else  #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  #endif
                                 text = "new superior is a referral";  
                                 rc = LDAP_OTHER;                                  rc = LDAP_OPERATIONS_ERROR;
                                 goto return_results;                                  goto return_results;
                         }                          }
   
Line 588  retry: /* transaction retry */ Line 436  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  #ifdef NEW_LOGGING
                                                 LDAP_LOG ( OPERATION, ERR,                                                   LDAP_LOG (( "modrdn", LDAP_LEVEL_ERR, "==>bdb_modrdn: no access to superior\n" ));
                                                         "==>bdb_modrdn: no access to superior\n", 0, 0, 0 );  
 #else  #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 );
 #endif  #endif
                                                 text = "no write access to new superior's children";                                                  send_ldap_result( conn, op, 
                                                           LDAP_INSUFFICIENT_ACCESS,
                                                           NULL, NULL, NULL, NULL );
                                                 goto return_results;                                                  goto return_results;
                                         }                                          }
   
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                                         LDAP_LOG ( OPERATION, DETAIL1,                                           LDAP_LOG (( "modrdn", LDAP_LEVEL_DETAIL1, "bdb_modrdn: wr to children entry \"\" OK\n" ));
                                                 "bdb_modrdn: wr to children entry \"\" OK\n", 0, 0, 0 );  
 #else  #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",
Line 619  retry: /* transaction retry */ Line 461  retry: /* transaction retry */
                                   
                                 } else {                                  } else {
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                                         LDAP_LOG ( OPERATION, ERR,                                           LDAP_LOG (( "modrdn", LDAP_LEVEL_ERR, "bdb_modrdn: new superior=\"\", not root & \"\" is not suffix\n" ));
                                                 "bdb_modrdn: new superior=\"\", not root & \"\" "  
                                                 "is not suffix\n", 0, 0, 0 );  
 #else  #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  #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  #ifdef NEW_LOGGING
                         LDAP_LOG ( OPERATION, DETAIL1,                           LDAP_LOG (( "modrdn", LDAP_LEVEL_DETAIL1, "bdb_modrdn: new superior=\"\"\n" ));
                                 "bdb_modrdn: new superior=\"\"\n", 0, 0, 0 );  
 #else  #else
                         Debug( LDAP_DEBUG_TRACE,                          Debug( LDAP_DEBUG_TRACE,
                                 "bdb_modrdn: new superior=\"\"\n",                                  "bdb_modrdn: new superior=\"\"\n",
Line 645  retry: /* transaction retry */ Line 483  retry: /* transaction retry */
                 }                  }
   
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                 LDAP_LOG ( OPERATION, DETAIL1,                   LDAP_LOG (( "modrdn", LDAP_LEVEL_DETAIL1, "bdb_modrdn: wr to new parent's children OK\n" ));
                         "bdb_modrdn: wr to new parent's children OK\n", 0, 0, 0 );  
 #else  #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",
Line 655  retry: /* transaction retry */ Line 492  retry: /* transaction retry */
   
                 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. */
         if (!new_dn.bv_val) build_new_dn( &new_dn, new_parent_dn, newrdn );           build_new_dn( &new_dn, new_parent_dn, newrdn ); 
   
         if (!new_ndn.bv_val) dnNormalize2( NULL, &new_dn, &new_ndn );          dnNormalize2( NULL, &new_dn, &new_ndn );
   
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
         LDAP_LOG ( OPERATION, RESULTS,           LDAP_LOG (( "modrdn", LDAP_LEVEL_RESULTS, "bdb_modrdn: new ndn=%s\n", new_ndn.bv_val ));
                 "bdb_modrdn: new ndn=%s\n", new_ndn.bv_val, 0, 0 );  
 #else  #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  #endif
   
         rc = bdb_dn2id ( be, ltid, &new_ndn, &id, 0 );          rc = bdb_dn2id ( be, ltid, &new_ndn, &id );
         switch( rc ) {          switch( rc ) {
         case DB_LOCK_DEADLOCK:          case DB_LOCK_DEADLOCK:
         case DB_LOCK_NOTGRANTED:          case DB_LOCK_NOTGRANTED:
Line 685  retry: /* transaction retry */ Line 521  retry: /* transaction retry */
                 goto return_results;                  goto return_results;
         }          }
   
   #ifdef NEW_LOGGING
           LDAP_LOG (( "modrdn", LDAP_LEVEL_ERR, "bdb_modrdn: new ndn=%s does not exist\n", new_ndn.bv_val ));
   #else
           Debug( LDAP_DEBUG_TRACE,
                   "bdb_modrdn: new ndn=%s does not exist\n",
                   new_ndn.bv_val, 0, 0 );
   #endif
   
         /* 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 ( !new_rdn && ldap_bv2rdn( newrdn, &new_rdn, (char **)&text,          if ( ldap_bv2rdn( newrdn, &new_rdn, (char **)&text,
                 LDAP_DN_FORMAT_LDAP ) )                  LDAP_DN_FORMAT_LDAP ) )
         {          {
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                 LDAP_LOG ( OPERATION, ERR,                   LDAP_LOG (( "modrdn", LDAP_LEVEL_ERR, "bdb_modrdn: can't figure out type(s)/values(s) of newrdn\n" ));
                         "bdb_modrdn: can't figure out "  
                         "type(s)/values(s) of newrdn\n",   
                         0, 0, 0 );  
 #else  #else
                 Debug( LDAP_DEBUG_TRACE,                  Debug( LDAP_DEBUG_TRACE,
                         "bdb_modrdn: can't figure out "                          "bdb_modrdn: can't figure out type(s)/values(s) "
                         "type(s)/values(s) of newrdn\n",                           "of newrdn\n", 0, 0, 0 );
                         0, 0, 0 );  
 #endif  #endif
                 rc = LDAP_INVALID_DN_SYNTAX;                  rc = LDAP_OPERATIONS_ERROR;
                 text = "unknown type(s) used in RDN";                  text = "unknown type(s) used in RDN";
                 goto return_results;                  goto return_results;            
         }          }
   
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
         LDAP_LOG ( OPERATION, RESULTS,           LDAP_LOG (( "modrdn", LDAP_LEVEL_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 ));
                 "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  #else
         Debug( LDAP_DEBUG_TRACE,          Debug( LDAP_DEBUG_TRACE,
                 "bdb_modrdn: new_rdn_type=\"%s\", "                  "bdb_modrdn: new_rdn_type=\"%s\", new_rdn_val=\"%s\"\n",
                 "new_rdn_val=\"%s\"\n",                  new_rdn[0][0]->la_attr.bv_val, new_rdn[0][0]->la_value.bv_val, 0 );
                 new_rdn[ 0 ][ 0 ]->la_attr.bv_val,  #endif
                 new_rdn[ 0 ][ 0 ]->la_value.bv_val, 0 );  
           if ( ldap_bv2rdn( dn, &old_rdn, (char **)&text,
                   LDAP_DN_FORMAT_LDAP ) )
           {
   #ifdef NEW_LOGGING
                   LDAP_LOG (( "modrdn", LDAP_LEVEL_ERR, "bdb_modrdn: can't figure out type(s)/values(s) of old_rdn\n" ));
   #else
                   Debug( LDAP_DEBUG_TRACE,
                           "bdb_back_modrdn: can't figure out the old_rdn "
                           "type(s)/value(s)\n", 0, 0, 0 );
   #endif
                   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 */
   #ifdef NEW_LOGGING
                   LDAP_LOG (( "modrdn", LDAP_LEVEL_ERR, "bdb_modrdn: old_rdn_type(s)=%s, new_rdn_type(s)=%s do not match\n", old_rdn_types[ 0 ], new_rdn_types[ 0 ] ));
   #else
                   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 ) {
   #ifdef NEW_LOGGING
                           LDAP_LOG (( "modrdn", LDAP_LEVEL_ERR, "bdb_modrdn: %s: %s (new)\n", text, new_rdn[0][a_cnt]->la_attr.bv_val ));
   #else
                           Debug( LDAP_DEBUG_TRACE,
                                   "bdb_modrdn: %s: %s (new)\n",
                                   text, new_rdn[0][ a_cnt ]->la_attr.bv_val, 0 );
 #endif  #endif
                           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 ) ) {
   #ifdef NEW_LOGGING
                           LDAP_LOG (( "modrdn", LDAP_LEVEL_ERR, "bdb_modrdn: access to attr \"%s\" (new) not allowed\n", new_rdn[0][a_cnt]->la_attr.bv_val ));
   #else
                           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 );
   #endif
                           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 ) {
                 if ( !old_rdn && ldap_bv2rdn( dn, &old_rdn, (char **)&text,                  /* Get value of old rdn */
                         LDAP_DN_FORMAT_LDAP ) )                  if ( old_rdn == NULL) {
                 {  
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                         LDAP_LOG ( OPERATION, ERR,                           LDAP_LOG (( "modrdn", LDAP_LEVEL_ERR, "bdb_modrdn: can't figure out old RDN values(s) from old RDN\n" ));
                                 "bdb_modrdn: can't figure out "  
                                 "type(s)/values(s) of old_rdn\n",   
                                 0, 0, 0 );  
 #else  #else
                         Debug( LDAP_DEBUG_TRACE,                          Debug( LDAP_DEBUG_TRACE,
                                 "bdb_modrdn: can't figure out "                                  "bdb_modrdn: can't figure out old RDN value(s) "
                                 "the old_rdn type(s)/value(s)\n",                                   "from old RDN\n", 0, 0, 0 );
                                 0, 0, 0 );  
 #endif  #endif
                         rc = LDAP_OTHER;                          rc = LDAP_OTHER;
                         text = "cannot parse RDN from old DN";                          text = "could not parse value(s) from old RDN";
                         goto return_results;                                      goto return_results;            
                 }                  }
         }  
   
         /* prepare modlist of modifications from old/new rdn */                  for ( d_cnt = 0; old_rdn[0][ d_cnt ]; d_cnt++ ) {
         if (!mod) {                          int                     rc;
                 rc = slap_modrdn2mods( be, conn, op, e, old_rdn, new_rdn,                           AttributeDescription    *desc = NULL;
                         deleteoldrdn, &mod );                          Modifications           *mod_tmp;
                 if ( rc != LDAP_SUCCESS ) {  
                         goto return_results;                          rc = slap_bv2ad( &old_rdn[0][ d_cnt ]->la_attr,
                                           &desc, &text );
   
                           if ( rc != LDAP_SUCCESS ) {
   #ifdef NEW_LOGGING
                                   LDAP_LOG (( "modrdn", LDAP_LEVEL_ERR, "bdb_modrdn: %s: %s (old)\n", text, old_rdn[0][d_cnt]->la_attr.bv_val ));
   #else
                                   Debug( LDAP_DEBUG_TRACE,
                                           "bdb_modrdn: %s: %s (old)\n",
                                           text, old_rdn[0][ d_cnt ]->la_attr.bv_val, 0 );
   #endif
                                   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 ) ) {
   #ifdef NEW_LOGGING
                                   LDAP_LOG (( "modrdn", LDAP_LEVEL_ERR, "bdb_modrdn: access to attr \"%s\" (old) not allowed\n", old_rdn[0][d_cnt]->la_attr.bv_val ));
   #else
                                   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 );
   #endif
                                   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 767  retry: /* transaction retry */ Line 711  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. But if a previous modrdn has           * free individual fields. Leave new_dn/new_ndn set so
          * already happened, must free the names.           * they can be individually freed later.
          */           */
         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 796  retry: /* transaction retry */ Line 733  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 837  retry: /* transaction retry */ Line 763  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 859  retry: /* transaction retry */ Line 784  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 874  retry: /* transaction retry */ Line 798  retry: /* transaction retry */
     
         if( rc == LDAP_SUCCESS ) {          if( rc == LDAP_SUCCESS ) {
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                 LDAP_LOG ( OPERATION, RESULTS,                   LDAP_LOG (( "modrdn", LDAP_LEVEL_RESULTS, "bdb_modrdn: rdn modified%s id=%08lx dn=\"%s\"\n", op->o_noop ? " (no-op)" : "", e->e_id, e->e_dn ));
                         "bdb_modrdn: rdn modified%s id=%08lx dn=\"%s\"\n",   
                         op->o_noop ? " (no-op)" : "", e->e_id, e->e_dn );  
 #else  #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  #endif
                 text = NULL;                  text = NULL;
                   bdb_cache_entry_commit( e );
   
         } else {          } else {
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                 LDAP_LOG ( OPERATION, RESULTS, "bdb_modrdn: %s : %s (%d)\n",                   LDAP_LOG (( "modrdn", LDAP_LEVEL_RESULTS, "bdb_modrdn: %s : %s (%d)\n", text, db_strerror(rc), rc ));
                         text, db_strerror(rc), rc );  
 #else  #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 );
Line 898  return_results: Line 821  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 927  done: Line 832  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 ) {          if( new_rdn != NULL ) ldap_rdnfree( new_rdn );
                 ldap_rdnfree( new_rdn );          if( old_rdn != NULL ) ldap_rdnfree( old_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 944  done: Line 845  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_unlocked_cache_return_entry_r(&bdb->bi_cache, np);                  bdb_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_unlocked_cache_return_entry_r(&bdb->bi_cache, p);                  bdb_cache_return_entry_r(&bdb->bi_cache, p);
         }          }
   
         /* free entry */          /* free entry */
         if( e != NULL ) {          if( e != NULL ) {
                 bdb_unlocked_cache_return_entry_w( &bdb->bi_cache, e);                  bdb_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 == LDAP_SUCCESS ) ? noop : rc );          return rc;
 }  }

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


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