Diff for /servers/slapd/back-bdb/modrdn.c between versions 1.99 and 1.100

version 1.99, 2003/04/12 08:47:33 version 1.100, 2003/04/16 14:23:36
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.98 2003/04/10 23:29:30 hyc Exp $ */  /* $OpenLDAP: pkg/ldap/servers/slapd/back-bdb/modrdn.c,v 1.99 2003/04/12 08:47:33 hyc Exp $ */
 /*  /*
  * Copyright 1998-2003 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 24  bdb_modrdn( Operation *op, SlapReply *rs Line 24  bdb_modrdn( Operation *op, SlapReply *rs
         int             isroot = -1;          int             isroot = -1;
         Entry           *e = NULL;          Entry           *e = NULL;
         Entry           *p = NULL;          Entry           *p = NULL;
         Entry           *matched;          EntryInfo       *ei = NULL, *eip = NULL, *nei = NULL, *neip = NULL;
         /* LDAP v2 supporting correct attribute handling. */          /* LDAP v2 supporting correct attribute handling. */
         LDAPRDN         new_rdn = NULL;          LDAPRDN         new_rdn = NULL;
         LDAPRDN         old_rdn = NULL;          LDAPRDN         old_rdn = NULL;
         char textbuf[SLAP_TEXT_BUFLEN];          char textbuf[SLAP_TEXT_BUFLEN];
         size_t textlen = sizeof textbuf;          size_t textlen = sizeof textbuf;
         DB_TXN *        ltid = NULL;          DB_TXN          *ltid = NULL, *lt2;
         struct bdb_op_info opinfo;          struct bdb_op_info opinfo;
           Entry dummy, *save;
   
         ID                      id;          ID                      id;
   
