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

   1 /* $OpenLDAP$ */
   2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   3  *
   4  * Copyright 1999-2004 The OpenLDAP Foundation.
   5  * Portions Copyright 1999 Dmitry Kovalev.
   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 /* ACKNOWLEDGEMENTS:
  17  * This work was initially developed by Dmitry Kovalev for inclusion
  18  * by OpenLDAP Software.
  19  */
  20
  21 #include "portable.h"
  22
  23 #ifdef SLAPD_SQL
  24
  25 #include <stdio.h>
  26 #include <sys/types.h>
  27 #include "ac/string.h"
  28
  29 #include "slap.h"
  30 #include "proto-sql.h"
  31
  32 typedef struct backsql_delete_attr_t {
  33         Operation               *op;
  34         SlapReply               *rs;
  35         SQLHDBC                 dbh;
  36         backsql_entryID         *e_id;
  37 } backsql_delete_attr_t;
  38
  39 static int
  40 backsql_delete_attr_f( void *v_at, void *v_bda )
  41 {
  42         backsql_at_map_rec      *at = (backsql_at_map_rec *)v_at;
  43         backsql_delete_attr_t   *bda = (backsql_delete_attr_t *)v_bda;
  44         int                     rc;
  45
  46         rc = backsql_modify_delete_all_values( bda->op,
  47                         bda->rs, bda->dbh, bda->e_id, at );
  48
  49         if ( rc != LDAP_SUCCESS ) {
  50                 return BACKSQL_AVL_STOP;
  51         }
  52
  53         return BACKSQL_AVL_CONTINUE;
  54 }
  55
  56 static int
  57 backsql_delete_all_attrs(
  58         Operation               *op,
  59         SlapReply               *rs,
  60         SQLHDBC                 dbh,
  61         backsql_entryID         *e_id,
  62         backsql_oc_map_rec      *oc )
  63 {
  64         backsql_delete_attr_t   bda;
  65         int                     rc;
  66
  67         bda.op = op;
  68         bda.rs = rs;
  69         bda.dbh = dbh;
  70         bda.e_id = e_id;
  71
  72         rc = avl_apply( oc->bom_attrs, backsql_delete_attr_f, &bda,
  73                         BACKSQL_AVL_STOP, AVL_INORDER );
  74         if ( rc == BACKSQL_AVL_STOP ) {
  75                 return rs->sr_err;
  76         }
  77
  78         return LDAP_SUCCESS;
  79 }
  80
  81 int
  82 backsql_delete( Operation *op, SlapReply *rs )
  83 {
  84         backsql_info            *bi = (backsql_info*)op->o_bd->be_private;
  85         SQLHDBC                 dbh;
  86         SQLHSTMT                sth;
  87         RETCODE                 rc;
  88         int                     retval;
  89         backsql_oc_map_rec      *oc = NULL;
  90         backsql_entryID         e_id = BACKSQL_ENTRYID_INIT;
  91         Entry                   e;
  92         /* first parameter no */
  93         SQLUSMALLINT            pno;
  94
  95         Debug( LDAP_DEBUG_TRACE, "==>backsql_delete(): deleting entry \"%s\"\n",
  96                         op->o_req_ndn.bv_val, 0, 0 );
  97
  98         dnParent( &op->o_req_dn, &e.e_name );
  99         dnParent( &op->o_req_ndn, &e.e_nname );
 100         e.e_attrs = NULL;
 101
 102         /* check parent for "children" acl */
 103         if ( !access_allowed( op, &e, slap_schema.si_ad_children,
 104                         NULL, ACL_WRITE, NULL ) ) {
 105                 Debug( LDAP_DEBUG_TRACE, "   backsql_delete(): "
 106                         "no write access to parent\n",
 107                         0, 0, 0 );
 108                 rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
 109                 goto done;
 110
 111         }
 112
 113         rs->sr_err = backsql_get_db_conn( op, &dbh );
 114         if ( rs->sr_err != LDAP_SUCCESS ) {
 115                 Debug( LDAP_DEBUG_TRACE, "   backsql_delete(): "
 116                         "could not get connection handle - exiting\n",
 117                         0, 0, 0 );
 118                 rs->sr_text = ( rs->sr_err == LDAP_OTHER )
 119                         ? "SQL-backend error" : NULL;
 120                 goto done;
 121         }
 122
 123         /* FIXME: API... */
 124         rs->sr_err = backsql_dn2id( bi, &e_id, dbh, &op->o_req_ndn );
 125         if ( rs->sr_err != LDAP_SUCCESS ) {
 126                 Debug( LDAP_DEBUG_TRACE, "   backsql_delete(): "
 127                         "could not lookup entry id\n", 0, 0, 0 );
 128                 goto done;
 129         }
 130
 131         rs->sr_err = backsql_has_children( bi, dbh, &op->o_req_ndn );
 132         switch ( rs->sr_err ) {
 133         case LDAP_COMPARE_TRUE:
 134                 Debug( LDAP_DEBUG_TRACE, "   backsql_delete(): "
 135                         "entry \"%s\" has children\n",
 136                         op->o_req_dn.bv_val, 0, 0 );
 137                 rs->sr_err = LDAP_NOT_ALLOWED_ON_NONLEAF;
 138                 rs->sr_text = "subtree delete not supported";
 139                 goto done;
 140
 141         case LDAP_COMPARE_FALSE:
 142                 break;
 143
 144         default:
 145                 goto done;
 146         }
 147
 148         oc = backsql_id2oc( bi, e_id.eid_oc_id );
 149         if ( oc == NULL ) {
 150                 Debug( LDAP_DEBUG_TRACE, "   backsql_delete(): "
 151                         "cannot determine objectclass of entry -- aborting\n",
 152                         0, 0, 0 );
 153                 rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
 154                 rs->sr_text = "operation not permitted within namingContext";
 155                 goto done;
 156         }
 157
 158         if ( oc->bom_delete_proc == NULL ) {
 159                 Debug( LDAP_DEBUG_TRACE, "   backsql_delete(): "
 160                         "delete procedure is not defined "
 161                         "for this objectclass - aborting\n", 0, 0, 0 );
 162                 rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
 163                 rs->sr_text = "operation not permitted within namingContext";
 164                 goto done;
 165         }
 166
 167         /* avl_apply ... */
 168         rs->sr_err = backsql_delete_all_attrs( op, rs, dbh, &e_id, oc );
 169         if ( rs->sr_err != LDAP_SUCCESS ) {
 170                 goto done;
 171         }
 172
 173         rc = backsql_Prepare( dbh, &sth, oc->bom_delete_proc, 0 );
 174         if ( rc != SQL_SUCCESS ) {
 175                 Debug( LDAP_DEBUG_TRACE,
 176                         "   backsql_delete(): "
 177                         "error preparing delete query\n",
 178                         0, 0, 0 );
 179                 backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc );
 180
 181                 rs->sr_err = LDAP_OTHER;
 182                 rs->sr_text = "SQL-backend error";
 183                 goto done;
 184         }
 185
 186         if ( BACKSQL_IS_DEL( oc->bom_expect_return ) ) {
 187                 pno = 1;
 188                 rc = backsql_BindParamInt( sth, 1, SQL_PARAM_OUTPUT, &retval );
 189                 if ( rc != SQL_SUCCESS ) {
 190                         Debug( LDAP_DEBUG_TRACE,
 191                                 "   backsql_delete(): "
 192                                 "error binding output parameter for objectClass %s\n",
 193                                 oc->bom_oc->soc_cname.bv_val, 0, 0 );
 194                         backsql_PrintErrors( bi->sql_db_env, dbh,
 195                                 sth, rc );
 196                         SQLFreeStmt( sth, SQL_DROP );
 197
 198                         rs->sr_text = "SQL-backend error";
 199                         rs->sr_err = LDAP_OTHER;
 200                         goto done;
 201                 }
 202
 203         } else {
 204                 pno = 0;
 205         }
 206
 207         rc = backsql_BindParamID( sth, pno + 1, SQL_PARAM_INPUT, &e_id.eid_keyval );
 208         if ( rc != SQL_SUCCESS ) {
 209                 Debug( LDAP_DEBUG_TRACE,
 210                         "   backsql_delete(): "
 211                         "error binding keyval parameter for objectClass %s\n",
 212                         oc->bom_oc->soc_cname.bv_val, 0, 0 );
 213                 backsql_PrintErrors( bi->sql_db_env, dbh,
 214                         sth, rc );
 215                 SQLFreeStmt( sth, SQL_DROP );
 216
 217                 rs->sr_text = "SQL-backend error";
 218                 rs->sr_err = LDAP_OTHER;
 219                 goto done;
 220         }
 221
 222         rc = SQLExecute( sth );
 223         if ( rc != SQL_SUCCESS ) {
 224                 Debug( LDAP_DEBUG_TRACE, "   backsql_delete(): "
 225                         "delete_proc execution failed\n", 0, 0, 0 );
 226                 backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc );
 227                 SQLFreeStmt( sth, SQL_DROP );
 228                 rs->sr_err = LDAP_OTHER;
 229                 rs->sr_text = "SQL-backend error";
 230                 goto done;
 231         }
 232         SQLFreeStmt( sth, SQL_DROP );
 233
 234         /* delete "auxiliary" objectClasses, if any... */
 235         rc = backsql_Prepare( dbh, &sth, bi->sql_delobjclasses_query, 0 );
 236         if ( rc != SQL_SUCCESS ) {
 237                 Debug( LDAP_DEBUG_TRACE,
 238                         "   backsql_delete(): "
 239                         "error preparing ldap_entry_objclasses delete query\n",
 240                         0, 0, 0 );
 241                 backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc );
 242
 243                 rs->sr_err = LDAP_OTHER;
 244                 rs->sr_text = "SQL-backend error";
 245                 goto done;
 246         }
 247
 248         rc = backsql_BindParamID( sth, 1, SQL_PARAM_INPUT, &e_id.eid_id );
 249         if ( rc != SQL_SUCCESS ) {
 250                 Debug( LDAP_DEBUG_TRACE,
 251                         "   backsql_delete(): "
 252                         "error binding auxiliary objectClasses "
 253                         "entry ID parameter for objectClass %s\n",
 254                         oc->bom_oc->soc_cname.bv_val, 0, 0 );
 255                 backsql_PrintErrors( bi->sql_db_env, dbh,
 256                         sth, rc );
 257                 SQLFreeStmt( sth, SQL_DROP );
 258
 259                 rs->sr_text = "SQL-backend error";
 260                 rs->sr_err = LDAP_OTHER;
 261                 goto done;
 262         }
 263
 264         rc = SQLExecute( sth );
 265         switch ( rc ) {
 266         case SQL_NO_DATA:
 267                 /* apparently there were no "auxiliary" objectClasses
 268                  * for this entry... */
 269         case SQL_SUCCESS:
 270                 break;
 271
 272         default:
 273                 Debug( LDAP_DEBUG_TRACE, "   backsql_delete(): "
 274                         "failed to delete record from ldap_entry_objclasses\n",
 275                         0, 0, 0 );
 276                 backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc );
 277                 SQLFreeStmt( sth, SQL_DROP );
 278                 rs->sr_err = LDAP_OTHER;
 279                 rs->sr_text = "SQL-backend error";
 280                 goto done;
 281         }
 282         SQLFreeStmt( sth, SQL_DROP );
 283
 284         /* delete referrals, if any... */
 285         rc = backsql_Prepare( dbh, &sth, bi->sql_delreferrals_query, 0 );
 286         if ( rc != SQL_SUCCESS ) {
 287                 Debug( LDAP_DEBUG_TRACE,
 288                         "   backsql_delete(): "
 289                         "error preparing ldap_referrals delete query\n",
 290                         0, 0, 0 );
 291                 backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc );
 292
 293                 rs->sr_err = LDAP_OTHER;
 294                 rs->sr_text = "SQL-backend error";
 295                 goto done;
 296         }
 297
 298         rc = backsql_BindParamID( sth, 1, SQL_PARAM_INPUT, &e_id.eid_id );
 299         if ( rc != SQL_SUCCESS ) {
 300                 Debug( LDAP_DEBUG_TRACE,
 301                         "   backsql_delete(): "
 302                         "error binding referrals entry ID parameter "
 303                         "for objectClass %s\n",
 304                         oc->bom_oc->soc_cname.bv_val, 0, 0 );
 305                 backsql_PrintErrors( bi->sql_db_env, dbh,
 306                         sth, rc );
 307                 SQLFreeStmt( sth, SQL_DROP );
 308
 309                 rs->sr_text = "SQL-backend error";
 310                 rs->sr_err = LDAP_OTHER;
 311                 goto done;
 312         }
 313
 314         rc = SQLExecute( sth );
 315         switch ( rc ) {
 316         case SQL_NO_DATA:
 317                 /* apparently there were no referrals
 318                  * for this entry... */
 319         case SQL_SUCCESS:
 320                 break;
 321
 322         default:
 323                 Debug( LDAP_DEBUG_TRACE, "   backsql_delete(): "
 324                         "failed to delete record from ldap_referrals\n",
 325                         0, 0, 0 );
 326                 backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc );
 327                 SQLFreeStmt( sth, SQL_DROP );
 328                 rs->sr_err = LDAP_OTHER;
 329                 rs->sr_text = "SQL-backend error";
 330                 goto done;
 331         }
 332         SQLFreeStmt( sth, SQL_DROP );
 333
 334         /* delete entry... */
 335         rc = backsql_Prepare( dbh, &sth, bi->sql_delentry_query, 0 );
 336         if ( rc != SQL_SUCCESS ) {
 337                 Debug( LDAP_DEBUG_TRACE,
 338                         "   backsql_delete(): "
 339                         "error preparing ldap_entries delete query\n",
 340                         0, 0, 0 );
 341                 backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc );
 342
 343                 rs->sr_err = LDAP_OTHER;
 344                 rs->sr_text = "SQL-backend error";
 345                 goto done;
 346         }
 347
 348         rc = backsql_BindParamID( sth, 1, SQL_PARAM_INPUT, &e_id.eid_id );
 349         if ( rc != SQL_SUCCESS ) {
 350                 Debug( LDAP_DEBUG_TRACE,
 351                         "   backsql_delete(): "
 352                         "error binding entry ID parameter "
 353                         "for objectClass %s\n",
 354                         oc->bom_oc->soc_cname.bv_val, 0, 0 );
 355                 backsql_PrintErrors( bi->sql_db_env, dbh,
 356                         sth, rc );
 357                 SQLFreeStmt( sth, SQL_DROP );
 358
 359                 rs->sr_text = "SQL-backend error";
 360                 rs->sr_err = LDAP_OTHER;
 361                 goto done;
 362         }
 363
 364         rc = SQLExecute( sth );
 365         if ( rc != SQL_SUCCESS ) {
 366                 Debug( LDAP_DEBUG_TRACE, "   backsql_delete(): "
 367                         "failed to delete record from ldap_entries\n",
 368                         0, 0, 0 );
 369                 backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc );
 370                 SQLFreeStmt( sth, SQL_DROP );
 371                 rs->sr_err = LDAP_OTHER;
 372                 rs->sr_text = "SQL-backend error";
 373                 goto done;
 374         }
 375         SQLFreeStmt( sth, SQL_DROP );
 376
 377         /*
 378          * Commit only if all operations succeed
 379          *
 380          * FIXME: backsql_add() does not fail if add operations
 381          * are not available for some attributes, or if
 382          * a multiple value add actually results in a replace,
 383          * or if a single operation on an attribute fails
 384          * for any reason
 385          */
 386         SQLTransact( SQL_NULL_HENV, dbh,
 387                         op->o_noop ? SQL_ROLLBACK : SQL_COMMIT );
 388
 389         rs->sr_err = LDAP_SUCCESS;
 390
 391 done:;
 392         send_ldap_result( op, rs );
 393
 394         Debug( LDAP_DEBUG_TRACE, "<==backsql_delete()\n", 0, 0, 0 );
 395
 396         return ( ( rs->sr_err == LDAP_SUCCESS ) ? op->o_noop : 1 );
 397 }
 398
 399 #endif /* SLAPD_SQL */
 400