git.sur5r.net Git - openldap/blob - servers/slapd/back-bdb/modrdn.c

   1 /* modrdn.c - bdb backend modrdn routine */
   2 /* $OpenLDAP$ */
   3 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   4  *
   5  * Copyright 2000-2004 The OpenLDAP Foundation.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted only as authorized by the OpenLDAP
  10  * Public License.
  11  *
  12  * A copy of this license is available in the file LICENSE in the
  13  * top-level directory of the distribution or, alternatively, at
  14  * <http://www.OpenLDAP.org/license.html>.
  15  */
  16
  17 #include "portable.h"
  18
  19 #include <stdio.h>
  20 #include <ac/string.h>
  21
  22 #include "back-bdb.h"
  23 #include "external.h"
  24
  25 int
  26 bdb_modrdn( Operation   *op, SlapReply *rs )
  27 {
  28         struct bdb_info *bdb = (struct bdb_info *) op->o_bd->be_private;
  29         AttributeDescription *children = slap_schema.si_ad_children;
  30         AttributeDescription *entry = slap_schema.si_ad_entry;
  31         struct berval   p_dn, p_ndn;
  32         struct berval   new_dn = {0, NULL}, new_ndn = {0, NULL};
  33         int             isroot = -1;
  34         Entry           *e = NULL;
  35         Entry           *p = NULL;
  36         EntryInfo       *ei = NULL, *eip = NULL, *nei = NULL, *neip = NULL;
  37         /* LDAP v2 supporting correct attribute handling. */
  38         LDAPRDN         new_rdn = NULL;
  39         LDAPRDN         old_rdn = NULL;
  40         char textbuf[SLAP_TEXT_BUFLEN];
  41         size_t textlen = sizeof textbuf;
  42         DB_TXN          *ltid = NULL, *lt2;
  43         struct bdb_op_info opinfo;
  44         Entry dummy, *save;
  45
  46         ID                      id;
  47
  48         Entry           *np = NULL;                     /* newSuperior Entry */
  49         struct berval   *np_dn = NULL;                  /* newSuperior dn */
  50         struct berval   *np_ndn = NULL;                 /* newSuperior ndn */
  51         struct berval   *new_parent_dn = NULL;  /* np_dn, p_dn, or NULL */
  52
  53         /* Used to interface with bdb_modify_internal() */
  54         Modifications   *mod = NULL;            /* Used to delete old rdn */
  55
  56         int             manageDSAit = get_manageDSAit( op );
  57
  58         u_int32_t       locker = 0;
  59         DB_LOCK         lock, plock, nplock;
  60
  61         int             num_retries = 0;
  62
  63         LDAPControl *ctrls[SLAP_MAX_RESPONSE_CONTROLS];
  64         int num_ctrls = 0;
  65
  66         Operation *ps_list;
  67         struct psid_entry *pm_list, *pm_prev;
  68         int     rc;
  69         EntryInfo       *suffix_ei;
  70         Entry           *ctxcsn_e;
  71         int                     ctxcsn_added = 0;
  72
  73 #ifdef NEW_LOGGING
  74         LDAP_LOG ( OPERATION, ENTRY, "==>bdb_modrdn(%s,%s,%s)\n",
  75                 op->o_req_dn.bv_val,op->oq_modrdn.rs_newrdn.bv_val,
  76                 op->oq_modrdn.rs_newSup ? op->oq_modrdn.rs_newSup->bv_val : "NULL" );
  77 #else
  78         Debug( LDAP_DEBUG_TRACE, "==>bdb_modrdn(%s,%s,%s)\n",
  79                 op->o_req_dn.bv_val,op->oq_modrdn.rs_newrdn.bv_val,
  80                 op->oq_modrdn.rs_newSup ? op->oq_modrdn.rs_newSup->bv_val : "NULL" );
  81 #endif
  82
  83         if( 0 ) {
  84 retry:  /* transaction retry */
  85                 if (e != NULL) {
  86                         bdb_unlocked_cache_return_entry_w(&bdb->bi_cache, e);
  87                         e = NULL;
  88                 }
  89                 if (p != NULL) {
  90                         bdb_unlocked_cache_return_entry_r(&bdb->bi_cache, p);
  91                         p = NULL;
  92                 }
  93                 if (np != NULL) {
  94                         bdb_unlocked_cache_return_entry_r(&bdb->bi_cache, np);
  95                         np = NULL;
  96                 }
  97 #ifdef NEW_LOGGING
  98                 LDAP_LOG ( OPERATION, DETAIL1, "==>bdb_modrdn: retrying...\n", 0, 0, 0);
  99 #else
 100                 Debug( LDAP_DEBUG_TRACE, "==>bdb_modrdn: retrying...\n", 0, 0, 0 );
 101 #endif
 102                 pm_list = LDAP_LIST_FIRST(&op->o_pm_list);
 103                 while ( pm_list != NULL ) {
 104                         LDAP_LIST_REMOVE ( pm_list, ps_link );
 105                         pm_prev = pm_list;
 106                         pm_list = LDAP_LIST_NEXT ( pm_list, ps_link );
 107                         ch_free( pm_prev );
 108                 }
 109
 110                 rs->sr_err = TXN_ABORT( ltid );
 111                 ltid = NULL;
 112                 op->o_private = NULL;
 113                 op->o_do_not_cache = opinfo.boi_acl_cache;
 114                 if( rs->sr_err != 0 ) {
 115                         rs->sr_err = LDAP_OTHER;
 116                         rs->sr_text = "internal error";
 117                         goto return_results;
 118                 }
 119                 ldap_pvt_thread_yield();
 120                 bdb_trans_backoff( ++num_retries );
 121         }
 122
 123         /* begin transaction */
 124         rs->sr_err = TXN_BEGIN( bdb->bi_dbenv, NULL, &ltid,
 125                 bdb->bi_db_opflags );
 126         rs->sr_text = NULL;
 127         if( rs->sr_err != 0 ) {
 128 #ifdef NEW_LOGGING
 129                 LDAP_LOG ( OPERATION, ERR,
 130                         "==>bdb_modrdn: txn_begin failed: %s (%d)\n",
 131                         db_strerror(rs->sr_err), rs->sr_err, 0 );
 132 #else
 133                 Debug( LDAP_DEBUG_TRACE,
 134                         "bdb_delete: txn_begin failed: %s (%d)\n",
 135                         db_strerror(rs->sr_err), rs->sr_err, 0 );
 136 #endif
 137                 rs->sr_err = LDAP_OTHER;
 138                 rs->sr_text = "internal error";
 139                 goto return_results;
 140         }
 141
 142         locker = TXN_ID ( ltid );
 143
 144         opinfo.boi_bdb = op->o_bd;
 145         opinfo.boi_txn = ltid;
 146         opinfo.boi_locker = locker;
 147         opinfo.boi_err = 0;
 148         opinfo.boi_acl_cache = op->o_do_not_cache;
 149         op->o_private = &opinfo;
 150
 151         /* get entry */
 152         rs->sr_err = bdb_dn2entry( op, ltid, &op->o_req_ndn, &ei, 1,
 153                 locker, &lock );
 154
 155         switch( rs->sr_err ) {
 156         case 0:
 157         case DB_NOTFOUND:
 158                 break;
 159         case DB_LOCK_DEADLOCK:
 160         case DB_LOCK_NOTGRANTED:
 161                 goto retry;
 162         case LDAP_BUSY:
 163                 rs->sr_text = "ldap server busy";
 164                 goto return_results;
 165         default:
 166                 rs->sr_err = LDAP_OTHER;
 167                 rs->sr_text = "internal error";
 168                 goto return_results;
 169         }
 170
 171         e = ei->bei_e;
 172         /* FIXME: dn2entry() should return non-glue entry */
 173         if (( rs->sr_err == DB_NOTFOUND ) || ( !manageDSAit && e && is_entry_glue( e ))) {
 174                 if( e != NULL ) {
 175                         rs->sr_matched = ch_strdup( e->e_dn );
 176                         rs->sr_ref = is_entry_referral( e )
 177                                 ? get_entry_referrals( op, e )
 178                                 : NULL;
 179                         bdb_unlocked_cache_return_entry_r( &bdb->bi_cache, e);
 180                         e = NULL;
 181
 182                 } else {
 183                         BerVarray deref = NULL;
 184                         if ( !LDAP_STAILQ_EMPTY( &op->o_bd->be_syncinfo )) {
 185                                 syncinfo_t *si;
 186                                 LDAP_STAILQ_FOREACH( si, &op->o_bd->be_syncinfo, si_next ) {
 187                                         struct berval tmpbv;
 188                                         ber_dupbv( &tmpbv, &si->si_provideruri_bv[0] );
 189                                         ber_bvarray_add( &deref, &tmpbv );
 190                 }
 191                         } else {
 192                                 deref = default_referral;
 193                         }
 194                         rs->sr_ref = referral_rewrite( deref, NULL, &op->o_req_dn,
 195                                 LDAP_SCOPE_DEFAULT );
 196                 }
 197
 198                 rs->sr_err = LDAP_REFERRAL;
 199                 send_ldap_result( op, rs );
 200
 201                 ber_bvarray_free( rs->sr_ref );
 202                 free( (char *)rs->sr_matched );
 203                 rs->sr_ref = NULL;
 204                 rs->sr_matched = NULL;
 205
 206                 goto done;
 207         }
 208
 209         if ( get_assert( op ) &&
 210                 ( test_filter( op, e, get_assertion( op )) != LDAP_COMPARE_TRUE ))
 211         {
 212                 rs->sr_err = LDAP_ASSERTION_FAILED;
 213                 goto return_results;
 214         }
 215
 216         /* check write on old entry */
 217         rs->sr_err = access_allowed( op, e, entry, NULL, ACL_WRITE, NULL );
 218         if ( ! rs->sr_err ) {
 219                 switch( opinfo.boi_err ) {
 220                 case DB_LOCK_DEADLOCK:
 221                 case DB_LOCK_NOTGRANTED:
 222                         goto retry;
 223                 }
 224
 225 #ifdef NEW_LOGGING
 226                 LDAP_LOG ( OPERATION, ERR,
 227                         "==>bdb_modrdn: no access to entry\n", 0, 0, 0 );
 228 #else
 229                 Debug( LDAP_DEBUG_TRACE, "no access to entry\n", 0,
 230                         0, 0 );
 231 #endif
 232                 rs->sr_text = "no write access to old entry";
 233                 rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
 234                 goto return_results;
 235         }
 236
 237 #ifndef BDB_HIER
 238         rs->sr_err = bdb_cache_children( op, ltid, e );
 239         if ( rs->sr_err != DB_NOTFOUND ) {
 240                 switch( rs->sr_err ) {
 241                 case DB_LOCK_DEADLOCK:
 242                 case DB_LOCK_NOTGRANTED:
 243                         goto retry;
 244                 case 0:
 245 #ifdef NEW_LOGGING
 246                         LDAP_LOG ( OPERATION, DETAIL1,
 247                                 "<=- bdb_modrdn: non-leaf %s\n", op->o_req_dn.bv_val, 0, 0 );
 248 #else
 249                         Debug(LDAP_DEBUG_ARGS,
 250                                 "<=- bdb_modrdn: non-leaf %s\n",
 251                                 op->o_req_dn.bv_val, 0, 0);
 252 #endif
 253                         rs->sr_err = LDAP_NOT_ALLOWED_ON_NONLEAF;
 254                         rs->sr_text = "subtree rename not supported";
 255                         break;
 256                 default:
 257 #ifdef NEW_LOGGING
 258                         LDAP_LOG ( OPERATION, ERR,
 259                                 "<=- bdb_modrdn: has_children failed %s (%d)\n",
 260                                 db_strerror(rs->sr_err), rs->sr_err, 0 );
 261 #else
 262                         Debug(LDAP_DEBUG_ARGS,
 263                                 "<=- bdb_modrdn: has_children failed: %s (%d)\n",
 264                                 db_strerror(rs->sr_err), rs->sr_err, 0 );
 265 #endif
 266                         rs->sr_err = LDAP_OTHER;
 267                         rs->sr_text = "internal error";
 268                 }
 269                 goto return_results;
 270         }
 271         ei->bei_state |= CACHE_ENTRY_NO_KIDS;
 272 #endif
 273         if (!manageDSAit && is_entry_referral( e ) ) {
 274                 /* parent is a referral, don't allow add */
 275                 rs->sr_ref = get_entry_referrals( op, e );
 276
 277 #ifdef NEW_LOGGING
 278                 LDAP_LOG ( OPERATION, DETAIL1,
 279                         "==>bdb_modrdn: entry %s is referral \n", e->e_dn, 0, 0 );
 280 #else
 281                 Debug( LDAP_DEBUG_TRACE, "bdb_modrdn: entry %s is referral\n",
 282                         e->e_dn, 0, 0 );
 283 #endif
 284
 285                 rs->sr_err = LDAP_REFERRAL,
 286                 rs->sr_matched = e->e_name.bv_val;
 287                 send_ldap_result( op, rs );
 288
 289                 ber_bvarray_free( rs->sr_ref );
 290                 rs->sr_ref = NULL;
 291                 rs->sr_matched = NULL;
 292                 goto done;
 293         }
 294
 295         if ( be_issuffix( op->o_bd, &e->e_nname ) ) {
 296                 p_ndn = slap_empty_bv;
 297         } else {
 298                 dnParent( &e->e_nname, &p_ndn );
 299         }
 300         np_ndn = &p_ndn;
 301         if ( p_ndn.bv_len != 0 ) {
 302                 /* Make sure parent entry exist and we can write its
 303                  * children.
 304                  */
 305                 eip = ei->bei_parent;
 306                 rs->sr_err = bdb_cache_find_id( op, ltid,
 307                         eip->bei_id, &eip, 0, locker, &plock );
 308
 309                 switch( rs->sr_err ) {
 310                 case 0:
 311                 case DB_NOTFOUND:
 312                         break;
 313                 case DB_LOCK_DEADLOCK:
 314                 case DB_LOCK_NOTGRANTED:
 315                         goto retry;
 316                 case LDAP_BUSY:
 317                         rs->sr_text = "ldap server busy";
 318                         goto return_results;
 319                 default:
 320                         rs->sr_err = LDAP_OTHER;
 321                         rs->sr_text = "internal error";
 322                         goto return_results;
 323                 }
 324
 325                 p = eip->bei_e;
 326                 if( p == NULL) {
 327 #ifdef NEW_LOGGING
 328                         LDAP_LOG ( OPERATION, ERR,
 329                                 "==>bdb_modrdn: parent does not exist\n", 0, 0, 0 );
 330 #else
 331                         Debug( LDAP_DEBUG_TRACE, "bdb_modrdn: parent does not exist\n",
 332                                 0, 0, 0);
 333 #endif
 334                         rs->sr_err = LDAP_OTHER;
 335                         rs->sr_text = "old entry's parent does not exist";
 336                         goto return_results;
 337                 }
 338
 339                 /* check parent for "children" acl */
 340                 rs->sr_err = access_allowed( op, p,
 341                         children, NULL, ACL_WRITE, NULL );
 342
 343                 if ( ! rs->sr_err ) {
 344                         switch( opinfo.boi_err ) {
 345                         case DB_LOCK_DEADLOCK:
 346                         case DB_LOCK_NOTGRANTED:
 347                                 goto retry;
 348                         }
 349
 350                         rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
 351 #ifdef NEW_LOGGING
 352                         LDAP_LOG ( OPERATION, ERR,
 353                                 "==>bdb_modrdn: no access to parent\n", 0, 0, 0 );
 354 #else
 355                         Debug( LDAP_DEBUG_TRACE, "no access to parent\n", 0,
 356                                 0, 0 );
 357 #endif
 358                         rs->sr_text = "no write access to old parent's children";
 359                         goto return_results;
 360                 }
 361
 362 #ifdef NEW_LOGGING
 363                 LDAP_LOG ( OPERATION, DETAIL1,
 364                         "==>bdb_modrdn: wr to children %s is OK\n", p_ndn.bv_val, 0, 0 );
 365 #else
 366                 Debug( LDAP_DEBUG_TRACE,
 367                         "bdb_modrdn: wr to children of entry %s OK\n",
 368                         p_ndn.bv_val, 0, 0 );
 369 #endif
 370
 371                 if ( p_ndn.bv_val == slap_empty_bv.bv_val ) {
 372                         p_dn = slap_empty_bv;
 373                 } else {
 374                         dnParent( &e->e_name, &p_dn );
 375                 }
 376
 377 #ifdef NEW_LOGGING
 378                 LDAP_LOG ( OPERATION, DETAIL1,
 379                         "==>bdb_modrdn: parent dn=%s\n", p_dn.bv_val, 0, 0 );
 380 #else
 381                 Debug( LDAP_DEBUG_TRACE,
 382                         "bdb_modrdn: parent dn=%s\n",
 383                         p_dn.bv_val, 0, 0 );
 384 #endif
 385
 386         } else {
 387                 /* no parent, modrdn entry directly under root */
 388                 isroot = be_isroot( op->o_bd, &op->o_ndn );
 389                 if ( ! isroot ) {
 390                         if ( be_issuffix( op->o_bd, (struct berval *)&slap_empty_bv )
 391                                 || be_isupdate( op->o_bd, &op->o_ndn ) ) {
 392
 393                                 p = (Entry *)&slap_entry_root;
 394
 395                                 /* check parent for "children" acl */
 396                                 rs->sr_err = access_allowed( op, p,
 397                                         children, NULL, ACL_WRITE, NULL );
 398
 399                                 p = NULL;
 400
 401                                 if ( ! rs->sr_err ) {
 402                                         switch( opinfo.boi_err ) {
 403                                         case DB_LOCK_DEADLOCK:
 404                                         case DB_LOCK_NOTGRANTED:
 405                                                 goto retry;
 406                                         }
 407
 408                                         rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
 409 #ifdef NEW_LOGGING
 410                                         LDAP_LOG ( OPERATION, ERR,
 411                                                 "==>bdb_modrdn: no access to parent\n", 0, 0, 0 );
 412 #else
 413                                         Debug( LDAP_DEBUG_TRACE,
 414                                                 "no access to parent\n",
 415                                                 0, 0, 0 );
 416 #endif
 417                                         rs->sr_text = "no write access to old parent";
 418                                         goto return_results;
 419                                 }
 420
 421 #ifdef NEW_LOGGING
 422                                 LDAP_LOG ( OPERATION, DETAIL1,
 423                                         "==>bdb_modrdn: wr to children of entry \"%s\" OK\n",
 424                                         p_dn.bv_val, 0, 0 );
 425 #else
 426                                 Debug( LDAP_DEBUG_TRACE,
 427                                         "bdb_modrdn: wr to children of entry \"\" OK\n",
 428                                         0, 0, 0 );
 429 #endif
 430
 431                                 p_dn.bv_val = "";
 432                                 p_dn.bv_len = 0;
 433
 434 #ifdef NEW_LOGGING
 435                                 LDAP_LOG ( OPERATION, DETAIL1,
 436                                         "==>bdb_modrdn: parent dn=\"\" \n", 0, 0, 0 );
 437 #else
 438                                 Debug( LDAP_DEBUG_TRACE,
 439                                         "bdb_modrdn: parent dn=\"\"\n",
 440                                         0, 0, 0 );
 441 #endif
 442
 443                         } else {
 444 #ifdef NEW_LOGGING
 445                                 LDAP_LOG ( OPERATION, ERR,
 446                                         "==>bdb_modrdn: no parent, not root &\"\" is not "
 447                                         "suffix\n", 0, 0, 0 );
 448 #else
 449                                 Debug( LDAP_DEBUG_TRACE,
 450                                         "bdb_modrdn: no parent, not root "
 451                                         "& \"\" is not suffix\n",
 452                                         0, 0, 0);
 453 #endif
 454                                 rs->sr_text = "no write access to old parent";
 455                                 rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
 456                                 goto return_results;
 457                         }
 458                 }
 459         }
 460
 461         new_parent_dn = &p_dn;  /* New Parent unless newSuperior given */
 462
 463         if ( op->oq_modrdn.rs_newSup != NULL ) {
 464 #ifdef NEW_LOGGING
 465                 LDAP_LOG ( OPERATION, DETAIL1,
 466                         "==>bdb_modrdn: new parent \"%s\" requested...\n",
 467                         op->oq_modrdn.rs_newSup->bv_val, 0, 0 );
 468 #else
 469                 Debug( LDAP_DEBUG_TRACE,
 470                         "bdb_modrdn: new parent \"%s\" requested...\n",
 471                         op->oq_modrdn.rs_newSup->bv_val, 0, 0 );
 472 #endif
 473
 474                 /*  newSuperior == oldParent? */
 475                 if( dn_match( &p_ndn, op->oq_modrdn.rs_nnewSup ) ) {
 476 #ifdef NEW_LOGGING
 477                         LDAP_LOG( BACK_BDB, INFO, "bdb_back_modrdn: "
 478                                 "new parent \"%s\" same as the old parent \"%s\"\n",
 479                                 op->oq_modrdn.rs_newSup->bv_val, p_dn.bv_val, 0 );
 480 #else
 481                         Debug( LDAP_DEBUG_TRACE, "bdb_back_modrdn: "
 482                                 "new parent \"%s\" same as the old parent \"%s\"\n",
 483                                 op->oq_modrdn.rs_newSup->bv_val, p_dn.bv_val, 0 );
 484 #endif
 485                         op->oq_modrdn.rs_newSup = NULL; /* ignore newSuperior */
 486                 }
 487         }
 488
 489         if ( op->oq_modrdn.rs_newSup != NULL ) {
 490                 if ( op->oq_modrdn.rs_newSup->bv_len ) {
 491                         np_dn = op->oq_modrdn.rs_newSup;
 492                         np_ndn = op->oq_modrdn.rs_nnewSup;
 493
 494                         /* newSuperior == oldParent?, if so ==> ERROR */
 495                         /* newSuperior == entry being moved?, if so ==> ERROR */
 496                         /* Get Entry with dn=newSuperior. Does newSuperior exist? */
 497
 498                         rs->sr_err = bdb_dn2entry( op, ltid, np_ndn,
 499                                 &neip, 0, locker, &nplock );
 500
 501                         switch( rs->sr_err ) {
 502                         case 0: np = neip->bei_e;
 503                         case DB_NOTFOUND:
 504                                 break;
 505                         case DB_LOCK_DEADLOCK:
 506                         case DB_LOCK_NOTGRANTED:
 507                                 goto retry;
 508                         case LDAP_BUSY:
 509                                 rs->sr_text = "ldap server busy";
 510                                 goto return_results;
 511                         default:
 512                                 rs->sr_err = LDAP_OTHER;
 513                                 rs->sr_text = "internal error";
 514                                 goto return_results;
 515                         }
 516
 517                         if( np == NULL) {
 518 #ifdef NEW_LOGGING
 519                                 LDAP_LOG ( OPERATION, DETAIL1,
 520                                         "==>bdb_modrdn: newSup(ndn=%s) not here!\n",
 521                                         np_ndn->bv_val, 0, 0 );
 522 #else
 523                                 Debug( LDAP_DEBUG_TRACE,
 524                                         "bdb_modrdn: newSup(ndn=%s) not here!\n",
 525                                         np_ndn->bv_val, 0, 0);
 526 #endif
 527                                 rs->sr_text = "new superior not found";
 528                                 rs->sr_err = LDAP_OTHER;
 529                                 goto return_results;
 530                         }
 531
 532 #ifdef NEW_LOGGING
 533                         LDAP_LOG ( OPERATION, DETAIL1,
 534                                 "==>bdb_modrdn: wr to new parent OK np=%p, id=%ld\n",
 535                                 (void *) np, (long) np->e_id, 0 );
 536 #else
 537                         Debug( LDAP_DEBUG_TRACE,
 538                                 "bdb_modrdn: wr to new parent OK np=%p, id=%ld\n",
 539                                 (void *) np, (long) np->e_id, 0 );
 540 #endif
 541
 542                         /* check newSuperior for "children" acl */
 543                         rs->sr_err = access_allowed( op, np, children,
 544                                 NULL, ACL_WRITE, NULL );
 545
 546                         if( ! rs->sr_err ) {
 547                                 switch( opinfo.boi_err ) {
 548                                 case DB_LOCK_DEADLOCK:
 549                                 case DB_LOCK_NOTGRANTED:
 550                                         goto retry;
 551                                 }
 552
 553 #ifdef NEW_LOGGING
 554                                 LDAP_LOG ( OPERATION, DETAIL1,
 555                                         "==>bdb_modrdn: no wr to newSup children\n", 0, 0, 0 );
 556 #else
 557                                 Debug( LDAP_DEBUG_TRACE,
 558                                         "bdb_modrdn: no wr to newSup children\n",
 559                                         0, 0, 0 );
 560 #endif
 561                                 rs->sr_text = "no write access to new superior's children";
 562                                 rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
 563                                 goto return_results;
 564                         }
 565
 566 #ifdef BDB_ALIASES
 567                         if ( is_entry_alias( np ) ) {
 568                                 /* parent is an alias, don't allow add */
 569 #ifdef NEW_LOGGING
 570                                 LDAP_LOG ( OPERATION, DETAIL1,
 571                                         "==>bdb_modrdn: entry is alias\n", 0, 0, 0 );
 572 #else
 573                                 Debug( LDAP_DEBUG_TRACE, "bdb_modrdn: entry is alias\n",
 574                                         0, 0, 0 );
 575 #endif
 576                                 rs->sr_text = "new superior is an alias";
 577                                 rs->sr_err = LDAP_ALIAS_PROBLEM;
 578                                 goto return_results;
 579                         }
 580 #endif
 581
 582                         if ( is_entry_referral( np ) ) {
 583                                 /* parent is a referral, don't allow add */
 584 #ifdef NEW_LOGGING
 585                                 LDAP_LOG ( OPERATION, DETAIL1,
 586                                         "==>bdb_modrdn: entry is referral\n", 0, 0, 0 );
 587 #else
 588                                 Debug( LDAP_DEBUG_TRACE, "bdb_modrdn: entry is referral\n",
 589                                         0, 0, 0 );
 590 #endif
 591                                 rs->sr_text = "new superior is a referral";
 592                                 rs->sr_err = LDAP_OTHER;
 593                                 goto return_results;
 594                         }
 595
 596                 } else {
 597                         if ( isroot == -1 ) {
 598                                 isroot = be_isroot( op->o_bd, &op->o_ndn );
 599                         }
 600
 601                         np_dn = NULL;
 602
 603                         /* no parent, modrdn entry directly under root */
 604                         if ( ! isroot ) {
 605                                 if ( be_issuffix( op->o_bd, (struct berval *)&slap_empty_bv )
 606                                         || be_isupdate( op->o_bd, &op->o_ndn ) ) {
 607                                         np = (Entry *)&slap_entry_root;
 608
 609                                         /* check parent for "children" acl */
 610                                         rs->sr_err = access_allowed( op, np,
 611                                                 children, NULL, ACL_WRITE, NULL );
 612
 613                                         np = NULL;
 614
 615                                         if ( ! rs->sr_err ) {
 616                                                 switch( opinfo.boi_err ) {
 617                                                 case DB_LOCK_DEADLOCK:
 618                                                 case DB_LOCK_NOTGRANTED:
 619                                                         goto retry;
 620                                                 }
 621
 622                                                 rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
 623 #ifdef NEW_LOGGING
 624                                                 LDAP_LOG ( OPERATION, ERR,
 625                                                         "==>bdb_modrdn: no access to superior\n", 0, 0, 0 );
 626 #else
 627                                                 Debug( LDAP_DEBUG_TRACE,
 628                                                         "no access to new superior\n",
 629                                                         0, 0, 0 );
 630 #endif
 631                                                 rs->sr_text = "no write access to new superior's children";
 632                                                 goto return_results;
 633                                         }
 634
 635 #ifdef NEW_LOGGING
 636                                         LDAP_LOG ( OPERATION, DETAIL1,
 637                                                 "bdb_modrdn: wr to children entry \"\" OK\n", 0, 0, 0 );
 638 #else
 639                                         Debug( LDAP_DEBUG_TRACE,
 640                                                 "bdb_modrdn: wr to children of entry \"\" OK\n",
 641                                                 0, 0, 0 );
 642 #endif
 643
 644                                 } else {
 645 #ifdef NEW_LOGGING
 646                                         LDAP_LOG ( OPERATION, ERR,
 647                                                 "bdb_modrdn: new superior=\"\", not root & \"\" "
 648                                                 "is not suffix\n", 0, 0, 0 );
 649 #else
 650                                         Debug( LDAP_DEBUG_TRACE,
 651                                                 "bdb_modrdn: new superior=\"\", not root "
 652                                                 "& \"\" is not suffix\n",
 653                                                 0, 0, 0);
 654 #endif
 655                                         rs->sr_text = "no write access to new superior's children";
 656                                         rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
 657                                         goto return_results;
 658                                 }
 659                         }
 660
 661 #ifdef NEW_LOGGING
 662                         LDAP_LOG ( OPERATION, DETAIL1,
 663                                 "bdb_modrdn: new superior=\"\"\n", 0, 0, 0 );
 664 #else
 665                         Debug( LDAP_DEBUG_TRACE,
 666                                 "bdb_modrdn: new superior=\"\"\n",
 667                                 0, 0, 0 );
 668 #endif
 669                 }
 670
 671 #ifdef NEW_LOGGING
 672                 LDAP_LOG ( OPERATION, DETAIL1,
 673                         "bdb_modrdn: wr to new parent's children OK\n", 0, 0, 0 );
 674 #else
 675                 Debug( LDAP_DEBUG_TRACE,
 676                         "bdb_modrdn: wr to new parent's children OK\n",
 677                         0, 0, 0 );
 678 #endif
 679
 680                 new_parent_dn = np_dn;
 681         }
 682
 683         /* Build target dn and make sure target entry doesn't exist already. */
 684         if (!new_dn.bv_val) build_new_dn( &new_dn, new_parent_dn, &op->oq_modrdn.rs_newrdn, NULL );
 685
 686         if (!new_ndn.bv_val) {
 687                 struct berval bv = {0, NULL};
 688                 dnNormalize( 0, NULL, NULL, &new_dn, &bv, op->o_tmpmemctx );
 689                 ber_dupbv( &new_ndn, &bv );
 690         }
 691
 692 #ifdef NEW_LOGGING
 693         LDAP_LOG ( OPERATION, RESULTS,
 694                 "bdb_modrdn: new ndn=%s\n", new_ndn.bv_val, 0, 0 );
 695 #else
 696         Debug( LDAP_DEBUG_TRACE, "bdb_modrdn: new ndn=%s\n",
 697                 new_ndn.bv_val, 0, 0 );
 698 #endif
 699
 700
 701         /* Shortcut the search */
 702         nei = neip ? neip : eip;
 703         rs->sr_err = bdb_cache_find_ndn ( op, ltid, &new_ndn, &nei );
 704         if ( nei ) bdb_cache_entryinfo_unlock( nei );
 705         switch( rs->sr_err ) {
 706         case DB_LOCK_DEADLOCK:
 707         case DB_LOCK_NOTGRANTED:
 708                 goto retry;
 709         case DB_NOTFOUND:
 710                 break;
 711         case 0:
 712                 rs->sr_err = LDAP_ALREADY_EXISTS;
 713                 goto return_results;
 714         default:
 715                 rs->sr_err = LDAP_OTHER;
 716                 rs->sr_text = "internal error";
 717                 goto return_results;
 718         }
 719
 720         /* Get attribute type and attribute value of our new rdn, we will
 721          * need to add that to our new entry
 722          */
 723         if ( !new_rdn && ldap_bv2rdn_x( &op->oq_modrdn.rs_newrdn, &new_rdn, (char **)&rs->sr_text,
 724                 LDAP_DN_FORMAT_LDAP, op->o_tmpmemctx ) )
 725         {
 726 #ifdef NEW_LOGGING
 727                 LDAP_LOG ( OPERATION, ERR,
 728                         "bdb_modrdn: can't figure out "
 729                         "type(s)/values(s) of newrdn\n",
 730                         0, 0, 0 );
 731 #else
 732                 Debug( LDAP_DEBUG_TRACE,
 733                         "bdb_modrdn: can't figure out "
 734                         "type(s)/values(s) of newrdn\n",
 735                         0, 0, 0 );
 736 #endif
 737                 rs->sr_err = LDAP_INVALID_DN_SYNTAX;
 738                 rs->sr_text = "unknown type(s) used in RDN";
 739                 goto return_results;
 740         }
 741
 742 #ifdef NEW_LOGGING
 743         LDAP_LOG ( OPERATION, RESULTS,
 744                 "bdb_modrdn: new_rdn_type=\"%s\", "
 745                 "new_rdn_val=\"%s\"\n",
 746                 new_rdn[ 0 ]->la_attr.bv_val,
 747                 new_rdn[ 0 ]->la_value.bv_val, 0 );
 748 #else
 749         Debug( LDAP_DEBUG_TRACE,
 750                 "bdb_modrdn: new_rdn_type=\"%s\", "
 751                 "new_rdn_val=\"%s\"\n",
 752                 new_rdn[ 0 ]->la_attr.bv_val,
 753                 new_rdn[ 0 ]->la_value.bv_val, 0 );
 754 #endif
 755
 756         if ( op->oq_modrdn.rs_deleteoldrdn ) {
 757                 if ( !old_rdn && ldap_bv2rdn_x( &op->o_req_dn, &old_rdn, (char **)&rs->sr_text,
 758                         LDAP_DN_FORMAT_LDAP, op->o_tmpmemctx ) )
 759                 {
 760 #ifdef NEW_LOGGING
 761                         LDAP_LOG ( OPERATION, ERR,
 762                                 "bdb_modrdn: can't figure out "
 763                                 "type(s)/values(s) of old_rdn\n",
 764                                 0, 0, 0 );
 765 #else
 766                         Debug( LDAP_DEBUG_TRACE,
 767                                 "bdb_modrdn: can't figure out "
 768                                 "the old_rdn type(s)/value(s)\n",
 769                                 0, 0, 0 );
 770 #endif
 771                         rs->sr_err = LDAP_OTHER;
 772                         rs->sr_text = "cannot parse RDN from old DN";
 773                         goto return_results;
 774                 }
 775         }
 776
 777         /* prepare modlist of modifications from old/new rdn */
 778         if (!mod) {
 779                 rs->sr_err = slap_modrdn2mods( op, rs, e, old_rdn, new_rdn, &mod );
 780                 if ( rs->sr_err != LDAP_SUCCESS ) {
 781                         goto return_results;
 782                 }
 783         }
 784
 785         if( op->o_preread ) {
 786                 if( slap_read_controls( op, rs, e,
 787                         &slap_pre_read_bv, &ctrls[num_ctrls] ) )
 788                 {
 789 #ifdef NEW_LOGGING
 790                         LDAP_LOG ( OPERATION, DETAIL1,
 791                                 "<=- bdb_modrdn: post-read failed!\n", 0, 0, 0 );
 792 #else
 793                         Debug( LDAP_DEBUG_TRACE,
 794                                 "<=- bdb_modrdn: post-read failed!\n", 0, 0, 0 );
 795 #endif
 796                         goto return_results;
 797                 }
 798                 ctrls[++num_ctrls] = NULL;
 799                 op->o_preread = 0;  /* prevent redo on retry */
 800         }
 801
 802         /* nested transaction */
 803         rs->sr_err = TXN_BEGIN( bdb->bi_dbenv, ltid, &lt2,
 804                 bdb->bi_db_opflags );
 805         rs->sr_text = NULL;
 806         if( rs->sr_err != 0 ) {
 807 #ifdef NEW_LOGGING
 808                 LDAP_LOG ( OPERATION, ERR,
 809                         "bdb_modrdn: txn_begin(2) failed: %s (%d)\n", db_strerror(rs->sr_err), rs->sr_err, 0 );
 810 #else
 811                 Debug( LDAP_DEBUG_TRACE,
 812                         "bdb_modrdn: txn_begin(2) failed: %s (%d)\n",
 813                         db_strerror(rs->sr_err), rs->sr_err, 0 );
 814 #endif
 815                 rs->sr_err = LDAP_OTHER;
 816                 rs->sr_text = "internal error";
 817                 goto return_results;
 818         }
 819
 820         dummy = *e;
 821         save = e;
 822         e = &dummy;
 823
 824         /* delete old one */
 825         rs->sr_err = bdb_dn2id_delete( op, lt2, eip, e );
 826         if ( rs->sr_err != 0 ) {
 827 #ifdef NEW_LOGGING
 828                 LDAP_LOG ( OPERATION, ERR,
 829                         "<=- bdb_modrdn: dn2id del failed: %s (%d)\n",
 830                         db_strerror(rs->sr_err), rs->sr_err, 0 );
 831 #else
 832                 Debug(LDAP_DEBUG_TRACE,
 833                         "<=- bdb_modrdn: dn2id del failed: %s (%d)\n",
 834                         db_strerror(rs->sr_err), rs->sr_err, 0 );
 835 #endif
 836                 switch( rs->sr_err ) {
 837                 case DB_LOCK_DEADLOCK:
 838                 case DB_LOCK_NOTGRANTED:
 839                         goto retry;
 840                 }
 841                 rs->sr_err = LDAP_OTHER;
 842                 rs->sr_text = "DN index delete fail";
 843                 goto return_results;
 844         }
 845
 846         /* Binary format uses a single contiguous block, cannot
 847          * free individual fields. But if a previous modrdn has
 848          * already happened, must free the names. The frees are
 849          * done in bdb_cache_modrdn().
 850          */
 851         if( e->e_nname.bv_val < e->e_bv.bv_val || e->e_nname.bv_val >
 852                 e->e_bv.bv_val + e->e_bv.bv_len ) {
 853                 e->e_name.bv_val = NULL;
 854                 e->e_nname.bv_val = NULL;
 855         }
 856         e->e_name = new_dn;
 857         e->e_nname = new_ndn;
 858         new_dn.bv_val = NULL;
 859         new_ndn.bv_val = NULL;
 860
 861         /* add new one */
 862         rs->sr_err = bdb_dn2id_add( op, lt2, neip ? neip : eip, e );
 863         if ( rs->sr_err != 0 ) {
 864 #ifdef NEW_LOGGING
 865                 LDAP_LOG ( OPERATION, ERR,
 866                         "<=- bdb_modrdn: dn2id add failed: %s (%d)\n",
 867                         db_strerror(rs->sr_err), rs->sr_err, 0 );
 868 #else
 869                 Debug(LDAP_DEBUG_TRACE,
 870                         "<=- bdb_modrdn: dn2id add failed: %s (%d)\n",
 871                         db_strerror(rs->sr_err), rs->sr_err, 0 );
 872 #endif
 873                 switch( rs->sr_err ) {
 874                 case DB_LOCK_DEADLOCK:
 875                 case DB_LOCK_NOTGRANTED:
 876                         goto retry;
 877                 }
 878                 rs->sr_err = LDAP_OTHER;
 879                 rs->sr_text = "DN index add failed";
 880                 goto return_results;
 881         }
 882
 883         if ( rs->sr_err == LDAP_SUCCESS && !op->o_noop && !op->o_no_psearch ) {
 884                 ldap_pvt_thread_rdwr_rlock( &bdb->bi_pslist_rwlock );
 885                 LDAP_LIST_FOREACH ( ps_list, &bdb->bi_psearch_list, o_ps_link ) {
 886                         bdb_psearch( op, rs, ps_list, e, LDAP_PSEARCH_BY_PREMODIFY );
 887                 }
 888                 ldap_pvt_thread_rdwr_runlock( &bdb->bi_pslist_rwlock );
 889         }
 890
 891         /* modify entry */
 892         rs->sr_err = bdb_modify_internal( op, lt2, &mod[0], e,
 893                 &rs->sr_text, textbuf, textlen );
 894
 895         if( rs->sr_err != LDAP_SUCCESS ) {
 896 #ifdef NEW_LOGGING
 897                 LDAP_LOG ( OPERATION, ERR,
 898                         "<=- bdb_modrdn: modify failed: %s (%d)\n",
 899                         db_strerror(rs->sr_err), rs->sr_err, 0 );
 900 #else
 901                 Debug(LDAP_DEBUG_TRACE,
 902                         "<=- bdb_modrdn: modify failed: %s (%d)\n",
 903                         db_strerror(rs->sr_err), rs->sr_err, 0 );
 904 #endif
 905                 if ( ( rs->sr_err == LDAP_INSUFFICIENT_ACCESS ) && opinfo.boi_err ) {
 906                         rs->sr_err = opinfo.boi_err;
 907                 }
 908                 switch( rs->sr_err ) {
 909                 case DB_LOCK_DEADLOCK:
 910                 case DB_LOCK_NOTGRANTED:
 911                         goto retry;
 912                 }
 913                 goto return_results;
 914         }
 915
 916         if( op->o_postread ) {
 917                 if( slap_read_controls( op, rs, e,
 918                         &slap_post_read_bv, &ctrls[num_ctrls] ) )
 919                 {
 920 #ifdef NEW_LOGGING
 921                         LDAP_LOG ( OPERATION, DETAIL1,
 922                                 "<=- bdb_modrdn: post-read failed!\n", 0, 0, 0 );
 923 #else
 924                         Debug( LDAP_DEBUG_TRACE,
 925                                 "<=- bdb_modrdn: post-read failed!\n", 0, 0, 0 );
 926 #endif
 927                         goto return_results;
 928                 }
 929                 ctrls[++num_ctrls] = NULL;
 930                 op->o_postread = 0;  /* prevent redo on retry */
 931                 /* FIXME: should read entry on the last retry */
 932         }
 933
 934         /* id2entry index */
 935         rs->sr_err = bdb_id2entry_update( op->o_bd, lt2, e );
 936         if ( rs->sr_err != 0 ) {
 937 #ifdef NEW_LOGGING
 938                 LDAP_LOG ( OPERATION, ERR,
 939                         "<=- bdb_modrdn: id2entry failed: %s (%d)\n",
 940                         db_strerror(rs->sr_err), rs->sr_err, 0 );
 941 #else
 942                 Debug(LDAP_DEBUG_TRACE,
 943                         "<=- bdb_modrdn: id2entry failed: %s (%d)\n",
 944                         db_strerror(rs->sr_err), rs->sr_err, 0 );
 945 #endif
 946                 switch( rs->sr_err ) {
 947                 case DB_LOCK_DEADLOCK:
 948                 case DB_LOCK_NOTGRANTED:
 949                         goto retry;
 950                 }
 951                 rs->sr_err = LDAP_OTHER;
 952                 rs->sr_text = "entry update failed";
 953                 goto return_results;
 954         }
 955         if ( TXN_COMMIT( lt2, 0 ) != 0 ) {
 956                 rs->sr_err = LDAP_OTHER;
 957                 rs->sr_text = "txn_commit(2) failed";
 958                 goto return_results;
 959         }
 960
 961         if ( LDAP_STAILQ_EMPTY( &op->o_bd->be_syncinfo )) {
 962                 rc = bdb_csn_commit( op, rs, ltid, ei, &suffix_ei,
 963                         &ctxcsn_e, &ctxcsn_added, locker );
 964                 switch ( rc ) {
 965                 case BDB_CSN_ABORT :
 966                         goto return_results;
 967                 case BDB_CSN_RETRY :
 968                         goto retry;
 969                 }
 970         }
 971
 972         if( op->o_noop ) {
 973                 if(( rs->sr_err=TXN_ABORT( ltid )) != 0 ) {
 974                         rs->sr_text = "txn_abort (no-op) failed";
 975                 } else {
 976                         rs->sr_err = LDAP_SUCCESS;
 977                         goto return_results;
 978                 }
 979
 980         } else {
 981                 bdb_cache_modrdn( save, &op->orr_nnewrdn, e, neip,
 982                         bdb->bi_dbenv, locker, &lock );
 983
 984                 if ( LDAP_STAILQ_EMPTY( &op->o_bd->be_syncinfo )) {
 985                         if ( ctxcsn_added ) {
 986                                 bdb_cache_add( bdb, suffix_ei, ctxcsn_e,
 987                                         (struct berval *)&slap_ldapsync_cn_bv, locker );
 988                         }
 989                 }
 990
 991                 if ( rs->sr_err == LDAP_SUCCESS ) {
 992                         /* Loop through in-scope entries for each psearch spec */
 993                         ldap_pvt_thread_rdwr_rlock( &bdb->bi_pslist_rwlock );
 994                         LDAP_LIST_FOREACH ( ps_list, &bdb->bi_psearch_list, o_ps_link ) {
 995                                 bdb_psearch( op, rs, ps_list, e, LDAP_PSEARCH_BY_MODIFY );
 996                         }
 997                         ldap_pvt_thread_rdwr_runlock( &bdb->bi_pslist_rwlock );
 998                         pm_list = LDAP_LIST_FIRST(&op->o_pm_list);
 999                         while ( pm_list != NULL ) {
1000                                 bdb_psearch(op, rs, pm_list->ps_op,
1001                                                         e, LDAP_PSEARCH_BY_SCOPEOUT);
1002                                 pm_prev = pm_list;
1003                                 LDAP_LIST_REMOVE ( pm_list, ps_link );
1004                                 pm_list = LDAP_LIST_NEXT ( pm_list, ps_link );
1005                                 ch_free( pm_prev );
1006                         }
1007                 }
1008
1009                 if(( rs->sr_err=TXN_COMMIT( ltid, 0 )) != 0 ) {
1010                         rs->sr_text = "txn_commit failed";
1011                 } else {
1012                         rs->sr_err = LDAP_SUCCESS;
1013                 }
1014         }
1015
1016         ltid = NULL;
1017         op->o_private = NULL;
1018
1019         if( rs->sr_err != LDAP_SUCCESS ) {
1020 #ifdef NEW_LOGGING
1021                 LDAP_LOG ( OPERATION, RESULTS, "bdb_modrdn: %s : %s (%d)\n",
1022                         rs->sr_text, db_strerror(rs->sr_err), rs->sr_err );
1023 #else
1024                 Debug( LDAP_DEBUG_TRACE, "bdb_add: %s : %s (%d)\n",
1025                         rs->sr_text, db_strerror(rs->sr_err), rs->sr_err );
1026 #endif
1027                 rs->sr_err = LDAP_OTHER;
1028
1029                 goto return_results;
1030         }
1031
1032 #ifdef NEW_LOGGING
1033         LDAP_LOG ( OPERATION, RESULTS,
1034                 "bdb_modrdn: rdn modified%s id=%08lx dn=\"%s\"\n",
1035                 op->o_noop ? " (no-op)" : "",
1036                 e->e_id, e->e_dn );
1037 #else
1038         Debug(LDAP_DEBUG_TRACE,
1039                 "bdb_modrdn: rdn modified%s id=%08lx dn=\"%s\"\n",
1040                 op->o_noop ? " (no-op)" : "",
1041                 e->e_id, e->e_dn );
1042 #endif
1043         rs->sr_text = NULL;
1044         if( num_ctrls ) rs->sr_ctrls = ctrls;
1045
1046 return_results:
1047         send_ldap_result( op, rs );
1048
1049         if( rs->sr_err == LDAP_SUCCESS && bdb->bi_txn_cp ) {
1050                 ldap_pvt_thread_yield();
1051                 TXN_CHECKPOINT( bdb->bi_dbenv,
1052                         bdb->bi_txn_cp_kbyte, bdb->bi_txn_cp_min, 0 );
1053         }
1054
1055 done:
1056         if( new_dn.bv_val != NULL ) free( new_dn.bv_val );
1057         if( new_ndn.bv_val != NULL ) free( new_ndn.bv_val );
1058
1059         /* LDAP v2 supporting correct attribute handling. */
1060         if ( new_rdn != NULL ) {
1061                 ldap_rdnfree_x( new_rdn, op->o_tmpmemctx );
1062         }
1063         if ( old_rdn != NULL ) {
1064                 ldap_rdnfree_x( old_rdn, op->o_tmpmemctx );
1065         }
1066         if( mod != NULL ) {
1067                 Modifications *tmp;
1068                 for (; mod; mod=tmp ) {
1069                         tmp = mod->sml_next;
1070                         /* slap_modrdn2mods does things one way,
1071                          * slap_mods_opattrs does it differently
1072                          */
1073                         if ( mod->sml_op != SLAP_MOD_SOFTADD &&
1074                                 mod->sml_op != LDAP_MOD_DELETE ) break;
1075                         if ( mod->sml_nvalues ) free( mod->sml_nvalues[0].bv_val );
1076                         free( mod );
1077                 }
1078                 slap_mods_free( mod );
1079         }
1080
1081         /* LDAP v3 Support */
1082         if( np != NULL ) {
1083                 /* free new parent and reader lock */
1084                 bdb_unlocked_cache_return_entry_r(&bdb->bi_cache, np);
1085         }
1086
1087         if( p != NULL ) {
1088                 /* free parent and reader lock */
1089                 bdb_unlocked_cache_return_entry_r(&bdb->bi_cache, p);
1090         }
1091
1092         /* free entry */
1093         if( e != NULL ) {
1094                 bdb_unlocked_cache_return_entry_w( &bdb->bi_cache, e);
1095         }
1096
1097         if( ltid != NULL ) {
1098                 pm_list = LDAP_LIST_FIRST(&op->o_pm_list);
1099                 while ( pm_list != NULL ) {
1100                         LDAP_LIST_REMOVE ( pm_list, ps_link );
1101                         pm_prev = pm_list;
1102                         pm_list = LDAP_LIST_NEXT ( pm_list, ps_link );
1103                         ch_free( pm_prev );
1104                 }
1105                 TXN_ABORT( ltid );
1106                 op->o_private = NULL;
1107         }
1108
1109         return rs->sr_err;
1110 }