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

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