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