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

   1 /* add.c - ldap BerkeleyDB back-end add routine */
   2 /* $OpenLDAP$ */
   3 /*
   4  * Copyright 1998-2003 The OpenLDAP Foundation, All Rights Reserved.
   5  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   6  */
   7
   8 #include "portable.h"
   9
  10 #include <stdio.h>
  11 #include <ac/string.h>
  12
  13 #include "back-bdb.h"
  14 #include "external.h"
  15
  16 int
  17 bdb_add(Operation *op, SlapReply *rs )
  18 {
  19         struct bdb_info *bdb = (struct bdb_info *) op->o_bd->be_private;
  20         struct berval   pdn;
  21         Entry           *p;
  22         EntryInfo       *ei;
  23         char textbuf[SLAP_TEXT_BUFLEN];
  24         size_t textlen = sizeof textbuf;
  25         AttributeDescription *children = slap_schema.si_ad_children;
  26         AttributeDescription *entry = slap_schema.si_ad_entry;
  27         DB_TXN          *ltid = NULL, *lt2;
  28         struct bdb_op_info opinfo;
  29 #ifdef BDB_SUBENTRIES
  30         int subentry;
  31 #endif
  32         u_int32_t       locker = 0;
  33         DB_LOCK         lock;
  34         int             noop = 0;
  35
  36         int             num_retries = 0;
  37
  38         Operation* ps_list;
  39         int             rc;
  40         EntryInfo       *suffix_ei;
  41         Entry           *ctxcsn_e;
  42         int                     ctxcsn_added = 0;
  43
  44 #ifdef NEW_LOGGING
  45         LDAP_LOG ( OPERATION, ARGS, "==> bdb_add: %s\n", op->oq_add.rs_e->e_name.bv_val, 0, 0 );
  46 #else
  47         Debug(LDAP_DEBUG_ARGS, "==> bdb_add: %s\n", op->oq_add.rs_e->e_name.bv_val, 0, 0);
  48 #endif
  49
  50         /* check entry's schema */
  51         rs->sr_err = entry_schema_check( op->o_bd, op->oq_add.rs_e, NULL, &rs->sr_text, textbuf, textlen );
  52         if ( rs->sr_err != LDAP_SUCCESS ) {
  53 #ifdef NEW_LOGGING
  54         LDAP_LOG ( OPERATION, ERR,
  55                 "bdb_add: entry failed schema check: %s (%d)\n", rs->sr_text, rs->sr_err, 0 );
  56 #else
  57                 Debug( LDAP_DEBUG_TRACE,
  58                         "bdb_add: entry failed schema check: %s (%d)\n",
  59                         rs->sr_text, rs->sr_err, 0 );
  60 #endif
  61                 goto return_results;
  62         }
  63
  64 #ifdef BDB_SUBENTRIES
  65         subentry = is_entry_subentry( op->oq_add.rs_e );
  66 #endif
  67
  68         /*
  69          * acquire an ID outside of the operation transaction
  70          * to avoid serializing adds.
  71          */
  72         rs->sr_err = bdb_next_id( op->o_bd, NULL, &op->oq_add.rs_e->e_id );
  73         if( rs->sr_err != 0 ) {
  74 #ifdef NEW_LOGGING
  75                 LDAP_LOG ( OPERATION, ERR,
  76                         "bdb_add: next_id failed (%d)\n", rs->sr_err, 0, 0 );
  77 #else
  78                 Debug( LDAP_DEBUG_TRACE,
  79                         "bdb_add: next_id failed (%d)\n", rs->sr_err, 0, 0 );
  80 #endif
  81                 rs->sr_err = LDAP_OTHER;
  82                 rs->sr_text = "internal error";
  83                 goto return_results;
  84         }
  85
  86         if( 0 ) {
  87 retry:  /* transaction retry */
  88                 if( p ) {
  89                         /* free parent and reader lock */
  90                         bdb_unlocked_cache_return_entry_r( &bdb->bi_cache, p );
  91                         p = NULL;
  92                 }
  93                 rs->sr_err = TXN_ABORT( ltid );
  94                 ltid = NULL;
  95                 op->o_private = NULL;
  96                 op->o_do_not_cache = opinfo.boi_acl_cache;
  97                 if( rs->sr_err != 0 ) {
  98                         rs->sr_err = LDAP_OTHER;
  99                         rs->sr_text = "internal error";
 100                         goto return_results;
 101                 }
 102                 bdb_trans_backoff( ++num_retries );
 103                 ldap_pvt_thread_yield();
 104         }
 105
 106         /* begin transaction */
 107         rs->sr_err = TXN_BEGIN( bdb->bi_dbenv, NULL, &ltid,
 108                 bdb->bi_db_opflags );
 109         rs->sr_text = NULL;
 110         if( rs->sr_err != 0 ) {
 111 #ifdef NEW_LOGGING
 112                 LDAP_LOG ( OPERATION, ERR,
 113                         "bdb_add: txn_begin failed: %s (%d)\n", db_strerror(rs->sr_err), rs->sr_err, 0 );
 114 #else
 115                 Debug( LDAP_DEBUG_TRACE,
 116                         "bdb_add: txn_begin failed: %s (%d)\n",
 117                         db_strerror(rs->sr_err), rs->sr_err, 0 );
 118 #endif
 119                 rs->sr_err = LDAP_OTHER;
 120                 rs->sr_text = "internal error";
 121                 goto return_results;
 122         }
 123
 124         locker = TXN_ID ( ltid );
 125
 126         opinfo.boi_bdb = op->o_bd;
 127         opinfo.boi_txn = ltid;
 128         opinfo.boi_locker = locker;
 129         opinfo.boi_err = 0;
 130         opinfo.boi_acl_cache = op->o_do_not_cache;
 131         op->o_private = &opinfo;
 132
 133         /*
 134          * Get the parent dn and see if the corresponding entry exists.
 135          * If the parent does not exist, only allow the "root" user to
 136          * add the entry.
 137          */
 138         if ( be_issuffix( op->o_bd, &op->oq_add.rs_e->e_nname ) ) {
 139                 pdn = slap_empty_bv;
 140         } else {
 141                 dnParent( &op->oq_add.rs_e->e_nname, &pdn );
 142         }
 143
 144         /* get entry or parent */
 145         rs->sr_err = bdb_dn2entry( op, ltid, &op->ora_e->e_nname, &ei,
 146                 1, locker, &lock );
 147         switch( rs->sr_err ) {
 148         case 0:
 149                 rs->sr_err = LDAP_ALREADY_EXISTS;
 150                 goto return_results;
 151         case DB_NOTFOUND:
 152                 break;
 153         case DB_LOCK_DEADLOCK:
 154         case DB_LOCK_NOTGRANTED:
 155                 goto retry;
 156         case LDAP_BUSY:
 157                 rs->sr_text = "ldap server busy";
 158                 goto return_results;
 159         default:
 160                 rs->sr_err = LDAP_OTHER;
 161                 rs->sr_text = "internal error";
 162                 goto return_results;
 163         }
 164
 165         p = ei->bei_e;
 166         if ( p ) {
 167                 if ( !bvmatch( &pdn, &p->e_nname ) ) {
 168                         rs->sr_matched = ber_strdup_x( p->e_name.bv_val,
 169                                 op->o_tmpmemctx );
 170                         rs->sr_ref = is_entry_referral( p )
 171                                 ? get_entry_referrals( op, p )
 172                                 : NULL;
 173                         bdb_unlocked_cache_return_entry_r( &bdb->bi_cache, p );
 174                         p = NULL;
 175 #ifdef NEW_LOGGING
 176                         LDAP_LOG ( OPERATION, DETAIL1,
 177                                 "bdb_add: parent does not exist\n", 0, 0, 0 );
 178 #else
 179                         Debug( LDAP_DEBUG_TRACE, "bdb_add: parent does not exist\n",
 180                                 0, 0, 0 );
 181 #endif
 182
 183                         rs->sr_err = LDAP_REFERRAL;
 184                         send_ldap_result( op, rs );
 185
 186                         ber_bvarray_free( rs->sr_ref );
 187                         op->o_tmpfree( (char *)rs->sr_matched, op->o_tmpmemctx );
 188                         rs->sr_ref = NULL;
 189                         rs->sr_matched = NULL;
 190
 191                         goto done;
 192                 }
 193
 194                 rs->sr_err = access_allowed( op, p,
 195                         children, NULL, ACL_WRITE, NULL );
 196
 197                 if ( ! rs->sr_err ) {
 198                         switch( opinfo.boi_err ) {
 199                         case DB_LOCK_DEADLOCK:
 200                         case DB_LOCK_NOTGRANTED:
 201                                 goto retry;
 202                         }
 203
 204 #ifdef NEW_LOGGING
 205                         LDAP_LOG ( OPERATION, DETAIL1,
 206                                 "bdb_add: no write access to parent\n", 0, 0, 0 );
 207 #else
 208                         Debug( LDAP_DEBUG_TRACE, "bdb_add: no write access to parent\n",
 209                                 0, 0, 0 );
 210 #endif
 211                         rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
 212                         rs->sr_text = "no write access to parent";
 213                         goto return_results;;
 214                 }
 215
 216 #ifdef BDB_SUBENTRIES
 217                 if ( is_entry_subentry( p ) ) {
 218                         /* parent is a subentry, don't allow add */
 219 #ifdef NEW_LOGGING
 220                         LDAP_LOG ( OPERATION, DETAIL1,
 221                                 "bdb_add: parent is subentry\n", 0, 0, 0 );
 222 #else
 223                         Debug( LDAP_DEBUG_TRACE, "bdb_add: parent is subentry\n",
 224                                 0, 0, 0 );
 225 #endif
 226                         rs->sr_err = LDAP_OBJECT_CLASS_VIOLATION;
 227                         rs->sr_text = "parent is a subentry";
 228                         goto return_results;;
 229                 }
 230 #endif
 231 #ifdef BDB_ALIASES
 232                 if ( is_entry_alias( p ) ) {
 233                         /* parent is an alias, don't allow add */
 234 #ifdef NEW_LOGGING
 235                         LDAP_LOG ( OPERATION, DETAIL1,
 236                                 "bdb_add: parent is alias\n", 0, 0, 0 );
 237 #else
 238                         Debug( LDAP_DEBUG_TRACE, "bdb_add: parent is alias\n",
 239                                 0, 0, 0 );
 240 #endif
 241                         rs->sr_err = LDAP_ALIAS_PROBLEM;
 242                         rs->sr_text = "parent is an alias";
 243                         goto return_results;;
 244                 }
 245 #endif
 246
 247                 if ( is_entry_referral( p ) ) {
 248                         /* parent is a referral, don't allow add */
 249                         rs->sr_matched = p->e_name.bv_val;
 250                         rs->sr_ref = get_entry_referrals( op, p );
 251
 252 #ifdef NEW_LOGGING
 253                         LDAP_LOG ( OPERATION, DETAIL1,
 254                                 "bdb_add: parent is referral\n", 0, 0, 0 );
 255 #else
 256                         Debug( LDAP_DEBUG_TRACE, "bdb_add: parent is referral\n",
 257                                 0, 0, 0 );
 258 #endif
 259
 260                         rs->sr_err = LDAP_REFERRAL;
 261                         send_ldap_result( op, rs );
 262
 263                         ber_bvarray_free( rs->sr_ref );
 264                         bdb_unlocked_cache_return_entry_r( &bdb->bi_cache, p );
 265                         rs->sr_ref = NULL;
 266                         rs->sr_matched = NULL;
 267                         p = NULL;
 268                         goto done;
 269                 }
 270
 271 #ifdef BDB_SUBENTRIES
 272                 if ( subentry ) {
 273                         /* FIXME: */
 274                         /* parent must be an administrative point of the required kind */
 275                 }
 276 #endif
 277
 278                 /* free parent and reader lock */
 279                 bdb_unlocked_cache_return_entry_r( &bdb->bi_cache, p );
 280                 p = NULL;
 281
 282         } else {
 283                 /*
 284                  * no parent!
 285                  *      must be adding entry at suffix or with parent ""
 286                  */
 287                 if ( !be_isroot( op->o_bd, &op->o_ndn )) {
 288                         if ( be_issuffix( op->o_bd, (struct berval *)&slap_empty_bv )
 289                                 || be_isupdate( op->o_bd, &op->o_ndn ) )
 290                         {
 291                                 p = (Entry *)&slap_entry_root;
 292
 293                                 /* check parent for "children" acl */
 294                                 rs->sr_err = access_allowed( op, p,
 295                                         children, NULL, ACL_WRITE, NULL );
 296
 297                                 p = NULL;
 298
 299                                 if ( ! rs->sr_err ) {
 300                                         switch( opinfo.boi_err ) {
 301                                         case DB_LOCK_DEADLOCK:
 302                                         case DB_LOCK_NOTGRANTED:
 303                                                 goto retry;
 304                                         }
 305
 306 #ifdef NEW_LOGGING
 307                                         LDAP_LOG ( OPERATION, DETAIL1,
 308                                                 "bdb_add: no write access to parent\n", 0, 0, 0 );
 309 #else
 310                                         Debug( LDAP_DEBUG_TRACE,
 311                                                 "bdb_add: no write access to parent\n",
 312                                                 0, 0, 0 );
 313 #endif
 314                                         rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
 315                                         rs->sr_text = "no write access to parent";
 316                                         goto return_results;
 317                                 }
 318                         } else if ( !is_entry_glue( op->oq_add.rs_e )) {
 319 #ifdef NEW_LOGGING
 320                                 LDAP_LOG ( OPERATION, DETAIL1, "bdb_add: %s denied\n",
 321                                         pdn.bv_len == 0 ? "suffix" : "entry at root", 0, 0 );
 322 #else
 323                                 Debug( LDAP_DEBUG_TRACE, "bdb_add: %s denied\n",
 324                                         pdn.bv_len == 0 ? "suffix" : "entry at root",
 325                                         0, 0 );
 326 #endif
 327                                 rs->sr_err = LDAP_NO_SUCH_OBJECT;
 328                                 goto return_results;
 329                         }
 330                 }
 331
 332 #ifdef BDB_SUBENTRIES
 333                 if( subentry ) {
 334 #ifdef NEW_LOGGING
 335                         LDAP_LOG ( OPERATION, DETAIL1,
 336                                 "bdb_add: no parent, cannot add subentry\n", 0, 0, 0 );
 337 #else
 338                         Debug( LDAP_DEBUG_TRACE,
 339                                 "bdb_add: no parent, cannot add subentry\n",
 340                                 0, 0, 0 );
 341 #endif
 342                         rs->sr_err = LDAP_NO_SUCH_OBJECT;
 343                         rs->sr_text = "no parent, cannot add subentry";
 344                         goto return_results;
 345                 }
 346 #endif
 347         }
 348
 349         if ( get_assert( op ) &&
 350                 ( test_filter( op, op->oq_add.rs_e, get_assertion( op ))
 351                         != LDAP_COMPARE_TRUE ))
 352         {
 353                 rs->sr_err = LDAP_ASSERTION_FAILED;
 354                 goto return_results;
 355         }
 356
 357         rs->sr_err = access_allowed( op, op->oq_add.rs_e,
 358                 entry, NULL, ACL_WRITE, NULL );
 359
 360         if ( ! rs->sr_err ) {
 361                 switch( opinfo.boi_err ) {
 362                 case DB_LOCK_DEADLOCK:
 363                 case DB_LOCK_NOTGRANTED:
 364                         goto retry;
 365                 }
 366
 367 #ifdef NEW_LOGGING
 368                 LDAP_LOG ( OPERATION, DETAIL1,
 369                         "bdb_add: no write access to entry\n", 0, 0, 0 );
 370 #else
 371                 Debug( LDAP_DEBUG_TRACE, "bdb_add: no write access to entry\n",
 372                         0, 0, 0 );
 373 #endif
 374                 rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
 375                 rs->sr_text = "no write access to entry";
 376                 goto return_results;;
 377         }
 378
 379         /* nested transaction */
 380         rs->sr_err = TXN_BEGIN( bdb->bi_dbenv, ltid, &lt2,
 381                 bdb->bi_db_opflags );
 382         rs->sr_text = NULL;
 383         if( rs->sr_err != 0 ) {
 384 #ifdef NEW_LOGGING
 385                 LDAP_LOG ( OPERATION, ERR,
 386                         "bdb_add: txn_begin(2) failed: %s (%d)\n", db_strerror(rs->sr_err), rs->sr_err, 0 );
 387 #else
 388                 Debug( LDAP_DEBUG_TRACE,
 389                         "bdb_add: txn_begin(2) failed: %s (%d)\n",
 390                         db_strerror(rs->sr_err), rs->sr_err, 0 );
 391 #endif
 392                 rs->sr_err = LDAP_OTHER;
 393                 rs->sr_text = "internal error";
 394                 goto return_results;
 395         }
 396
 397         /* dn2id index */
 398         rs->sr_err = bdb_dn2id_add( op, lt2, ei, op->oq_add.rs_e );
 399         if ( rs->sr_err != 0 ) {
 400 #ifdef NEW_LOGGING
 401                 LDAP_LOG ( OPERATION, ERR,
 402                         "bdb_add: dn2id_add failed: %s (%d)\n", db_strerror(rs->sr_err), rs->sr_err, 0 );
 403 #else
 404                 Debug( LDAP_DEBUG_TRACE, "bdb_add: dn2id_add failed: %s (%d)\n",
 405                         db_strerror(rs->sr_err), rs->sr_err, 0 );
 406 #endif
 407
 408                 switch( rs->sr_err ) {
 409                 case DB_LOCK_DEADLOCK:
 410                 case DB_LOCK_NOTGRANTED:
 411                         goto retry;
 412                 case DB_KEYEXIST:
 413                         rs->sr_err = LDAP_ALREADY_EXISTS;
 414                         break;
 415                 default:
 416                         rs->sr_err = LDAP_OTHER;
 417                 }
 418                 goto return_results;
 419         }
 420
 421         /* id2entry index */
 422         rs->sr_err = bdb_id2entry_add( op->o_bd, lt2, op->oq_add.rs_e );
 423         if ( rs->sr_err != 0 ) {
 424 #ifdef NEW_LOGGING
 425                 LDAP_LOG ( OPERATION, ERR, "bdb_add: id2entry_add failed\n", 0, 0, 0 );
 426 #else
 427                 Debug( LDAP_DEBUG_TRACE, "bdb_add: id2entry_add failed\n",
 428                         0, 0, 0 );
 429 #endif
 430                 switch( rs->sr_err ) {
 431                 case DB_LOCK_DEADLOCK:
 432                 case DB_LOCK_NOTGRANTED:
 433                         goto retry;
 434                 default:
 435                         rs->sr_err = LDAP_OTHER;
 436                 }
 437                 rs->sr_text = "entry store failed";
 438                 goto return_results;
 439         }
 440
 441         /* attribute indexes */
 442         rs->sr_err = bdb_index_entry_add( op, lt2, op->oq_add.rs_e );
 443         if ( rs->sr_err != LDAP_SUCCESS ) {
 444 #ifdef NEW_LOGGING
 445                 LDAP_LOG ( OPERATION, ERR,
 446                         "bdb_add: index_entry_add failed\n", 0, 0, 0 );
 447 #else
 448                 Debug( LDAP_DEBUG_TRACE, "bdb_add: index_entry_add failed\n",
 449                         0, 0, 0 );
 450 #endif
 451                 switch( rs->sr_err ) {
 452                 case DB_LOCK_DEADLOCK:
 453                 case DB_LOCK_NOTGRANTED:
 454                         goto retry;
 455                 default:
 456                         rs->sr_err = LDAP_OTHER;
 457                 }
 458                 rs->sr_text = "index generation failed";
 459                 goto return_results;
 460         }
 461         if ( TXN_COMMIT( lt2, 0 ) != 0 ) {
 462                 rs->sr_err = LDAP_OTHER;
 463                 rs->sr_text = "txn_commit(2) failed";
 464                 goto return_results;
 465         }
 466
 467         if ( !op->o_bd->syncinfo ) {
 468                 rc = bdb_csn_commit( op, rs, ltid, ei, &suffix_ei, &ctxcsn_e, &ctxcsn_added, locker );
 469                 switch ( rc ) {
 470                 case BDB_CSN_ABORT :
 471                         goto return_results;
 472                 case BDB_CSN_RETRY :
 473                         goto retry;
 474                 }
 475         }
 476
 477         if ( op->o_noop ) {
 478                 if (( rs->sr_err=TXN_ABORT( ltid )) != 0 ) {
 479                         rs->sr_text = "txn_abort (no-op) failed";
 480                 } else {
 481                         noop = 1;
 482                         rs->sr_err = LDAP_SUCCESS;
 483                 }
 484
 485         } else {
 486                 char gid[DB_XIDDATASIZE];
 487
 488                 snprintf( gid, sizeof( gid ), "%s-%08lx-%08lx",
 489                         bdb_uuid.bv_val, (long) op->o_connid, (long) op->o_opid );
 490
 491                 if (( rs->sr_err=TXN_PREPARE( ltid, gid )) != 0 ) {
 492                         rs->sr_text = "txn_prepare failed";
 493
 494                 } else {
 495                         struct berval nrdn;
 496                         struct berval ctx_nrdn;
 497
 498                         if (pdn.bv_len) {
 499                                 nrdn.bv_val = op->ora_e->e_nname.bv_val;
 500                                 nrdn.bv_len = pdn.bv_val - nrdn.bv_val - 1;
 501                         } else {
 502                                 nrdn = op->ora_e->e_nname;
 503                         }
 504
 505                         bdb_cache_add( bdb, ei, op->oq_add.rs_e, &nrdn, locker );
 506
 507                         if ( suffix_ei == NULL ) {
 508                                 suffix_ei = op->oq_add.rs_e->e_private;
 509                         }
 510
 511                         if ( !op->o_bd->syncinfo ) {
 512                                 if ( ctxcsn_added ) {
 513                                         ctx_nrdn.bv_val = "cn=ldapsync";
 514                                         ctx_nrdn.bv_len = strlen( ctx_nrdn.bv_val );
 515                                         bdb_cache_add( bdb, suffix_ei, ctxcsn_e, &ctx_nrdn, locker );
 516                                 }
 517                         }
 518
 519                         if(( rs->sr_err=TXN_COMMIT( ltid, 0 )) != 0 ) {
 520                                 rs->sr_text = "txn_commit failed";
 521                         } else {
 522                                 rs->sr_err = LDAP_SUCCESS;
 523                         }
 524                 }
 525         }
 526
 527         ltid = NULL;
 528         op->o_private = NULL;
 529
 530         if (rs->sr_err == LDAP_SUCCESS) {
 531 #ifdef NEW_LOGGING
 532                 LDAP_LOG ( OPERATION, RESULTS,
 533                         "bdb_add: added%s id=%08lx dn=\"%s\"\n",
 534                         op->o_noop ? " (no-op)" : "", op->oq_add.rs_e->e_id, op->oq_add.rs_e->e_dn );
 535 #else
 536                 Debug(LDAP_DEBUG_TRACE, "bdb_add: added%s id=%08lx dn=\"%s\"\n",
 537                         op->o_noop ? " (no-op)" : "", op->oq_add.rs_e->e_id, op->oq_add.rs_e->e_dn );
 538 #endif
 539                 rs->sr_text = NULL;
 540         }
 541         else {
 542 #ifdef NEW_LOGGING
 543                 LDAP_LOG ( OPERATION, ERR,
 544                         "bdb_add: %s : %s (%d)\n",  rs->sr_text, db_strerror(rs->sr_err), rs->sr_err );
 545 #else
 546                 Debug( LDAP_DEBUG_TRACE, "bdb_add: %s : %s (%d)\n",
 547                         rs->sr_text, db_strerror(rs->sr_err), rs->sr_err );
 548 #endif
 549                 rs->sr_err = LDAP_OTHER;
 550         }
 551
 552 return_results:
 553         send_ldap_result( op, rs );
 554
 555         if ( rs->sr_err == LDAP_SUCCESS && !noop ) {
 556                 LDAP_LIST_FOREACH ( ps_list, &bdb->bi_psearch_list, o_ps_link ) {
 557                         bdb_psearch( op, rs, ps_list, op->oq_add.rs_e, LDAP_PSEARCH_BY_ADD );
 558                 }
 559         }
 560
 561         if( rs->sr_err == LDAP_SUCCESS && bdb->bi_txn_cp ) {
 562                 ldap_pvt_thread_yield();
 563                 TXN_CHECKPOINT( bdb->bi_dbenv,
 564                         bdb->bi_txn_cp_kbyte, bdb->bi_txn_cp_min, 0 );
 565         }
 566
 567 done:
 568
 569         if( ltid != NULL ) {
 570                 TXN_ABORT( ltid );
 571                 op->o_private = NULL;
 572         }
 573
 574         return ( ( rs->sr_err == LDAP_SUCCESS ) ? noop : rs->sr_err );
 575 }