]> git.sur5r.net Git - openldap/blob - servers/slapd/back-sql/add.c
slapi_ch_bvdup() should be implemented in terms of ber_dupbv()
[openldap] / servers / slapd / back-sql / add.c
1 /* $OpenLDAP$ */
2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
3  *
4  * Copyright 1999-2006 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[%lu]\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[%lu]\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[%lu]\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         char                    textbuf[ SLAP_TEXT_BUFLEN ];
934         size_t                  textlen = sizeof( textbuf );
935
936 #ifdef BACKSQL_SYNCPROV
937         /*
938          * NOTE: fake successful result to force contextCSN to be bumped up
939          */
940         if ( op->o_sync ) {
941                 char            buf[ LDAP_LUTIL_CSNSTR_BUFSIZE ];
942                 struct berval   csn;
943
944                 csn.bv_val = buf;
945                 csn.bv_len = sizeof( buf );
946                 slap_get_csn( op, &csn, 1 );
947
948                 rs->sr_err = LDAP_SUCCESS;
949                 send_ldap_result( op, rs );
950
951                 slap_graduate_commit_csn( op );
952
953                 return 0;
954         }
955 #endif /* BACKSQL_SYNCPROV */
956
957         Debug( LDAP_DEBUG_TRACE, "==>backsql_add(\"%s\")\n",
958                         op->ora_e->e_name.bv_val, 0, 0 );
959
960         slap_add_opattrs( op, &rs->sr_text, textbuf, textlen, 1 );
961
962         /* check schema */
963         if ( BACKSQL_CHECK_SCHEMA( bi ) ) {
964                 char            textbuf[ SLAP_TEXT_BUFLEN ] = { '\0' };
965
966                 rs->sr_err = entry_schema_check( op, op->ora_e, NULL, 0,
967                         &rs->sr_text, textbuf, sizeof( textbuf ) );
968                 if ( rs->sr_err != LDAP_SUCCESS ) {
969                         Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
970                                 "entry failed schema check -- aborting\n",
971                                 op->ora_e->e_name.bv_val, 0, 0 );
972                         e = NULL;
973                         goto done;
974                 }
975         }
976
977         /* search structuralObjectClass */
978         for ( at = op->ora_e->e_attrs; at != NULL; at = at->a_next ) {
979                 if ( at->a_desc == slap_schema.si_ad_structuralObjectClass ) {
980                         break;
981                 }
982         }
983
984         /* there must exist */
985         if ( at == NULL ) {
986                 char            buf[ SLAP_TEXT_BUFLEN ];
987                 const char      *text;
988
989                 /* search structuralObjectClass */
990                 for ( at = op->ora_e->e_attrs; at != NULL; at = at->a_next ) {
991                         if ( at->a_desc == slap_schema.si_ad_objectClass ) {
992                                 break;
993                         }
994                 }
995
996                 if ( at == NULL ) {
997                         Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
998                                 "no objectClass\n",
999                                 op->ora_e->e_name.bv_val, 0, 0 );
1000                         rs->sr_err = LDAP_OBJECT_CLASS_VIOLATION;
1001                         e = NULL;
1002                         goto done;
1003                 }
1004
1005                 rs->sr_err = structural_class( at->a_vals, &scname, NULL,
1006                                 &text, buf, sizeof( buf ) );
1007                 if ( rs->sr_err != LDAP_SUCCESS ) {
1008                         Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
1009                                 "%s (%d)\n",
1010                                 op->ora_e->e_name.bv_val, text, rs->sr_err );
1011                         e = NULL;
1012                         goto done;
1013                 }
1014
1015         } else {
1016                 scname = at->a_vals[0];
1017         }
1018
1019         /* I guess we should play with sub/supertypes to find a suitable oc */
1020         oc = backsql_name2oc( bi, &scname );
1021
1022         if ( oc == NULL ) {
1023                 Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
1024                         "cannot map structuralObjectClass \"%s\" -- aborting\n",
1025                         op->ora_e->e_name.bv_val,
1026                         scname.bv_val, 0 );
1027                 rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
1028                 rs->sr_text = "operation not permitted within namingContext";
1029                 e = NULL;
1030                 goto done;
1031         }
1032
1033         if ( oc->bom_create_proc == NULL ) {
1034                 Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
1035                         "create procedure is not defined "
1036                         "for structuralObjectClass \"%s\" - aborting\n",
1037                         op->ora_e->e_name.bv_val,
1038                         scname.bv_val, 0 );
1039                 rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
1040                 rs->sr_text = "operation not permitted within namingContext";
1041                 e = NULL;
1042                 goto done;
1043
1044         } else if ( BACKSQL_CREATE_NEEDS_SELECT( bi )
1045                         && oc->bom_create_keyval == NULL ) {
1046                 Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
1047                         "create procedure needs select procedure, "
1048                         "but none is defined for structuralObjectClass \"%s\" "
1049                         "- aborting\n",
1050                         op->ora_e->e_name.bv_val,
1051                         scname.bv_val, 0 );
1052                 rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
1053                 rs->sr_text = "operation not permitted within namingContext";
1054                 e = NULL;
1055                 goto done;
1056         }
1057
1058         /* check write access */
1059         if ( !access_allowed_mask( op, op->ora_e,
1060                                 slap_schema.si_ad_entry,
1061                                 NULL, ACL_WADD, NULL, &mask ) )
1062         {
1063                 rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
1064                 e = op->ora_e;
1065                 goto done;
1066         }
1067
1068         rs->sr_err = backsql_get_db_conn( op, &dbh );
1069         if ( rs->sr_err != LDAP_SUCCESS ) {
1070                 Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
1071                         "could not get connection handle - exiting\n", 
1072                         op->ora_e->e_name.bv_val, 0, 0 );
1073                 rs->sr_text = ( rs->sr_err == LDAP_OTHER )
1074                         ?  "SQL-backend error" : NULL;
1075                 e = NULL;
1076                 goto done;
1077         }
1078
1079         /*
1080          * Check if entry exists
1081          *
1082          * NOTE: backsql_api_dn2odbc() is called explicitly because
1083          * we need the mucked DN to pass it to the create procedure.
1084          */
1085         realdn = op->ora_e->e_name;
1086         if ( backsql_api_dn2odbc( op, rs, &realdn ) ) {
1087                 Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
1088                         "backsql_api_dn2odbc(\"%s\") failed\n", 
1089                         op->ora_e->e_name.bv_val, realdn.bv_val, 0 );
1090                 rs->sr_err = LDAP_OTHER;
1091                 rs->sr_text = "SQL-backend error";
1092                 e = NULL;
1093                 goto done;
1094         }
1095
1096         rs->sr_err = backsql_dn2id( op, rs, dbh, &realdn, NULL, 0, 0 );
1097         if ( rs->sr_err == LDAP_SUCCESS ) {
1098                 Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
1099                         "entry exists\n",
1100                         op->ora_e->e_name.bv_val, 0, 0 );
1101                 rs->sr_err = LDAP_ALREADY_EXISTS;
1102                 e = op->ora_e;
1103                 goto done;
1104         }
1105
1106         /*
1107          * Get the parent dn and see if the corresponding entry exists.
1108          */
1109         if ( be_issuffix( op->o_bd, &op->ora_e->e_nname ) ) {
1110                 pdn = slap_empty_bv;
1111
1112         } else {
1113                 dnParent( &op->ora_e->e_nname, &pdn );
1114
1115                 /*
1116                  * Get the parent
1117                  */
1118                 bsi.bsi_e = &p;
1119                 rs->sr_err = backsql_init_search( &bsi, &pdn,
1120                                 LDAP_SCOPE_BASE, 
1121                                 (time_t)(-1), NULL, dbh, op, rs, slap_anlist_no_attrs,
1122                                 ( BACKSQL_ISF_MATCHED | BACKSQL_ISF_GET_ENTRY ) );
1123                 if ( rs->sr_err != LDAP_SUCCESS ) {
1124                         Debug( LDAP_DEBUG_TRACE, "backsql_add(): "
1125                                 "could not retrieve addDN parent "
1126                                 "\"%s\" ID - %s matched=\"%s\"\n", 
1127                                 pdn.bv_val,
1128                                 rs->sr_err == LDAP_REFERRAL ? "referral" : "no such entry",
1129                                 rs->sr_matched ? rs->sr_matched : "(null)" );
1130                         e = &p;
1131                         goto done;
1132                 }
1133
1134                 /* check "children" pseudo-attribute access to parent */
1135                 if ( !access_allowed( op, &p, slap_schema.si_ad_children,
1136                                         NULL, ACL_WADD, NULL ) )
1137                 {
1138                         rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
1139                         e = &p;
1140                         goto done;
1141                 }
1142         }
1143
1144         /*
1145          * create_proc is executed; if expect_return is set, then
1146          * an output parameter is bound, which should contain 
1147          * the id of the added row; otherwise the procedure
1148          * is expected to return the id as the first column of a select
1149          */
1150         rc = backsql_Prepare( dbh, &sth, oc->bom_create_proc, 0 );
1151         if ( rc != SQL_SUCCESS ) {
1152                 rs->sr_err = LDAP_OTHER;
1153                 rs->sr_text = "SQL-backend error";
1154                 e = NULL;
1155                 goto done;
1156         }
1157
1158         colnum = 1;
1159         if ( BACKSQL_IS_ADD( oc->bom_expect_return ) ) {
1160                 rc = backsql_BindParamInt( sth, 1, SQL_PARAM_OUTPUT, &new_keyval );
1161                 if ( rc != SQL_SUCCESS ) {
1162                         Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
1163                                 "error binding keyval parameter "
1164                                 "for objectClass %s\n",
1165                                 op->ora_e->e_name.bv_val,
1166                                 oc->bom_oc->soc_cname.bv_val, 0 );
1167                         backsql_PrintErrors( bi->sql_db_env, dbh, 
1168                                 sth, rc );
1169                         SQLFreeStmt( sth, SQL_DROP );
1170
1171                         rs->sr_text = "SQL-backend error";
1172                         rs->sr_err = LDAP_OTHER;
1173                         e = NULL;
1174                         goto done;
1175                 }
1176                 colnum++;
1177         }
1178
1179         if ( oc->bom_create_hint ) {
1180                 at = attr_find( op->ora_e->e_attrs, oc->bom_create_hint );
1181                 if ( at && at->a_vals ) {
1182                         backsql_BindParamStr( sth, colnum, SQL_PARAM_INPUT,
1183                                         at->a_vals[0].bv_val,
1184                                         at->a_vals[0].bv_len );
1185                         Debug( LDAP_DEBUG_TRACE, "backsql_add(): "
1186                                         "create_proc hint: param = '%s'\n",
1187                                         at->a_vals[0].bv_val, 0, 0 );
1188
1189                 } else {
1190                         backsql_BindParamStr( sth, colnum, SQL_PARAM_INPUT,
1191                                         "", 0 );
1192                         Debug( LDAP_DEBUG_TRACE, "backsql_add(): "
1193                                         "create_proc hint (%s) not avalable\n",
1194                                         oc->bom_create_hint->ad_cname.bv_val,
1195                                         0, 0 );
1196                 }
1197                 colnum++;
1198         }
1199
1200         Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): executing \"%s\"\n",
1201                 op->ora_e->e_name.bv_val, oc->bom_create_proc, 0 );
1202         rc = SQLExecute( sth );
1203         if ( rc != SQL_SUCCESS ) {
1204                 Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
1205                         "create_proc execution failed\n",
1206                         op->ora_e->e_name.bv_val, 0, 0 );
1207                 backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc);
1208                 SQLFreeStmt( sth, SQL_DROP );
1209                 rs->sr_err = LDAP_OTHER;
1210                 rs->sr_text = "SQL-backend error";
1211                 e = NULL;
1212                 goto done;
1213         }
1214
1215         /* FIXME: after SQLExecute(), the row is already inserted
1216          * (at least with PostgreSQL and unixODBC); needs investigation */
1217
1218         if ( !BACKSQL_IS_ADD( oc->bom_expect_return ) ) {
1219                 SWORD           ncols;
1220                 SQLINTEGER      value_len;
1221
1222                 if ( BACKSQL_CREATE_NEEDS_SELECT( bi ) ) {
1223                         SQLFreeStmt( sth, SQL_DROP );
1224
1225                         rc = backsql_Prepare( dbh, &sth, oc->bom_create_keyval, 0 );
1226                         if ( rc != SQL_SUCCESS ) {
1227                                 rs->sr_err = LDAP_OTHER;
1228                                 rs->sr_text = "SQL-backend error";
1229                                 e = NULL;
1230                                 goto done;
1231                         }
1232
1233                         rc = SQLExecute( sth );
1234                         if ( rc != SQL_SUCCESS ) {
1235                                 rs->sr_err = LDAP_OTHER;
1236                                 rs->sr_text = "SQL-backend error";
1237                                 e = NULL;
1238                                 goto done;
1239                         }
1240                 }
1241
1242                 /*
1243                  * the query to know the id of the inserted entry
1244                  * must be embedded in the create procedure
1245                  */
1246                 rc = SQLNumResultCols( sth, &ncols );
1247                 if ( rc != SQL_SUCCESS ) {
1248                         Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
1249                                 "create_proc result evaluation failed\n",
1250                                 op->ora_e->e_name.bv_val, 0, 0 );
1251                         backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc);
1252                         SQLFreeStmt( sth, SQL_DROP );
1253                         rs->sr_err = LDAP_OTHER;
1254                         rs->sr_text = "SQL-backend error";
1255                         e = NULL;
1256                         goto done;
1257
1258                 } else if ( ncols != 1 ) {
1259                         Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
1260                                 "create_proc result is bogus (ncols=%d)\n",
1261                                 op->ora_e->e_name.bv_val, ncols, 0 );
1262                         backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc);
1263                         SQLFreeStmt( sth, SQL_DROP );
1264                         rs->sr_err = LDAP_OTHER;
1265                         rs->sr_text = "SQL-backend error";
1266                         e = NULL;
1267                         goto done;
1268                 }
1269
1270 #if 0
1271                 {
1272                         SQLCHAR         colname[ 64 ];
1273                         SQLSMALLINT     name_len, col_type, col_scale, col_null;
1274                         UDWORD          col_prec;
1275
1276                         /*
1277                          * FIXME: check whether col_type is compatible,
1278                          * if it can be null and so on ...
1279                          */
1280                         rc = SQLDescribeCol( sth, (SQLUSMALLINT)1, 
1281                                         &colname[ 0 ], 
1282                                         (SQLUINTEGER)( sizeof( colname ) - 1 ),
1283                                         &name_len, &col_type,
1284                                         &col_prec, &col_scale, &col_null );
1285                 }
1286 #endif
1287
1288                 rc = SQLBindCol( sth, (SQLUSMALLINT)1, SQL_C_ULONG,
1289                                 (SQLPOINTER)&new_keyval, 
1290                                 (SQLINTEGER)sizeof( new_keyval ), 
1291                                 &value_len );
1292
1293                 rc = SQLFetch( sth );
1294
1295                 if ( value_len <= 0 ) {
1296                         Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
1297                                 "create_proc result is empty?\n",
1298                                 op->ora_e->e_name.bv_val, 0, 0 );
1299                         backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc);
1300                         SQLFreeStmt( sth, SQL_DROP );
1301                         rs->sr_err = LDAP_OTHER;
1302                         rs->sr_text = "SQL-backend error";
1303                         e = NULL;
1304                         goto done;
1305                 }
1306         }
1307
1308         SQLFreeStmt( sth, SQL_DROP );
1309
1310         Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
1311                 "create_proc returned keyval=%ld\n",
1312                 op->ora_e->e_name.bv_val, new_keyval, 0 );
1313
1314         rc = backsql_Prepare( dbh, &sth, bi->sql_insentry_stmt, 0 );
1315         if ( rc != SQL_SUCCESS ) {
1316                 rs->sr_err = LDAP_OTHER;
1317                 rs->sr_text = "SQL-backend error";
1318                 e = NULL;
1319                 goto done;
1320         }
1321         
1322         rc = backsql_BindParamBerVal( sth, 1, SQL_PARAM_INPUT, &realdn );
1323         if ( rc != SQL_SUCCESS ) {
1324                 Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
1325                         "error binding DN parameter for objectClass %s\n",
1326                         op->ora_e->e_name.bv_val,
1327                         oc->bom_oc->soc_cname.bv_val, 0 );
1328                 backsql_PrintErrors( bi->sql_db_env, dbh, 
1329                         sth, rc );
1330                 SQLFreeStmt( sth, SQL_DROP );
1331
1332                 rs->sr_text = "SQL-backend error";
1333                 rs->sr_err = LDAP_OTHER;
1334                 e = NULL;
1335                 goto done;
1336         }
1337
1338         rc = backsql_BindParamInt( sth, 2, SQL_PARAM_INPUT, &oc->bom_id );
1339         if ( rc != SQL_SUCCESS ) {
1340                 Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
1341                         "error binding objectClass ID parameter "
1342                         "for objectClass %s\n",
1343                         op->ora_e->e_name.bv_val,
1344                         oc->bom_oc->soc_cname.bv_val, 0 );
1345                 backsql_PrintErrors( bi->sql_db_env, dbh, 
1346                         sth, rc );
1347                 SQLFreeStmt( sth, SQL_DROP );
1348
1349                 rs->sr_text = "SQL-backend error";
1350                 rs->sr_err = LDAP_OTHER;
1351                 e = NULL;
1352                 goto done;
1353         }
1354
1355         rc = backsql_BindParamID( sth, 3, SQL_PARAM_INPUT, &bsi.bsi_base_id.eid_id );
1356         if ( rc != SQL_SUCCESS ) {
1357                 Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
1358                         "error binding parent ID parameter "
1359                         "for objectClass %s\n",
1360                         op->ora_e->e_name.bv_val,
1361                         oc->bom_oc->soc_cname.bv_val, 0 );
1362                 backsql_PrintErrors( bi->sql_db_env, dbh, 
1363                         sth, rc );
1364                 SQLFreeStmt( sth, SQL_DROP );
1365
1366                 rs->sr_text = "SQL-backend error";
1367                 rs->sr_err = LDAP_OTHER;
1368                 e = NULL;
1369                 goto done;
1370         }
1371
1372         rc = backsql_BindParamInt( sth, 4, SQL_PARAM_INPUT, &new_keyval );
1373         if ( rc != SQL_SUCCESS ) {
1374                 Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
1375                         "error binding entry ID parameter "
1376                         "for objectClass %s\n",
1377                         op->ora_e->e_name.bv_val,
1378                         oc->bom_oc->soc_cname.bv_val, 0 );
1379                 backsql_PrintErrors( bi->sql_db_env, dbh, 
1380                         sth, rc );
1381                 SQLFreeStmt( sth, SQL_DROP );
1382
1383                 rs->sr_text = "SQL-backend error";
1384                 rs->sr_err = LDAP_OTHER;
1385                 e = NULL;
1386                 goto done;
1387         }
1388
1389         Debug( LDAP_DEBUG_TRACE, "   backsql_add(): executing \"%s\" for dn \"%s\"\n",
1390                         bi->sql_insentry_stmt, op->ora_e->e_name.bv_val, 0 );
1391 #ifdef BACKSQL_ARBITRARY_KEY
1392         Debug( LDAP_DEBUG_TRACE, "                  for oc_map_id=%ld, "
1393                         "p_id=%s, keyval=%ld\n",
1394                         oc->bom_id, bsi.bsi_base_id.eid_id.bv_val, new_keyval );
1395 #else /* ! BACKSQL_ARBITRARY_KEY */
1396         Debug( LDAP_DEBUG_TRACE, "                  for oc_map_id=%ld, "
1397                         "p_id=%ld, keyval=%ld\n",
1398                         oc->bom_id, bsi.bsi_base_id.eid_id, new_keyval );
1399 #endif /* ! BACKSQL_ARBITRARY_KEY */
1400         rc = SQLExecute( sth );
1401         if ( rc != SQL_SUCCESS ) {
1402                 Debug( LDAP_DEBUG_TRACE, "   backsql_add(\"%s\"): "
1403                         "could not insert ldap_entries record\n",
1404                         op->ora_e->e_name.bv_val, 0, 0 );
1405                 backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc );
1406                 
1407                 /*
1408                  * execute delete_proc to delete data added !!!
1409                  */
1410                 SQLFreeStmt( sth, SQL_DROP );
1411                 rs->sr_err = LDAP_OTHER;
1412                 rs->sr_text = "SQL-backend error";
1413                 e = NULL;
1414                 goto done;
1415         }
1416
1417         SQLFreeStmt( sth, SQL_DROP );
1418
1419         for ( at = op->ora_e->e_attrs; at != NULL; at = at->a_next ) {
1420                 Debug( LDAP_DEBUG_TRACE, "   backsql_add(): "
1421                         "adding attribute \"%s\"\n", 
1422                         at->a_desc->ad_cname.bv_val, 0, 0 );
1423
1424                 /*
1425                  * Skip:
1426                  * - the first occurrence of objectClass, which is used
1427                  *   to determine how to build the SQL entry (FIXME ?!?)
1428                  * - operational attributes
1429                  * - empty attributes (FIXME ?!?)
1430                  */
1431                 if ( backsql_attr_skip( at->a_desc, at->a_vals ) ) {
1432                         continue;
1433                 }
1434
1435                 if ( at->a_desc == slap_schema.si_ad_objectClass ) {
1436                         at_objectClass = at;
1437                         continue;
1438                 }
1439
1440                 rs->sr_err = backsql_add_attr( op, rs, dbh, oc, at, new_keyval );
1441                 if ( rs->sr_err != LDAP_SUCCESS ) {
1442                         e = op->ora_e;
1443                         goto done;
1444                 }
1445         }
1446
1447         if ( at_objectClass ) {
1448                 rs->sr_err = backsql_add_attr( op, rs, dbh, oc,
1449                                 at_objectClass, new_keyval );
1450                 if ( rs->sr_err != LDAP_SUCCESS ) {
1451                         e = op->ora_e;
1452                         goto done;
1453                 }
1454         }
1455
1456 done:;
1457         /*
1458          * Commit only if all operations succeed
1459          */
1460         if ( sth != SQL_NULL_HSTMT ) {
1461                 SQLUSMALLINT    CompletionType = SQL_ROLLBACK;
1462
1463                 if ( rs->sr_err == LDAP_SUCCESS && !op->o_noop ) {
1464                         CompletionType = SQL_COMMIT;
1465                 }
1466
1467                 SQLTransact( SQL_NULL_HENV, dbh, CompletionType );
1468         }
1469
1470         /*
1471          * FIXME: NOOP does not work for add -- it works for all 
1472          * the other operations, and I don't get the reason :(
1473          * 
1474          * hint: there might be some autocommit in Postgres
1475          * so that when the unique id of the key table is
1476          * automatically increased, there's no rollback.
1477          * We might implement a "rollback" procedure consisting
1478          * in deleting that row.
1479          */
1480
1481 #ifdef SLAP_ACL_HONOR_DISCLOSE
1482         if ( e != NULL ) {
1483                 int     disclose = 1;
1484
1485                 if ( e == op->ora_e && !ACL_GRANT( mask, ACL_DISCLOSE ) ) {
1486                         /* mask already collected */
1487                         disclose = 0;
1488
1489                 } else if ( e == &p && !access_allowed( op, &p,
1490                                         slap_schema.si_ad_entry, NULL,
1491                                         ACL_DISCLOSE, NULL ) )
1492                 {
1493                         disclose = 0;
1494                 }
1495
1496                 if ( disclose == 0 ) {
1497                         rs->sr_err = LDAP_NO_SUCH_OBJECT;
1498                         rs->sr_text = NULL;
1499                         rs->sr_matched = NULL;
1500                         if ( rs->sr_ref ) {
1501                                 ber_bvarray_free( rs->sr_ref );
1502                                 rs->sr_ref = NULL;
1503                         }
1504                 }
1505         }
1506 #endif /* SLAP_ACL_HONOR_DISCLOSE */
1507
1508         send_ldap_result( op, rs );
1509         slap_graduate_commit_csn( op );
1510
1511         if ( !BER_BVISNULL( &realdn )
1512                         && realdn.bv_val != op->ora_e->e_name.bv_val )
1513         {
1514                 ch_free( realdn.bv_val );
1515         }
1516
1517         if ( !BER_BVISNULL( &bsi.bsi_base_id.eid_ndn ) ) {
1518                 (void)backsql_free_entryID( op, &bsi.bsi_base_id, 0 );
1519         }
1520
1521         if ( !BER_BVISNULL( &p.e_nname ) ) {
1522                 backsql_entry_clean( op, &p );
1523         }
1524
1525         Debug( LDAP_DEBUG_TRACE, "<==backsql_add(\"%s\"): %d \"%s\"\n",
1526                         op->ora_e->e_name.bv_val,
1527                         rs->sr_err,
1528                         rs->sr_text ? rs->sr_text : "" );
1529
1530         rs->sr_text = NULL;
1531         rs->sr_matched = NULL;
1532         if ( rs->sr_ref ) {
1533                 ber_bvarray_free( rs->sr_ref );
1534                 rs->sr_ref = NULL;
1535         }
1536
1537         return rs->sr_err;
1538 }
1539