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 )
 289                         || !dn_match( &pdn, &slap_empty_bv ))
 290                         && !is_entry_glue( op->oq_add.rs_e ))
 291                 {
 292 #ifdef NEW_LOGGING
 293                         LDAP_LOG ( OPERATION, DETAIL1, "bdb_add: %s denied\n",
 294                                 pdn.bv_len == 0 ? "suffix" : "entry at root", 0, 0 );
 295 #else
 296                         Debug( LDAP_DEBUG_TRACE, "bdb_add: %s denied\n",
 297                                 pdn.bv_len == 0 ? "suffix" : "entry at root",
 298                                 0, 0 );
 299 #endif
 300                         rs->sr_err = LDAP_NO_SUCH_OBJECT;
 301                         goto return_results;
 302                 }
 303         }
 304
 305         if ( get_assert( op ) &&
 306                 ( test_filter( op, op->oq_add.rs_e, get_assertion( op ))
 307                         != LDAP_COMPARE_TRUE ))
 308         {
 309                 rs->sr_err = LDAP_ASSERTION_FAILED;
 310                 goto return_results;
 311         }
 312
 313         rs->sr_err = access_allowed( op, op->oq_add.rs_e,
 314                 entry, NULL, ACL_WRITE, NULL );
 315
 316         if ( ! rs->sr_err ) {
 317                 switch( opinfo.boi_err ) {
 318                 case DB_LOCK_DEADLOCK:
 319                 case DB_LOCK_NOTGRANTED:
 320                         goto retry;
 321                 }
 322
 323 #ifdef NEW_LOGGING
 324                 LDAP_LOG ( OPERATION, DETAIL1,
 325                         "bdb_add: no write access to entry\n", 0, 0, 0 );
 326 #else
 327                 Debug( LDAP_DEBUG_TRACE, "bdb_add: no write access to entry\n",
 328                         0, 0, 0 );
 329 #endif
 330                 rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
 331                 rs->sr_text = "no write access to entry";
 332                 goto return_results;;
 333         }
 334
 335         /* post-read */
 336         if( op->o_postread ) {
 337                 if ( slap_read_controls( op, rs, op->oq_add.rs_e,
 338                         &slap_post_read_bv, &ctrls[num_ctrls] ) )
 339                 {
 340 #ifdef NEW_LOGGING
 341                         LDAP_LOG ( OPERATION, DETAIL1,
 342                                 "<=- bdb_add: post-read failed!\n", 0, 0, 0 );
 343 #else
 344                         Debug( LDAP_DEBUG_TRACE,
 345                                 "<=- bdb_add: post-read failed!\n", 0, 0, 0 );
 346 #endif
 347                         goto return_results;
 348                 }
 349                 ctrls[++num_ctrls] = NULL;
 350         }
 351
 352         /* nested transaction */
 353         rs->sr_err = TXN_BEGIN( bdb->bi_dbenv, ltid, &lt2,
 354                 bdb->bi_db_opflags );
 355         rs->sr_text = NULL;
 356         if( rs->sr_err != 0 ) {
 357 #ifdef NEW_LOGGING
 358                 LDAP_LOG ( OPERATION, ERR,
 359                         "bdb_add: txn_begin(2) failed: %s (%d)\n", db_strerror(rs->sr_err), rs->sr_err, 0 );
 360 #else
 361                 Debug( LDAP_DEBUG_TRACE,
 362                         "bdb_add: txn_begin(2) failed: %s (%d)\n",
 363                         db_strerror(rs->sr_err), rs->sr_err, 0 );
 364 #endif
 365                 rs->sr_err = LDAP_OTHER;
 366                 rs->sr_text = "internal error";
 367                 goto return_results;
 368         }
 369
 370         /* dn2id index */
 371         rs->sr_err = bdb_dn2id_add( op, lt2, ei, op->oq_add.rs_e );
 372         if ( rs->sr_err != 0 ) {
 373 #ifdef NEW_LOGGING
 374                 LDAP_LOG ( OPERATION, ERR,
 375                         "bdb_add: dn2id_add failed: %s (%d)\n", db_strerror(rs->sr_err), rs->sr_err, 0 );
 376 #else
 377                 Debug( LDAP_DEBUG_TRACE, "bdb_add: dn2id_add failed: %s (%d)\n",
 378                         db_strerror(rs->sr_err), rs->sr_err, 0 );
 379 #endif
 380
 381                 switch( rs->sr_err ) {
 382                 case DB_LOCK_DEADLOCK:
 383                 case DB_LOCK_NOTGRANTED:
 384                         goto retry;
 385                 case DB_KEYEXIST:
 386                         rs->sr_err = LDAP_ALREADY_EXISTS;
 387                         break;
 388                 default:
 389                         rs->sr_err = LDAP_OTHER;
 390                 }
 391                 goto return_results;
 392         }
 393
 394         /* id2entry index */
 395         rs->sr_err = bdb_id2entry_add( op->o_bd, lt2, op->oq_add.rs_e );
 396         if ( rs->sr_err != 0 ) {
 397 #ifdef NEW_LOGGING
 398                 LDAP_LOG ( OPERATION, ERR, "bdb_add: id2entry_add failed\n", 0, 0, 0 );
 399 #else
 400                 Debug( LDAP_DEBUG_TRACE, "bdb_add: id2entry_add failed\n",
 401                         0, 0, 0 );
 402 #endif
 403                 switch( rs->sr_err ) {
 404                 case DB_LOCK_DEADLOCK:
 405                 case DB_LOCK_NOTGRANTED:
 406                         goto retry;
 407                 default:
 408                         rs->sr_err = LDAP_OTHER;
 409                 }
 410                 rs->sr_text = "entry store failed";
 411                 goto return_results;
 412         }
 413
 414         /* attribute indexes */
 415         rs->sr_err = bdb_index_entry_add( op, lt2, op->oq_add.rs_e );
 416         if ( rs->sr_err != LDAP_SUCCESS ) {
 417 #ifdef NEW_LOGGING
 418                 LDAP_LOG ( OPERATION, ERR,
 419                         "bdb_add: index_entry_add failed\n", 0, 0, 0 );
 420 #else
 421                 Debug( LDAP_DEBUG_TRACE, "bdb_add: index_entry_add failed\n",
 422                         0, 0, 0 );
 423 #endif
 424                 switch( rs->sr_err ) {
 425                 case DB_LOCK_DEADLOCK:
 426                 case DB_LOCK_NOTGRANTED:
 427                         goto retry;
 428                 default:
 429                         rs->sr_err = LDAP_OTHER;
 430                 }
 431                 rs->sr_text = "index generation failed";
 432                 goto return_results;
 433         }
 434         if ( TXN_COMMIT( lt2, 0 ) != 0 ) {
 435                 rs->sr_err = LDAP_OTHER;
 436                 rs->sr_text = "txn_commit(2) failed";
 437                 goto return_results;
 438         }
 439
 440         if ( !op->o_bd->syncinfo ) {
 441                 rc = bdb_csn_commit( op, rs, ltid, ei, &suffix_ei,
 442                         &ctxcsn_e, &ctxcsn_added, locker );
 443                 switch ( rc ) {
 444                 case BDB_CSN_ABORT :
 445                         goto return_results;
 446                 case BDB_CSN_RETRY :
 447                         goto retry;
 448                 }
 449         }
 450
 451         if ( op->o_noop ) {
 452                 if (( rs->sr_err=TXN_ABORT( ltid )) != 0 ) {
 453                         rs->sr_text = "txn_abort (no-op) failed";
 454                 } else {
 455                         noop = 1;
 456                         rs->sr_err = LDAP_SUCCESS;
 457                 }
 458
 459         } else {
 460                 char gid[DB_XIDDATASIZE];
 461
 462                 memset( gid, 0, sizeof(gid) );
 463                 snprintf( gid, sizeof( gid ), "%s-%08lx-%08lx",
 464                         bdb_uuid.bv_val, (long) op->o_connid, (long) op->o_opid );
 465
 466                 if (( rs->sr_err=TXN_PREPARE( ltid, gid )) != 0 ) {
 467                         rs->sr_text = "txn_prepare failed";
 468
 469                 } else {
 470                         struct berval nrdn;
 471
 472                         if (pdn.bv_len) {
 473                                 nrdn.bv_val = op->ora_e->e_nname.bv_val;
 474                                 nrdn.bv_len = pdn.bv_val - nrdn.bv_val - 1;
 475                         } else {
 476                                 nrdn = op->ora_e->e_nname;
 477                         }
 478
 479                         bdb_cache_add( bdb, ei, op->oq_add.rs_e, &nrdn, locker );
 480
 481                         if ( suffix_ei == NULL ) {
 482                                 suffix_ei = op->oq_add.rs_e->e_private;
 483                         }
 484
 485                         if ( !op->o_bd->syncinfo ) {
 486                                 if ( ctxcsn_added ) {
 487                                         bdb_cache_add( bdb, suffix_ei, ctxcsn_e, (struct berval *)&slap_ldapsync_cn_bv, locker );
 488                                 }
 489                         }
 490
 491                         if(( rs->sr_err=TXN_COMMIT( ltid, 0 )) != 0 ) {
 492                                 rs->sr_text = "txn_commit failed";
 493                         } else {
 494                                 rs->sr_err = LDAP_SUCCESS;
 495                         }
 496                 }
 497         }
 498
 499         ltid = NULL;
 500         op->o_private = NULL;
 501
 502         if (rs->sr_err != LDAP_SUCCESS) {
 503 #ifdef NEW_LOGGING
 504                 LDAP_LOG ( OPERATION, ERR,
 505                         "bdb_add: %s : %s (%d)\n",  rs->sr_text,
 506                                 db_strerror(rs->sr_err), rs->sr_err );
 507 #else
 508                 Debug( LDAP_DEBUG_TRACE, "bdb_add: %s : %s (%d)\n",
 509                         rs->sr_text, db_strerror(rs->sr_err), rs->sr_err );
 510 #endif
 511                 rs->sr_err = LDAP_OTHER;
 512                 goto return_results;
 513         }
 514
 515 #ifdef NEW_LOGGING
 516         LDAP_LOG ( OPERATION, RESULTS,
 517                 "bdb_add: added%s id=%08lx dn=\"%s\"\n",
 518                 op->o_noop ? " (no-op)" : "",
 519                 op->oq_add.rs_e->e_id, op->oq_add.rs_e->e_dn );
 520 #else
 521         Debug(LDAP_DEBUG_TRACE, "bdb_add: added%s id=%08lx dn=\"%s\"\n",
 522                 op->o_noop ? " (no-op)" : "",
 523                 op->oq_add.rs_e->e_id, op->oq_add.rs_e->e_dn );
 524 #endif
 525
 526         rs->sr_text = NULL;
 527         if( num_ctrls ) rs->sr_ctrls = ctrls;
 528
 529 return_results:
 530         send_ldap_result( op, rs );
 531
 532         if ( rs->sr_err == LDAP_SUCCESS && !noop ) {
 533                 LDAP_LIST_FOREACH ( ps_list, &bdb->bi_psearch_list, o_ps_link ) {
 534                         bdb_psearch( op, rs, ps_list, op->oq_add.rs_e, LDAP_PSEARCH_BY_ADD );
 535                 }
 536         }
 537
 538         if( rs->sr_err == LDAP_SUCCESS && bdb->bi_txn_cp ) {
 539                 ldap_pvt_thread_yield();
 540                 TXN_CHECKPOINT( bdb->bi_dbenv,
 541                         bdb->bi_txn_cp_kbyte, bdb->bi_txn_cp_min, 0 );
 542         }
 543
 544 done:
 545         if( ltid != NULL ) {
 546                 TXN_ABORT( ltid );
 547                 op->o_private = NULL;
 548         }
 549
 550         return ( ( rs->sr_err == LDAP_SUCCESS ) ? noop : rs->sr_err );
 551 }