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

   1 /* $OpenLDAP$ */
   2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   3  *
   4  * Copyright 1999-2005 The OpenLDAP Foundation.
   5  * Portions Copyright 1999 Dmitry Kovalev.
   6  * Portions Copyright 2002 Pierangelo Masarati.
   7  * Portions Copyright 2004 Mark Adamson.
   8  * All rights reserved.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted only as authorized by the OpenLDAP
  12  * Public License.
  13  *
  14  * A copy of this license is available in the file LICENSE in the
  15  * top-level directory of the distribution or, alternatively, at
  16  * <http://www.OpenLDAP.org/license.html>.
  17  */
  18 /* ACKNOWLEDGEMENTS:
  19  * This work was initially developed by Dmitry Kovalev for inclusion
  20  * by OpenLDAP Software.  Additional significant contributors include
  21  * Pierangelo Masarati and Mark Adamson.
  22
  23  */
  24
  25 #include "portable.h"
  26
  27 #include <stdio.h>
  28 #include <sys/types.h>
  29 #include "ac/string.h"
  30
  31 #include "slap.h"
  32 #include "proto-sql.h"
  33
  34 #ifdef BACKSQL_SYNCPROV
  35 #include <lutil.h>
  36 #endif /* BACKSQL_SYNCPROV */
  37
  38 /*
  39  * Skip:
  40  * - null values (e.g. delete modification)
  41  * - single occurrence of objectClass, because it is already used
  42  *   to determine how to build the SQL entry
  43  * - operational attributes
  44  * - empty attributes
  45  */
  46 #define backsql_opattr_skip(ad) \
  47         (is_at_operational( (ad)->ad_type ) && (ad) != slap_schema.si_ad_ref )
  48 #define backsql_attr_skip(ad, vals) \
  49         ( \
  50                 ( (ad) == slap_schema.si_ad_objectClass \
  51                                 && (vals) && BER_BVISNULL( &((vals)[ 1 ]) ) ) \
  52                 || backsql_opattr_skip( (ad) ) \
  53                 || ( (vals) && BER_BVISNULL( &((vals)[ 0 ]) ) ) \
  54         )
  55
  56 int
  57 backsql_modify_delete_all_values(
  58         Operation               *op,
  59         SlapReply               *rs,
  60         SQLHDBC                 dbh,
  61         backsql_entryID         *e_id,
  62         backsql_at_map_rec      *at )
  63 {
  64         backsql_info    *bi = (backsql_info *)op->o_bd->be_private;
  65         RETCODE         rc;
  66         SQLHSTMT        asth = SQL_NULL_HSTMT;
  67         BACKSQL_ROW_NTS row;
  68
  69         assert( at != NULL );
  70         if ( at->bam_delete_proc == NULL ) {
  71                 Debug( LDAP_DEBUG_TRACE,
  72                         "   backsql_modify_delete_all_values(): "
  73                         "missing attribute value delete procedure "
  74                         "for attr \"%s\"\n",
  75                         at->bam_ad->ad_cname.bv_val, 0, 0 );
  76                 if ( BACKSQL_FAIL_IF_NO_MAPPING( bi ) ) {
  77                         rs->sr_text = "SQL-backend error";
  78                         return rs->sr_err = LDAP_OTHER;
  79                 }
  80
  81                 return LDAP_SUCCESS;
  82         }
  83
  84         rc = backsql_Prepare( dbh, &asth, at->bam_query, 0 );
  85         if ( rc != SQL_SUCCESS ) {
  86                 Debug( LDAP_DEBUG_TRACE,
  87                         "   backsql_modify_delete_all_values(): "
  88                         "error preparing attribute value select query "
  89                         "\"%s\"\n",
  90                         at->bam_query, 0, 0 );
  91                 backsql_PrintErrors( bi->sql_db_env, dbh,
  92                                 asth, rc );
  93
  94                 rs->sr_text = "SQL-backend error";
  95                 return rs->sr_err = LDAP_OTHER;
  96         }
  97
  98         rc = backsql_BindParamID( asth, 1, SQL_PARAM_INPUT, &e_id->eid_keyval );
  99         if ( rc != SQL_SUCCESS ) {
 100                 Debug( LDAP_DEBUG_TRACE,
 101                         "   backsql_modify_delete_all_values(): "
 102                         "error binding key value parameter "
 103                         "to attribute value select query\n",
 104                         0, 0, 0 );
 105                 backsql_PrintErrors( bi->sql_db_env, dbh,
 106                                 asth, rc );
 107                 SQLFreeStmt( asth, SQL_DROP );
 108
 109                 rs->sr_text = "SQL-backend error";
 110                 return rs->sr_err = LDAP_OTHER;
 111         }
 112
 113         rc = SQLExecute( asth );
 114         if ( !BACKSQL_SUCCESS( rc ) ) {
 115                 Debug( LDAP_DEBUG_TRACE,
 116                         "   backsql_modify_delete_all_values(): "
 117                         "error executing attribute value select query\n",
 118                         0, 0, 0 );
 119                 backsql_PrintErrors( bi->sql_db_env, dbh,
 120                                 asth, rc );
 121                 SQLFreeStmt( asth, SQL_DROP );
 122
 123                 rs->sr_text = "SQL-backend error";
 124                 return rs->sr_err = LDAP_OTHER;
 125         }
 126
 127         backsql_BindRowAsStrings_x( asth, &row, op->o_tmpmemctx );
 128         for ( rc = SQLFetch( asth );
 129                         BACKSQL_SUCCESS( rc );
 130                         rc = SQLFetch( asth ) )
 131         {
 132                 int             i;
 133                 /* first parameter no, parameter order */
 134                 SQLUSMALLINT    pno = 0,
 135                                 po = 0;
 136                 /* procedure return code */
 137                 int             prc = LDAP_SUCCESS;
 138
 139                 for ( i = 0; i < row.ncols; i++ ) {
 140                         SQLHSTMT        sth = SQL_NULL_HSTMT;
 141                         ber_len_t       col_len;
 142
 143                         rc = backsql_Prepare( dbh, &sth, at->bam_delete_proc, 0 );
 144                         if ( rc != SQL_SUCCESS ) {
 145                                 Debug( LDAP_DEBUG_TRACE,
 146                                         "   backsql_modify_delete_all_values(): "
 147                                         "error preparing attribute value "
 148                                         "delete procedure "
 149                                         "\"%s\"\n",
 150                                         at->bam_delete_proc, 0, 0 );
 151                                 backsql_PrintErrors( bi->sql_db_env, dbh,
 152                                                 sth, rc );
 153
 154                                 rs->sr_text = "SQL-backend error";
 155                                 rs->sr_err = LDAP_OTHER;
 156                                 goto done;
 157                         }
 158
 159                         if ( BACKSQL_IS_DEL( at->bam_expect_return ) ) {
 160                                 pno = 1;
 161                                 rc = backsql_BindParamInt( sth, 1,
 162                                                 SQL_PARAM_OUTPUT, &prc );
 163                                 if ( rc != SQL_SUCCESS ) {
 164                                         Debug( LDAP_DEBUG_TRACE,
 165                                                 "   backsql_modify_delete_all_values(): "
 166                                                 "error binding output parameter for %s[%d]\n",
 167                                                 at->bam_ad->ad_cname.bv_val, i, 0 );
 168                                         backsql_PrintErrors( bi->sql_db_env, dbh,
 169                                                 sth, rc );
 170                                         SQLFreeStmt( sth, SQL_DROP );
 171
 172                                         rs->sr_text = "SQL-backend error";
 173                                         rs->sr_err = LDAP_OTHER;
 174                                         goto done;
 175                                 }
 176                         }
 177                         po = ( BACKSQL_IS_DEL( at->bam_param_order ) ) > 0;
 178                         rc = backsql_BindParamID( sth, pno + 1 + po,
 179                                 SQL_PARAM_INPUT, &e_id->eid_keyval );
 180                         if ( rc != SQL_SUCCESS ) {
 181                                 Debug( LDAP_DEBUG_TRACE,
 182                                         "   backsql_modify_delete_all_values(): "
 183                                         "error binding keyval parameter for %s[%d]\n",
 184                                         at->bam_ad->ad_cname.bv_val, i, 0 );
 185                                 backsql_PrintErrors( bi->sql_db_env, dbh,
 186                                         sth, rc );
 187                                 SQLFreeStmt( sth, SQL_DROP );
 188
 189                                 rs->sr_text = "SQL-backend error";
 190                                 rs->sr_err = LDAP_OTHER;
 191                                 goto done;
 192                         }
 193 #ifdef BACKSQL_ARBITRARY_KEY
 194                         Debug( LDAP_DEBUG_TRACE,
 195                                 "   backsql_modify_delete_all_values() "
 196                                 "arg(%d)=%s\n",
 197                                 pno + 1 + po, e_id->eid_keyval.bv_val, 0 );
 198 #else /* ! BACKSQL_ARBITRARY_KEY */
 199                         Debug( LDAP_DEBUG_TRACE,
 200                                 "   backsql_modify_delete_all_values() "
 201                                 "arg(%d)=%lu\n",
 202                                 pno + 1 + po, e_id->eid_keyval, 0 );
 203 #endif /* ! BACKSQL_ARBITRARY_KEY */
 204
 205                         /*
 206                          * check for syntax needed here
 207                          * maybe need binary bind?
 208                          */
 209                         col_len = strlen( row.cols[ i ] );
 210                         rc = backsql_BindParamStr( sth, pno + 2 - po,
 211                                 SQL_PARAM_INPUT, row.cols[ i ], col_len );
 212                         if ( rc != SQL_SUCCESS ) {
 213                                 Debug( LDAP_DEBUG_TRACE,
 214                                         "   backsql_modify_delete_all_values(): "
 215                                         "error binding value parameter for %s[%d]\n",
 216                                         at->bam_ad->ad_cname.bv_val, i, 0 );
 217                                 backsql_PrintErrors( bi->sql_db_env, dbh,
 218                                         sth, rc );
 219                                 SQLFreeStmt( sth, SQL_DROP );
 220
 221                                 rs->sr_text = "SQL-backend error";
 222                                 rs->sr_err = LDAP_OTHER;
 223                                 goto done;
 224                         }
 225
 226                         Debug( LDAP_DEBUG_TRACE,
 227                                 "   backsql_modify_delete_all_values(): "
 228                                 "arg(%d)=%s; executing \"%s\"\n",
 229                                 pno + 2 - po, row.cols[ i ],
 230                                 at->bam_delete_proc );
 231                         rc = SQLExecute( sth );
 232                         if ( rc == SQL_SUCCESS && prc == LDAP_SUCCESS ) {
 233                                 rs->sr_err = LDAP_SUCCESS;
 234
 235                         } else {
 236                                 Debug( LDAP_DEBUG_TRACE,
 237                                         "   backsql_modify_delete_all_values(): "
 238                                         "delete_proc "
 239                                         "execution failed (rc=%d, prc=%d)\n",
 240                                         rc, prc, 0 );
 241                                 if ( prc != LDAP_SUCCESS ) {
 242                                         /* SQL procedure executed fine
 243                                          * but returned an error */
 244                                         rs->sr_err = BACKSQL_SANITIZE_ERROR( prc );
 245
 246                                 } else {
 247                                         backsql_PrintErrors( bi->sql_db_env, dbh,
 248                                                         sth, rc );
 249                                         rs->sr_err = LDAP_OTHER;
 250                                 }
 251                                 rs->sr_text = op->o_req_dn.bv_val;
 252                                 SQLFreeStmt( sth, SQL_DROP );
 253                                 goto done;
 254                         }
 255                         SQLFreeStmt( sth, SQL_DROP );
 256                 }
 257         }
 258
 259         rs->sr_err = LDAP_SUCCESS;
 260
 261 done:;
 262         backsql_FreeRow_x( &row, op->o_tmpmemctx );
 263         SQLFreeStmt( asth, SQL_DROP );
 264
 265         return rs->sr_err;
 266 }
 267
 268 int
 269 backsql_modify_internal(
 270         Operation               *op,
 271         SlapReply               *rs,
 272         SQLHDBC                 dbh,
 273         backsql_oc_map_rec      *oc,
 274         backsql_entryID         *e_id,
 275         Modifications           *modlist )
 276 {
 277         backsql_info    *bi = (backsql_info *)op->o_bd->be_private;
 278         RETCODE         rc;
 279         Modifications   *ml;
 280
 281         Debug( LDAP_DEBUG_TRACE, "==>backsql_modify_internal(): "
 282                 "traversing modifications list\n", 0, 0, 0 );
 283
 284         for ( ml = modlist; ml != NULL; ml = ml->sml_next ) {
 285                 AttributeDescription    *ad;
 286                 int                     sm_op;
 287                 static char             *sm_ops[] = { "add", "delete", "replace", "increment", NULL };
 288
 289                 BerVarray               sm_values;
 290 #if 0
 291                 /* NOTE: some day we'll have to pass
 292                  * the normalized values as well */
 293                 BerVarray               sm_nvalues;
 294 #endif
 295                 backsql_at_map_rec      *at = NULL;
 296                 struct berval           *at_val;
 297                 int                     i;
 298
 299                 ad = ml->sml_mod.sm_desc;
 300                 sm_op = ( ml->sml_mod.sm_op & LDAP_MOD_OP );
 301                 sm_values = ml->sml_mod.sm_values;
 302 #if 0
 303                 sm_nvalues = ml->sml_mod.sm_nvalues;
 304 #endif
 305
 306                 Debug( LDAP_DEBUG_TRACE, "   backsql_modify_internal(): "
 307                         "modifying attribute \"%s\" (%s) according to "
 308                         "mappings for objectClass \"%s\"\n",
 309                         ad->ad_cname.bv_val, sm_ops[ sm_op ], BACKSQL_OC_NAME( oc ) );
 310
 311                 if ( backsql_attr_skip( ad, sm_values ) ) {
 312                         continue;
 313                 }
 314
 315                 at = backsql_ad2at( oc, ad );
 316                 if ( at == NULL ) {
 317                         Debug( LDAP_DEBUG_TRACE, "   backsql_modify_internal(): "
 318                                 "attribute \"%s\" is not registered "
 319                                 "in objectClass \"%s\"\n",
 320                                 ad->ad_cname.bv_val, BACKSQL_OC_NAME( oc ), 0 );
 321
 322                         if ( BACKSQL_FAIL_IF_NO_MAPPING( bi ) ) {
 323                                 rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
 324                                 rs->sr_text = "operation not permitted "
 325                                         "within namingContext";
 326                                 goto done;
 327                         }
 328
 329                         continue;
 330                 }
 331
 332                 switch ( sm_op ) {
 333                 case LDAP_MOD_REPLACE: {
 334                         Debug( LDAP_DEBUG_TRACE, "   backsql_modify_internal(): "
 335                                 "replacing values for attribute \"%s\"\n",
 336                                 at->bam_ad->ad_cname.bv_val, 0, 0 );
 337
 338                         if ( at->bam_add_proc == NULL ) {
 339                                 Debug( LDAP_DEBUG_TRACE,
 340                                         "   backsql_modify_internal(): "
 341                                         "add procedure is not defined "
 342                                         "for attribute \"%s\" "
 343                                         "- unable to perform replacements\n",
 344                                         at->bam_ad->ad_cname.bv_val, 0, 0 );
 345
 346                                 if ( BACKSQL_FAIL_IF_NO_MAPPING( bi ) ) {
 347                                         rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
 348                                         rs->sr_text = "operation not permitted "
 349                                                 "within namingContext";
 350                                         goto done;
 351                                 }
 352
 353                                 break;
 354                         }
 355
 356                         if ( at->bam_delete_proc == NULL ) {
 357                                 if ( BACKSQL_FAIL_IF_NO_MAPPING( bi ) ) {
 358                                         Debug( LDAP_DEBUG_TRACE,
 359                                                 "   backsql_modify_internal(): "
 360                                                 "delete procedure is not defined "
 361                                                 "for attribute \"%s\"\n",
 362                                                 at->bam_ad->ad_cname.bv_val, 0, 0 );
 363
 364                                         rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
 365                                         rs->sr_text = "operation not permitted "
 366                                                 "within namingContext";
 367                                         goto done;
 368                                 }
 369
 370                                 Debug( LDAP_DEBUG_TRACE,
 371                                         "   backsql_modify_internal(): "
 372                                         "delete procedure is not defined "
 373                                         "for attribute \"%s\" "
 374                                         "- adding only\n",
 375                                         at->bam_ad->ad_cname.bv_val, 0, 0 );
 376
 377                                 goto add_only;
 378                         }
 379
 380 del_all:
 381                         rs->sr_err = backsql_modify_delete_all_values( op, rs, dbh, e_id, at );
 382                         if ( rs->sr_err != LDAP_SUCCESS ) {
 383                                 goto done;
 384                         }
 385
 386                         /* LDAP_MOD_DELETE gets here if all values must be deleted */
 387                         if ( sm_op == LDAP_MOD_DELETE ) {
 388                                 break;
 389                         }
 390                 }
 391
 392                 /*
 393                  * PASSTHROUGH - to add new attributes -- do NOT add break
 394                  */
 395                 case LDAP_MOD_ADD:
 396                 /* case SLAP_MOD_SOFTADD: */
 397 add_only:;
 398                         if ( at->bam_add_proc == NULL ) {
 399                                 Debug( LDAP_DEBUG_TRACE,
 400                                         "   backsql_modify_internal(): "
 401                                         "add procedure is not defined "
 402                                         "for attribute \"%s\"\n",
 403                                         at->bam_ad->ad_cname.bv_val, 0, 0 );
 404
 405                                 if ( BACKSQL_FAIL_IF_NO_MAPPING( bi ) ) {
 406                                         rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
 407                                         rs->sr_text = "operation not permitted "
 408                                                 "within namingContext";
 409                                         goto done;
 410                                 }
 411
 412                                 break;
 413                         }
 414
 415                         Debug( LDAP_DEBUG_TRACE, "   backsql_modify_internal(): "
 416                                 "adding new values for attribute \"%s\"\n",
 417                                 at->bam_ad->ad_cname.bv_val, 0, 0 );
 418
 419                         /* can't add a NULL val array */
 420                         assert( sm_values != NULL );
 421
 422                         for ( i = 0, at_val = sm_values;
 423                                         !BER_BVISNULL( at_val );
 424                                         i++, at_val++ )
 425                         {
 426                                 SQLHSTMT        sth = SQL_NULL_HSTMT;
 427                                 /* first parameter position, parameter order */
 428                                 SQLUSMALLINT    pno = 0,
 429                                                 po;
 430                                 /* procedure return code */
 431                                 int             prc = LDAP_SUCCESS;
 432
 433                                 rc = backsql_Prepare( dbh, &sth, at->bam_add_proc, 0 );
 434                                 if ( rc != SQL_SUCCESS ) {
 435                                         Debug( LDAP_DEBUG_TRACE,
 436                                                 "   backsql_modify_internal(): "
 437                                                 "error preparing add query\n",
 438                                                 0, 0, 0 );
 439                                         backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc );
 440
 441                                         rs->sr_err = LDAP_OTHER;
 442                                         rs->sr_text = "SQL-backend error";
 443                                         goto done;
 444                                 }
 445
 446                                 if ( BACKSQL_IS_ADD( at->bam_expect_return ) ) {
 447                                         pno = 1;
 448                                         rc = backsql_BindParamInt( sth, 1,
 449                                                 SQL_PARAM_OUTPUT, &prc );
 450                                         if ( rc != SQL_SUCCESS ) {
 451                                                 Debug( LDAP_DEBUG_TRACE,
 452                                                         "   backsql_modify_internal(): "
 453                                                         "error binding output parameter for %s[%d]\n",
 454                                                         at->bam_ad->ad_cname.bv_val, i, 0 );
 455                                                 backsql_PrintErrors( bi->sql_db_env, dbh,
 456                                                         sth, rc );
 457                                                 SQLFreeStmt( sth, SQL_DROP );
 458
 459                                                 rs->sr_text = "SQL-backend error";
 460                                                 rs->sr_err = LDAP_OTHER;
 461                                                 goto done;
 462                                         }
 463                                 }
 464                                 po = ( BACKSQL_IS_ADD( at->bam_param_order ) ) > 0;
 465                                 rc = backsql_BindParamID( sth, pno + 1 + po,
 466                                         SQL_PARAM_INPUT, &e_id->eid_keyval );
 467                                 if ( rc != SQL_SUCCESS ) {
 468                                         Debug( LDAP_DEBUG_TRACE,
 469                                                 "   backsql_modify_internal(): "
 470                                                 "error binding keyval parameter for %s[%d]\n",
 471                                                 at->bam_ad->ad_cname.bv_val, i, 0 );
 472                                         backsql_PrintErrors( bi->sql_db_env, dbh,
 473                                                 sth, rc );
 474                                         SQLFreeStmt( sth, SQL_DROP );
 475
 476                                         rs->sr_text = "SQL-backend error";
 477                                         rs->sr_err = LDAP_OTHER;
 478                                         goto done;
 479                                 }
 480 #ifdef BACKSQL_ARBITRARY_KEY
 481                                 Debug( LDAP_DEBUG_TRACE,
 482                                         "   backsql_modify_internal(): "
 483                                         "arg(%d)=\"%s\"\n",
 484                                         pno + 1 + po, e_id->eid_keyval.bv_val, 0 );
 485 #else /* ! BACKSQL_ARBITRARY_KEY */
 486                                 Debug( LDAP_DEBUG_TRACE,
 487                                         "   backsql_modify_internal(): "
 488                                         "arg(%d)=\"%lu\"\n",
 489                                         pno + 1 + po, e_id->eid_keyval, 0 );
 490 #endif /* ! BACKSQL_ARBITRARY_KEY */
 491
 492                                 /*
 493                                  * check for syntax needed here
 494                                  * maybe need binary bind?
 495                                  */
 496                                 rc = backsql_BindParamBerVal( sth, pno + 2 - po,
 497                                         SQL_PARAM_INPUT, at_val );
 498                                 if ( rc != SQL_SUCCESS ) {
 499                                         Debug( LDAP_DEBUG_TRACE,
 500                                                 "   backsql_modify_internal(): "
 501                                                 "error binding value parameter for %s[%d]\n",
 502                                                 at->bam_ad->ad_cname.bv_val, i, 0 );
 503                                         backsql_PrintErrors( bi->sql_db_env, dbh,
 504                                                 sth, rc );
 505                                         SQLFreeStmt( sth, SQL_DROP );
 506
 507                                         rs->sr_text = "SQL-backend error";
 508                                         rs->sr_err = LDAP_OTHER;
 509                                         goto done;
 510                                 }
 511                                 Debug( LDAP_DEBUG_TRACE,
 512                                         "   backsql_modify_internal(): "
 513                                         "arg(%d)=\"%s\"; executing \"%s\"\n",
 514                                         pno + 2 - po, at_val->bv_val,
 515                                         at->bam_add_proc );
 516
 517                                 rc = SQLExecute( sth );
 518                                 if ( rc == SQL_SUCCESS && prc == LDAP_SUCCESS ) {
 519                                         rs->sr_err = LDAP_SUCCESS;
 520
 521                                 } else {
 522                                         Debug( LDAP_DEBUG_TRACE,
 523                                                 "   backsql_modify_internal(): "
 524                                                 "add_proc execution failed "
 525                                                 "(rc=%d, prc=%d)\n",
 526                                                 rc, prc, 0 );
 527                                         if ( prc != LDAP_SUCCESS ) {
 528                                                 /* SQL procedure executed fine
 529                                                  * but returned an error */
 530                                                 SQLFreeStmt( sth, SQL_DROP );
 531
 532                                                 rs->sr_err = BACKSQL_SANITIZE_ERROR( prc );
 533                                                 rs->sr_text = at->bam_ad->ad_cname.bv_val;
 534                                                 return rs->sr_err;
 535
 536                                         } else {
 537                                                 backsql_PrintErrors( bi->sql_db_env, dbh,
 538                                                                 sth, rc );
 539                                                 if ( BACKSQL_FAIL_IF_NO_MAPPING( bi ) )
 540                                                 {
 541                                                         SQLFreeStmt( sth, SQL_DROP );
 542
 543                                                         rs->sr_err = LDAP_OTHER;
 544                                                         rs->sr_text = "SQL-backend error";
 545                                                         goto done;
 546                                                 }
 547                                         }
 548                                 }
 549                                 SQLFreeStmt( sth, SQL_DROP );
 550                         }
 551                         break;
 552
 553                 case LDAP_MOD_DELETE:
 554                         if ( at->bam_delete_proc == NULL ) {
 555                                 Debug( LDAP_DEBUG_TRACE,
 556                                         "   backsql_modify_internal(): "
 557                                         "delete procedure is not defined "
 558                                         "for attribute \"%s\"\n",
 559                                         at->bam_ad->ad_cname.bv_val, 0, 0 );
 560
 561                                 if ( BACKSQL_FAIL_IF_NO_MAPPING( bi ) ) {
 562                                         rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
 563                                         rs->sr_text = "operation not permitted "
 564                                                 "within namingContext";
 565                                         goto done;
 566                                 }
 567
 568                                 break;
 569                         }
 570
 571                         if ( sm_values == NULL ) {
 572                                 Debug( LDAP_DEBUG_TRACE,
 573                                         "   backsql_modify_internal(): "
 574                                         "no values given to delete "
 575                                         "for attribute \"%s\" "
 576                                         "-- deleting all values\n",
 577                                         at->bam_ad->ad_cname.bv_val, 0, 0 );
 578                                 goto del_all;
 579                         }
 580
 581                         Debug( LDAP_DEBUG_TRACE, "   backsql_modify_internal(): "
 582                                 "deleting values for attribute \"%s\"\n",
 583                                 at->bam_ad->ad_cname.bv_val, 0, 0 );
 584
 585                         for ( i = 0, at_val = sm_values;
 586                                         !BER_BVISNULL( at_val );
 587                                         i++, at_val++ )
 588                         {
 589                                 SQLHSTMT        sth = SQL_NULL_HSTMT;
 590                                 /* first parameter position, parameter order */
 591                                 SQLUSMALLINT    pno = 0,
 592                                                 po;
 593                                 /* procedure return code */
 594                                 int             prc = LDAP_SUCCESS;
 595
 596                                 rc = backsql_Prepare( dbh, &sth, at->bam_delete_proc, 0 );
 597                                 if ( rc != SQL_SUCCESS ) {
 598                                         Debug( LDAP_DEBUG_TRACE,
 599                                                 "   backsql_modify_internal(): "
 600                                                 "error preparing delete query\n",
 601                                                 0, 0, 0 );
 602                                         backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc );
 603
 604                                         rs->sr_err = LDAP_OTHER;
 605                                         rs->sr_text = "SQL-backend error";
 606                                         goto done;
 607                                 }
 608
 609                                 if ( BACKSQL_IS_DEL( at->bam_expect_return ) ) {
 610                                         pno = 1;
 611                                         rc = backsql_BindParamInt( sth, 1,
 612                                                 SQL_PARAM_OUTPUT, &prc );
 613                                         if ( rc != SQL_SUCCESS ) {
 614                                                 Debug( LDAP_DEBUG_TRACE,
 615                                                         "   backsql_modify_internal(): "
 616                                                         "error binding output parameter for %s[%d]\n",
 617                                                         at->bam_ad->ad_cname.bv_val, i, 0 );
 618                                                 backsql_PrintErrors( bi->sql_db_env, dbh,
 619                                                         sth, rc );
 620                                                 SQLFreeStmt( sth, SQL_DROP );
 621
 622                                                 rs->sr_text = "SQL-backend error";
 623                                                 rs->sr_err = LDAP_OTHER;
 624                                                 goto done;
 625                                         }
 626                                 }
 627                                 po = ( BACKSQL_IS_DEL( at->bam_param_order ) ) > 0;
 628                                 rc = backsql_BindParamID( sth, pno + 1 + po,
 629                                         SQL_PARAM_INPUT, &e_id->eid_keyval );
 630                                 if ( rc != SQL_SUCCESS ) {
 631                                         Debug( LDAP_DEBUG_TRACE,
 632                                                 "   backsql_modify_internal(): "
 633                                                 "error binding keyval parameter for %s[%d]\n",
 634                                                 at->bam_ad->ad_cname.bv_val, i, 0 );
 635                                         backsql_PrintErrors( bi->sql_db_env, dbh,
 636                                                 sth, rc );
 637                                         SQLFreeStmt( sth, SQL_DROP );
 638
 639                                         rs->sr_text = "SQL-backend error";
 640                                         rs->sr_err = LDAP_OTHER;
 641                                         goto done;
 642                                 }
 643 #ifdef BACKSQL_ARBITRARY_KEY
 644                                 Debug( LDAP_DEBUG_TRACE,
 645                                         "   backsql_modify_internal(): "
 646                                         "arg(%d)=\"%s\"\n",
 647                                         pno + 1 + po, e_id->eid_keyval.bv_val, 0 );
 648 #else /* ! BACKSQL_ARBITRARY_KEY */
 649                                 Debug( LDAP_DEBUG_TRACE,
 650                                         "   backsql_modify_internal(): "
 651                                         "arg(%d)=\"%lu\"\n",
 652                                         pno + 1 + po, e_id->eid_keyval, 0 );
 653 #endif /* ! BACKSQL_ARBITRARY_KEY */
 654
 655                                 /*
 656                                  * check for syntax needed here
 657                                  * maybe need binary bind?
 658                                  */
 659                                 rc = backsql_BindParamBerVal( sth, pno + 2 - po,
 660                                         SQL_PARAM_INPUT, at_val );
 661                                 if ( rc != SQL_SUCCESS ) {
 662                                         Debug( LDAP_DEBUG_TRACE,
 663                                                 "   backsql_modify_internal(): "
 664                                                 "error binding value parameter for %s[%d]\n",
 665                                                 at->bam_ad->ad_cname.bv_val, i, 0 );
 666                                         backsql_PrintErrors( bi->sql_db_env, dbh,
 667                                                 sth, rc );
 668                                         SQLFreeStmt( sth, SQL_DROP );
 669
 670                                         rs->sr_text = "SQL-backend error";
 671                                         rs->sr_err = LDAP_OTHER;
 672                                         goto done;
 673                                 }
 674
 675                                 Debug( LDAP_DEBUG_TRACE,
 676                                         "   backsql_modify_internal(): "
 677                                         "executing \"%s\"\n",
 678                                         at->bam_delete_proc, 0, 0 );
 679                                 rc = SQLExecute( sth );
 680                                 if ( rc == SQL_SUCCESS && prc == LDAP_SUCCESS )
 681                                 {
 682                                         rs->sr_err = LDAP_SUCCESS;
 683
 684                                 } else {
 685                                         Debug( LDAP_DEBUG_TRACE,
 686                                                 "   backsql_modify_internal(): "
 687                                                 "delete_proc execution "
 688                                                 "failed (rc=%d, prc=%d)\n",
 689                                                 rc, prc, 0 );
 690
 691                                         if ( prc != LDAP_SUCCESS ) {
 692                                                 /* SQL procedure executed fine
 693                                                  * but returned an error */
 694                                                 rs->sr_err = BACKSQL_SANITIZE_ERROR( prc );
 695                                                 rs->sr_text = at->bam_ad->ad_cname.bv_val;
 696                                                 goto done;
 697
 698                                         } else {
 699                                                 backsql_PrintErrors( bi->sql_db_env,
 700                                                                 dbh, sth, rc );
 701                                                 SQLFreeStmt( sth, SQL_DROP );
 702                                                 rs->sr_err = LDAP_OTHER;
 703                                                 rs->sr_text = at->bam_ad->ad_cname.bv_val;
 704                                                 goto done;
 705                                         }
 706                                 }
 707                                 SQLFreeStmt( sth, SQL_DROP );
 708                         }
 709                         break;
 710
 711                 case LDAP_MOD_INCREMENT:
 712                         Debug( LDAP_DEBUG_TRACE, "   backsql_modify_internal(): "
 713                                 "increment not supported yet\n", 0, 0, 0 );
 714                         if ( BACKSQL_FAIL_IF_NO_MAPPING( bi ) ) {
 715                                 rs->sr_err = LDAP_OTHER;
 716                                 rs->sr_text = "SQL-backend error";
 717                                 goto done;
 718                         }
 719                         break;
 720                 }
 721         }
 722
 723 done:;
 724         Debug( LDAP_DEBUG_TRACE, "<==backsql_modify_internal(): %d%s%s\n",
 725                 rs->sr_err,
 726                 rs->sr_text ? ": " : "",
 727                 rs->sr_text ? rs->sr_text : "" );
 728
 729         /*
 730          * FIXME: should fail in case one change fails?
 731          */
 732         return rs->sr_err;
 733 }
 734
 735 static int
 736 backsql_add_attr(
 737         Operation               *op,
 738         SlapReply               *rs,
 739         SQLHDBC                 dbh,
 740         backsql_oc_map_rec      *oc,
 741         Attribute               *at,
 742         unsigned long           new_keyval )
 743 {
 744         backsql_info            *bi = (backsql_info*)op->o_bd->be_private;
 745         backsql_at_map_rec      *at_rec = NULL;
 746         struct berval           *at_val;
 747         unsigned long           i;
 748         RETCODE                 rc;
 749         SQLUSMALLINT            currpos;
 750         SQLHSTMT                sth = SQL_NULL_HSTMT;
 751
 752         at_rec = backsql_ad2at( oc, at->a_desc );
 753
 754         if ( at_rec == NULL ) {
 755                 Debug( LDAP_DEBUG_TRACE, "   backsql_add_attr(\"%s\"): "
 756                         "attribute \"%s\" is not registered "
 757                         "in objectclass \"%s\"\n",
 758                         op->ora_e->e_name.bv_val,
 759                         at->a_desc->ad_cname.bv_val,
 760                         BACKSQL_OC_NAME( oc ) );
 761
 762                 if ( BACKSQL_FAIL_IF_NO_MAPPING( bi ) ) {
 763                         rs->sr_text = "operation not permitted "
 764                                 "within namingContext";
 765                         return rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
 766                 }
 767
 768                 return LDAP_SUCCESS;
 769         }
 770
 771         if ( at_rec->bam_add_proc == NULL ) {
 772                 Debug( LDAP_DEBUG_TRACE, "   backsql_add_attr(\"%s\"): "
 773                         "add procedure is not defined "
 774                         "for attribute \"%s\" "
 775                         "of structuralObjectClass \"%s\"\n",
 776                         op->ora_e->e_name.bv_val,
 777                         at->a_desc->ad_cname.bv_val,
 778                         BACKSQL_OC_NAME( oc ) );
 779
 780                 if ( BACKSQL_FAIL_IF_NO_MAPPING( bi ) ) {
 781                         rs->sr_text = "operation not permitted "
 782                                 "within namingContext";
 783                         return rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
 784                 }
 785
 786                 return LDAP_SUCCESS;
 787         }
 788
 789         for ( i = 0, at_val = &at->a_vals[ i ];
 790                         !BER_BVISNULL( at_val );
 791                         i++, at_val = &at->a_vals[ i ] )
 792         {
 793                 /* procedure return code */
 794                 int             prc = LDAP_SUCCESS;
 795                 /* first parameter #, parameter order */
 796                 SQLUSMALLINT    pno, po;
 797                 char            logbuf[] = "val[18446744073709551615UL], id=18446744073709551615UL";
 798
 799                 /*
 800                  * Do not deal with the objectClass that is used
 801                  * to build the entry
 802                  */
 803                 if ( at->a_desc == slap_schema.si_ad_objectClass ) {
 804                         if ( dn_match( at_val, &oc->bom_oc->soc_cname ) )
 805                         {
 806                                 continue;
 807                         }
 808                 }
 809
 810                 rc = backsql_Prepare( dbh, &sth, at_rec->bam_add_proc, 0 );
 811                 if ( rc != SQL_SUCCESS ) {
 812                         rs->sr_text = "SQL-backend error";
 813                         return rs->sr_err = LDAP_OTHER;
 814                 }
 815
 816                 if ( BACKSQL_IS_ADD( at_rec->bam_expect_return ) ) {
 817                         pno = 1;
 818                         rc = backsql_BindParamInt( sth, 1, SQL_PARAM_OUTPUT, &prc );
 819                         if ( rc != SQL_SUCCESS ) {
 820                                 Debug( LDAP_DEBUG_TRACE,
 821                                         "   backsql_add_attr(): "
 822                                         "error binding output parameter for %s[%d]\n",
 823                                         at_rec->bam_ad->ad_cname.bv_val, i, 0 );
 824                                 backsql_PrintErrors( bi->sql_db_env, dbh,
 825                                         sth, rc );
 826                                 SQLFreeStmt( sth, SQL_DROP );
 827
 828                                 rs->sr_text = "SQL-backend error";
 829                                 return rs->sr_err = LDAP_OTHER;
 830                         }
 831
 832                 } else {
 833                         pno = 0;
 834                 }
 835
 836                 po = ( BACKSQL_IS_ADD( at_rec->bam_param_order ) ) > 0;
 837                 currpos = pno + 1 + po;
 838                 rc = backsql_BindParamInt( sth, currpos,
 839                                 SQL_PARAM_INPUT, &new_keyval );
 840                 if ( rc != SQL_SUCCESS ) {
 841                         Debug( LDAP_DEBUG_TRACE,
 842                                 "   backsql_add_attr(): "
 843                                 "error binding keyval parameter for %s[%d]\n",
 844                                 at_rec->bam_ad->ad_cname.bv_val, i, 0 );
 845                         backsql_PrintErrors( bi->sql_db_env, dbh,
 846                                 sth, rc );
 847                         SQLFreeStmt( sth, SQL_DROP );
 848
 849                         rs->sr_text = "SQL-backend error";
 850                         return rs->sr_err = LDAP_OTHER;
 851                 }
 852
 853                 currpos = pno + 2 - po;
 854
 855                 /*
 856                  * check for syntax needed here
 857                  * maybe need binary bind?
 858                  */
 859
 860                 rc = backsql_BindParamBerVal( sth, currpos, SQL_PARAM_INPUT, at_val );
 861                 if ( rc != SQL_SUCCESS ) {
 862                         Debug( LDAP_DEBUG_TRACE,
 863                                 "   backsql_add_attr(): "
 864                                 "error binding value parameter for %s[%d]\n",
 865                                 at_rec->bam_ad->ad_cname.bv_val, i, 0 );
 866                         backsql_PrintErrors( bi->sql_db_env, dbh,
 867                                 sth, rc );
 868                         SQLFreeStmt( sth, SQL_DROP );
 869
 870                         rs->sr_text = "SQL-backend error";
 871                         return rs->sr_err = LDAP_OTHER;
 872                 }
 873
 874 #ifdef LDAP_DEBUG
 875                 snprintf( logbuf, sizeof( logbuf ), "val[%lu], id=%lu",
 876                                 i, new_keyval );
 877                 Debug( LDAP_DEBUG_TRACE, "   backsql_add_attr(\"%s\"): "
 878                         "executing \"%s\" %s\n",
 879                         op->ora_e->e_name.bv_val,
 880                         at_rec->bam_add_proc, logbuf );
 881 #endif
 882                 rc = SQLExecute( sth );
 883                 if ( rc == SQL_SUCCESS && prc == LDAP_SUCCESS ) {
 884                         rs->sr_err = LDAP_SUCCESS;
 885
 886                 } else {
 887                         Debug( LDAP_DEBUG_TRACE,
 888                                 "   backsql_add_attr(\"%s\"): "
 889                                 "add_proc execution failed (rc=%d, prc=%d)\n",
 890                                 op->ora_e->e_name.bv_val, rc, prc );
 891                         if ( prc != LDAP_SUCCESS ) {
 892                                 /* SQL procedure executed fine
 893                                  * but returned an error */
 894                                 rs->sr_err = BACKSQL_SANITIZE_ERROR( prc );
 895                                 rs->sr_text = op->ora_e->e_name.bv_val;
 896                                 SQLFreeStmt( sth, SQL_DROP );
 897                                 return rs->sr_err;
 898
 899                         } else {
 900                                 backsql_PrintErrors( bi->sql_db_env, dbh,
 901                                                 sth, rc );
 902                                 rs->sr_err = LDAP_OTHER;
 903                                 rs->sr_text = op->ora_e->e_name.bv_val;
 904                                 SQLFreeStmt( sth, SQL_DROP );
 905                                 return rs->sr_err;
 906                         }
 907                 }
 908                 SQLFreeStmt( sth, SQL_DROP );
 909         }
 910
 911         return LDAP_SUCCESS;
 912 }
 913
 914 int
 915 backsql_add( Operation *op, SlapReply *rs )
 916 {
 917         backsql_info            *bi = (backsql_info*)op->o_bd->be_private;
 918         SQLHDBC                 dbh = SQL_NULL_HDBC;
 919         SQLHSTMT                sth = SQL_NULL_HSTMT;
 920         unsigned long           new_keyval = 0;
 921         RETCODE                 rc;
 922         backsql_oc_map_rec      *oc = NULL;
 923         backsql_srch_info       bsi = { 0 };
 924         Entry                   p = { 0 }, *e = NULL;
 925         Attribute               *at,
 926                                 *at_objectClass = NULL;
 927         struct berval           scname = BER_BVNULL;
 928         struct berval           pdn;
 929         struct berval           realdn = BER_BVNULL;
 930         int                     colnum;
 931         slap_mask_t             mask;
 932
 933 #ifdef BACKSQL_SYNCPROV
 934         /*
 935          * NOTE: fake successful result to force contextCSN to be bumped up
 936          */
 937         if ( op->o_sync ) {
 938                 char            buf[ LDAP_LUTIL_CSNSTR_BUFSIZE ];
 939                 struct berval   csn = BER_BVNULL;
 940
 941                 slap_get_csn( op, buf, sizeof( buf ), &csn, 1 );
 942
 943                 rs->sr_err = LDAP_SUCCESS;
 944                 send_ldap_result( op, rs );
 945
 946                 slap_graduate_commit_csn( op );
 947
 948                 return 0;
 949         }
 950 #endif /* BACKSQL_SYNCPROV */
 951
 952         Debug( LDAP_DEBUG_TRACE, "==>backsql_add(\"%s\")\n",
 953                         op->ora_e->e_name.bv_val, 0, 0 );
 954
 955         /* check schema */
 956         if ( BACKSQL_CHECK_SCHEMA( bi ) ) {
 957                 char            textbuf[ SLAP_TEXT_BUFLEN ] = { '\0' };
 958
 959                 rs->sr_err = entry_schema_check( op, op->ora_e, NULL, 0,
 960                         &rs->sr_text, textbuf, sizeof( textbuf ) );
 961                 if ( rs->sr_err != LDAP_SUCCESS ) {
 962                         Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
 963                                 "entry failed schema check -- aborting\n",
 964                                 op->ora_e->e_name.bv_val, 0, 0 );
 965                         e = NULL;
 966                         goto done;
 967                 }
 968         }
 969
 970         /* search structuralObjectClass */
 971         for ( at = op->ora_e->e_attrs; at != NULL; at = at->a_next ) {
 972                 if ( at->a_desc == slap_schema.si_ad_structuralObjectClass ) {
 973                         break;
 974                 }
 975         }
 976
 977         /* there must exist */
 978         if ( at == NULL ) {
 979                 char            buf[ SLAP_TEXT_BUFLEN ];
 980                 const char      *text;
 981
 982                 /* search structuralObjectClass */
 983                 for ( at = op->ora_e->e_attrs; at != NULL; at = at->a_next ) {
 984                         if ( at->a_desc == slap_schema.si_ad_objectClass ) {
 985                                 break;
 986                         }
 987                 }
 988
 989                 if ( at == NULL ) {
 990                         Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
 991                                 "no objectClass\n",
 992                                 op->ora_e->e_name.bv_val, 0, 0 );
 993                         rs->sr_err = LDAP_OBJECT_CLASS_VIOLATION;
 994                         e = NULL;
 995                         goto done;
 996                 }
 997
 998                 rs->sr_err = structural_class( at->a_vals, &scname, NULL,
 999                                 &text, buf, sizeof( buf ) );
