git.sur5r.net Git - openldap/blob - servers/slapd/back-mdb/delete.c

   1 /* delete.c - mdb backend delete routine */
   2 /* $OpenLDAP$ */
   3 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   4  *
   5  * Copyright 2000-2017 The OpenLDAP Foundation.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted only as authorized by the OpenLDAP
  10  * Public License.
  11  *
  12  * A copy of this license is available in the file LICENSE in the
  13  * top-level directory of the distribution or, alternatively, at
  14  * <http://www.OpenLDAP.org/license.html>.
  15  */
  16
  17 #include "portable.h"
  18
  19 #include <stdio.h>
  20 #include <ac/string.h>
  21
  22 #include "lutil.h"
  23 #include "back-mdb.h"
  24
  25 int
  26 mdb_delete( Operation *op, SlapReply *rs )
  27 {
  28         struct mdb_info *mdb = (struct mdb_info *) op->o_bd->be_private;
  29         struct berval   pdn = {0, NULL};
  30         Entry   *e = NULL;
  31         Entry   *p = NULL;
  32         int             manageDSAit = get_manageDSAit( op );
  33         AttributeDescription *children = slap_schema.si_ad_children;
  34         AttributeDescription *entry = slap_schema.si_ad_entry;
  35         MDB_txn         *txn = NULL;
  36         MDB_cursor      *mc;
  37         mdb_op_info opinfo = {{{ 0 }}}, *moi = &opinfo;
  38
  39         LDAPControl **preread_ctrl = NULL;
  40         LDAPControl *ctrls[SLAP_MAX_RESPONSE_CONTROLS];
  41         int num_ctrls = 0;
  42
  43         int     parent_is_glue = 0;
  44         int parent_is_leaf = 0;
  45
  46         Debug( LDAP_DEBUG_ARGS, "==> " LDAP_XSTRING(mdb_delete) ": %s\n",
  47                 op->o_req_dn.bv_val, 0, 0 );
  48
  49 #ifdef LDAP_X_TXN
  50         if( op->o_txnSpec && txn_preop( op, rs ))
  51                 return rs->sr_err;
  52 #endif
  53
  54         ctrls[num_ctrls] = 0;
  55
  56         /* begin transaction */
  57         rs->sr_err = mdb_opinfo_get( op, mdb, 0, &moi );
  58         rs->sr_text = NULL;
  59         if( rs->sr_err != 0 ) {
  60                 Debug( LDAP_DEBUG_TRACE,
  61                         LDAP_XSTRING(mdb_delete) ": txn_begin failed: "
  62                         "%s (%d)\n", mdb_strerror(rs->sr_err), rs->sr_err, 0 );
  63                 rs->sr_err = LDAP_OTHER;
  64                 rs->sr_text = "internal error";
  65                 goto return_results;
  66         }
  67         txn = moi->moi_txn;
  68
  69         /* allocate CSN */
  70         if ( BER_BVISNULL( &op->o_csn ) ) {
  71                 struct berval csn;
  72                 char csnbuf[LDAP_PVT_CSNSTR_BUFSIZE];
  73
  74                 csn.bv_val = csnbuf;
  75                 csn.bv_len = sizeof(csnbuf);
  76                 slap_get_csn( op, &csn, 1 );
  77         }
  78
  79         if ( !be_issuffix( op->o_bd, &op->o_req_ndn ) ) {
  80                 dnParent( &op->o_req_ndn, &pdn );
  81         }
  82
  83         rs->sr_err = mdb_cursor_open( txn, mdb->mi_dn2id, &mc );
  84         if ( rs->sr_err ) {
  85                 rs->sr_err = LDAP_OTHER;
  86                 rs->sr_text = "internal error";
  87                 goto return_results;
  88         }
  89         /* get parent */
  90         rs->sr_err = mdb_dn2entry( op, txn, mc, &pdn, &p, NULL, 1 );
  91         switch( rs->sr_err ) {
  92         case 0:
  93         case MDB_NOTFOUND:
  94                 break;
  95         case LDAP_BUSY:
  96                 rs->sr_text = "ldap server busy";
  97                 goto return_results;
  98         default:
  99                 rs->sr_err = LDAP_OTHER;
 100                 rs->sr_text = "internal error";
 101                 goto return_results;
 102         }
 103         if ( rs->sr_err == MDB_NOTFOUND ) {
 104                 Debug( LDAP_DEBUG_ARGS,
 105                         "<=- " LDAP_XSTRING(mdb_delete) ": no such object %s\n",
 106                         op->o_req_dn.bv_val, 0, 0);
 107
 108                 if ( p && !BER_BVISEMPTY( &p->e_name )) {
 109                         rs->sr_matched = ch_strdup( p->e_name.bv_val );
 110                         if ( is_entry_referral( p )) {
 111                                 BerVarray ref = get_entry_referrals( op, p );
 112                                 rs->sr_ref = referral_rewrite( ref, &p->e_name,
 113                                         &op->o_req_dn, LDAP_SCOPE_DEFAULT );
 114                                 ber_bvarray_free( ref );
 115                         } else {
 116                                 rs->sr_ref = NULL;
 117                         }
 118                 } else {
 119                         rs->sr_ref = referral_rewrite( default_referral, NULL,
 120                                         &op->o_req_dn, LDAP_SCOPE_DEFAULT );
 121                 }
 122                 if ( p ) {
 123                         mdb_entry_return( op, p );
 124                         p = NULL;
 125                 }
 126
 127                 rs->sr_err = LDAP_REFERRAL;
 128                 rs->sr_flags = REP_MATCHED_MUSTBEFREED | REP_REF_MUSTBEFREED;
 129                 goto return_results;
 130         }
 131
 132         /* get entry */
 133         rs->sr_err = mdb_dn2entry( op, txn, mc, &op->o_req_ndn, &e, NULL, 0 );
 134         switch( rs->sr_err ) {
 135         case MDB_NOTFOUND:
 136                 e = p;
 137                 p = NULL;
 138         case 0:
 139                 break;
 140         case LDAP_BUSY:
 141                 rs->sr_text = "ldap server busy";
 142                 goto return_results;
 143         default:
 144                 rs->sr_err = LDAP_OTHER;
 145                 rs->sr_text = "internal error";
 146                 goto return_results;
 147         }
 148
 149         /* FIXME : dn2entry() should return non-glue entry */
 150         if ( rs->sr_err == MDB_NOTFOUND || ( !manageDSAit && is_entry_glue( e ))) {
 151                 Debug( LDAP_DEBUG_ARGS,
 152                         "<=- " LDAP_XSTRING(mdb_delete) ": no such object %s\n",
 153                         op->o_req_dn.bv_val, 0, 0);
 154
 155                 rs->sr_matched = ch_strdup( e->e_dn );
 156                 if ( is_entry_referral( e )) {
 157                         BerVarray ref = get_entry_referrals( op, e );
 158                         rs->sr_ref = referral_rewrite( ref, &e->e_name,
 159                                 &op->o_req_dn, LDAP_SCOPE_DEFAULT );
 160                         ber_bvarray_free( ref );
 161                 } else {
 162                         rs->sr_ref = NULL;
 163                 }
 164                 mdb_entry_return( op, e );
 165                 e = NULL;
 166
 167                 rs->sr_err = LDAP_REFERRAL;
 168                 rs->sr_flags = REP_MATCHED_MUSTBEFREED | REP_REF_MUSTBEFREED;
 169                 goto return_results;
 170         }
 171
 172         if ( pdn.bv_len != 0 ) {
 173                 /* check parent for "children" acl */
 174                 rs->sr_err = access_allowed( op, p,
 175                         children, NULL, ACL_WDEL, NULL );
 176
 177                 if ( !rs->sr_err  ) {
 178                         Debug( LDAP_DEBUG_TRACE,
 179                                 "<=- " LDAP_XSTRING(mdb_delete) ": no write "
 180                                 "access to parent\n", 0, 0, 0 );
 181                         rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
 182                         rs->sr_text = "no write access to parent";
 183                         goto return_results;
 184                 }
 185
 186         } else {
 187                 /* no parent, must be root to delete */
 188                 if( ! be_isroot( op ) ) {
 189                         if ( be_issuffix( op->o_bd, (struct berval *)&slap_empty_bv )
 190                                 || be_shadow_update( op ) ) {
 191                                 p = (Entry *)&slap_entry_root;
 192
 193                                 /* check parent for "children" acl */
 194                                 rs->sr_err = access_allowed( op, p,
 195                                         children, NULL, ACL_WDEL, NULL );
 196
 197                                 p = NULL;
 198
 199                                 if ( !rs->sr_err  ) {
 200                                         Debug( LDAP_DEBUG_TRACE,
 201                                                 "<=- " LDAP_XSTRING(mdb_delete)
 202                                                 ": no access to parent\n",
 203                                                 0, 0, 0 );
 204                                         rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
 205                                         rs->sr_text = "no write access to parent";
 206                                         goto return_results;
 207                                 }
 208
 209                         } else {
 210                                 Debug( LDAP_DEBUG_TRACE,
 211                                         "<=- " LDAP_XSTRING(mdb_delete)
 212                                         ": no parent and not root\n", 0, 0, 0 );
 213                                 rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
 214                                 goto return_results;
 215                         }
 216                 }
 217         }
 218
 219         if ( get_assert( op ) &&
 220                 ( test_filter( op, e, get_assertion( op )) != LDAP_COMPARE_TRUE ))
 221         {
 222                 rs->sr_err = LDAP_ASSERTION_FAILED;
 223                 goto return_results;
 224         }
 225
 226         rs->sr_err = access_allowed( op, e,
 227                 entry, NULL, ACL_WDEL, NULL );
 228
 229         if ( !rs->sr_err  ) {
 230                 Debug( LDAP_DEBUG_TRACE,
 231                         "<=- " LDAP_XSTRING(mdb_delete) ": no write access "
 232                         "to entry\n", 0, 0, 0 );
 233                 rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
 234                 rs->sr_text = "no write access to entry";
 235                 goto return_results;
 236         }
 237
 238         if ( !manageDSAit && is_entry_referral( e ) ) {
 239                 /* entry is a referral, don't allow delete */
 240                 rs->sr_ref = get_entry_referrals( op, e );
 241
 242                 Debug( LDAP_DEBUG_TRACE,
 243                         LDAP_XSTRING(mdb_delete) ": entry is referral\n",
 244                         0, 0, 0 );
 245
 246                 rs->sr_err = LDAP_REFERRAL;
 247                 rs->sr_matched = ch_strdup( e->e_name.bv_val );
 248                 rs->sr_flags = REP_MATCHED_MUSTBEFREED | REP_REF_MUSTBEFREED;
 249                 goto return_results;
 250         }
 251
 252         /* pre-read */
 253         if( op->o_preread ) {
 254                 if( preread_ctrl == NULL ) {
 255                         preread_ctrl = &ctrls[num_ctrls++];
 256                         ctrls[num_ctrls] = NULL;
 257                 }
 258                 if( slap_read_controls( op, rs, e,
 259                         &slap_pre_read_bv, preread_ctrl ) )
 260                 {
 261                         Debug( LDAP_DEBUG_TRACE,
 262                                 "<=- " LDAP_XSTRING(mdb_delete) ": pre-read "
 263                                 "failed!\n", 0, 0, 0 );
 264                         if ( op->o_preread & SLAP_CONTROL_CRITICAL ) {
 265                                 /* FIXME: is it correct to abort
 266                                  * operation if control fails? */
 267                                 goto return_results;
 268                         }
 269                 }
 270         }
 271
 272         rs->sr_text = NULL;
 273
 274         /* Can't do it if we have kids */
 275         rs->sr_err = mdb_dn2id_children( op, txn, e );
 276         if( rs->sr_err != MDB_NOTFOUND ) {
 277                 switch( rs->sr_err ) {
 278                 case 0:
 279                         Debug(LDAP_DEBUG_ARGS,
 280                                 "<=- " LDAP_XSTRING(mdb_delete)
 281                                 ": non-leaf %s\n",
 282                                 op->o_req_dn.bv_val, 0, 0);
 283                         rs->sr_err = LDAP_NOT_ALLOWED_ON_NONLEAF;
 284                         rs->sr_text = "subordinate objects must be deleted first";
 285                         break;
 286                 default:
 287                         Debug(LDAP_DEBUG_ARGS,
 288                                 "<=- " LDAP_XSTRING(mdb_delete)
 289                                 ": has_children failed: %s (%d)\n",
 290                                 mdb_strerror(rs->sr_err), rs->sr_err, 0 );
 291                         rs->sr_err = LDAP_OTHER;
 292                         rs->sr_text = "internal error";
 293                 }
 294                 goto return_results;
 295         }
 296
 297         /* delete from dn2id */
 298         rs->sr_err = mdb_dn2id_delete( op, mc, e->e_id, 1 );
 299         mdb_cursor_close( mc );
 300         if ( rs->sr_err != 0 ) {
 301                 Debug(LDAP_DEBUG_TRACE,
 302                         "<=- " LDAP_XSTRING(mdb_delete) ": dn2id failed: "
 303                         "%s (%d)\n", mdb_strerror(rs->sr_err), rs->sr_err, 0 );
 304                 rs->sr_text = "DN index delete failed";
 305                 rs->sr_err = LDAP_OTHER;
 306                 goto return_results;
 307         }
 308
 309         /* delete indices for old attributes */
 310         rs->sr_err = mdb_index_entry_del( op, txn, e );
 311         if ( rs->sr_err != LDAP_SUCCESS ) {
 312                 Debug(LDAP_DEBUG_TRACE,
 313                         "<=- " LDAP_XSTRING(mdb_delete) ": index failed: "
 314                         "%s (%d)\n", mdb_strerror(rs->sr_err), rs->sr_err, 0 );
 315                 rs->sr_text = "entry index delete failed";
 316                 rs->sr_err = LDAP_OTHER;
 317                 goto return_results;
 318         }
 319
 320         /* fixup delete CSN */
 321         if ( !SLAP_SHADOW( op->o_bd )) {
 322                 struct berval vals[2];
 323
 324                 assert( !BER_BVISNULL( &op->o_csn ) );
 325                 vals[0] = op->o_csn;
 326                 BER_BVZERO( &vals[1] );
 327                 rs->sr_err = mdb_index_values( op, txn, slap_schema.si_ad_entryCSN,
 328                         vals, 0, SLAP_INDEX_ADD_OP );
 329                 if ( rs->sr_err != LDAP_SUCCESS ) {
 330                         rs->sr_text = "entryCSN index update failed";
 331                         rs->sr_err = LDAP_OTHER;
 332                         goto return_results;
 333                 }
 334         }
 335
 336         /* delete from id2entry */
 337         rs->sr_err = mdb_id2entry_delete( op->o_bd, txn, e );
 338         if ( rs->sr_err != 0 ) {
 339                 Debug( LDAP_DEBUG_TRACE,
 340                         "<=- " LDAP_XSTRING(mdb_delete) ": id2entry failed: "
 341                         "%s (%d)\n", mdb_strerror(rs->sr_err), rs->sr_err, 0 );
 342                 rs->sr_text = "entry delete failed";
 343                 rs->sr_err = LDAP_OTHER;
 344                 goto return_results;
 345         }
 346
 347         if ( pdn.bv_len != 0 ) {
 348                 parent_is_glue = is_entry_glue(p);
 349                 rs->sr_err = mdb_dn2id_children( op, txn, p );
 350                 if ( rs->sr_err != MDB_NOTFOUND ) {
 351                         switch( rs->sr_err ) {
 352                         case 0:
 353                                 break;
 354                         default:
 355                                 Debug(LDAP_DEBUG_ARGS,
 356                                         "<=- " LDAP_XSTRING(mdb_delete)
 357                                         ": has_children failed: %s (%d)\n",
 358                                         mdb_strerror(rs->sr_err), rs->sr_err, 0 );
 359                                 rs->sr_err = LDAP_OTHER;
 360                                 rs->sr_text = "internal error";
 361                                 goto return_results;
 362                         }
 363                         parent_is_leaf = 1;
 364                 }
 365                 mdb_entry_return( op, p );
 366                 p = NULL;
 367         }
 368
 369         if( moi == &opinfo ) {
 370                 LDAP_SLIST_REMOVE( &op->o_extra, &opinfo.moi_oe, OpExtra, oe_next );
 371                 opinfo.moi_oe.oe_key = NULL;
 372                 if( op->o_noop ) {
 373                         mdb_txn_abort( txn );
 374                         rs->sr_err = LDAP_X_NO_OPERATION;
 375                         txn = NULL;
 376                         goto return_results;
 377                 } else {
 378                         rs->sr_err = mdb_txn_commit( txn );
 379                 }
 380                 txn = NULL;
 381         }
 382
 383         if( rs->sr_err != 0 ) {
 384                 Debug( LDAP_DEBUG_ANY,
 385                         LDAP_XSTRING(mdb_delete) ": txn_%s failed: %s (%d)\n",
 386                         op->o_noop ? "abort (no-op)" : "commit",
 387                         mdb_strerror(rs->sr_err), rs->sr_err );
 388                 rs->sr_err = LDAP_OTHER;
 389                 rs->sr_text = "commit failed";
 390
 391                 goto return_results;
 392         }
 393
 394         Debug( LDAP_DEBUG_TRACE,
 395                 LDAP_XSTRING(mdb_delete) ": deleted%s id=%08lx dn=\"%s\"\n",
 396                 op->o_noop ? " (no-op)" : "",
 397                 e->e_id, op->o_req_dn.bv_val );
 398         rs->sr_err = LDAP_SUCCESS;
 399         rs->sr_text = NULL;
 400         if( num_ctrls ) rs->sr_ctrls = ctrls;
 401
 402 return_results:
 403         if ( rs->sr_err == LDAP_SUCCESS && parent_is_glue && parent_is_leaf ) {
 404                 op->o_delete_glue_parent = 1;
 405         }
 406
 407         if ( p != NULL ) {
 408                 mdb_entry_return( op, p );
 409         }
 410
 411         /* free entry */
 412         if( e != NULL ) {
 413                 mdb_entry_return( op, e );
 414         }
 415
 416         if( moi == &opinfo ) {
 417                 if( txn != NULL ) {
 418                         mdb_txn_abort( txn );
 419                 }
 420                 if ( opinfo.moi_oe.oe_key ) {
 421                         LDAP_SLIST_REMOVE( &op->o_extra, &opinfo.moi_oe, OpExtra, oe_next );
 422                 }
 423         } else {
 424                 moi->moi_ref--;
 425         }
 426
 427         send_ldap_result( op, rs );
 428         slap_graduate_commit_csn( op );
 429
 430         if( preread_ctrl != NULL && (*preread_ctrl) != NULL ) {
 431                 slap_sl_free( (*preread_ctrl)->ldctl_value.bv_val, op->o_tmpmemctx );
 432                 slap_sl_free( *preread_ctrl, op->o_tmpmemctx );
 433         }
 434
 435 #if 0
 436         if( rs->sr_err == LDAP_SUCCESS && mdb->bi_txn_cp_kbyte ) {
 437                 TXN_CHECKPOINT( mdb->bi_dbenv,
 438                         mdb->bi_txn_cp_kbyte, mdb->bi_txn_cp_min, 0 );
 439         }
 440 #endif
 441         return rs->sr_err;
 442 }