Line 46  bdb_modrdn( Operation *op, SlapReply *rs Line 47  bdb_modrdn( Operation *op, SlapReply *rs
         int             manageDSAit = get_manageDSAit( op );          int             manageDSAit = get_manageDSAit( op );
   
         u_int32_t       locker = 0;          u_int32_t       locker = 0;
         DB_LOCK         lock;          DB_LOCK         lock, plock, nplock;
   
         int             noop = 0;          int             noop = 0;
   
Line 68  bdb_modrdn( Operation *op, SlapReply *rs Line 69  bdb_modrdn( Operation *op, SlapReply *rs
         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_unlocked_cache_return_entry_w(&bdb->bi_cache, e);                          bdb_unlocked_cache_return_entry_w(&bdb->bi_cache, e);
                         e = NULL;                          e = NULL;
                 }                  }
Line 137  retry: /* transaction retry */ Line 137  retry: /* transaction retry */
         op->o_private = &opinfo;          op->o_private = &opinfo;
   
         /* get entry */          /* get entry */
         rs->sr_err = bdb_dn2entry_w( op->o_bd, ltid, &op->o_req_ndn, &e, &matched, DB_RMW, locker, &lock );          rs->sr_err = bdb_dn2entry( op->o_bd, ltid, &op->o_req_ndn, &ei, 1,
                   locker, &lock, op->o_tmpmemctx );
   
         switch( rs->sr_err ) {          switch( rs->sr_err ) {
         case 0:          case 0:
Line 155  retry: /* transaction retry */ Line 156  retry: /* transaction retry */
                 goto return_results;                  goto return_results;
         }          }
   
         if ( e == NULL ) {          e = ei->bei_e;
                 if( matched != NULL ) {          if ( rs->sr_err == DB_NOTFOUND ) {
                         rs->sr_matched = ch_strdup( matched->e_dn );                  if( e != NULL ) {
                         rs->sr_ref = is_entry_referral( matched )                          rs->sr_matched = ch_strdup( e->e_dn );
                                 ? get_entry_referrals( op, matched )                          rs->sr_ref = is_entry_referral( e )
                                   ? get_entry_referrals( op, e )
                                 : NULL;                                  : NULL;
                         bdb_unlocked_cache_return_entry_r( &bdb->bi_cache, matched);                          bdb_unlocked_cache_return_entry_r( &bdb->bi_cache, e);
                         matched = NULL;                          e = NULL;
   
                 } else {                  } else {
                         rs->sr_ref = referral_rewrite( default_referral,                          rs->sr_ref = referral_rewrite( default_referral,
Line 203  retry: /* transaction retry */ Line 205  retry: /* transaction retry */
         }          }
   
 #ifndef BDB_HIER  #ifndef BDB_HIER
         rs->sr_err = bdb_dn2id_children( op->o_bd, ltid, &e->e_nname, 0 );          rs->sr_err = ei->bei_kids ? 0 : bdb_dn2id_children( op->o_bd, ltid,
                   &e->e_nname, 0 );
         if ( rs->sr_err != DB_NOTFOUND ) {          if ( rs->sr_err != DB_NOTFOUND ) {
                 switch( rs->sr_err ) {                  switch( rs->sr_err ) {
                 case DB_LOCK_DEADLOCK:                  case DB_LOCK_DEADLOCK:
Line 269  retry: /* transaction retry */ Line 272  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.
                  */                   */
                 rs->sr_err = bdb_dn2entry_r( op->o_bd, ltid, &p_ndn, &p, NULL, 0, locker, &lock );                  eip = ei->bei_parent;
                   rs->sr_err = bdb_cache_find_entry_id( op->o_bd, ltid,
                           eip->bei_id, &eip, 0, locker, &plock, op->o_tmpmemctx );
   
                 switch( rs->sr_err ) {                  switch( rs->sr_err ) {
                 case 0:                  case 0:
Line 287  retry: /* transaction retry */ Line 292  retry: /* transaction retry */
                         goto return_results;                          goto return_results;
                 }                  }
   
                   p = eip->bei_e;
                 if( p == NULL) {                  if( p == NULL) {
 #ifdef NEW_LOGGING  #ifdef NEW_LOGGING
                         LDAP_LOG ( OPERATION, ERR,                           LDAP_LOG ( OPERATION, ERR, 
Line 459  retry: /* transaction retry */ Line 465  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? */
   
                         rs->sr_err = bdb_dn2entry_r( op->o_bd,                          rs->sr_err = bdb_dn2entry( op->o_bd, ltid, np_ndn,
                                 ltid, np_ndn, &np, NULL, 0, locker, &lock );                                  &neip, 0, locker, &nplock, op->o_tmpmemctx );
   
                         switch( rs->sr_err ) {                          switch( rs->sr_err ) {
                         case 0:                          case 0: np = neip->bei_e;
                         case DB_NOTFOUND:                          case DB_NOTFOUND:
                                 break;                                  break;
                         case DB_LOCK_DEADLOCK:                          case DB_LOCK_DEADLOCK:
Line 661  retry: /* transaction retry */ Line 667  retry: /* transaction retry */
                 new_ndn.bv_val, 0, 0 );                  new_ndn.bv_val, 0, 0 );
 #endif  #endif
   
         rs->sr_err = bdb_dn2id ( op->o_bd, ltid, &new_ndn, &id, 0 );          /* Shortcut the search */
           nei = neip ? neip : eip;
           rs->sr_err = bdb_cache_find_entry_ndn2id ( op->o_bd, ltid, &new_ndn,
                   &nei, locker, op->o_tmpmemctx );
           if ( nei ) bdb_cache_entryinfo_unlock( nei );
         switch( rs->sr_err ) {          switch( rs->sr_err ) {
         case DB_LOCK_DEADLOCK:          case DB_LOCK_DEADLOCK:
         case DB_LOCK_NOTGRANTED:          case DB_LOCK_NOTGRANTED:
Line 741  retry: /* transaction retry */ Line 751  retry: /* transaction retry */
                         goto return_results;                          goto return_results;
                 }                  }
         }          }
           
           /* nested transaction */
           rs->sr_err = TXN_BEGIN( bdb->bi_dbenv, ltid, &lt2, 
                   bdb->bi_db_opflags );
           rs->sr_text = NULL;
           if( rs->sr_err != 0 ) {
   #ifdef NEW_LOGGING
                   LDAP_LOG ( OPERATION, ERR, 
                           "bdb_modrdn: txn_begin(2) failed: %s (%d)\n", db_strerror(rs->sr_err), rs->sr_err, 0 );
   #else
                   Debug( LDAP_DEBUG_TRACE,
                           "bdb_modrdn: txn_begin(2) failed: %s (%d)\n",
                           db_strerror(rs->sr_err), rs->sr_err, 0 );
   #endif
                   rs->sr_err = LDAP_OTHER;
                   rs->sr_text = "internal error";
                   goto return_results;
           }
   
           dummy = *e;
           save = e;
           e = &dummy;
   
         /* delete old one */          /* delete old one */
         rs->sr_err = bdb_dn2id_delete( op->o_bd, ltid, p_ndn.bv_val, e );          rs->sr_err = bdb_dn2id_delete( op->o_bd, lt2, p_ndn.bv_val, e );
         if ( rs->sr_err != 0 ) {          if ( rs->sr_err != 0 ) {
                 switch( rs->sr_err ) {                  switch( rs->sr_err ) {
                 case DB_LOCK_DEADLOCK:                  case DB_LOCK_DEADLOCK:
Line 755  retry: /* transaction retry */ Line 787  retry: /* transaction retry */
                 goto return_results;                  goto return_results;
         }          }
   
         (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. But if a previous modrdn has
          * already happened, must free the names.           * already happened, must free the names. The frees are
            * done in bdb_cache_modrdn().
          */           */
 #ifdef BDB_HIER  #ifdef BDB_HIER
         ch_free(e->e_name.bv_val);  
         e->e_name.bv_val = ch_malloc(new_dn.bv_len + new_ndn.bv_len + 2);          e->e_name.bv_val = ch_malloc(new_dn.bv_len + new_ndn.bv_len + 2);
         e->e_name.bv_len = new_dn.bv_len;          e->e_name.bv_len = new_dn.bv_len;
         e->e_nname.bv_val = e->e_name.bv_val + new_dn.bv_len + 1;          e->e_nname.bv_val = e->e_name.bv_val + new_dn.bv_len + 1;
Line 772  retry: /* transaction retry */ Line 802  retry: /* transaction retry */
 #else  #else
         if( e->e_nname.bv_val < e->e_bv.bv_val || e->e_nname.bv_val >          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 ) {                  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_name.bv_val = NULL;
                 e->e_nname.bv_val = NULL;                  e->e_nname.bv_val = NULL;
         }          }
Line 783  retry: /* transaction retry */ Line 811  retry: /* transaction retry */
         new_ndn.bv_val = NULL;          new_ndn.bv_val = NULL;
 #endif  #endif
         /* add new one */          /* add new one */
         rs->sr_err = bdb_dn2id_add( op->o_bd, ltid, np_ndn, e );          rs->sr_err = bdb_dn2id_add( op->o_bd, lt2, np_ndn, e );
         if ( rs->sr_err != 0 ) {          if ( rs->sr_err != 0 ) {
                 switch( rs->sr_err ) {                  switch( rs->sr_err ) {
                 case DB_LOCK_DEADLOCK:                  case DB_LOCK_DEADLOCK:
Line 804  retry: /* transaction retry */ Line 832  retry: /* transaction retry */
 #endif  #endif
   
         /* modify entry */          /* modify entry */
         rs->sr_err = bdb_modify_internal( op, ltid, &mod[0], e,          rs->sr_err = bdb_modify_internal( op, lt2, &mod[0], e,
                 &rs->sr_text, textbuf, textlen );                  &rs->sr_text, textbuf, textlen );
   
         if( rs->sr_err != LDAP_SUCCESS ) {          if( rs->sr_err != LDAP_SUCCESS ) {
Line 820  retry: /* transaction retry */ Line 848  retry: /* transaction retry */
         }          }
                   
         /* id2entry index */          /* id2entry index */
         rs->sr_err = bdb_id2entry_update( op->o_bd, ltid, e );          rs->sr_err = bdb_id2entry_update( op->o_bd, lt2, e );
         if ( rs->sr_err != 0 ) {          if ( rs->sr_err != 0 ) {
                 switch( rs->sr_err ) {                  switch( rs->sr_err ) {
                 case DB_LOCK_DEADLOCK:                  case DB_LOCK_DEADLOCK:
Line 831  retry: /* transaction retry */ Line 859  retry: /* transaction retry */
                 rs->sr_text = "entry update failed";                  rs->sr_text = "entry update failed";
                 goto return_results;                  goto return_results;
         }          }
           if ( TXN_COMMIT( lt2, 0 ) != 0 ) {
                   rs->sr_err = LDAP_OTHER;
                   rs->sr_text = "txn_commit(2) failed";
                   goto return_results;
           }
   
         if( op->o_noop ) {          if( op->o_noop ) {
                 if(( rs->sr_err=TXN_ABORT( ltid )) != 0 ) {                  if(( rs->sr_err=TXN_ABORT( ltid )) != 0 ) {
Line 849  retry: /* transaction retry */ Line 882  retry: /* transaction retry */
                 if(( rs->sr_err=TXN_PREPARE( ltid, gid )) != 0 ) {                  if(( rs->sr_err=TXN_PREPARE( ltid, gid )) != 0 ) {
                         rs->sr_text = "txn_prepare failed";                          rs->sr_text = "txn_prepare failed";
                 } else {                  } else {
                         if( bdb_cache_update_entry(&bdb->bi_cache, e) == -1 ) {                          bdb_cache_modrdn( save, &op->orr_newrdn, e, neip,
                                 if(( rs->sr_err=TXN_ABORT( ltid )) != 0 ) {                                  bdb->bi_dbenv, locker, &lock );
                                         rs->sr_text ="cache update & txn_abort failed";                          if(( rs->sr_err=TXN_COMMIT( ltid, 0 )) != 0 ) {
                                 } else {                                  rs->sr_text = "txn_commit failed";
                                         rs->sr_err = LDAP_OTHER;  
                                         rs->sr_text = "cache update failed";  
                                 }  
   
                         } else {                          } else {
                                 bdb_cache_entry_commit( e );                                  rs->sr_err = LDAP_SUCCESS;
                                 if(( rs->sr_err=TXN_COMMIT( ltid, 0 )) != 0 ) {  
                                         rs->sr_text = "txn_commit failed";  
                                 } else {  
                                         rs->sr_err = LDAP_SUCCESS;  
                                 }  
                         }                          }
                 }                  }
         }          }

Removed from v.1.99  
changed lines
  Added in v.1.100


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