1000                 if ( rs->sr_err != LDAP_SUCCESS ) {
1001                         Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
1002                                 "%s (%d)\n",
1003                                 op->ora_e->e_name.bv_val, text, rs->sr_err );
1004                         e = NULL;
1005                         goto done;
1006                 }
1007
1008         } else {
1009                 scname = at->a_vals[0];
1010         }
1011
1012         /* I guess we should play with sub/supertypes to find a suitable oc */
1013         oc = backsql_name2oc( bi, &scname );
1014
1015         if ( oc == NULL ) {
1016                 Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
1017                         "cannot map structuralObjectClass \"%s\" -- aborting\n",
1018                         op->ora_e->e_name.bv_val,
1019                         scname.bv_val, 0 );
1020                 rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
1021                 rs->sr_text = "operation not permitted within namingContext";
1022                 e = NULL;
1023                 goto done;
1024         }
1025
1026         if ( oc->bom_create_proc == NULL ) {
1027                 Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
1028                         "create procedure is not defined "
1029                         "for structuralObjectClass \"%s\" - aborting\n",
1030                         op->ora_e->e_name.bv_val,
1031                         scname.bv_val, 0 );
1032                 rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
1033                 rs->sr_text = "operation not permitted within namingContext";
1034                 e = NULL;
1035                 goto done;
1036
1037         } else if ( BACKSQL_CREATE_NEEDS_SELECT( bi )
1038                         && oc->bom_create_keyval == NULL ) {
1039                 Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
1040                         "create procedure needs select procedure, "
1041                         "but none is defined for structuralObjectClass \"%s\" "
1042                         "- aborting\n",
1043                         op->ora_e->e_name.bv_val,
1044                         scname.bv_val, 0 );
1045                 rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
1046                 rs->sr_text = "operation not permitted within namingContext";
1047                 e = NULL;
1048                 goto done;
1049         }
1050
1051         rs->sr_err = backsql_get_db_conn( op, &dbh );
1052         if ( rs->sr_err != LDAP_SUCCESS ) {
1053                 Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
1054                         "could not get connection handle - exiting\n",
1055                         op->ora_e->e_name.bv_val, 0, 0 );
1056                 rs->sr_text = ( rs->sr_err == LDAP_OTHER )
1057                         ?  "SQL-backend error" : NULL;
1058                 e = NULL;
1059                 goto done;
1060         }
1061
1062         /*
1063          * Check if entry exists
1064         *
1065          * NOTE: backsql_api_dn2odbc() is called explicitly because
1066          * we need the mucked DN to pass it to the create procedure.
1067          */
1068         realdn = op->ora_e->e_name;
1069         if ( backsql_api_dn2odbc( op, rs, &realdn ) ) {
1070                 Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
1071                         "backsql_api_dn2odbc(\"%s\") failed\n",
1072                         op->ora_e->e_name.bv_val, realdn.bv_val, 0 );
1073                 rs->sr_err = LDAP_OTHER;
1074                 rs->sr_text = "SQL-backend error";
1075                 e = NULL;
1076                 goto done;
1077         }
1078
1079         rs->sr_err = backsql_dn2id( op, rs, dbh, &realdn, NULL, 0, 0 );
1080         if ( rs->sr_err == LDAP_SUCCESS ) {
1081                 Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
1082                         "entry exists\n",
1083                         op->ora_e->e_name.bv_val, 0, 0 );
1084                 rs->sr_err = LDAP_ALREADY_EXISTS;
1085                 e = op->ora_e;
1086                 goto done;
1087         }
1088
1089         /*
1090          * Get the parent dn and see if the corresponding entry exists.
1091          */
1092         if ( be_issuffix( op->o_bd, &op->ora_e->e_nname ) ) {
1093                 pdn = slap_empty_bv;
1094
1095         } else {
1096                 dnParent( &op->ora_e->e_nname, &pdn );
1097         }
1098
1099         /*
1100          * Get the parent
1101          */
1102         bsi.bsi_e = &p;
1103         rs->sr_err = backsql_init_search( &bsi, &pdn,
1104                         LDAP_SCOPE_BASE,
1105                         SLAP_NO_LIMIT, SLAP_NO_LIMIT,
1106                         (time_t)(-1), NULL, dbh, op, rs, slap_anlist_no_attrs,
1107                         ( BACKSQL_ISF_MATCHED | BACKSQL_ISF_GET_ENTRY ) );
1108         if ( rs->sr_err != LDAP_SUCCESS ) {
1109                 Debug( LDAP_DEBUG_TRACE, "backsql_add(): "
1110                         "could not retrieve addDN parent "
1111                         "\"%s\" ID - %s matched=\"%s\"\n",
1112                         pdn.bv_val,
1113                         rs->sr_err == LDAP_REFERRAL ? "referral" : "no such entry",
1114                         rs->sr_matched ? rs->sr_matched : "(null)" );
1115                 e = &p;
1116                 goto done;
1117         }
1118
1119         /* check "children" pseudo-attribute access to parent */
1120         if ( !access_allowed( op, &p, slap_schema.si_ad_children,
1121                                 NULL, ACL_WADD, NULL ) )
1122         {
1123                 rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
1124                 e = &p;
1125                 goto done;
1126         }
1127
1128         if ( get_assert( op ) &&
1129                 ( test_filter( op, op->oq_add.rs_e, get_assertion( op ) )
1130                         != LDAP_COMPARE_TRUE ) )
1131         {
1132                 rs->sr_err = LDAP_ASSERTION_FAILED;
1133                 e = op->ora_e;
1134                 goto done;
1135         }
1136
1137         if ( !access_allowed_mask( op, op->ora_e,
1138                                 slap_schema.si_ad_entry,
1139                                 NULL, ACL_WADD, NULL, &mask ) )
1140         {
1141                 rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
1142                 e = op->ora_e;
1143                 goto done;
1144         }
1145
1146         /*
1147          * create_proc is executed; if expect_return is set, then
1148          * an output parameter is bound, which should contain
1149          * the id of the added row; otherwise the procedure
1150          * is expected to return the id as the first column of a select
1151          */
1152         rc = backsql_Prepare( dbh, &sth, oc->bom_create_proc, 0 );
1153         if ( rc != SQL_SUCCESS ) {
1154                 rs->sr_err = LDAP_OTHER;
1155                 rs->sr_text = "SQL-backend error";
1156                 e = NULL;
1157                 goto done;
1158         }
1159
1160         colnum = 1;
1161         if ( BACKSQL_IS_ADD( oc->bom_expect_return ) ) {
1162                 rc = backsql_BindParamInt( sth, 1, SQL_PARAM_OUTPUT, &new_keyval );
1163                 if ( rc != SQL_SUCCESS ) {
1164                         Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
1165                                 "error binding keyval parameter "
1166                                 "for objectClass %s\n",
1167                                 op->ora_e->e_name.bv_val,
1168                                 oc->bom_oc->soc_cname.bv_val, 0 );
1169                         backsql_PrintErrors( bi->sql_db_env, dbh,
1170                                 sth, rc );
1171                         SQLFreeStmt( sth, SQL_DROP );
1172
1173                         rs->sr_text = "SQL-backend error";
1174                         rs->sr_err = LDAP_OTHER;
1175                         e = NULL;
1176                         goto done;
1177                 }
1178                 colnum++;
1179         }
1180
1181         if ( oc->bom_create_hint ) {
1182                 at = attr_find( op->ora_e->e_attrs, oc->bom_create_hint );
1183                 if ( at && at->a_vals ) {
1184                         backsql_BindParamStr( sth, colnum, SQL_PARAM_INPUT,
1185                                         at->a_vals[0].bv_val,
1186                                         at->a_vals[0].bv_len );
1187                         Debug( LDAP_DEBUG_TRACE, "backsql_add(): "
1188                                         "create_proc hint: param = '%s'\n",
1189                                         at->a_vals[0].bv_val, 0, 0 );
1190
1191                 } else {
1192                         backsql_BindParamStr( sth, colnum, SQL_PARAM_INPUT,
1193                                         "", 0 );
1194                         Debug( LDAP_DEBUG_TRACE, "backsql_add(): "
1195                                         "create_proc hint (%s) not avalable\n",
1196                                         oc->bom_create_hint->ad_cname.bv_val,
1197                                         0, 0 );
1198                 }
1199                 colnum++;
1200         }
1201
1202         Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): executing \"%s\"\n",
1203                 op->ora_e->e_name.bv_val, oc->bom_create_proc, 0 );
1204         rc = SQLExecute( sth );
1205         if ( rc != SQL_SUCCESS ) {
1206                 Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
1207                         "create_proc execution failed\n",
1208                         op->ora_e->e_name.bv_val, 0, 0 );
1209                 backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc);
1210                 SQLFreeStmt( sth, SQL_DROP );
1211                 rs->sr_err = LDAP_OTHER;
1212                 rs->sr_text = "SQL-backend error";
1213                 e = NULL;
1214                 goto done;
1215         }
1216
1217         /* FIXME: after SQLExecute(), the row is already inserted
1218          * (at least with PostgreSQL and unixODBC); needs investigation */
1219
1220         if ( !BACKSQL_IS_ADD( oc->bom_expect_return ) ) {
1221                 SWORD           ncols;
1222                 SQLINTEGER      value_len;
1223
1224                 if ( BACKSQL_CREATE_NEEDS_SELECT( bi ) ) {
1225                         SQLFreeStmt( sth, SQL_DROP );
1226
1227                         rc = backsql_Prepare( dbh, &sth, oc->bom_create_keyval, 0 );
1228                         if ( rc != SQL_SUCCESS ) {
1229                                 rs->sr_err = LDAP_OTHER;
1230                                 rs->sr_text = "SQL-backend error";
1231                                 e = NULL;
1232                                 goto done;
1233                         }
1234
1235                         rc = SQLExecute( sth );
1236                         if ( rc != SQL_SUCCESS ) {
1237                                 rs->sr_err = LDAP_OTHER;
1238                                 rs->sr_text = "SQL-backend error";
1239                                 e = NULL;
1240                                 goto done;
1241                         }
1242                 }
1243
1244                 /*
1245                  * the query to know the id of the inserted entry
1246                  * must be embedded in the create procedure
1247                  */
1248                 rc = SQLNumResultCols( sth, &ncols );
1249                 if ( rc != SQL_SUCCESS ) {
1250                         Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
1251                                 "create_proc result evaluation failed\n",
1252                                 op->ora_e->e_name.bv_val, 0, 0 );
1253                         backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc);
1254                         SQLFreeStmt( sth, SQL_DROP );
1255                         rs->sr_err = LDAP_OTHER;
1256                         rs->sr_text = "SQL-backend error";
1257                         e = NULL;
1258                         goto done;
1259
1260                 } else if ( ncols != 1 ) {
1261                         Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
1262                                 "create_proc result is bogus (ncols=%d)\n",
1263                                 op->ora_e->e_name.bv_val, ncols, 0 );
1264                         backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc);
1265                         SQLFreeStmt( sth, SQL_DROP );
1266                         rs->sr_err = LDAP_OTHER;
1267                         rs->sr_text = "SQL-backend error";
1268                         e = NULL;
1269                         goto done;
1270                 }
1271
1272 #if 0
1273                 {
1274                         SQLCHAR         colname[ 64 ];
1275                         SQLSMALLINT     name_len, col_type, col_scale, col_null;
1276                         UDWORD          col_prec;
1277
1278                         /*
1279                          * FIXME: check whether col_type is compatible,
1280                          * if it can be null and so on ...
1281                          */
1282                         rc = SQLDescribeCol( sth, (SQLUSMALLINT)1,
1283                                         &colname[ 0 ],
1284                                         (SQLUINTEGER)( sizeof( colname ) - 1 ),
1285                                         &name_len, &col_type,
1286                                         &col_prec, &col_scale, &col_null );
1287                 }
1288 #endif
1289
1290                 rc = SQLBindCol( sth, (SQLUSMALLINT)1, SQL_C_ULONG,
1291                                 (SQLPOINTER)&new_keyval,
1292                                 (SQLINTEGER)sizeof( new_keyval ),
1293                                 &value_len );
1294
1295                 rc = SQLFetch( sth );
1296
1297                 if ( value_len <= 0 ) {
1298                         Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
1299                                 "create_proc result is empty?\n",
1300                                 op->ora_e->e_name.bv_val, 0, 0 );
1301                         backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc);
1302                         SQLFreeStmt( sth, SQL_DROP );
1303                         rs->sr_err = LDAP_OTHER;
1304                         rs->sr_text = "SQL-backend error";
1305                         e = NULL;
1306                         goto done;
1307                 }
1308         }
1309
1310         SQLFreeStmt( sth, SQL_DROP );
1311
1312         Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
1313                 "create_proc returned keyval=%ld\n",
1314                 op->ora_e->e_name.bv_val, new_keyval, 0 );
1315
1316         rc = backsql_Prepare( dbh, &sth, bi->sql_insentry_stmt, 0 );
1317         if ( rc != SQL_SUCCESS ) {
1318                 rs->sr_err = LDAP_OTHER;
1319                 rs->sr_text = "SQL-backend error";
1320                 e = NULL;
1321                 goto done;
1322         }
1323
1324         rc = backsql_BindParamBerVal( sth, 1, SQL_PARAM_INPUT, &realdn );
1325         if ( rc != SQL_SUCCESS ) {
1326                 Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
1327                         "error binding DN parameter for objectClass %s\n",
1328                         op->ora_e->e_name.bv_val,
1329                         oc->bom_oc->soc_cname.bv_val, 0 );
1330                 backsql_PrintErrors( bi->sql_db_env, dbh,
1331                         sth, rc );
1332                 SQLFreeStmt( sth, SQL_DROP );
1333
1334                 rs->sr_text = "SQL-backend error";
1335                 rs->sr_err = LDAP_OTHER;
1336                 e = NULL;
1337                 goto done;
1338         }
1339
1340         rc = backsql_BindParamInt( sth, 2, SQL_PARAM_INPUT, &oc->bom_id );
1341         if ( rc != SQL_SUCCESS ) {
1342                 Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
1343                         "error binding objectClass ID parameter "
1344                         "for objectClass %s\n",
1345                         op->ora_e->e_name.bv_val,
1346                         oc->bom_oc->soc_cname.bv_val, 0 );
1347                 backsql_PrintErrors( bi->sql_db_env, dbh,
1348                         sth, rc );
1349                 SQLFreeStmt( sth, SQL_DROP );
1350
1351                 rs->sr_text = "SQL-backend error";
1352                 rs->sr_err = LDAP_OTHER;
1353                 e = NULL;
1354                 goto done;
1355         }
1356
1357         rc = backsql_BindParamID( sth, 3, SQL_PARAM_INPUT, &bsi.bsi_base_id.eid_id );
1358         if ( rc != SQL_SUCCESS ) {
1359                 Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
1360                         "error binding parent ID parameter "
1361                         "for objectClass %s\n",
1362                         op->ora_e->e_name.bv_val,
1363                         oc->bom_oc->soc_cname.bv_val, 0 );
1364                 backsql_PrintErrors( bi->sql_db_env, dbh,
1365                         sth, rc );
1366                 SQLFreeStmt( sth, SQL_DROP );
1367
1368                 rs->sr_text = "SQL-backend error";
1369                 rs->sr_err = LDAP_OTHER;
1370                 e = NULL;
1371                 goto done;
1372         }
1373
1374         rc = backsql_BindParamInt( sth, 4, SQL_PARAM_INPUT, &new_keyval );
1375         if ( rc != SQL_SUCCESS ) {
1376                 Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
1377                         "error binding entry ID parameter "
1378                         "for objectClass %s\n",
1379                         op->ora_e->e_name.bv_val,
1380                         oc->bom_oc->soc_cname.bv_val, 0 );
1381                 backsql_PrintErrors( bi->sql_db_env, dbh,
1382                         sth, rc );
1383                 SQLFreeStmt( sth, SQL_DROP );
1384
1385                 rs->sr_text = "SQL-backend error";
1386                 rs->sr_err = LDAP_OTHER;
1387                 e = NULL;
1388                 goto done;
1389         }
1390
1391         Debug( LDAP_DEBUG_TRACE, "   backsql_add(): executing \"%s\" for dn \"%s\"\n",
1392                         bi->sql_insentry_stmt, op->ora_e->e_name.bv_val, 0 );
1393 #ifdef BACKSQL_ARBITRARY_KEY
1394         Debug( LDAP_DEBUG_TRACE, "                  for oc_map_id=%ld, "
1395                         "p_id=%s, keyval=%ld\n",
1396                         oc->bom_id, bsi.bsi_base_id.eid_id.bv_val, new_keyval );
1397 #else /* ! BACKSQL_ARBITRARY_KEY */
1398         Debug( LDAP_DEBUG_TRACE, "                  for oc_map_id=%ld, "
1399                         "p_id=%ld, keyval=%ld\n",
1400                         oc->bom_id, bsi.bsi_base_id.eid_id, new_keyval );
1401 #endif /* ! BACKSQL_ARBITRARY_KEY */
1402         rc = SQLExecute( sth );
1403         if ( rc != SQL_SUCCESS ) {
1404                 Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
1405                         "could not insert ldap_entries record\n",
1406                         op->ora_e->e_name.bv_val, 0, 0 );
1407                 backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc );
1408
1409                 /*
1410                  * execute delete_proc to delete data added !!!
1411                  */
1412                 SQLFreeStmt( sth, SQL_DROP );
1413                 rs->sr_err = LDAP_OTHER;
1414                 rs->sr_text = "SQL-backend error";
1415                 e = NULL;
1416                 goto done;
1417         }
1418
1419         SQLFreeStmt( sth, SQL_DROP );
1420
1421         for ( at = op->ora_e->e_attrs; at != NULL; at = at->a_next ) {
1422                 Debug( LDAP_DEBUG_TRACE, "   backsql_add(): "
1423                         "adding attribute \"%s\"\n",
1424                         at->a_desc->ad_cname.bv_val, 0, 0 );
1425
1426                 /*
1427                  * Skip:
1428                  * - the first occurrence of objectClass, which is used
1429                  *   to determine how to build the SQL entry (FIXME ?!?)
1430                  * - operational attributes
1431                  * - empty attributes (FIXME ?!?)
1432                  */
1433                 if ( backsql_attr_skip( at->a_desc, at->a_vals ) ) {
1434                         continue;
1435                 }
1436
1437                 if ( at->a_desc == slap_schema.si_ad_objectClass ) {
1438                         at_objectClass = at;
1439                         continue;
1440                 }
1441
1442                 rs->sr_err = backsql_add_attr( op, rs, dbh, oc, at, new_keyval );
1443                 if ( rs->sr_err != LDAP_SUCCESS ) {
1444                         e = op->ora_e;
1445                         goto done;
1446                 }
1447         }
1448
1449         if ( at_objectClass ) {
1450                 rs->sr_err = backsql_add_attr( op, rs, dbh, oc,
1451                                 at_objectClass, new_keyval );
1452                 if ( rs->sr_err != LDAP_SUCCESS ) {
1453                         e = op->ora_e;
1454                         goto done;
1455                 }
1456         }
1457
1458 done:;
1459         /*
1460          * Commit only if all operations succeed
1461          */
1462         if ( sth != SQL_NULL_HSTMT ) {
1463                 SQLUSMALLINT    CompletionType = SQL_ROLLBACK;
1464
1465                 if ( rs->sr_err == LDAP_SUCCESS && !op->o_noop ) {
1466                         CompletionType = SQL_COMMIT;
1467                 }
1468
1469                 SQLTransact( SQL_NULL_HENV, dbh, CompletionType );
1470         }
1471
1472         /*
1473          * FIXME: NOOP does not work for add -- it works for all
1474          * the other operations, and I don't get the reason :(
1475          *
1476          * hint: there might be some autocommit in Postgres
1477          * so that when the unique id of the key table is
1478          * automatically increased, there's no rollback.
1479          * We might implement a "rollback" procedure consisting
1480          * in deleting that row.
1481          */
1482
1483 #ifdef SLAP_ACL_HONOR_DISCLOSE
1484         if ( e != NULL ) {
1485                 int     disclose = 1;
1486
1487                 if ( e == op->ora_e && !ACL_GRANT( mask, ACL_DISCLOSE ) ) {
1488                         /* mask already collected */
1489                         disclose = 0;
1490
1491                 } else if ( e == &p && !access_allowed( op, &p,
1492                                         slap_schema.si_ad_entry, NULL,
1493                                         ACL_DISCLOSE, NULL ) )
1494                 {
1495                         disclose = 0;
1496                 }
1497
1498                 if ( disclose == 0 ) {
1499                         rs->sr_err = LDAP_NO_SUCH_OBJECT;
1500                         rs->sr_text = NULL;
1501                         rs->sr_matched = NULL;
1502                         if ( rs->sr_ref ) {
1503                                 ber_bvarray_free( rs->sr_ref );
1504                                 rs->sr_ref = NULL;
1505                         }
1506                 }
1507         }
1508 #endif /* SLAP_ACL_HONOR_DISCLOSE */
1509
1510         send_ldap_result( op, rs );
1511
1512         if ( !BER_BVISNULL( &realdn )
1513                         && realdn.bv_val != op->ora_e->e_name.bv_val )
1514         {
1515                 ch_free( realdn.bv_val );
1516         }
1517
1518         if ( !BER_BVISNULL( &bsi.bsi_base_id.eid_ndn ) ) {
1519                 (void)backsql_free_entryID( op, &bsi.bsi_base_id, 0 );
1520         }
1521
1522         if ( !BER_BVISNULL( &p.e_nname ) ) {
1523                 backsql_entry_clean( op, &p );
1524         }
1525
1526         Debug( LDAP_DEBUG_TRACE, "<==backsql_add(\"%s\"): %d \"%s\"\n",
1527                         op->ora_e->e_name.bv_val,
1528                         rs->sr_err,
1529                         rs->sr_text ? rs->sr_text : "" );
1530
1531         rs->sr_text = NULL;
1532         rs->sr_matched = NULL;
1533         if ( rs->sr_ref ) {
1534                 ber_bvarray_free( rs->sr_ref );
1535                 rs->sr_ref = NULL;
1536         }
1537
1538         return rs->sr_err;
1539 }
1540