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

   1 /* $OpenLDAP$ */
   2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   3  *
   4  * Copyright 1999-2004 The OpenLDAP Foundation.
   5  * Portions Copyright 1999 Dmitry Kovalev.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted only as authorized by the OpenLDAP
  10  * Public License.
  11  *
  12  * A copy of this license is available in the file LICENSE in the
  13  * top-level directory of the distribution or, alternatively, at
  14  * <http://www.OpenLDAP.org/license.html>.
  15  */
  16 /* ACKNOWLEDGEMENTS:
  17  * This work was initially developed by Dmitry Kovalev for inclusion
  18  * by OpenLDAP Software.
  19  */
  20
  21 #include "portable.h"
  22
  23 #include <stdio.h>
  24 #include <sys/types.h>
  25 #include "ac/string.h"
  26 #include "ac/ctype.h"
  27
  28 #include "slap.h"
  29 #include "proto-sql.h"
  30
  31 static int backsql_process_filter( backsql_srch_info *bsi, Filter *f );
  32 static int backsql_process_filter_eq( backsql_srch_info *bsi,
  33                 backsql_at_map_rec *at,
  34                 int casefold, struct berval *filter_value );
  35 static int backsql_process_filter_like( backsql_srch_info *bsi,
  36                 backsql_at_map_rec *at,
  37                 int casefold, struct berval *filter_value );
  38 static int backsql_process_filter_attr( backsql_srch_info *bsi, Filter *f,
  39                 backsql_at_map_rec *at );
  40
  41 static int
  42 backsql_attrlist_add( backsql_srch_info *bsi, AttributeDescription *ad )
  43 {
  44         int             n_attrs = 0;
  45         AttributeName   *an = NULL;
  46
  47         if ( bsi->bsi_attrs == NULL ) {
  48                 return 1;
  49         }
  50
  51         /*
  52          * clear the list (retrieve all attrs)
  53          */
  54         if ( ad == NULL ) {
  55                 ch_free( bsi->bsi_attrs );
  56                 bsi->bsi_attrs = NULL;
  57                 bsi->bsi_flags |= BSQL_SF_ALL_ATTRS;
  58                 return 1;
  59         }
  60
  61         for ( ; !BER_BVISNULL( &bsi->bsi_attrs[ n_attrs ].an_name ); n_attrs++ ) {
  62                 an = &bsi->bsi_attrs[ n_attrs ];
  63
  64                 Debug( LDAP_DEBUG_TRACE, "==>backsql_attrlist_add(): "
  65                         "attribute \"%s\" is in list\n",
  66                         an->an_name.bv_val, 0, 0 );
  67                 /*
  68                  * We can live with strcmp because the attribute
  69                  * list has been normalized before calling be_search
  70                  */
  71                 if ( !BACKSQL_NCMP( &an->an_name, &ad->ad_cname ) ) {
  72                         return 1;
  73                 }
  74         }
  75
  76         Debug( LDAP_DEBUG_TRACE, "==>backsql_attrlist_add(): "
  77                 "adding \"%s\" to list\n", ad->ad_cname.bv_val, 0, 0 );
  78
  79         an = (AttributeName *)ch_realloc( bsi->bsi_attrs,
  80                         sizeof( AttributeName ) * ( n_attrs + 2 ) );
  81         if ( an == NULL ) {
  82                 return -1;
  83         }
  84
  85         an[ n_attrs ].an_name = ad->ad_cname;
  86         an[ n_attrs ].an_desc = ad;
  87         BER_BVZERO( &an[ n_attrs + 1 ].an_name );
  88
  89         bsi->bsi_attrs = an;
  90
  91         return 1;
  92 }
  93
  94 /*
  95  * Initializes the search structure.
  96  *
  97  * If get_base_id != 0, the field bsi_base_id is filled
  98  * with the entryID of bsi_base_ndn; it must be freed
  99  * by backsql_free_entryID() when no longer required.
 100  *
 101  * NOTE: base must be normalized
 102  */
 103 int
 104 backsql_init_search(
 105         backsql_srch_info       *bsi,
 106         struct berval           *nbase,
 107         int                     scope,
 108         int                     slimit,
 109         int                     tlimit,
 110         time_t                  stoptime,
 111         Filter                  *filter,
 112         SQLHDBC                 dbh,
 113         Operation               *op,
 114         SlapReply               *rs,
 115         AttributeName           *attrs,
 116         int                     get_base_id )
 117 {
 118         AttributeName           *p;
 119         int                     rc = LDAP_SUCCESS;
 120
 121         bsi->bsi_base_ndn = nbase;
 122         BER_BVZERO( &bsi->bsi_base_id.eid_dn );
 123         BER_BVZERO( &bsi->bsi_base_id.eid_ndn );
 124         bsi->bsi_scope = scope;
 125         bsi->bsi_slimit = slimit;
 126         bsi->bsi_tlimit = tlimit;
 127         bsi->bsi_filter = filter;
 128         bsi->bsi_dbh = dbh;
 129         bsi->bsi_op = op;
 130         bsi->bsi_rs = rs;
 131         bsi->bsi_flags = BSQL_SF_NONE;
 132
 133         /*
 134          * handle "*"
 135          */
 136         if ( attrs == NULL ) {
 137                 /* also add request for all operational */
 138                 bsi->bsi_attrs = NULL;
 139                 bsi->bsi_flags |= BSQL_SF_ALL_USER;
 140
 141         } else {
 142                 int     got_oc = 0;
 143
 144                 bsi->bsi_attrs = (AttributeName *)ch_calloc( 1,
 145                                 sizeof( AttributeName ) );
 146                 BER_BVZERO( &bsi->bsi_attrs[ 0 ].an_name );
 147
 148                 for ( p = attrs; !BER_BVISNULL( &p->an_name ); p++ ) {
 149                         /*
 150                          * ignore "1.1"; handle "+"
 151                          */
 152                         if ( BACKSQL_NCMP( &p->an_name, &AllUser ) == 0 ) {
 153                                 bsi->bsi_flags |= BSQL_SF_ALL_USER;
 154                                 continue;
 155
 156                         } else if ( BACKSQL_NCMP( &p->an_name, &AllOper ) == 0 ) {
 157                                 bsi->bsi_flags |= BSQL_SF_ALL_OPER;
 158                                 continue;
 159
 160                         } else if ( BACKSQL_NCMP( &p->an_name, &NoAttrs ) == 0 ) {
 161                                 continue;
 162
 163                         } else if ( p->an_desc == slap_schema.si_ad_objectClass ) {
 164                                 got_oc = 1;
 165                         }
 166
 167                         backsql_attrlist_add( bsi, p->an_desc );
 168                 }
 169
 170                 if ( got_oc == 0 ) {
 171                         /* add objectClass if not present,
 172                          * because it is required to understand
 173                          * if an entry is a referral, an alias
 174                          * or so... */
 175                         backsql_attrlist_add( bsi, slap_schema.si_ad_objectClass );
 176                 }
 177         }
 178
 179         bsi->bsi_abandon = 0;
 180         bsi->bsi_id_list = NULL;
 181         bsi->bsi_id_listtail = &bsi->bsi_id_list;
 182         bsi->bsi_n_candidates = 0;
 183         bsi->bsi_stoptime = stoptime;
 184         BER_BVZERO( &bsi->bsi_sel.bb_val );
 185         bsi->bsi_sel.bb_len = 0;
 186         BER_BVZERO( &bsi->bsi_from.bb_val );
 187         bsi->bsi_from.bb_len = 0;
 188         BER_BVZERO( &bsi->bsi_join_where.bb_val );
 189         bsi->bsi_join_where.bb_len = 0;
 190         BER_BVZERO( &bsi->bsi_flt_where.bb_val );
 191         bsi->bsi_flt_where.bb_len = 0;
 192         bsi->bsi_filter_oc = NULL;
 193
 194         if ( get_base_id ) {
 195                 assert( op->o_bd->be_private );
 196
 197                 rc = backsql_dn2id( op, rs, &bsi->bsi_base_id, dbh, nbase );
 198         }
 199
 200         return ( bsi->bsi_status = rc );
 201 }
 202
 203 static int
 204 backsql_process_filter_list( backsql_srch_info *bsi, Filter *f, int op )
 205 {
 206         int             res;
 207
 208         if ( !f ) {
 209                 return 0;
 210         }
 211
 212         backsql_strfcat( &bsi->bsi_flt_where, "c", '(' /* ) */  );
 213
 214         while ( 1 ) {
 215                 res = backsql_process_filter( bsi, f );
 216                 if ( res < 0 ) {
 217                         /*
 218                          * TimesTen : If the query has no answers,
 219                          * don't bother to run the query.
 220                          */
 221                         return -1;
 222                 }
 223
 224                 f = f->f_next;
 225                 if ( f == NULL ) {
 226                         break;
 227                 }
 228
 229                 switch ( op ) {
 230                 case LDAP_FILTER_AND:
 231                         backsql_strfcat( &bsi->bsi_flt_where, "l",
 232                                         (ber_len_t)STRLENOF( " AND " ),
 233                                                 " AND " );
 234                         break;
 235
 236                 case LDAP_FILTER_OR:
 237                         backsql_strfcat( &bsi->bsi_flt_where, "l",
 238                                         (ber_len_t)STRLENOF( " OR " ),
 239                                                 " OR " );
 240                         break;
 241                 }
 242         }
 243
 244         backsql_strfcat( &bsi->bsi_flt_where, "c", /* ( */ ')' );
 245
 246         return 1;
 247 }
 248
 249 static int
 250 backsql_process_sub_filter( backsql_srch_info *bsi, Filter *f,
 251         backsql_at_map_rec *at )
 252 {
 253         backsql_info            *bi = (backsql_info *)bsi->bsi_op->o_bd->be_private;
 254         int                     i;
 255         int                     casefold = 0;
 256
 257         if ( !f ) {
 258                 return 0;
 259         }
 260
 261         /* always uppercase strings by now */
 262 #ifdef BACKSQL_UPPERCASE_FILTER
 263         if ( SLAP_MR_ASSOCIATED( f->f_sub_desc->ad_type->sat_substr,
 264                         bi->sql_caseIgnoreMatch ) )
 265 #endif /* BACKSQL_UPPERCASE_FILTER */
 266         {
 267                 casefold = 1;
 268         }
 269
 270         if ( SLAP_MR_ASSOCIATED( f->f_sub_desc->ad_type->sat_substr,
 271                         bi->sql_telephoneNumberMatch ) )
 272         {
 273
 274                 struct berval   bv;
 275                 ber_len_t       i, s, a;
 276
 277                 /*
 278                  * to check for matching telephone numbers
 279                  * with intermixed chars, e.g. val='1234'
 280                  * use
 281                  *
 282                  * val LIKE '%1%2%3%4%'
 283                  */
 284
 285                 BER_BVZERO( &bv );
 286                 if ( f->f_sub_initial.bv_val ) {
 287                         bv.bv_len += f->f_sub_initial.bv_len;
 288                 }
 289                 if ( f->f_sub_any != NULL ) {
 290                         for ( a = 0; f->f_sub_any[ a ].bv_val != NULL; a++ ) {
 291                                 bv.bv_len += f->f_sub_any[ a ].bv_len;
 292                         }
 293                 }
 294                 if ( f->f_sub_final.bv_val ) {
 295                         bv.bv_len += f->f_sub_final.bv_len;
 296                 }
 297                 bv.bv_len = 2 * bv.bv_len - 1;
 298                 bv.bv_val = ch_malloc( bv.bv_len + 1 );
 299
 300                 s = 0;
 301                 if ( !BER_BVISNULL( &f->f_sub_initial ) ) {
 302                         bv.bv_val[ s ] = f->f_sub_initial.bv_val[ 0 ];
 303                         for ( i = 1; i < f->f_sub_initial.bv_len; i++ ) {
 304                                 bv.bv_val[ s + 2 * i - 1 ] = '%';
 305                                 bv.bv_val[ s + 2 * i ] = f->f_sub_initial.bv_val[ i ];
 306                         }
 307                         bv.bv_val[ s + 2 * i - 1 ] = '%';
 308                         s += 2 * i;
 309                 }
 310
 311                 if ( f->f_sub_any != NULL ) {
 312                         for ( a = 0; !BER_BVISNULL( &f->f_sub_any[ a ] ); a++ ) {
 313                                 bv.bv_val[ s ] = f->f_sub_any[ a ].bv_val[ 0 ];
 314                                 for ( i = 1; i < f->f_sub_any[ a ].bv_len; i++ ) {
 315                                         bv.bv_val[ s + 2 * i - 1 ] = '%';
 316                                         bv.bv_val[ s + 2 * i ] = f->f_sub_any[ a ].bv_val[ i ];
 317                                 }
 318                                 bv.bv_val[ s + 2 * i - 1 ] = '%';
 319                                 s += 2 * i;
 320                         }
 321                 }
 322
 323                 if ( !BER_BVISNULL( &f->f_sub_final ) ) {
 324                         bv.bv_val[ s ] = f->f_sub_final.bv_val[ 0 ];
 325                         for ( i = 1; i < f->f_sub_final.bv_len; i++ ) {
 326                                 bv.bv_val[ s + 2 * i - 1 ] = '%';
 327                                 bv.bv_val[ s + 2 * i ] = f->f_sub_final.bv_val[ i ];
 328                         }
 329                                 bv.bv_val[ s + 2 * i - 1 ] = '%';
 330                         s += 2 * i;
 331                 }
 332
 333                 bv.bv_val[ s - 1 ] = '\0';
 334
 335                 (void)backsql_process_filter_like( bsi, at, casefold, &bv );
 336                 ch_free( bv.bv_val );
 337
 338                 return 1;
 339         }
 340
 341         /*
 342          * When dealing with case-sensitive strings
 343          * we may omit normalization; however, normalized
 344          * SQL filters are more liberal.
 345          */
 346
 347         backsql_strfcat( &bsi->bsi_flt_where, "c", '(' /* ) */  );
 348
 349         /* TimesTen */
 350         Debug( LDAP_DEBUG_TRACE, "backsql_process_sub_filter(%s):\n",
 351                 at->bam_ad->ad_cname.bv_val, 0, 0 );
 352         Debug(LDAP_DEBUG_TRACE, "   expr: '%s%s%s'\n", at->bam_sel_expr.bv_val,
 353                 at->bam_sel_expr_u.bv_val ? "' '" : "",
 354                 at->bam_sel_expr_u.bv_val ? at->bam_sel_expr_u.bv_val : "" );
 355         if ( casefold && BACKSQL_AT_CANUPPERCASE( at ) ) {
 356                 /*
 357                  * If a pre-upper-cased version of the column
 358                  * or a precompiled upper function exists, use it
 359                  */
 360                 backsql_strfcat( &bsi->bsi_flt_where,
 361                                 "bl",
 362                                 &at->bam_sel_expr_u,
 363                                 (ber_len_t)STRLENOF( " LIKE '" ),
 364                                         " LIKE '" );
 365
 366         } else {
 367                 backsql_strfcat( &bsi->bsi_flt_where, "bl",
 368                                 &at->bam_sel_expr,
 369                                 (ber_len_t)STRLENOF( " LIKE '" ), " LIKE '" );
 370         }
 371
 372         if ( !BER_BVISNULL( &f->f_sub_initial ) ) {
 373                 ber_len_t       start;
 374
 375 #ifdef BACKSQL_TRACE
 376                 Debug( LDAP_DEBUG_TRACE,
 377                         "==>backsql_process_sub_filter(%s): "
 378                         "sub_initial=\"%s\"\n", at->bam_ad->ad_cname.bv_val,
 379                         f->f_sub_initial.bv_val, 0 );
 380 #endif /* BACKSQL_TRACE */
 381
 382                 start = bsi->bsi_flt_where.bb_val.bv_len;
 383                 backsql_strfcat( &bsi->bsi_flt_where, "b",
 384                                 &f->f_sub_initial );
 385                 if ( casefold && BACKSQL_AT_CANUPPERCASE( at ) ) {
 386                         ldap_pvt_str2upper( &bsi->bsi_flt_where.bb_val.bv_val[ start ] );
 387                 }
 388         }
 389
 390         backsql_strfcat( &bsi->bsi_flt_where, "c", '%' );
 391
 392         if ( f->f_sub_any != NULL ) {
 393                 for ( i = 0; !BER_BVISNULL( &f->f_sub_any[ i ] ); i++ ) {
 394                         ber_len_t       start;
 395
 396 #ifdef BACKSQL_TRACE
 397                         Debug( LDAP_DEBUG_TRACE,
 398                                 "==>backsql_process_sub_filter(%s): "
 399                                 "sub_any[%d]=\"%s\"\n", at->bam_ad->ad_cname.bv_val,
 400                                 i, f->f_sub_any[ i ].bv_val );
 401 #endif /* BACKSQL_TRACE */
 402
 403                         start = bsi->bsi_flt_where.bb_val.bv_len;
 404                         backsql_strfcat( &bsi->bsi_flt_where,
 405                                         "bc",
 406                                         &f->f_sub_any[ i ],
 407                                         '%' );
 408                         if ( casefold && BACKSQL_AT_CANUPPERCASE( at ) ) {
 409                                 /*
 410                                  * Note: toupper('%') = '%'
 411                                  */
 412                                 ldap_pvt_str2upper( &bsi->bsi_flt_where.bb_val.bv_val[ start ] );
 413                         }
 414                 }
 415         }
 416
 417         if ( !BER_BVISNULL( &f->f_sub_final ) ) {
 418                 ber_len_t       start;
 419
 420 #ifdef BACKSQL_TRACE
 421                 Debug( LDAP_DEBUG_TRACE,
 422                         "==>backsql_process_sub_filter(%s): "
 423                         "sub_final=\"%s\"\n", at->bam_ad->ad_cname.bv_val,
 424                         f->f_sub_final.bv_val, 0 );
 425 #endif /* BACKSQL_TRACE */
 426
 427                 start = bsi->bsi_flt_where.bb_val.bv_len;
 428                 backsql_strfcat( &bsi->bsi_flt_where, "b",
 429                                 &f->f_sub_final );
 430                 if ( casefold && BACKSQL_AT_CANUPPERCASE( at ) ) {
 431                         ldap_pvt_str2upper( &bsi->bsi_flt_where.bb_val.bv_val[ start ] );
 432                 }
 433         }
 434
 435         backsql_strfcat( &bsi->bsi_flt_where, "l",
 436                         (ber_len_t)STRLENOF( /* (' */ "')" ), /* (' */ "')" );
 437
 438         return 1;
 439 }
 440
 441 static int
 442 backsql_merge_from_tbls( backsql_srch_info *bsi, struct berval *from_tbls )
 443 {
 444         if ( BER_BVISNULL( from_tbls ) ) {
 445                 return LDAP_SUCCESS;
 446         }
 447
 448         if ( !BER_BVISNULL( &bsi->bsi_from.bb_val ) ) {
 449                 char    *start, *end, *tmp;
 450
 451                 tmp = ch_strdup( from_tbls->bv_val );
 452
 453                 for ( start = tmp, end = strchr( start, ',' ); start; ) {
 454                         if ( end ) {
 455                                 end[0] = '\0';
 456                         }
 457
 458                         if ( strstr( bsi->bsi_from.bb_val.bv_val, start) == NULL )
 459                         {
 460                                 backsql_strfcat( &bsi->bsi_from, "cs", ',', start );
 461                         }
 462
 463                         if ( end ) {
 464                                 /* in case there are spaces after the comma... */
 465                                 for ( start = &end[1]; isspace( start[0] ); start++ );
 466                                 if ( start[0] ) {
 467                                         end = strchr( start, ',' );
 468                                 } else {
 469                                         start = NULL;
 470                                 }
 471                         } else {
 472                                 start = NULL;
 473                         }
 474                 }
 475
 476                 ch_free( tmp );
 477
 478         } else {
 479                 backsql_strfcat( &bsi->bsi_from, "b", from_tbls );
 480         }
 481
 482         return LDAP_SUCCESS;
 483 }
 484
 485 static int
 486 backsql_process_filter( backsql_srch_info *bsi, Filter *f )
 487 {
 488         backsql_at_map_rec      **vat = NULL;
 489         AttributeDescription    *ad = NULL;
 490         unsigned                i;
 491         int                     done = 0;
 492         int                     rc = 0;
 493
 494         Debug( LDAP_DEBUG_TRACE, "==>backsql_process_filter()\n", 0, 0, 0 );
 495         if ( f->f_choice == SLAPD_FILTER_COMPUTED ) {
 496                 Debug( LDAP_DEBUG_TRACE, "backsql_process_filter(): "
 497                         "invalid filter\n", 0, 0, 0 );
 498                 rc = -1;
 499                 goto done;
 500         }
 501
 502         switch( f->f_choice ) {
 503         case LDAP_FILTER_OR:
 504                 rc = backsql_process_filter_list( bsi, f->f_or,
 505                                 LDAP_FILTER_OR );
 506                 done = 1;
 507                 break;
 508
 509         case LDAP_FILTER_AND:
 510                 rc = backsql_process_filter_list( bsi, f->f_and,
 511                                 LDAP_FILTER_AND );
 512                 done = 1;
 513                 break;
 514
 515         case LDAP_FILTER_NOT:
 516                 backsql_strfcat( &bsi->bsi_flt_where, "l",
 517                                 (ber_len_t)STRLENOF( "NOT (" /* ) */ ),
 518                                         "NOT (" /* ) */ );
 519                 rc = backsql_process_filter( bsi, f->f_not );
 520                 backsql_strfcat( &bsi->bsi_flt_where, "c", /* ( */ ')' );
 521                 done = 1;
 522                 break;
 523
 524         case LDAP_FILTER_PRESENT:
 525                 ad = f->f_desc;
 526                 break;
 527
 528         case LDAP_FILTER_EXT:
 529                 ad = f->f_mra->ma_desc;
 530                 if ( f->f_mr_dnattrs ) {
 531                         /*
 532                          * if dn attrs filtering is requested, better return
 533                          * success and let test_filter() deal with candidate
 534                          * selection; otherwise we'd need to set conditions
 535                          * on the contents of the DN, e.g. "SELECT ... FROM
 536                          * ldap_entries AS attributeName WHERE attributeName.dn
 537                          * like '%attributeName=value%'"
 538                          */
 539                         backsql_strfcat( &bsi->bsi_flt_where, "l",
 540                                         (ber_len_t)STRLENOF( "1=1" ), "1=1" );
 541                         bsi->bsi_status = LDAP_SUCCESS;
 542                         rc = 1;
 543                         goto done;
 544                 }
 545                 break;
 546
 547         default:
 548                 ad = f->f_av_desc;
 549                 break;
 550         }
 551
 552         if ( rc == -1 ) {
 553                 goto done;
 554         }
 555
 556         if ( done ) {
 557                 rc = 1;
 558                 goto done;
 559         }
 560
 561         /*
 562          * Turn structuralObjectClass into objectClass
 563          */
 564         if ( ad == slap_schema.si_ad_objectClass
 565                         || ad == slap_schema.si_ad_structuralObjectClass )
 566         {
 567                 /*
 568                  * If the filter is LDAP_FILTER_PRESENT, then it's done;
 569                  * otherwise, let's see if we are lucky: filtering
 570                  * for "structural" objectclass or ancestor...
 571                  */
 572                 switch ( f->f_choice ) {
 573                 case LDAP_FILTER_EQUALITY:
 574                 {
 575                         ObjectClass     *oc = oc_bvfind( &f->f_av_value );
 576
 577                         if ( oc == NULL ) {
 578                                 Debug( LDAP_DEBUG_TRACE,
 579                                                 "backsql_process_filter(): "
 580                                                 "unknown objectClass \"%s\" "
 581                                                 "in filter\n",
 582                                                 f->f_av_value.bv_val, 0, 0 );
 583                                 bsi->bsi_status = LDAP_OTHER;
 584                                 rc = -1;
 585                                 goto done;
 586                         }
 587
 588                         /*
 589                          * "structural" objectClass inheritance:
 590                          * - a search for "person" will also return
 591                          *   "inetOrgPerson"
 592                          * - a search for "top" will return everything
 593                          */
 594                         if ( is_object_subclass( oc, bsi->bsi_oc->bom_oc ) ) {
 595                                 static struct berval ldap_entry_objclasses = BER_BVC( "ldap_entry_objclasses" );
 596
 597                                 backsql_merge_from_tbls( bsi, &ldap_entry_objclasses );
 598
 599                                 backsql_strfcat( &bsi->bsi_flt_where, "lbl",
 600                                                 (ber_len_t)STRLENOF( "1=1 OR (ldap_entries.id=ldap_entry_objclasses.entry_id AND ldap_entry_objclasses.oc_name='" /* ') */ ),
 601                                                         "1=1 OR (ldap_entries.id=ldap_entry_objclasses.entry_id AND ldap_entry_objclasses.oc_name='" /* ') */,
 602                                                 &bsi->bsi_oc->bom_oc->soc_cname,
 603                                                 (ber_len_t)STRLENOF( /* (' */ "')" ),
 604                                                         /* (' */ "')" );
 605                                 bsi->bsi_status = LDAP_SUCCESS;
 606                                 rc = 1;
 607                                 goto done;
 608                         }
 609
 610                         break;
 611                 }
 612
 613                 case LDAP_FILTER_PRESENT:
 614                         backsql_strfcat( &bsi->bsi_flt_where, "l",
 615                                         (ber_len_t)STRLENOF( "1=1" ), "1=1" );
 616                         bsi->bsi_status = LDAP_SUCCESS;
 617                         rc = 1;
 618                         goto done;
 619
 620                         /* FIXME: LDAP_FILTER_EXT? */
 621
 622                 default:
 623                         Debug( LDAP_DEBUG_TRACE,
 624                                         "backsql_process_filter(): "
 625                                         "illegal/unhandled filter "
 626                                         "on objectClass attribute",
 627                                         0, 0, 0 );
 628                         bsi->bsi_status = LDAP_OTHER;
 629                         rc = -1;
 630                         goto done;
 631                 }
 632
 633         } else if ( ad == slap_schema.si_ad_entryUUID ) {
 634                 unsigned long   oc_id;
 635 #ifdef BACKSQL_ARBITRARY_KEY
 636                 struct berval   keyval;
 637 #else /* ! BACKSQL_ARBITRARY_KEY */
 638                 unsigned long   keyval;
 639                 char            keyvalbuf[] = "18446744073709551615";
 640 #endif /* ! BACKSQL_ARBITRARY_KEY */
 641
 642                 switch ( f->f_choice ) {
 643                 case LDAP_FILTER_EQUALITY:
 644                         backsql_entryUUID_decode( &f->f_av_value, &oc_id, &keyval );
 645
 646                         if ( oc_id != bsi->bsi_oc->bom_id ) {
 647                                 bsi->bsi_status = LDAP_SUCCESS;
 648                                 rc = -1;
 649                                 goto done;
 650                         }
 651
 652 #ifdef BACKSQL_ARBITRARY_KEY
 653                         backsql_strfcat( &bsi->bsi_flt_where, "bcblbc",
 654                                         &bsi->bsi_oc->bom_keytbl, '.',
 655                                         &bsi->bsi_oc->bom_keycol,
 656                                         STRLENOF( " LIKE '" ), " LIKE '",
 657                                         &keyval, '\'' );
 658 #else /* ! BACKSQL_ARBITRARY_KEY */
 659                         snprintf( keyvalbuf, sizeof( keyvalbuf ), "%lu", keyval );
 660                         backsql_strfcat( &bsi->bsi_flt_where, "bcbcs",
 661                                         &bsi->bsi_oc->bom_keytbl, '.',
 662                                         &bsi->bsi_oc->bom_keycol, '=', keyvalbuf );
 663 #endif /* ! BACKSQL_ARBITRARY_KEY */
 664                         break;
 665
 666                 case LDAP_FILTER_PRESENT:
 667                         backsql_strfcat( &bsi->bsi_flt_where, "l",
 668                                         (ber_len_t)STRLENOF( "1=1" ), "1=1" );
 669                         break;
 670
 671                 default:
 672                         rc = -1;
 673                         goto done;
 674                 }
 675
 676                 bsi->bsi_flags |= BSQL_SF_FILTER_ENTRYUUID;
 677                 rc = 1;
 678                 goto done;
 679
 680 #ifdef BACKSQL_SYNCPROV
 681         } else if ( ad == slap_schema.si_ad_entryCSN ) {
 682                 /*
 683                  * TODO: introduce appropriate entryCSN filtering
 684                  * to support syncrepl as producer...
 685                  */
 686                 if ( !bsi->bsi_op->o_sync ) {
 687                         /* unsupported at present... */
 688                         bsi->bsi_status = LDAP_OTHER;
 689                         rc = -1;
 690                         goto done;
 691                 }
 692
 693                 bsi->bsi_flags |= ( BSQL_SF_FILTER_ENTRYCSN | BSQL_SF_RETURN_ENTRYUUID);
 694
 695                 /* if doing a syncrepl, try to return as much as possible,
 696                  * and always match the filter */
 697                 backsql_strfcat( &bsi->bsi_flt_where, "l",
 698                                 (ber_len_t)STRLENOF( "1=1" ), "1=1" );
 699
 700                 /* save for later use in operational attributes */
 701                 /* FIXME: saves only the first occurrence, because
 702                  * the filter during updates is written as
 703                  * "(&(entryCSN<={contextCSN})(entryCSN>={oldContextCSN})({filter}))"
 704                  * so we want our fake entryCSN to match the greatest
 705                  * value
 706                  */
 707                 if ( bsi->bsi_op->o_private == NULL ) {
 708                         bsi->bsi_op->o_private = &f->f_av_value;
 709                 }
 710                 bsi->bsi_status = LDAP_SUCCESS;
 711
 712                 rc = 1;
 713                 goto done;
 714 #endif /* BACKSQL_SYNCPROV */
 715
 716         } else if ( ad == slap_schema.si_ad_hasSubordinates || ad == NULL ) {
 717                 /*
 718                  * FIXME: this is not robust; e.g. a filter
 719                  * '(!(hasSubordinates=TRUE))' fails because
 720                  * in SQL it would read 'NOT (1=1)' instead
 721                  * of no condition.
 722                  * Note however that hasSubordinates is boolean,
 723                  * so a more appropriate filter would be
 724                  * '(hasSubordinates=FALSE)'
 725                  *
 726                  * A more robust search for hasSubordinates
 727                  * would * require joining the ldap_entries table
 728                  * selecting if there are descendants of the
 729                  * candidate.
 730                  */
 731                 backsql_strfcat( &bsi->bsi_flt_where, "l",
 732                                 (ber_len_t)STRLENOF( "1=1" ), "1=1" );
 733                 if ( ad == slap_schema.si_ad_hasSubordinates ) {
 734                         /*
 735                          * instruct candidate selection algorithm
 736                          * and attribute list to try to detect
 737                          * if an entry has subordinates
 738                          */
 739                         bsi->bsi_flags |= BSQL_SF_FILTER_HASSUBORDINATE;
 740
 741                 } else {
 742                         /*
 743                          * clear attributes to fetch, to require ALL
 744                          * and try extended match on all attributes
 745                          */
 746                         backsql_attrlist_add( bsi, NULL );
 747                 }
 748                 rc = 1;
 749                 goto done;
 750         }
 751
 752         /*
 753          * attribute inheritance:
 754          */
 755         if ( backsql_supad2at( bsi->bsi_oc, ad, &vat ) ) {
 756                 bsi->bsi_status = LDAP_OTHER;
 757                 rc = -1;
 758                 goto done;
 759         }
 760
 761         if ( vat == NULL ) {
 762                 /* search anyway; other parts of the filter
 763                  * may succeeed */
 764                 backsql_strfcat( &bsi->bsi_flt_where, "l",
 765                                 (ber_len_t)STRLENOF( "1=1" ), "1=1" );
 766                 bsi->bsi_status = LDAP_SUCCESS;
 767                 rc = 1;
 768                 goto done;
 769         }
 770
 771         /* if required, open extra level of parens */
 772         done = 0;
 773         if ( vat[0]->bam_next || vat[1] ) {
 774                 backsql_strfcat( &bsi->bsi_flt_where, "c", '(' );
 775                 done = 1;
 776         }
 777
 778         i = 0;
 779 next:;
 780         /* apply attr */
 781         if ( backsql_process_filter_attr( bsi, f, vat[i] ) == -1 ) {
 782                 return -1;
 783         }
 784
 785         /* if more definitions of the same attr, apply */
 786         if ( vat[i]->bam_next ) {
 787                 backsql_strfcat( &bsi->bsi_flt_where, "l",
 788                         STRLENOF( " OR " ), " OR " );
 789                 vat[i] = vat[i]->bam_next;
 790                 goto next;
 791         }
 792
 793         /* if more descendants of the same attr, apply */
 794         i++;
 795         if ( vat[i] ) {
 796                 backsql_strfcat( &bsi->bsi_flt_where, "l",
 797                         STRLENOF( " OR " ), " OR " );
 798                 goto next;
 799         }
 800
 801         /* if needed, close extra level of parens */
 802         if ( done ) {
 803                 backsql_strfcat( &bsi->bsi_flt_where, "c", ')' );
 804         }
 805
 806         rc = 1;
 807
 808 done:;
 809         if ( vat ) {
 810                 ch_free( vat );
 811         }
 812
 813         Debug( LDAP_DEBUG_TRACE,
 814                         "<==backsql_process_filter() %s\n",
 815                         rc == 1 ? "succeeded" : "failed", 0, 0);
 816
 817         return rc;
 818 }
 819
 820 static int
 821 backsql_process_filter_eq( backsql_srch_info *bsi, backsql_at_map_rec *at,
 822                 int casefold, struct berval *filter_value )
 823 {
 824         /*
 825          * maybe we should check type of at->sel_expr here somehow,
 826          * to know whether upper_func is applicable, but for now
 827          * upper_func stuff is made for Oracle, where UPPER is
 828          * safely applicable to NUMBER etc.
 829          */
 830         if ( casefold && BACKSQL_AT_CANUPPERCASE( at ) ) {
 831                 ber_len_t       start;
 832
 833                 backsql_strfcat( &bsi->bsi_flt_where, "cbl",
 834                                 '(', /* ) */
 835                                 &at->bam_sel_expr_u,
 836                                 (ber_len_t)STRLENOF( "='" ),
 837                                         "='" );
 838
 839                 start = bsi->bsi_flt_where.bb_val.bv_len;
 840
 841                 backsql_strfcat( &bsi->bsi_flt_where, "bl",
 842                                 filter_value,
 843                                 (ber_len_t)STRLENOF( /* (' */ "')" ),
 844                                         /* (' */ "')" );
 845
 846                 ldap_pvt_str2upper( &bsi->bsi_flt_where.bb_val.bv_val[ start ] );
 847
 848         } else {
 849                 backsql_strfcat( &bsi->bsi_flt_where, "cblbl",
 850                                 '(', /* ) */
 851                                 &at->bam_sel_expr,
 852                                 (ber_len_t)STRLENOF( "='" ), "='",
 853                                 filter_value,
 854                                 (ber_len_t)STRLENOF( /* (' */ "')" ),
 855                                         /* (' */ "')" );
 856         }
 857
 858         return 1;
 859 }
 860
 861 static int
 862 backsql_process_filter_like( backsql_srch_info *bsi, backsql_at_map_rec *at,
 863                 int casefold, struct berval *filter_value )
 864 {
 865         /*
 866          * maybe we should check type of at->sel_expr here somehow,
 867          * to know whether upper_func is applicable, but for now
 868          * upper_func stuff is made for Oracle, where UPPER is
 869          * safely applicable to NUMBER etc.
 870          */
 871         if ( casefold && BACKSQL_AT_CANUPPERCASE( at ) ) {
 872                 ber_len_t       start;
 873
 874                 backsql_strfcat( &bsi->bsi_flt_where, "cbl",
 875                                 '(', /* ) */
 876                                 &at->bam_sel_expr_u,
 877                                 (ber_len_t)STRLENOF( " LIKE '%" ),
 878                                         " LIKE '%" );
 879
 880                 start = bsi->bsi_flt_where.bb_val.bv_len;
 881
 882                 backsql_strfcat( &bsi->bsi_flt_where, "bl",
 883                                 filter_value,
 884                                 (ber_len_t)STRLENOF( /* (' */ "%')" ),
 885                                         /* (' */ "%')" );
 886
 887                 ldap_pvt_str2upper( &bsi->bsi_flt_where.bb_val.bv_val[ start ] );
 888
 889         } else {
 890                 backsql_strfcat( &bsi->bsi_flt_where, "cblbl",
 891                                 '(', /* ) */
 892                                 &at->bam_sel_expr,
 893                                 (ber_len_t)STRLENOF( " LIKE '%" ),
 894                                         " LIKE '%",
 895                                 filter_value,
 896                                 (ber_len_t)STRLENOF( /* (' */ "%')" ),
 897                                         /* (' */ "%')" );
 898         }
 899
 900         return 1;
 901 }
 902
 903 static int
 904 backsql_process_filter_attr( backsql_srch_info *bsi, Filter *f, backsql_at_map_rec *at )
 905 {
 906         backsql_info            *bi = (backsql_info *)bsi->bsi_op->o_bd->be_private;
 907         int                     casefold = 0;
 908         struct berval           *filter_value = NULL;
 909         MatchingRule            *matching_rule = NULL;
 910         struct berval           ordering = BER_BVC("<=");
 911
 912         Debug( LDAP_DEBUG_TRACE, "==>backsql_process_filter_attr(%s)\n",
 913                 at->bam_ad->ad_cname.bv_val, 0, 0 );
 914
 915         /*
 916          * need to add this attribute to list of attrs to load,
 917          * so that we can do test_filter() later
 918          */
 919         backsql_attrlist_add( bsi, at->bam_ad );
 920
 921         backsql_merge_from_tbls( bsi, &at->bam_from_tbls );
 922
 923         if ( !BER_BVISNULL( &at->bam_join_where )
 924                         && strstr( bsi->bsi_join_where.bb_val.bv_val,
 925                                 at->bam_join_where.bv_val ) == NULL )
 926         {
 927                 backsql_strfcat( &bsi->bsi_join_where, "lb",
 928                                 (ber_len_t)STRLENOF( " AND " ), " AND ",
 929                                 &at->bam_join_where );
 930         }
 931
 932         switch ( f->f_choice ) {
 933         case LDAP_FILTER_EQUALITY:
 934                 filter_value = &f->f_av_value;
 935                 matching_rule = at->bam_ad->ad_type->sat_equality;
 936
 937                 goto equality_match;
 938
 939                 /* fail over into next case */
 940
 941         case LDAP_FILTER_EXT:
 942                 filter_value = &f->f_mra->ma_value;
 943                 matching_rule = f->f_mr_rule;
 944
 945 equality_match:;
 946                 /* always uppercase strings by now */
 947 #ifdef BACKSQL_UPPERCASE_FILTER
 948                 if ( SLAP_MR_ASSOCIATED( matching_rule,
 949                                         bi->sql_caseIgnoreMatch ) )
 950 #endif /* BACKSQL_UPPERCASE_FILTER */
 951                 {
 952                         casefold = 1;
 953                 }
 954
 955                 if ( SLAP_MR_ASSOCIATED( matching_rule,
 956                                         bi->sql_telephoneNumberMatch ) )
 957                 {
 958                         struct berval   bv;
 959                         ber_len_t       i;
 960
 961                         /*
 962                          * to check for matching telephone numbers
 963                          * with intermized chars, e.g. val='1234'
 964                          * use
 965                          *
 966                          * val LIKE '%1%2%3%4%'
 967                          */
 968
 969                         bv.bv_len = 2 * filter_value->bv_len - 1;
 970                         bv.bv_val = ch_malloc( bv.bv_len + 1 );
 971
 972                         bv.bv_val[ 0 ] = filter_value->bv_val[ 0 ];
 973                         for ( i = 1; i < filter_value->bv_len; i++ ) {
 974                                 bv.bv_val[ 2 * i - 1 ] = '%';
 975                                 bv.bv_val[ 2 * i ] = filter_value->bv_val[ i ];
 976                         }
 977                         bv.bv_val[ 2 * i - 1 ] = '\0';
 978
 979                         (void)backsql_process_filter_like( bsi, at, casefold, &bv );
 980                         ch_free( bv.bv_val );
 981
 982                         break;
 983                 }
 984
 985                 /* NOTE: this is required by objectClass inheritance
 986                  * and auxiliary objectClass use in filters for slightly
 987                  * more efficient candidate selection. */
 988                 /* FIXME: a bit too many specializations to deal with
 989                  * very specific cases... */
 990                 if ( at->bam_ad == slap_schema.si_ad_objectClass
 991                                 || at->bam_ad == slap_schema.si_ad_structuralObjectClass )
 992                 {
 993                         backsql_strfcat( &bsi->bsi_flt_where, "lbl",
 994                                         (ber_len_t)STRLENOF( "(ldap_entries.id=ldap_entry_objclasses.entry_id AND ldap_entry_objclasses.oc_name='" /* ') */ ),
 995                                                 "(ldap_entries.id=ldap_entry_objclasses.entry_id AND ldap_entry_objclasses.oc_name='" /* ') */,
 996                                         filter_value,
 997                                         (ber_len_t)STRLENOF( /* (' */ "')" ),
 998                                                 /* (' */ "')" );
 999                         break;
1000                 }
1001
1002                 /*
1003                  * maybe we should check type of at->sel_expr here somehow,
1004                  * to know whether upper_func is applicable, but for now
1005                  * upper_func stuff is made for Oracle, where UPPER is
1006                  * safely applicable to NUMBER etc.
1007                  */
1008                 (void)backsql_process_filter_eq( bsi, at, casefold, filter_value );
1009                 break;
1010
1011         case LDAP_FILTER_GE:
1012                 ordering.bv_val = ">=";
1013
1014                 /* fall thru to next case */
1015
1016         case LDAP_FILTER_LE:
1017                 /* always uppercase strings by now */
1018 #ifdef BACKSQL_UPPERCASE_FILTER
1019                 if ( SLAP_MR_ASSOCIATED( at->bam_ad->ad_type->sat_ordering,
1020                                 bi->sql_caseIgnoreMatch ) )
1021 #endif /* BACKSQL_UPPERCASE_FILTER */
1022                 {
1023                         casefold = 1;
1024                 }
1025
1026                 /*
1027                  * FIXME: should we uppercase the operands?
1028                  */
1029                 if ( casefold && BACKSQL_AT_CANUPPERCASE( at ) ) {
1030                         ber_len_t       start;
1031
1032                         backsql_strfcat( &bsi->bsi_flt_where, "cbbc",
1033                                         '(', /* ) */
1034                                         &at->bam_sel_expr_u,
1035                                         &ordering,
1036                                         '\'' );
1037
1038                         start = bsi->bsi_flt_where.bb_val.bv_len;
1039
1040                         backsql_strfcat( &bsi->bsi_flt_where, "bl",
1041                                         filter_value,
1042                                         (ber_len_t)STRLENOF( /* (' */ "')" ),
1043                                                 /* (' */ "')" );
1044
1045                         ldap_pvt_str2upper( &bsi->bsi_flt_where.bb_val.bv_val[ start ] );
1046
1047                 } else {
1048                         backsql_strfcat( &bsi->bsi_flt_where, "cbbcbl",
1049                                         '(' /* ) */ ,
1050                                         &at->bam_sel_expr,
1051                                         &ordering,
1052                                         '\'',
1053                                         &f->f_av_value,
1054                                         (ber_len_t)STRLENOF( /* (' */ "')" ),
1055                                                 /* ( */ "')" );
1056                 }
1057                 break;
1058
1059         case LDAP_FILTER_PRESENT:
1060                 backsql_strfcat( &bsi->bsi_flt_where, "lbl",
1061                                 (ber_len_t)STRLENOF( "NOT (" /* ) */),
1062                                         "NOT (", /* ) */
1063                                 &at->bam_sel_expr,
1064                                 (ber_len_t)STRLENOF( /* ( */ " IS NULL)" ),
1065                                         /* ( */ " IS NULL)" );
1066                 break;
1067
1068         case LDAP_FILTER_SUBSTRINGS:
1069                 backsql_process_sub_filter( bsi, f, at );
1070                 break;
1071
1072         case LDAP_FILTER_APPROX:
1073                 /* we do our best */
1074
1075                 /*
1076                  * maybe we should check type of at->sel_expr here somehow,
1077                  * to know whether upper_func is applicable, but for now
1078                  * upper_func stuff is made for Oracle, where UPPER is
1079                  * safely applicable to NUMBER etc.
1080                  */
1081                 (void)backsql_process_filter_like( bsi, at, 1, &f->f_av_value );
1082                 break;
1083
1084         default:
1085                 /* unhandled filter type; should not happen */
1086                 assert( 0 );
1087                 backsql_strfcat( &bsi->bsi_flt_where, "l",
1088                                 (ber_len_t)STRLENOF( "1=1" ), "1=1" );
1089                 break;
1090
1091         }
1092
1093         Debug( LDAP_DEBUG_TRACE, "<==backsql_process_filter_attr(%s)\n",
1094                 at->bam_ad->ad_cname.bv_val, 0, 0 );
1095
1096         return 1;
1097 }
1098
1099 static int
1100 backsql_srch_query( backsql_srch_info *bsi, struct berval *query )
1101 {
1102         backsql_info    *bi = (backsql_info *)bsi->bsi_op->o_bd->be_private;
1103         int             rc;
1104
1105         assert( query );
1106         BER_BVZERO( query );
1107
1108         Debug( LDAP_DEBUG_TRACE, "==>backsql_srch_query()\n", 0, 0, 0 );
1109         BER_BVZERO( &bsi->bsi_sel.bb_val );
1110         BER_BVZERO( &bsi->bsi_sel.bb_val );
1111         bsi->bsi_sel.bb_len = 0;
1112         BER_BVZERO( &bsi->bsi_from.bb_val );
1113         bsi->bsi_from.bb_len = 0;
1114         BER_BVZERO( &bsi->bsi_join_where.bb_val );
1115         bsi->bsi_join_where.bb_len = 0;
1116         BER_BVZERO( &bsi->bsi_flt_where.bb_val );
1117         bsi->bsi_flt_where.bb_len = 0;
1118
1119         backsql_strfcat( &bsi->bsi_sel, "lbcbc",
1120                         (ber_len_t)STRLENOF( "SELECT DISTINCT ldap_entries.id," ),
1121                                 "SELECT DISTINCT ldap_entries.id,",
1122                         &bsi->bsi_oc->bom_keytbl,
1123                         '.',
1124                         &bsi->bsi_oc->bom_keycol,
1125                         ',' );
1126
1127         if ( !BER_BVISNULL( &bi->sql_strcast_func ) ) {
1128                 backsql_strfcat( &bsi->bsi_sel, "blbl",
1129                                 &bi->sql_strcast_func,
1130                                 (ber_len_t)STRLENOF( "('" /* ') */ ),
1131                                         "('" /* ') */ ,
1132                                 &bsi->bsi_oc->bom_oc->soc_cname,
1133                                 (ber_len_t)STRLENOF( /* (' */ "')" ),
1134                                         /* (' */ "')" );
1135         } else {
1136                 backsql_strfcat( &bsi->bsi_sel, "cbc",
1137                                 '\'',
1138                                 &bsi->bsi_oc->bom_oc->soc_cname,
1139                                 '\'' );
1140         }
1141 #ifdef BACKSQL_ALIASING_QUOTE
1142         backsql_strfcat( &bsi->bsi_sel, "lclcl",
1143                         (ber_len_t)STRLENOF( " " BACKSQL_ALIASING ),
1144                                 " " BACKSQL_ALIASING,
1145                         BACKSQL_ALIASING_QUOTE,
1146                         (ber_len_t)STRLENOF( "objectClass" ),
1147                                 "objectClass",
1148                         BACKSQL_ALIASING_QUOTE,
1149                         (ber_len_t)STRLENOF( ",ldap_entries.dn " BACKSQL_ALIASING "dn" ),
1150                                 ",ldap_entries.dn " BACKSQL_ALIASING "dn" );
1151 #else /* ! BACKSQL_ALIASING_QUOTE */
1152         backsql_strfcat( &bsi->bsi_sel, "l",
1153                         (ber_len_t)STRLENOF( " " BACKSQL_ALIASING "objectClass,ldap_entries.dn " BACKSQL_ALIASING "dn" ),
1154                                 " " BACKSQL_ALIASING "objectClass,ldap_entries.dn " BACKSQL_ALIASING "dn" );
1155 #endif /* ! BACKSQL_ALIASING_QUOTE */
1156
1157         backsql_strfcat( &bsi->bsi_from, "lb",
1158                         (ber_len_t)STRLENOF( " FROM ldap_entries," ),
1159                                 " FROM ldap_entries,",
1160                         &bsi->bsi_oc->bom_keytbl );
1161
1162         backsql_strfcat( &bsi->bsi_join_where, "lbcbl",
1163                         (ber_len_t)STRLENOF( " WHERE " ), " WHERE ",
1164                         &bsi->bsi_oc->bom_keytbl,
1165                         '.',
1166                         &bsi->bsi_oc->bom_keycol,
1167                         (ber_len_t)STRLENOF( "=ldap_entries.keyval AND ldap_entries.oc_map_id=? AND " ),
1168                                 "=ldap_entries.keyval AND ldap_entries.oc_map_id=? AND " );
1169
1170         switch ( bsi->bsi_scope ) {
1171         case LDAP_SCOPE_BASE:
1172                 if ( BACKSQL_CANUPPERCASE( bi ) ) {
1173                         backsql_strfcat( &bsi->bsi_join_where, "bl",
1174                                         &bi->sql_upper_func,
1175                                         (ber_len_t)STRLENOF( "(ldap_entries.dn)=?" ),
1176                                                 "(ldap_entries.dn)=?" );
1177                 } else {
1178                         backsql_strfcat( &bsi->bsi_join_where, "l",
1179                                         (ber_len_t)STRLENOF( "ldap_entries.dn=?" ),
1180                                                 "ldap_entries.dn=?" );
1181                 }
1182                 break;
1183
1184         case BACKSQL_SCOPE_BASE_LIKE:
1185                 if ( BACKSQL_CANUPPERCASE( bi ) ) {
1186                         backsql_strfcat( &bsi->bsi_join_where, "bl",
1187                                         &bi->sql_upper_func,
1188                                         (ber_len_t)STRLENOF( "(ldap_entries.dn) LIKE ?" ),
1189                                                 "(ldap_entries.dn) LIKE ?" );
1190                 } else {
1191                         backsql_strfcat( &bsi->bsi_join_where, "l",
1192                                         (ber_len_t)STRLENOF( "ldap_entries.dn LIKE ?" ),
1193                                                 "ldap_entries.dn LIKE ?" );
1194                 }
1195                 break;
1196
1197         case LDAP_SCOPE_ONELEVEL:
1198                 backsql_strfcat( &bsi->bsi_join_where, "l",
1199                                 (ber_len_t)STRLENOF( "ldap_entries.parent=?" ),
1200                                         "ldap_entries.parent=?" );
1201                 break;
1202
1203 #ifdef LDAP_SCOPE_SUBORDINATE
1204         case LDAP_SCOPE_SUBORDINATE:
1205 #endif /* LDAP_SCOPE_SUBORDINATE */
1206         case LDAP_SCOPE_SUBTREE:
1207                 if ( BACKSQL_CANUPPERCASE( bi ) ) {
1208                         backsql_strfcat( &bsi->bsi_join_where, "bl",
1209                                         &bi->sql_upper_func,
1210                                         (ber_len_t)STRLENOF( "(ldap_entries.dn) LIKE ?" ),
1211                                                 "(ldap_entries.dn) LIKE ?"  );
1212                 } else {
1213                         backsql_strfcat( &bsi->bsi_join_where, "l",
1214                                         (ber_len_t)STRLENOF( "ldap_entries.dn LIKE ?" ),
1215                                                 "ldap_entries.dn LIKE ?" );
1216                 }
1217
1218                 break;
1219
1220         default:
1221                 assert( 0 );
1222         }
1223
1224         rc = backsql_process_filter( bsi, bsi->bsi_filter );
1225         if ( rc > 0 ) {
1226                 struct berbuf   bb = BB_NULL;
1227
1228                 backsql_strfcat( &bb, "bbblb",
1229                                 &bsi->bsi_sel.bb_val,
1230                                 &bsi->bsi_from.bb_val,
1231                                 &bsi->bsi_join_where.bb_val,
1232                                 (ber_len_t)STRLENOF( " AND " ), " AND ",
1233                                 &bsi->bsi_flt_where.bb_val );
1234
1235                 *query = bb.bb_val;
1236
1237         } else if ( rc < 0 ) {
1238                 /*
1239                  * Indicates that there's no possible way the filter matches
1240                  * anything.  No need to issue the query
1241                  */
1242                 free( query->bv_val );
1243                 BER_BVZERO( query );
1244         }
1245
1246         free( bsi->bsi_sel.bb_val.bv_val );
1247         BER_BVZERO( &bsi->bsi_sel.bb_val );
1248         bsi->bsi_sel.bb_len = 0;
1249         free( bsi->bsi_from.bb_val.bv_val );
1250         BER_BVZERO( &bsi->bsi_from.bb_val );
1251         bsi->bsi_from.bb_len = 0;
1252         free( bsi->bsi_join_where.bb_val.bv_val );
1253         BER_BVZERO( &bsi->bsi_join_where.bb_val );
1254         bsi->bsi_join_where.bb_len = 0;
1255         free( bsi->bsi_flt_where.bb_val.bv_val );
1256         BER_BVZERO( &bsi->bsi_flt_where.bb_val );
1257         bsi->bsi_flt_where.bb_len = 0;
1258
1259         Debug( LDAP_DEBUG_TRACE, "<==backsql_srch_query() returns %s\n",
1260                 query->bv_val ? query->bv_val : "NULL", 0, 0 );
1261
1262         return ( rc <= 0 ? 1 : 0 );
1263 }
1264
1265 static int
1266 backsql_oc_get_candidates( void *v_oc, void *v_bsi )
1267 {
1268         backsql_oc_map_rec      *oc = v_oc;
1269         backsql_srch_info       *bsi = v_bsi;
1270         backsql_info            *bi = (backsql_info *)bsi->bsi_op->o_bd->be_private;
1271         struct berval           query;
1272         SQLHSTMT                sth;
1273         RETCODE                 rc;
1274         int                     res;
1275         BACKSQL_ROW_NTS         row;
1276         int                     i;
1277         int                     j;
1278         int                     n_candidates = bsi->bsi_n_candidates;
1279
1280         /*
1281          * + 1 because we need room for '%';
1282          * + 1 because we need room for ',' for LDAP_SCOPE_SUBORDINATE;
1283          * this makes a subtree
1284          * search for a DN BACKSQL_MAX_DN_LEN long legal
1285          * if it returns that DN only
1286          */
1287         char                    tmp_base_ndn[ BACKSQL_MAX_DN_LEN + 1 + 1 ];
1288
1289         bsi->bsi_status = LDAP_SUCCESS;
1290
1291         Debug( LDAP_DEBUG_TRACE, "==>backsql_oc_get_candidates(): oc=\"%s\"\n",
1292                         BACKSQL_OC_NAME( oc ), 0, 0 );
1293
1294         if ( bsi->bsi_n_candidates == -1 ) {
1295                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
1296                         "unchecked limit has been overcome\n", 0, 0, 0 );
1297                 /* should never get here */
1298                 assert( 0 );
1299                 bsi->bsi_status = LDAP_ADMINLIMIT_EXCEEDED;
1300                 return BACKSQL_AVL_STOP;
1301         }
1302
1303         bsi->bsi_oc = oc;
1304         res = backsql_srch_query( bsi, &query );
1305         if ( res ) {
1306                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
1307                         "error while constructing query for objectclass \"%s\"\n",
1308                         oc->bom_oc->soc_cname.bv_val, 0, 0 );
1309                 /*
1310                  * FIXME: need to separate errors from legally
1311                  * impossible filters
1312                  */
1313                 switch ( bsi->bsi_status ) {
1314                 case LDAP_SUCCESS:
1315                 case LDAP_UNDEFINED_TYPE:
1316                 case LDAP_NO_SUCH_OBJECT:
1317                         /* we are conservative... */
1318                 default:
1319                         bsi->bsi_status = LDAP_SUCCESS;
1320                         /* try next */
1321                         return BACKSQL_AVL_CONTINUE;
1322
1323                 case LDAP_ADMINLIMIT_EXCEEDED:
1324                 case LDAP_OTHER:
1325                         /* don't try any more */
1326                         return BACKSQL_AVL_STOP;
1327                 }
1328         }
1329
1330         if ( BER_BVISNULL( &query ) ) {
1331                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
1332                         "could not construct query for objectclass \"%s\"\n",
1333                         oc->bom_oc->soc_cname.bv_val, 0, 0 );
1334                 bsi->bsi_status = LDAP_SUCCESS;
1335                 return BACKSQL_AVL_CONTINUE;
1336         }
1337
1338         Debug( LDAP_DEBUG_TRACE, "Constructed query: %s\n",
1339                         query.bv_val, 0, 0 );
1340
1341         rc = backsql_Prepare( bsi->bsi_dbh, &sth, query.bv_val, 0 );
1342         free( query.bv_val );
1343         BER_BVZERO( &query );
1344         if ( rc != SQL_SUCCESS ) {
1345                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
1346                         "error preparing query\n", 0, 0, 0 );
1347                 backsql_PrintErrors( bi->sql_db_env, bsi->bsi_dbh, sth, rc );
1348                 bsi->bsi_status = LDAP_OTHER;
1349                 return BACKSQL_AVL_CONTINUE;
1350         }
1351
1352         Debug( LDAP_DEBUG_TRACE, "id: '%ld'\n", bsi->bsi_oc->bom_id, 0, 0 );
1353
1354         rc = backsql_BindParamInt( sth, 1, SQL_PARAM_INPUT,
1355                         &bsi->bsi_oc->bom_id );
1356         if ( rc != SQL_SUCCESS ) {
1357                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
1358                         "error binding objectclass id parameter\n", 0, 0, 0 );
1359                 bsi->bsi_status = LDAP_OTHER;
1360                 return BACKSQL_AVL_CONTINUE;
1361         }
1362
1363         switch ( bsi->bsi_scope ) {
1364         case LDAP_SCOPE_BASE:
1365         case BACKSQL_SCOPE_BASE_LIKE:
1366                 /*
1367                  * We do not accept DNs longer than BACKSQL_MAX_DN_LEN;
1368                  * however this should be handled earlier
1369                  */
1370                 if ( bsi->bsi_base_ndn->bv_len > BACKSQL_MAX_DN_LEN ) {
1371                         bsi->bsi_status = LDAP_OTHER;
1372                         return BACKSQL_AVL_CONTINUE;
1373                 }
1374
1375                 AC_MEMCPY( tmp_base_ndn, bsi->bsi_base_ndn->bv_val,
1376                                 bsi->bsi_base_ndn->bv_len + 1 );
1377
1378                 /* uppercase DN only if the stored DN can be uppercased
1379                  * for comparison */
1380                 if ( BACKSQL_CANUPPERCASE( bi ) ) {
1381                         ldap_pvt_str2upper( tmp_base_ndn );
1382                 }
1383
1384                 Debug( LDAP_DEBUG_TRACE, "(base)dn: \"%s\"\n",
1385                                 tmp_base_ndn, 0, 0 );
1386
1387                 rc = backsql_BindParamStr( sth, 2, SQL_PARAM_INPUT,
1388                                 tmp_base_ndn, BACKSQL_MAX_DN_LEN );
1389                 if ( rc != SQL_SUCCESS ) {
1390                         Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
1391                                 "error binding base_ndn parameter\n", 0, 0, 0 );
1392                         backsql_PrintErrors( bi->sql_db_env, bsi->bsi_dbh,
1393                                         sth, rc );
1394                         bsi->bsi_status = LDAP_OTHER;
1395                         return BACKSQL_AVL_CONTINUE;
1396                 }
1397                 break;
1398
1399 #ifdef LDAP_SCOPE_SUBORDINATE
1400         case LDAP_SCOPE_SUBORDINATE:
1401 #endif /* LDAP_SCOPE_SUBORDINATE */
1402         case LDAP_SCOPE_SUBTREE:
1403         {
1404                 /*
1405                  * We do not accept DNs longer than BACKSQL_MAX_DN_LEN;
1406                  * however this should be handled earlier
1407                  */
1408                 if ( bsi->bsi_base_ndn->bv_len > BACKSQL_MAX_DN_LEN ) {
1409                         bsi->bsi_status = LDAP_OTHER;
1410                         return BACKSQL_AVL_CONTINUE;
1411                 }
1412
1413                 /*
1414                  * Sets the parameters for the SQL built earlier
1415                  * NOTE that all the databases could actually use
1416                  * the TimesTen version, which would be cleaner
1417                  * and would also eliminate the need for the
1418                  * subtree_cond line in the configuration file.
1419                  * For now, I'm leaving it the way it is,
1420                  * so non-TimesTen databases use the original code.
1421                  * But at some point this should get cleaned up.
1422                  *
1423                  * If "dn" is being used, do a suffix search.
1424                  * If "dn_ru" is being used, do a prefix search.
1425                  */
1426                 if ( BACKSQL_HAS_LDAPINFO_DN_RU( bi ) ) {
1427                         tmp_base_ndn[ 0 ] = '\0';
1428
1429                         for ( i = 0, j = bsi->bsi_base_ndn->bv_len - 1;
1430                                         j >= 0; i++, j--) {
1431                                 tmp_base_ndn[ i ] = bsi->bsi_base_ndn->bv_val[ j ];
1432                         }
1433
1434 #ifdef LDAP_SCOPE_SUBORDINATE
1435                         if ( bsi->bsi_scope == LDAP_SCOPE_SUBORDINATE ) {
1436                                 tmp_base_ndn[ i++ ] = ',';
1437                         }
1438 #endif /* LDAP_SCOPE_SUBORDINATE */
1439
1440                         tmp_base_ndn[ i ] = '%';
1441                         tmp_base_ndn[ i + 1 ] = '\0';
1442
1443                 } else {
1444                         i = 0;
1445
1446                         tmp_base_ndn[ i++ ] = '%';
1447
1448 #ifdef LDAP_SCOPE_SUBORDINATE
1449                         if ( bsi->bsi_scope == LDAP_SCOPE_SUBORDINATE ) {
1450                                 tmp_base_ndn[ i++ ] = ',';
1451                         }
1452 #endif /* LDAP_SCOPE_SUBORDINATE */
1453
1454                         AC_MEMCPY( &tmp_base_ndn[ i ], bsi->bsi_base_ndn->bv_val,
1455                                 bsi->bsi_base_ndn->bv_len + 1 );
1456                 }
1457
1458                 /* uppercase DN only if the stored DN can be uppercased
1459                  * for comparison */
1460                 if ( BACKSQL_CANUPPERCASE( bi ) ) {
1461                         ldap_pvt_str2upper( tmp_base_ndn );
1462                 }
1463
1464 #ifdef LDAP_SCOPE_SUBORDINATE
1465                 if ( bsi->bsi_scope == LDAP_SCOPE_SUBORDINATE ) {
1466                         Debug( LDAP_DEBUG_TRACE, "(children)dn: \"%s\"\n",
1467                                 tmp_base_ndn, 0, 0 );
1468                 } else
1469 #endif /* LDAP_SCOPE_SUBORDINATE */
1470                 {
1471                         Debug( LDAP_DEBUG_TRACE, "(sub)dn: \"%s\"\n",
1472                                 tmp_base_ndn, 0, 0 );
1473                 }
1474
1475                 rc = backsql_BindParamStr( sth, 2, SQL_PARAM_INPUT,
1476                                 tmp_base_ndn, BACKSQL_MAX_DN_LEN );
1477                 if ( rc != SQL_SUCCESS ) {
1478                         Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
1479                                 "error binding base_ndn parameter (2)\n",
1480                                 0, 0, 0 );
1481                         backsql_PrintErrors( bi->sql_db_env, bsi->bsi_dbh,
1482                                         sth, rc );
1483                         bsi->bsi_status = LDAP_OTHER;
1484                         return BACKSQL_AVL_CONTINUE;
1485                 }
1486                 break;
1487         }
1488
1489         case LDAP_SCOPE_ONELEVEL:
1490                 assert( !BER_BVISNULL( &bsi->bsi_base_id.eid_ndn ) );
1491
1492 #ifdef BACKSQL_ARBITRARY_KEY
1493                 Debug( LDAP_DEBUG_TRACE, "(one)id: \"%s\"\n",
1494                                 bsi->bsi_base_id.eid_id.bv_val, 0, 0 );
1495 #else /* ! BACKSQL_ARBITRARY_KEY */
1496                 Debug( LDAP_DEBUG_TRACE, "(one)id: '%lu'\n",
1497                                 bsi->bsi_base_id.eid_id, 0, 0 );
1498 #endif /* ! BACKSQL_ARBITRARY_KEY */
1499                 rc = backsql_BindParamID( sth, 2, SQL_PARAM_INPUT,
1500                                 &bsi->bsi_base_id.eid_id );
1501                 if ( rc != SQL_SUCCESS ) {
1502                         Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
1503                                 "error binding base id parameter\n", 0, 0, 0 );
1504                         bsi->bsi_status = LDAP_OTHER;
1505                         return BACKSQL_AVL_CONTINUE;
1506                 }
1507                 break;
1508         }
1509
1510         rc = SQLExecute( sth );
1511         if ( !BACKSQL_SUCCESS( rc ) ) {
1512                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
1513                         "error executing query\n", 0, 0, 0 );
1514                 backsql_PrintErrors( bi->sql_db_env, bsi->bsi_dbh, sth, rc );
1515                 SQLFreeStmt( sth, SQL_DROP );
1516                 bsi->bsi_status = LDAP_OTHER;
1517                 return BACKSQL_AVL_CONTINUE;
1518         }
1519
1520         backsql_BindRowAsStrings( sth, &row );
1521         rc = SQLFetch( sth );
1522         for ( ; BACKSQL_SUCCESS( rc ); rc = SQLFetch( sth ) ) {
1523                 struct berval           dn, pdn, ndn;
1524                 backsql_entryID         *c_id = NULL;
1525                 int                     ret;
1526
1527                 ber_str2bv( row.cols[ 3 ], 0, 0, &dn );
1528
1529                 if ( backsql_api_odbc2dn( bsi->bsi_op, bsi->bsi_rs, &dn ) ) {
1530                         continue;
1531                 }
1532
1533                 ret = dnPrettyNormal( NULL, &dn, &pdn, &ndn, NULL );
1534                 if ( dn.bv_val != row.cols[ 3 ] ) {
1535                         free( dn.bv_val );
1536                 }
1537
1538                 if ( ret != LDAP_SUCCESS ) {
1539                         continue;
1540                 }
1541
1542                 if ( bi->sql_baseObject && dn_match( &ndn, &bi->sql_baseObject->e_nname ) ) {
1543                         free( pdn.bv_val );
1544                         free( ndn.bv_val );
1545                         continue;
1546                 }
1547
1548                 c_id = (backsql_entryID *)ch_calloc( 1,
1549                                 sizeof( backsql_entryID ) );
1550 #ifdef BACKSQL_ARBITRARY_KEY
1551                 ber_str2bv( row.cols[ 0 ], 0, 1, &c_id->eid_id );
1552                 ber_str2bv( row.cols[ 1 ], 0, 1, &c_id->eid_keyval );
1553 #else /* ! BACKSQL_ARBITRARY_KEY */
1554                 c_id->eid_id = strtol( row.cols[ 0 ], NULL, 0 );
1555                 c_id->eid_keyval = strtol( row.cols[ 1 ], NULL, 0 );
1556 #endif /* ! BACKSQL_ARBITRARY_KEY */
1557                 c_id->eid_oc_id = bsi->bsi_oc->bom_id;
1558
1559                 c_id->eid_dn = pdn;
1560                 c_id->eid_ndn = ndn;
1561
1562                 /* append at end of list ... */
1563                 c_id->eid_next = NULL;
1564                 *bsi->bsi_id_listtail = c_id;
1565                 bsi->bsi_id_listtail = &c_id->eid_next;
1566
1567 #ifdef BACKSQL_ARBITRARY_KEY
1568                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
1569                         "added entry id=%s, keyval=%s dn=\"%s\"\n",
1570                         c_id->eid_id.bv_val, c_id->eid_keyval.bv_val,
1571                         row.cols[ 3 ] );
1572 #else /* ! BACKSQL_ARBITRARY_KEY */
1573                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
1574                         "added entry id=%ld, keyval=%ld dn=\"%s\"\n",
1575                         c_id->eid_id, c_id->eid_keyval, row.cols[ 3 ] );
1576 #endif /* ! BACKSQL_ARBITRARY_KEY */
1577
1578                 /* count candidates, for unchecked limit */
1579                 bsi->bsi_n_candidates--;
1580                 if ( bsi->bsi_n_candidates == -1 ) {
1581                         break;
1582                 }
1583         }
1584         backsql_FreeRow( &row );
1585         SQLFreeStmt( sth, SQL_DROP );
1586
1587         Debug( LDAP_DEBUG_TRACE, "<==backsql_oc_get_candidates(): %d\n",
1588                         n_candidates - bsi->bsi_n_candidates, 0, 0 );
1589
1590         return ( bsi->bsi_n_candidates == -1 ? BACKSQL_AVL_STOP : BACKSQL_AVL_CONTINUE );
1591 }
1592
1593 int
1594 backsql_search( Operation *op, SlapReply *rs )
1595 {
1596         backsql_info            *bi = (backsql_info *)op->o_bd->be_private;
1597         SQLHDBC                 dbh;
1598         int                     sres;
1599         Entry                   user_entry = { 0 };
1600         int                     manageDSAit;
1601         time_t                  stoptime = 0;
1602         backsql_srch_info       bsi;
1603         backsql_entryID         *eid = NULL;
1604         struct berval           nbase = BER_BVNULL;
1605
1606         manageDSAit = get_manageDSAit( op );
1607
1608         Debug( LDAP_DEBUG_TRACE, "==>backsql_search(): "
1609                 "base=\"%s\", filter=\"%s\", scope=%d,",
1610                 op->o_req_ndn.bv_val,
1611                 op->ors_filterstr.bv_val,
1612                 op->ors_scope );
1613         Debug( LDAP_DEBUG_TRACE, " deref=%d, attrsonly=%d, "
1614                 "attributes to load: %s\n",
1615                 op->ors_deref,
1616                 op->ors_attrsonly,
1617                 op->ors_attrs == NULL ? "all" : "custom list" );
1618
1619         if ( op->o_req_ndn.bv_len > BACKSQL_MAX_DN_LEN ) {
1620                 Debug( LDAP_DEBUG_TRACE, "backsql_search(): "
1621                         "search base length (%ld) exceeds max length (%d)\n",
1622                         op->o_req_ndn.bv_len, BACKSQL_MAX_DN_LEN, 0 );
1623                 /*
1624                  * FIXME: a LDAP_NO_SUCH_OBJECT could be appropriate
1625                  * since it is impossible that such a long DN exists
1626                  * in the backend
1627                  */
1628                 rs->sr_err = LDAP_ADMINLIMIT_EXCEEDED;
1629                 send_ldap_result( op, rs );
1630                 return 1;
1631         }
1632
1633         sres = backsql_get_db_conn( op, &dbh );
1634         if ( sres != LDAP_SUCCESS ) {
1635                 Debug( LDAP_DEBUG_TRACE, "backsql_search(): "
1636                         "could not get connection handle - exiting\n",
1637                         0, 0, 0 );
1638                 rs->sr_err = sres;
1639                 rs->sr_text = sres == LDAP_OTHER ?  "SQL-backend error" : NULL;
1640                 send_ldap_result( op, rs );
1641                 return 1;
1642         }
1643
1644         /* compute it anyway; root does not use it */
1645         stoptime = op->o_time + op->ors_tlimit;
1646
1647         nbase = op->o_req_ndn;
1648         if ( backsql_api_dn2odbc( op, rs, &nbase ) ) {
1649                 Debug( LDAP_DEBUG_TRACE, "backsql_search(): "
1650                         "backsql_api_dn2odbc failed\n",
1651                         0, 0, 0 );
1652                 rs->sr_err = LDAP_OTHER;
1653                 rs->sr_text = "SQL-backend error";
1654                 send_ldap_result( op, rs );
1655                 goto done;
1656         }
1657
1658         /* init search */
1659         rs->sr_err = backsql_init_search( &bsi, &nbase,
1660                         op->ors_scope,
1661                         op->ors_slimit, op->ors_tlimit,
1662                         stoptime, op->ors_filter,
1663                         dbh, op, rs, op->ors_attrs, 1 );
1664         if ( rs->sr_err != LDAP_SUCCESS ) {
1665                 send_ldap_result( op, rs );
1666                 goto done;
1667         }
1668
1669         bsi.bsi_n_candidates =
1670                 ( op->ors_limit == NULL /* isroot == TRUE */ ? -2 :
1671                 ( op->ors_limit->lms_s_unchecked == -1 ? -2 :
1672                 ( op->ors_limit->lms_s_unchecked ) ) );
1673
1674         switch ( bsi.bsi_scope ) {
1675         case LDAP_SCOPE_BASE:
1676         case BACKSQL_SCOPE_BASE_LIKE:
1677                 /*
1678                  * probably already found...
1679                  */
1680                 bsi.bsi_id_list = &bsi.bsi_base_id;
1681                 bsi.bsi_id_listtail = &bsi.bsi_base_id.eid_next;
1682                 break;
1683
1684         case LDAP_SCOPE_SUBTREE:
1685                 /*
1686                  * if baseObject is defined, and if it is the root
1687                  * of the search, add it to the candidate list
1688                  */
1689                 if ( bi->sql_baseObject && BACKSQL_IS_BASEOBJECT_ID( &bsi.bsi_base_id.eid_id ) )
1690                 {
1691                         bsi.bsi_id_list = &bsi.bsi_base_id;
1692                         bsi.bsi_id_listtail = &bsi.bsi_base_id.eid_next;
1693                 }
1694
1695                 /* FALLTHRU */
1696         default:
1697
1698                 /*
1699                  * for each objectclass we try to construct query which gets IDs
1700                  * of entries matching LDAP query filter and scope (or at least
1701                  * candidates), and get the IDs
1702                  */
1703                 avl_apply( bi->sql_oc_by_oc, backsql_oc_get_candidates,
1704                                 &bsi, BACKSQL_AVL_STOP, AVL_INORDER );
1705         }
1706
1707         if ( op->ors_limit != NULL      /* isroot == FALSE */
1708                         && op->ors_limit->lms_s_unchecked != -1
1709                         && bsi.bsi_n_candidates == -1 )
1710         {
1711                 rs->sr_err = LDAP_ADMINLIMIT_EXCEEDED;
1712                 send_ldap_result( op, rs );
1713                 goto done;
1714         }
1715
1716         /*
1717          * now we load candidate entries (only those attributes
1718          * mentioned in attrs and filter), test it against full filter
1719          * and then send to client; don't free entry_id if baseObject...
1720          */
1721         for ( eid = bsi.bsi_id_list;
1722                         eid != NULL;
1723                         eid = backsql_free_entryID( eid, eid == &bsi.bsi_base_id ? 0 : 1 ) )
1724         {
1725                 int             rc;
1726                 Attribute       *a_hasSubordinate = NULL,
1727                                 *a_entryUUID = NULL,
1728                                 *a_entryCSN = NULL,
1729                                 **ap = NULL;
1730                 Entry           *e = NULL;
1731
1732                 /* check for abandon */
1733                 if ( op->o_abandon ) {
1734                         break;
1735                 }
1736
1737                 /* check time limit */
1738                 if ( op->ors_tlimit != SLAP_NO_LIMIT
1739                                 && slap_get_time() > stoptime )
1740                 {
1741                         rs->sr_err = LDAP_TIMELIMIT_EXCEEDED;
1742                         rs->sr_ctrls = NULL;
1743                         rs->sr_ref = rs->sr_v2ref;
1744                         rs->sr_err = (rs->sr_v2ref == NULL) ? LDAP_SUCCESS
1745                                 : LDAP_REFERRAL;
1746                         send_ldap_result( op, rs );
1747                         goto end_of_search;
1748                 }
1749
1750 #ifdef BACKSQL_ARBITRARY_KEY
1751                 Debug(LDAP_DEBUG_TRACE, "backsql_search(): loading data "
1752                         "for entry id=%s, oc_id=%ld, keyval=%s\n",
1753                         eid->eid_id.bv_val, eid->eid_oc_id,
1754                         eid->eid_keyval.bv_val );
1755 #else /* ! BACKSQL_ARBITRARY_KEY */
1756                 Debug(LDAP_DEBUG_TRACE, "backsql_search(): loading data "
1757                         "for entry id=%ld, oc_id=%ld, keyval=%ld\n",
1758                         eid->eid_id, eid->eid_oc_id, eid->eid_keyval );
1759 #endif /* ! BACKSQL_ARBITRARY_KEY */
1760
1761                 /* check scope */
1762                 switch ( op->ors_scope ) {
1763                 case LDAP_SCOPE_BASE:
1764                 case BACKSQL_SCOPE_BASE_LIKE:
1765                         if ( !dn_match( &eid->eid_ndn, &op->o_req_ndn ) ) {
1766                                 goto next_entry2;
1767                         }
1768                         break;
1769
1770                 case LDAP_SCOPE_ONE:
1771                 {
1772                         struct berval   rdn = eid->eid_ndn;
1773
1774                         rdn.bv_len -= op->o_req_ndn.bv_len + STRLENOF( "," );
1775                         if ( !dnIsOneLevelRDN( &rdn ) ) {
1776                                 goto next_entry2;
1777                         }
1778                         /* fall thru */
1779                 }
1780
1781 #ifdef LDAP_SCOPE_SUBORDINATE
1782                 case LDAP_SCOPE_SUBORDINATE:
1783                         /* discard the baseObject entry */
1784                         if ( dn_match( &eid->eid_ndn, &op->o_req_ndn ) ) {
1785                                 goto next_entry2;
1786                         }
1787                 /* FALLTHRU */
1788 #endif /* LDAP_SCOPE_SUBORDINATE */
1789
1790                 case LDAP_SCOPE_SUBTREE:
1791                         /* FIXME: this should never fail... */
1792                         if ( !dnIsSuffix( &eid->eid_ndn, &op->o_req_ndn ) ) {
1793                                 goto next_entry2;
1794                         }
1795                         break;
1796                 }
1797
1798                 /* don't recollect baseObject ... */
1799                 if ( BACKSQL_IS_BASEOBJECT_ID( &eid->eid_id ) ) {
1800                         e = bi->sql_baseObject;
1801
1802                 } else {
1803                         bsi.bsi_e = &user_entry;
1804                         rc = backsql_id2entry( &bsi, eid );
1805                         if ( rc != LDAP_SUCCESS ) {
1806                                 Debug( LDAP_DEBUG_TRACE, "backsql_search(): "
1807                                         "error %d in backsql_id2entry() "
1808                                         "- skipping\n", rc, 0, 0 );
1809                                 continue;
1810                         }
1811
1812                         e = &user_entry;
1813                 }
1814
1815                 if ( !manageDSAit &&
1816                                 op->ors_scope != LDAP_SCOPE_BASE &&
1817                                 op->ors_scope != BACKSQL_SCOPE_BASE_LIKE &&
1818                                 is_entry_referral( e ) )
1819                 {
1820                         BerVarray refs;
1821
1822                         refs = get_entry_referrals( op, e );
1823                         if ( !refs ) {
1824                                 backsql_srch_info       bsi2 = { 0 };
1825                                 Entry                   user_entry2 = { 0 };
1826
1827                                 /* retry with the full entry... */
1828                                 (void)backsql_init_search( &bsi2,
1829                                                 &e->e_nname,
1830                                                 LDAP_SCOPE_BASE,
1831                                                 -1, -1, -1, NULL,
1832                                                 dbh, op, rs, NULL, 0 );
1833                                 bsi2.bsi_e = &user_entry2;
1834                                 rc = backsql_id2entry( &bsi2, eid );
1835                                 if ( rc == LDAP_SUCCESS ) {
1836                                         if ( is_entry_referral( &user_entry2 ) )
1837                                         {
1838                                                 refs = get_entry_referrals( op,
1839                                                                 &user_entry2 );
1840                                         } /* else: FIXME: inconsistency! */
1841                                         entry_clean( &user_entry2 );
1842                                 }
1843                         }
1844
1845                         if ( refs ) {
1846                                 rs->sr_ref = referral_rewrite( refs,
1847                                                 &e->e_name,
1848                                                 &op->o_req_dn,
1849                                                 op->ors_scope );
1850                                 ber_bvarray_free( refs );
1851                         }
1852
1853                         if ( !rs->sr_ref ) {
1854                                 rs->sr_text = "bad_referral object";
1855                         }
1856
1857                         rs->sr_entry = e;
1858                         rs->sr_err = LDAP_REFERRAL;
1859                         rs->sr_matched = user_entry.e_name.bv_val;
1860                         send_search_reference( op, rs );
1861
1862                         ber_bvarray_free( rs->sr_ref );
1863                         rs->sr_ref = NULL;
1864                         rs->sr_matched = NULL;
1865                         rs->sr_entry = NULL;
1866
1867                         goto next_entry;
1868                 }
1869
1870                 /*
1871                  * We use this flag since we need to parse the filter
1872                  * anyway; we should have used the frontend API function
1873                  * filter_has_subordinates()
1874                  */
1875                 if ( bsi.bsi_flags & BSQL_SF_FILTER_HASSUBORDINATE ) {
1876                         rc = backsql_has_children( bi, dbh, &e->e_nname );
1877
1878                         switch ( rc ) {
1879                         case LDAP_COMPARE_TRUE:
1880                         case LDAP_COMPARE_FALSE:
1881                                 a_hasSubordinate = slap_operational_hasSubordinate( rc == LDAP_COMPARE_TRUE );
1882                                 if ( a_hasSubordinate != NULL ) {
1883                                         for ( ap = &user_entry.e_attrs;
1884                                                         *ap;
1885                                                         ap = &(*ap)->a_next );
1886
1887                                         *ap = a_hasSubordinate;
1888                                 }
1889                                 rc = 0;
1890                                 break;
1891
1892                         default:
1893                                 Debug(LDAP_DEBUG_TRACE,
1894                                         "backsql_search(): "
1895                                         "has_children failed( %d)\n",
1896                                         rc, 0, 0 );
1897                                 rc = 1;
1898                                 goto next_entry;
1899                         }
1900                 }
1901
1902                 if ( bsi.bsi_flags & BSQL_SF_FILTER_ENTRYUUID ) {
1903                         a_entryUUID = backsql_operational_entryUUID( bi, eid );
1904                         if ( a_entryUUID != NULL ) {
1905                                 if ( ap == NULL ) {
1906                                         ap = &user_entry.e_attrs;
1907                                 }
1908
1909                                 for ( ; *ap; ap = &(*ap)->a_next );
1910
1911                                 *ap = a_entryUUID;
1912                         }
1913                 }
1914
1915 #ifdef BACKSQL_SYNCPROV
1916                 if ( bsi.bsi_flags & BSQL_SF_FILTER_ENTRYCSN ) {
1917                         a_entryCSN = backsql_operational_entryCSN( op );
1918                         if ( a_entryCSN != NULL ) {
1919                                 if ( ap == NULL ) {
1920                                         ap = &user_entry.e_attrs;
1921                                 }
1922
1923                                 for ( ; *ap; ap = &(*ap)->a_next );
1924
1925                                 *ap = a_entryCSN;
1926                         }
1927                 }
1928 #endif /* BACKSQL_SYNCPROV */
1929
1930                 if ( test_filter( op, e, op->ors_filter ) == LDAP_COMPARE_TRUE )
1931                 {
1932                         rs->sr_attrs = op->ors_attrs;
1933                         rs->sr_operational_attrs = NULL;
1934                         rs->sr_entry = e;
1935                         if ( e == &user_entry ) {
1936                                 rs->sr_flags = REP_ENTRY_MODIFIABLE;
1937                         }
1938                         sres = send_search_entry( op, rs );
1939                         rs->sr_entry = NULL;
1940                         rs->sr_attrs = NULL;
1941                         rs->sr_operational_attrs = NULL;
1942
1943                         switch ( sres ) {
1944                         case 0:
1945                                 break;
1946
1947                         default:
1948                                 /*
1949                                  * FIXME: send_search_entry failed;
1950                                  * better stop
1951                                  */
1952                         case -1:
1953                                 Debug( LDAP_DEBUG_TRACE, "backsql_search(): "
1954                                         "connection lost\n", 0, 0, 0 );
1955                                 goto end_of_search;
1956                         }
1957                 }
1958
1959 next_entry:;
1960                 entry_clean( &user_entry );
1961
1962 next_entry2:;
1963                 if ( op->ors_slimit != SLAP_NO_LIMIT
1964                                 && rs->sr_nentries >= op->ors_slimit )
1965                 {
1966                         rs->sr_err = LDAP_SIZELIMIT_EXCEEDED;
1967                         send_ldap_result( op, rs );
1968                         goto end_of_search;
1969                 }
1970         }
1971
1972 end_of_search:;
1973         /* in case we got here accidentally */
1974         entry_clean( &user_entry );
1975
1976         if ( rs->sr_nentries > 0 ) {
1977                 rs->sr_ref = rs->sr_v2ref;
1978                 rs->sr_err = (rs->sr_v2ref == NULL) ? LDAP_SUCCESS
1979                         : LDAP_REFERRAL;
1980
1981         } else {
1982                 rs->sr_err = bsi.bsi_status;
1983         }
1984         send_ldap_result( op, rs );
1985
1986         if ( rs->sr_v2ref ) {
1987                 ber_bvarray_free( rs->sr_v2ref );
1988                 rs->sr_v2ref = NULL;
1989         }
1990
1991 #ifdef BACKSQL_SYNCPROV
1992         if ( op->o_sync ) {
1993                 Operation       op2 = *op;
1994                 SlapReply       rs2 = { 0 };
1995                 Entry           e = { 0 };
1996                 slap_callback   cb = { 0 };
1997
1998                 op2.o_tag = LDAP_REQ_ADD;
1999                 op2.o_bd = select_backend( &op->o_bd->be_nsuffix[0], 0, 0 );
2000                 op2.ora_e = &e;
2001                 op2.o_callback = &cb;
2002
2003                 e.e_name = op->o_bd->be_suffix[0];
2004                 e.e_nname = op->o_bd->be_nsuffix[0];
2005
2006                 cb.sc_response = slap_null_cb;
2007
2008                 op2.o_bd->be_add( &op2, &rs2 );
2009         }
2010 #endif /* BACKSQL_SYNCPROV */
2011
2012 done:;
2013         if ( !BER_BVISNULL( &bsi.bsi_base_id.eid_ndn ) ) {
2014                 (void)backsql_free_entryID( &bsi.bsi_base_id, 0 );
2015         }
2016
2017         if ( bsi.bsi_attrs ) {
2018                 ch_free( bsi.bsi_attrs );
2019         }
2020
2021         if ( !BER_BVISNULL( &nbase )
2022                         && nbase.bv_val != op->o_req_ndn.bv_val )
2023         {
2024                 ch_free( nbase.bv_val );
2025         }
2026
2027         /* restore scope ... FIXME: this should be done before ANY
2028          * frontend call that uses op */
2029         if ( op->ors_scope == BACKSQL_SCOPE_BASE_LIKE ) {
2030                 op->ors_scope = LDAP_SCOPE_BASE;
2031         }
2032
2033         Debug( LDAP_DEBUG_TRACE, "<==backsql_search()\n", 0, 0, 0 );
2034         return 0;
2035 }
2036
2037 /* return LDAP_SUCCESS IFF we can retrieve the specified entry.
2038  */
2039 int
2040 backsql_entry_get(
2041                 Operation               *op,
2042                 struct berval           *ndn,
2043                 ObjectClass             *oc,
2044                 AttributeDescription    *at,
2045                 int                     rw,
2046                 Entry                   **ent )
2047 {
2048         backsql_srch_info       bsi;
2049         SQLHDBC                 dbh;
2050         int                     rc;
2051         SlapReply               rs = { 0 };
2052         AttributeName           anlist[ 2 ];
2053
2054         rc = backsql_get_db_conn( op, &dbh );
2055         if ( !dbh ) {
2056                 return LDAP_OTHER;
2057         }
2058
2059         if ( at ) {
2060                 anlist[ 0 ].an_name = at->ad_cname;
2061                 anlist[ 0 ].an_desc = at;
2062                 BER_BVZERO( &anlist[ 1 ].an_name );
2063         }
2064
2065         rc = backsql_init_search( &bsi,
2066                         ndn,
2067                         LDAP_SCOPE_BASE,
2068                         SLAP_NO_LIMIT, SLAP_NO_LIMIT, -1, NULL,
2069                         dbh, op, &rs, at ? anlist : NULL, 1 );
2070         if ( rc != LDAP_SUCCESS ) {
2071                 return rc;
2072         }
2073
2074         bsi.bsi_e = ch_malloc( sizeof( Entry ) );
2075         rc = backsql_id2entry( &bsi, &bsi.bsi_base_id );
2076
2077         if ( !BER_BVISNULL( &bsi.bsi_base_id.eid_ndn ) ) {
2078                 (void)backsql_free_entryID( &bsi.bsi_base_id, 0 );
2079         }
2080
2081         if ( rc == LDAP_SUCCESS ) {
2082
2083 #if 0 /* not supported at present */
2084                 /* find attribute values */
2085                 if ( is_entry_alias( bsi.bsi_e ) ) {
2086                         Debug( LDAP_DEBUG_ACL,
2087                                 "<= backsql_entry_get: entry is an alias\n",
2088                                 0, 0, 0 );
2089                         rc = LDAP_ALIAS_PROBLEM;
2090                         goto return_results;
2091                 }
2092 #endif
2093
2094                 if ( is_entry_referral( bsi.bsi_e ) ) {
2095                         Debug( LDAP_DEBUG_ACL,
2096                                 "<= backsql_entry_get: entry is a referral\n",
2097                                 0, 0, 0 );
2098                         rc = LDAP_REFERRAL;
2099                         goto return_results;
2100                 }
2101
2102                 if ( oc && !is_entry_objectclass( bsi.bsi_e, oc, 0 ) ) {
2103                         Debug( LDAP_DEBUG_ACL,
2104                                         "<= backsql_entry_get: "
2105                                         "failed to find objectClass\n",
2106                                         0, 0, 0 );
2107                         rc = LDAP_NO_SUCH_ATTRIBUTE;
2108                         goto return_results;
2109                 }
2110
2111                 *ent = bsi.bsi_e;
2112         }
2113
2114 return_results:;
2115         if ( rc != LDAP_SUCCESS ) {
2116                 if ( bsi.bsi_e ) {
2117                         entry_free( bsi.bsi_e );
2118                 }
2119         }
2120
2121         return rc;
2122 }
2123