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