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          */
 139         if ( be_issuffix( op->o_bd, &op->oq_add.rs_e->e_nname ) ) {
 140                 pdn = slap_empty_bv;
 141         } else {
 142                 dnParent( &op->oq_add.rs_e->e_nname, &pdn );
 143         }
 144
 145         /* get entry or parent */
 146         rs->sr_err = bdb_dn2entry( op, ltid, &op->ora_e->e_nname, &ei,
 147                 1, locker, &lock );
 148         switch( rs->sr_err ) {
 149         case 0:
 150                 rs->sr_err = LDAP_ALREADY_EXISTS;
 151                 goto return_results;
 152         case DB_NOTFOUND:
 153                 break;
 154         case DB_LOCK_DEADLOCK:
 155         case DB_LOCK_NOTGRANTED:
 156                 goto retry;
 157         case LDAP_BUSY:
 158                 rs->sr_text = "ldap server busy";
 159                 goto return_results;
 160         default:
 161                 rs->sr_err = LDAP_OTHER;
 162                 rs->sr_text = "internal error";
 163                 goto return_results;
 164         }
 165
 166         p = ei->bei_e;
 167         if ( p ) {
 168                 if ( !bvmatch( &pdn, &p->e_nname ) ) {
 169                         rs->sr_matched = ber_strdup_x( p->e_name.bv_val,
 170                                 op->o_tmpmemctx );
 171                         rs->sr_ref = is_entry_referral( p )
 172                                 ? get_entry_referrals( op, p )
 173                                 : NULL;
 174                         bdb_unlocked_cache_return_entry_r( &bdb->bi_cache, p );
 175                         p = NULL;
 176 #ifdef NEW_LOGGING
 177                         LDAP_LOG ( OPERATION, DETAIL1,
 178                                 "bdb_add: parent does not exist\n", 0, 0, 0 );
 179 #else
 180                         Debug( LDAP_DEBUG_TRACE, "bdb_add: parent does not exist\n",
 181                                 0, 0, 0 );
 182 #endif
 183
 184                         rs->sr_err = LDAP_REFERRAL;
 185                         send_ldap_result( op, rs );
 186
 187                         ber_bvarray_free( rs->sr_ref );
 188                         op->o_tmpfree( (char *)rs->sr_matched, op->o_tmpmemctx );
 189                         rs->sr_ref = NULL;
 190                         rs->sr_matched = NULL;
 191
 192                         goto done;
 193                 }
 194
 195                 rs->sr_err = access_allowed( op, p,
 196                         children, NULL, ACL_WRITE, NULL );
 197
 198                 if ( ! rs->sr_err ) {
 199                         switch( opinfo.boi_err ) {
 200                         case DB_LOCK_DEADLOCK:
 201                         case DB_LOCK_NOTGRANTED:
 202                                 goto retry;
 203                         }
 204
 205 #ifdef NEW_LOGGING
 206                         LDAP_LOG ( OPERATION, DETAIL1,
 207                                 "bdb_add: no write access to parent\n", 0, 0, 0 );
 208 #else
 209                         Debug( LDAP_DEBUG_TRACE, "bdb_add: no write access to parent\n",
 210                                 0, 0, 0 );
 211 #endif
 212                         rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
 213                         rs->sr_text = "no write access to parent";
 214                         goto return_results;;
 215                 }
 216
 217 #ifdef BDB_SUBENTRIES
 218                 if ( is_entry_subentry( p ) ) {
 219                         /* parent is a subentry, don't allow add */
 220 #ifdef NEW_LOGGING
 221                         LDAP_LOG ( OPERATION, DETAIL1,
 222                                 "bdb_add: parent is subentry\n", 0, 0, 0 );
 223 #else
 224                         Debug( LDAP_DEBUG_TRACE, "bdb_add: parent is subentry\n",
 225                                 0, 0, 0 );
 226 #endif
 227                         rs->sr_err = LDAP_OBJECT_CLASS_VIOLATION;
 228                         rs->sr_text = "parent is a subentry";
 229                         goto return_results;;
 230                 }
 231 #endif
 232 #ifdef BDB_ALIASES
 233                 if ( is_entry_alias( p ) ) {
 234                         /* parent is an alias, don't allow add */
 235 #ifdef NEW_LOGGING
 236                         LDAP_LOG ( OPERATION, DETAIL1,
 237                                 "bdb_add: parent is alias\n", 0, 0, 0 );
 238 #else
 239                         Debug( LDAP_DEBUG_TRACE, "bdb_add: parent is alias\n",
 240                                 0, 0, 0 );
 241 #endif
 242                         rs->sr_err = LDAP_ALIAS_PROBLEM;
 243                         rs->sr_text = "parent is an alias";
 244                         goto return_results;;
 245                 }
 246 #endif
 247
 248                 if ( is_entry_referral( p ) ) {
 249                         /* parent is a referral, don't allow add */
 250                         rs->sr_matched = p->e_name.bv_val;
 251                         rs->sr_ref = get_entry_referrals( op, p );
 252
 253 #ifdef NEW_LOGGING
 254                         LDAP_LOG ( OPERATION, DETAIL1,
 255                                 "bdb_add: parent is referral\n", 0, 0, 0 );
 256 #else
 257                         Debug( LDAP_DEBUG_TRACE, "bdb_add: parent is referral\n",
 258                                 0, 0, 0 );
 259 #endif
 260
 261                         rs->sr_err = LDAP_REFERRAL;
 262                         send_ldap_result( op, rs );
 263
 264                         ber_bvarray_free( rs->sr_ref );
 265                         bdb_unlocked_cache_return_entry_r( &bdb->bi_cache, p );
 266                         rs->sr_ref = NULL;
 267                         rs->sr_matched = NULL;
 268                         p = NULL;
 269                         goto done;
 270                 }
 271
 272 #ifdef BDB_SUBENTRIES
 273                 if ( subentry ) {
 274                         /* FIXME: */
 275                         /* parent must be an administrative point of the required kind */
 276                 }
 277 #endif
 278
 279                 /* free parent and reader lock */
 280                 bdb_unlocked_cache_return_entry_r( &bdb->bi_cache, p );
 281                 p = NULL;
 282
 283         } else {
 284                 /*
 285                  * no parent!
 286                  *  if not attempting to add entry at suffix or with parent ""
 287                  */
 288                 if (( !be_isroot( op->o_bd, &op->o_ndn ) || pdn.bv_len > 0 )
 289                         && !is_entry_glue( op->oq_add.rs_e ))
 290                 {
 291 #ifdef NEW_LOGGING
 292                         LDAP_LOG ( OPERATION, DETAIL1, "bdb_add: %s denied\n",
 293                                 pdn.bv_len == 0 ? "suffix" : "entry at root", 0, 0 );
 294 #else
 295                         Debug( LDAP_DEBUG_TRACE, "bdb_add: %s denied\n",
 296                                 pdn.bv_len == 0 ? "suffix" : "entry at root",
 297                                 0, 0 );
 298 #endif
 299                         rs->sr_err = LDAP_NO_SUCH_OBJECT;
 300                         goto return_results;
 301                 }
 302         }
 303
 304         if ( get_assert( op ) &&
 305                 ( test_filter( op, op->oq_add.rs_e, get_assertion( op ))
 306                         != LDAP_COMPARE_TRUE ))
 307         {
 308                 rs->sr_err = LDAP_ASSERTION_FAILED;
 309                 goto return_results;
 310         }
 311
 312         rs->sr_err = access_allowed( op, op->oq_add.rs_e,
 313                 entry, NULL, ACL_WRITE, NULL );
 314
 315         if ( ! rs->sr_err ) {
 316                 switch( opinfo.boi_err ) {
 317                 case DB_LOCK_DEADLOCK:
 318                 case DB_LOCK_NOTGRANTED:
 319                         goto retry;
 320                 }
 321
 322 #ifdef NEW_LOGGING
 323                 LDAP_LOG ( OPERATION, DETAIL1,
 324                         "bdb_add: no write access to entry\n", 0, 0, 0 );
 325 #else
 326                 Debug( LDAP_DEBUG_TRACE, "bdb_add: no write access to entry\n",
 327                         0, 0, 0 );
 328 #endif
 329                 rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
 330                 rs->sr_text = "no write access to entry";
 331                 goto return_results;;
 332         }
 333
 334         /* post-read */
 335         if( op->o_postread ) {
 336                 if ( slap_read_controls( op, rs, op->oq_add.rs_e,
 337                         &slap_post_read_bv, &ctrls[num_ctrls] ) )
 338                 {
 339 #ifdef NEW_LOGGING
 340                         LDAP_LOG ( OPERATION, DETAIL1,
 341                                 "<=- bdb_add: post-read failed!\n", 0, 0, 0 );
 342 #else
 343                         Debug( LDAP_DEBUG_TRACE,
 344                                 "<=- bdb_add: post-read failed!\n", 0, 0, 0 );
 345 #endif
 346                         goto return_results;
 347                 }
 348                 ctrls[++num_ctrls] = NULL;
 349         }
 350
 351         /* nested transaction */
 352         rs->sr_err = TXN_BEGIN( bdb->bi_dbenv, ltid, &lt2,
 353                 bdb->bi_db_opflags );
 354         rs->sr_text = NULL;
 355         if( rs->sr_err != 0 ) {
 356 #ifdef NEW_LOGGING
 357                 LDAP_LOG ( OPERATION, ERR,
 358                         "bdb_add: txn_begin(2) failed: %s (%d)\n", db_strerror(rs->sr_err), rs->sr_err, 0 );
 359 #else
 360                 Debug( LDAP_DEBUG_TRACE,
 361                         "bdb_add: txn_begin(2) failed: %s (%d)\n",
 362                         db_strerror(rs->sr_err), rs->sr_err, 0 );
 363 #endif
 364                 rs->sr_err = LDAP_OTHER;
 365                 rs->sr_text = "internal error";
 366                 goto return_results;
 367         }
 368
 369         /* dn2id index */
 370         rs->sr_err = bdb_dn2id_add( op, lt2, ei, op->oq_add.rs_e );
 371         if ( rs->sr_err != 0 ) {
 372 #ifdef NEW_LOGGING
 373                 LDAP_LOG ( OPERATION, ERR,
 374                         "bdb_add: dn2id_add failed: %s (%d)\n", db_strerror(rs->sr_err), rs->sr_err, 0 );
 375 #else
 376                 Debug( LDAP_DEBUG_TRACE, "bdb_add: dn2id_add failed: %s (%d)\n",
 377                         db_strerror(rs->sr_err), rs->sr_err, 0 );
 378 #endif
 379
 380                 switch( rs->sr_err ) {
 381                 case DB_LOCK_DEADLOCK:
 382                 case DB_LOCK_NOTGRANTED:
 383                         goto retry;
 384                 case DB_KEYEXIST:
 385                         rs->sr_err = LDAP_ALREADY_EXISTS;
 386                         break;
 387                 default:
 388                         rs->sr_err = LDAP_OTHER;
 389                 }
 390                 goto return_results;
 391         }
 392
 393         /* id2entry index */
 394         rs->sr_err = bdb_id2entry_add( op->o_bd, lt2, op->oq_add.rs_e );
 395         if ( rs->sr_err != 0 ) {
 396 #ifdef NEW_LOGGING
 397                 LDAP_LOG ( OPERATION, ERR, "bdb_add: id2entry_add failed\n", 0, 0, 0 );
 398 #else
 399                 Debug( LDAP_DEBUG_TRACE, "bdb_add: id2entry_add failed\n",
 400                         0, 0, 0 );
 401 #endif
 402                 switch( rs->sr_err ) {
 403                 case DB_LOCK_DEADLOCK:
 404                 case DB_LOCK_NOTGRANTED:
 405                         goto retry;
 406                 default:
 407                         rs->sr_err = LDAP_OTHER;
 408                 }
 409                 rs->sr_text = "entry store failed";
 410                 goto return_results;
 411         }
 412
 413         /* attribute indexes */
 414         rs->sr_err = bdb_index_entry_add( op, lt2, op->oq_add.rs_e );
 415         if ( rs->sr_err != LDAP_SUCCESS ) {
 416 #ifdef NEW_LOGGING
 417                 LDAP_LOG ( OPERATION, ERR,
 418                         "bdb_add: index_entry_add failed\n", 0, 0, 0 );
 419 #else
 420                 Debug( LDAP_DEBUG_TRACE, "bdb_add: index_entry_add failed\n",
 421                         0, 0, 0 );
 422 #endif
 423                 switch( rs->sr_err ) {
 424                 case DB_LOCK_DEADLOCK:
 425                 case DB_LOCK_NOTGRANTED:
 426                         goto retry;
 427                 default:
 428                         rs->sr_err = LDAP_OTHER;
 429                 }
 430                 rs->sr_text = "index generation failed";
 431                 goto return_results;
 432         }
 433         if ( TXN_COMMIT( lt2, 0 ) != 0 ) {
 434                 rs->sr_err = LDAP_OTHER;
 435                 rs->sr_text = "txn_commit(2) failed";
 436                 goto return_results;
 437         }
 438
 439         if ( !op->o_bd->syncinfo ) {
 440                 rc = bdb_csn_commit( op, rs, ltid, ei, &suffix_ei,
 441                         &ctxcsn_e, &ctxcsn_added, locker );
 442                 switch ( rc ) {
 443                 case BDB_CSN_ABORT :
 444                         goto return_results;
 445                 case BDB_CSN_RETRY :
 446                         goto retry;
 447                 }
 448         }
 449
 450         if ( op->o_noop ) {
 451                 if (( rs->sr_err=TXN_ABORT( ltid )) != 0 ) {
 452                         rs->sr_text = "txn_abort (no-op) failed";
 453                 } else {
 454                         noop = 1;
 455                         rs->sr_err = LDAP_SUCCESS;
 456                 }
 457
 458         } else {
 459                 char gid[DB_XIDDATASIZE];
 460
 461                 memset( gid, 0, sizeof(gid) );
 462                 snprintf( gid, sizeof( gid ), "%s-%08lx-%08lx",
 463                         bdb_uuid.bv_val, (long) op->o_connid, (long) op->o_opid );
 464
 465                 if (( rs->sr_err=TXN_PREPARE( ltid, gid )) != 0 ) {
 466                         rs->sr_text = "txn_prepare failed";
 467
 468                 } else {
 469                         struct berval nrdn;
 470
 471                         if (pdn.bv_len) {
 472                                 nrdn.bv_val = op->ora_e->e_nname.bv_val;
 473                                 nrdn.bv_len = pdn.bv_val - nrdn.bv_val - 1;
 474                         } else {
 475                                 nrdn = op->ora_e->e_nname;
 476                         }
 477
 478                         bdb_cache_add( bdb, ei, op->oq_add.rs_e, &nrdn, locker );
 479
 480                         if ( suffix_ei == NULL ) {
 481                                 suffix_ei = op->oq_add.rs_e->e_private;
 482                         }
 483
 484                         if ( !op->o_bd->syncinfo ) {
 485                                 if ( ctxcsn_added ) {
 486                                         bdb_cache_add( bdb, suffix_ei, ctxcsn_e, (struct berval *)&slap_ldapsync_cn_bv, locker );
 487                                 }
 488                         }
 489
 490                         if(( rs->sr_err=TXN_COMMIT( ltid, 0 )) != 0 ) {
 491                                 rs->sr_text = "txn_commit failed";
 492                         } else {
 493                                 rs->sr_err = LDAP_SUCCESS;
 494                         }
 495                 }
 496         }
 497
 498         ltid = NULL;
 499         op->o_private = NULL;
 500
 501         if (rs->sr_err != LDAP_SUCCESS) {
 502 #ifdef NEW_LOGGING
 503                 LDAP_LOG ( OPERATION, ERR,
 504                         "bdb_add: %s : %s (%d)\n",  rs->sr_text,
 505                                 db_strerror(rs->sr_err), rs->sr_err );
 506 #else
 507                 Debug( LDAP_DEBUG_TRACE, "bdb_add: %s : %s (%d)\n",
 508                         rs->sr_text, db_strerror(rs->sr_err), rs->sr_err );
 509 #endif
 510                 rs->sr_err = LDAP_OTHER;
 511                 goto return_results;
 512         }
 513
 514 #ifdef NEW_LOGGING
 515         LDAP_LOG ( OPERATION, RESULTS,
 516                 "bdb_add: added%s id=%08lx dn=\"%s\"\n",
 517                 op->o_noop ? " (no-op)" : "",
 518                 op->oq_add.rs_e->e_id, op->oq_add.rs_e->e_dn );
 519 #else
 520         Debug(LDAP_DEBUG_TRACE, "bdb_add: added%s id=%08lx dn=\"%s\"\n",
 521                 op->o_noop ? " (no-op)" : "",
 522                 op->oq_add.rs_e->e_id, op->oq_add.rs_e->e_dn );
 523 #endif
 524
 525         rs->sr_text = NULL;
 526         if( num_ctrls ) rs->sr_ctrls = ctrls;
 527
 528 return_results:
 529         send_ldap_result( op, rs );
 530
 531         if ( rs->sr_err == LDAP_SUCCESS && !noop ) {
 532                 LDAP_LIST_FOREACH ( ps_list, &bdb->bi_psearch_list, o_ps_link ) {
 533                         bdb_psearch( op, rs, ps_list, op->oq_add.rs_e, LDAP_PSEARCH_BY_ADD );
 534                 }
 535         }
 536
 537         if( rs->sr_err == LDAP_SUCCESS && bdb->bi_txn_cp ) {
 538                 ldap_pvt_thread_yield();
 539                 TXN_CHECKPOINT( bdb->bi_dbenv,
 540                         bdb->bi_txn_cp_kbyte, bdb->bi_txn_cp_min, 0 );
 541         }
 542
 543 done:
 544         if( ltid != NULL ) {
 545                 TXN_ABORT( ltid );
 546                 op->o_private = NULL;
 547         }
 548
 549         return ( ( rs->sr_err == LDAP_SUCCESS ) ? noop : rs->sr_err );
 550 }