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 = BSQL_SF_NONE;
 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 ) {
 680                         /* unsupported at present... */
 681                         bsi->bsi_status = LDAP_OTHER;
 682                         rc = -1;
 683                         goto done;
 684                 }
 685
 686                 /* save for later use in operational attributes */
 687                 bsi->bsi_op->o_private = &f->f_av_value;
 688
 689                 bsi->bsi_flags |= ( BSQL_SF_FILTER_ENTRYCSN | BSQL_SF_RETURN_ENTRYUUID);
 690
 691                 /* if doing a syncrepl, try to return as much as possible,
 692                  * and always match the filter */
 693                 backsql_strfcat( &bsi->bsi_flt_where, "l",
 694                                 (ber_len_t)STRLENOF( "1=1" ), "1=1" );
 695
 696                 bsi->bsi_status = LDAP_SUCCESS;
 697                 rc = 1;
 698                 goto done;
 699
 700         } else if ( ad == slap_schema.si_ad_hasSubordinates || ad == NULL ) {
 701                 /*
 702                  * FIXME: this is not robust; e.g. a filter
 703                  * '(!(hasSubordinates=TRUE))' fails because
 704                  * in SQL it would read 'NOT (1=1)' instead
 705                  * of no condition.
 706                  * Note however that hasSubordinates is boolean,
 707                  * so a more appropriate filter would be
 708                  * '(hasSubordinates=FALSE)'
 709                  *
 710                  * A more robust search for hasSubordinates
 711                  * would * require joining the ldap_entries table
 712                  * selecting if there are descendants of the
 713                  * candidate.
 714                  */
 715                 backsql_strfcat( &bsi->bsi_flt_where, "l",
 716                                 (ber_len_t)STRLENOF( "1=1" ), "1=1" );
 717                 if ( ad == slap_schema.si_ad_hasSubordinates ) {
 718                         /*
 719                          * instruct candidate selection algorithm
 720                          * and attribute list to try to detect
 721                          * if an entry has subordinates
 722                          */
 723                         bsi->bsi_flags |= BSQL_SF_FILTER_HASSUBORDINATE;
 724
 725                 } else {
 726                         /*
 727                          * clear attributes to fetch, to require ALL
 728                          * and try extended match on all attributes
 729                          */
 730                         backsql_attrlist_add( bsi, NULL );
 731                 }
 732                 rc = 1;
 733                 goto done;
 734         }
 735
 736         /*
 737          * attribute inheritance:
 738          */
 739         if ( backsql_supad2at( bsi->bsi_oc, ad, &vat ) ) {
 740                 bsi->bsi_status = LDAP_OTHER;
 741                 rc = -1;
 742                 goto done;
 743         }
 744
 745         if ( vat == NULL ) {
 746                 /* search anyway; other parts of the filter
 747                  * may succeeed */
 748                 backsql_strfcat( &bsi->bsi_flt_where, "l",
 749                                 (ber_len_t)STRLENOF( "1=1" ), "1=1" );
 750                 bsi->bsi_status = LDAP_SUCCESS;
 751                 rc = 1;
 752                 goto done;
 753         }
 754
 755         /* if required, open extra level of parens */
 756         done = 0;
 757         if ( vat[0]->bam_next || vat[1] ) {
 758                 backsql_strfcat( &bsi->bsi_flt_where, "c", '(' );
 759                 done = 1;
 760         }
 761
 762         i = 0;
 763 next:;
 764         /* apply attr */
 765         if ( backsql_process_filter_attr( bsi, f, vat[i] ) == -1 ) {
 766                 return -1;
 767         }
 768
 769         /* if more definitions of the same attr, apply */
 770         if ( vat[i]->bam_next ) {
 771                 backsql_strfcat( &bsi->bsi_flt_where, "l",
 772                         STRLENOF( " OR " ), " OR " );
 773                 vat[i] = vat[i]->bam_next;
 774                 goto next;
 775         }
 776
 777         /* if more descendants of the same attr, apply */
 778         i++;
 779         if ( vat[i] ) {
 780                 backsql_strfcat( &bsi->bsi_flt_where, "l",
 781                         STRLENOF( " OR " ), " OR " );
 782                 goto next;
 783         }
 784
 785         /* if needed, close extra level of parens */
 786         if ( done ) {
 787                 backsql_strfcat( &bsi->bsi_flt_where, "c", ')' );
 788         }
 789
 790         rc = 1;
 791
 792 done:;
 793         if ( vat ) {
 794                 ch_free( vat );
 795         }
 796
 797         Debug( LDAP_DEBUG_TRACE,
 798                         "<==backsql_process_filter() %s\n",
 799                         rc == 1 ? "succeeded" : "failed", 0, 0);
 800
 801         return rc;
 802 }
 803
 804 static int
 805 backsql_process_filter_eq( backsql_srch_info *bsi, backsql_at_map_rec *at,
 806                 int casefold, struct berval *filter_value )
 807 {
 808         /*
 809          * maybe we should check type of at->sel_expr here somehow,
 810          * to know whether upper_func is applicable, but for now
 811          * upper_func stuff is made for Oracle, where UPPER is
 812          * safely applicable to NUMBER etc.
 813          */
 814         if ( casefold && BACKSQL_AT_CANUPPERCASE( at ) ) {
 815                 ber_len_t       start;
 816
 817                 backsql_strfcat( &bsi->bsi_flt_where, "cbl",
 818                                 '(', /* ) */
 819                                 &at->bam_sel_expr_u,
 820                                 (ber_len_t)STRLENOF( "='" ),
 821                                         "='" );
 822
 823                 start = bsi->bsi_flt_where.bb_val.bv_len;
 824
 825                 backsql_strfcat( &bsi->bsi_flt_where, "bl",
 826                                 filter_value,
 827                                 (ber_len_t)STRLENOF( /* (' */ "')" ),
 828                                         /* (' */ "')" );
 829
 830                 ldap_pvt_str2upper( &bsi->bsi_flt_where.bb_val.bv_val[ start ] );
 831
 832         } else {
 833                 backsql_strfcat( &bsi->bsi_flt_where, "cblbl",
 834                                 '(', /* ) */
 835                                 &at->bam_sel_expr,
 836                                 (ber_len_t)STRLENOF( "='" ), "='",
 837                                 filter_value,
 838                                 (ber_len_t)STRLENOF( /* (' */ "')" ),
 839                                         /* (' */ "')" );
 840         }
 841
 842         return 1;
 843 }
 844
 845 static int
 846 backsql_process_filter_like( backsql_srch_info *bsi, backsql_at_map_rec *at,
 847                 int casefold, struct berval *filter_value )
 848 {
 849         /*
 850          * maybe we should check type of at->sel_expr here somehow,
 851          * to know whether upper_func is applicable, but for now
 852          * upper_func stuff is made for Oracle, where UPPER is
 853          * safely applicable to NUMBER etc.
 854          */
 855         if ( casefold && BACKSQL_AT_CANUPPERCASE( at ) ) {
 856                 ber_len_t       start;
 857
 858                 backsql_strfcat( &bsi->bsi_flt_where, "cbl",
 859                                 '(', /* ) */
 860                                 &at->bam_sel_expr_u,
 861                                 (ber_len_t)STRLENOF( " LIKE '%" ),
 862                                         " LIKE '%" );
 863
 864                 start = bsi->bsi_flt_where.bb_val.bv_len;
 865
 866                 backsql_strfcat( &bsi->bsi_flt_where, "bl",
 867                                 filter_value,
 868                                 (ber_len_t)STRLENOF( /* (' */ "%')" ),
 869                                         /* (' */ "%')" );
 870
 871                 ldap_pvt_str2upper( &bsi->bsi_flt_where.bb_val.bv_val[ start ] );
 872
 873         } else {
 874                 backsql_strfcat( &bsi->bsi_flt_where, "cblbl",
 875                                 '(', /* ) */
 876                                 &at->bam_sel_expr,
 877                                 (ber_len_t)STRLENOF( " LIKE '%" ),
 878                                         " LIKE '%",
 879                                 filter_value,
 880                                 (ber_len_t)STRLENOF( /* (' */ "%')" ),
 881                                         /* (' */ "%')" );
 882         }
 883
 884         return 1;
 885 }
 886
 887 static int
 888 backsql_process_filter_attr( backsql_srch_info *bsi, Filter *f, backsql_at_map_rec *at )
 889 {
 890         backsql_info            *bi = (backsql_info *)bsi->bsi_op->o_bd->be_private;
 891         int                     casefold = 0;
 892         struct berval           *filter_value = NULL;
 893         MatchingRule            *matching_rule = NULL;
 894         struct berval           ordering = BER_BVC("<=");
 895
 896         Debug( LDAP_DEBUG_TRACE, "==>backsql_process_filter_attr(%s)\n",
 897                 at->bam_ad->ad_cname.bv_val, 0, 0 );
 898
 899         /*
 900          * need to add this attribute to list of attrs to load,
 901          * so that we can do test_filter() later
 902          */
 903         backsql_attrlist_add( bsi, at->bam_ad );
 904
 905         backsql_merge_from_tbls( bsi, &at->bam_from_tbls );
 906
 907         if ( !BER_BVISNULL( &at->bam_join_where )
 908                         && strstr( bsi->bsi_join_where.bb_val.bv_val,
 909                                 at->bam_join_where.bv_val ) == NULL )
 910         {
 911                 backsql_strfcat( &bsi->bsi_join_where, "lb",
 912                                 (ber_len_t)STRLENOF( " AND " ), " AND ",
 913                                 &at->bam_join_where );
 914         }
 915
 916         switch ( f->f_choice ) {
 917         case LDAP_FILTER_EQUALITY:
 918                 filter_value = &f->f_av_value;
 919                 matching_rule = at->bam_ad->ad_type->sat_equality;
 920
 921                 goto equality_match;
 922
 923                 /* fail over into next case */
 924
 925         case LDAP_FILTER_EXT:
 926                 filter_value = &f->f_mra->ma_value;
 927                 matching_rule = f->f_mr_rule;
 928
 929 equality_match:;
 930                 /* always uppercase strings by now */
 931 #ifdef BACKSQL_UPPERCASE_FILTER
 932                 if ( SLAP_MR_ASSOCIATED( matching_rule,
 933                                         bi->sql_caseIgnoreMatch ) )
 934 #endif /* BACKSQL_UPPERCASE_FILTER */
 935                 {
 936                         casefold = 1;
 937                 }
 938
 939                 if ( SLAP_MR_ASSOCIATED( matching_rule,
 940                                         bi->sql_telephoneNumberMatch ) )
 941                 {
 942                         struct berval   bv;
 943                         ber_len_t       i;
 944
 945                         /*
 946                          * to check for matching telephone numbers
 947                          * with intermized chars, e.g. val='1234'
 948                          * use
 949                          *
 950                          * val LIKE '%1%2%3%4%'
 951                          */
 952
 953                         bv.bv_len = 2 * filter_value->bv_len - 1;
 954                         bv.bv_val = ch_malloc( bv.bv_len + 1 );
 955
 956                         bv.bv_val[ 0 ] = filter_value->bv_val[ 0 ];
 957                         for ( i = 1; i < filter_value->bv_len; i++ ) {
 958                                 bv.bv_val[ 2 * i - 1 ] = '%';
 959                                 bv.bv_val[ 2 * i ] = filter_value->bv_val[ i ];
 960                         }
 961                         bv.bv_val[ 2 * i - 1 ] = '\0';
 962
 963                         (void)backsql_process_filter_like( bsi, at, casefold, &bv );
 964                         ch_free( bv.bv_val );
 965
 966                         break;
 967                 }
 968
 969                 /* NOTE: this is required by objectClass inheritance
 970                  * and auxiliary objectClass use in filters for slightly
 971                  * more efficient candidate selection. */
 972                 /* FIXME: a bit too many specializations to deal with
 973                  * very specific cases... */
 974                 if ( at->bam_ad == slap_schema.si_ad_objectClass
 975                                 || at->bam_ad == slap_schema.si_ad_structuralObjectClass )
 976                 {
 977                         backsql_strfcat( &bsi->bsi_flt_where, "lbl",
 978                                         (ber_len_t)STRLENOF( "(ldap_entries.id=ldap_entry_objclasses.entry_id AND ldap_entry_objclasses.oc_name='" /* ') */ ),
 979                                                 "(ldap_entries.id=ldap_entry_objclasses.entry_id AND ldap_entry_objclasses.oc_name='" /* ') */,
 980                                         filter_value,
 981                                         (ber_len_t)STRLENOF( /* (' */ "')" ),
 982                                                 /* (' */ "')" );
 983                         break;
 984                 }
 985
 986                 /*
 987                  * maybe we should check type of at->sel_expr here somehow,
 988                  * to know whether upper_func is applicable, but for now
 989                  * upper_func stuff is made for Oracle, where UPPER is
 990                  * safely applicable to NUMBER etc.
 991                  */
 992                 (void)backsql_process_filter_eq( bsi, at, casefold, filter_value );
 993                 break;
 994
 995         case LDAP_FILTER_GE:
 996                 ordering.bv_val = ">=";
 997
 998                 /* fall thru to next case */
 999
1000         case LDAP_FILTER_LE:
1001                 /* always uppercase strings by now */
1002 #ifdef BACKSQL_UPPERCASE_FILTER
1003                 if ( SLAP_MR_ASSOCIATED( at->bam_ad->ad_type->sat_ordering,
1004                                 bi->sql_caseIgnoreMatch ) )
1005 #endif /* BACKSQL_UPPERCASE_FILTER */
1006                 {
1007                         casefold = 1;
1008                 }
1009
1010                 /*
1011                  * FIXME: should we uppercase the operands?
1012                  */
1013                 if ( casefold && BACKSQL_AT_CANUPPERCASE( at ) ) {
1014                         ber_len_t       start;
1015
1016                         backsql_strfcat( &bsi->bsi_flt_where, "cbbc",
1017                                         '(', /* ) */
1018                                         &at->bam_sel_expr_u,
1019                                         &ordering,
1020                                         '\'' );
1021
1022                         start = bsi->bsi_flt_where.bb_val.bv_len;
1023
1024                         backsql_strfcat( &bsi->bsi_flt_where, "bl",
1025                                         filter_value,
1026                                         (ber_len_t)STRLENOF( /* (' */ "')" ),
1027                                                 /* (' */ "')" );
1028
1029                         ldap_pvt_str2upper( &bsi->bsi_flt_where.bb_val.bv_val[ start ] );
1030
1031                 } else {
1032                         backsql_strfcat( &bsi->bsi_flt_where, "cbbcbl",
1033                                         '(' /* ) */ ,
1034                                         &at->bam_sel_expr,
1035                                         &ordering,
1036                                         '\'',
1037                                         &f->f_av_value,
1038                                         (ber_len_t)STRLENOF( /* (' */ "')" ),
1039                                                 /* ( */ "')" );
1040                 }
1041                 break;
1042
1043         case LDAP_FILTER_PRESENT:
1044                 backsql_strfcat( &bsi->bsi_flt_where, "lbl",
1045                                 (ber_len_t)STRLENOF( "NOT (" /* ) */),
1046                                         "NOT (", /* ) */
1047                                 &at->bam_sel_expr,
1048                                 (ber_len_t)STRLENOF( /* ( */ " IS NULL)" ),
1049                                         /* ( */ " IS NULL)" );
1050                 break;
1051
1052         case LDAP_FILTER_SUBSTRINGS:
1053                 backsql_process_sub_filter( bsi, f, at );
1054                 break;
1055
1056         case LDAP_FILTER_APPROX:
1057                 /* we do our best */
1058
1059                 /*
1060                  * maybe we should check type of at->sel_expr here somehow,
1061                  * to know whether upper_func is applicable, but for now
1062                  * upper_func stuff is made for Oracle, where UPPER is
1063                  * safely applicable to NUMBER etc.
1064                  */
1065                 (void)backsql_process_filter_like( bsi, at, 1, &f->f_av_value );
1066                 break;
1067
1068         default:
1069                 /* unhandled filter type; should not happen */
1070                 assert( 0 );
1071                 backsql_strfcat( &bsi->bsi_flt_where, "l",
1072                                 (ber_len_t)STRLENOF( "1=1" ), "1=1" );
1073                 break;
1074
1075         }
1076
1077         Debug( LDAP_DEBUG_TRACE, "<==backsql_process_filter_attr(%s)\n",
1078                 at->bam_ad->ad_cname.bv_val, 0, 0 );
1079
1080         return 1;
1081 }
1082
1083 static int
1084 backsql_srch_query( backsql_srch_info *bsi, struct berval *query )
1085 {
1086         backsql_info    *bi = (backsql_info *)bsi->bsi_op->o_bd->be_private;
1087         int             rc;
1088
1089         assert( query );
1090         BER_BVZERO( query );
1091
1092         Debug( LDAP_DEBUG_TRACE, "==>backsql_srch_query()\n", 0, 0, 0 );
1093         BER_BVZERO( &bsi->bsi_sel.bb_val );
1094         BER_BVZERO( &bsi->bsi_sel.bb_val );
1095         bsi->bsi_sel.bb_len = 0;
1096         BER_BVZERO( &bsi->bsi_from.bb_val );
1097         bsi->bsi_from.bb_len = 0;
1098         BER_BVZERO( &bsi->bsi_join_where.bb_val );
1099         bsi->bsi_join_where.bb_len = 0;
1100         BER_BVZERO( &bsi->bsi_flt_where.bb_val );
1101         bsi->bsi_flt_where.bb_len = 0;
1102
1103         backsql_strfcat( &bsi->bsi_sel, "lbcbc",
1104                         (ber_len_t)STRLENOF( "SELECT DISTINCT ldap_entries.id," ),
1105                                 "SELECT DISTINCT ldap_entries.id,",
1106                         &bsi->bsi_oc->bom_keytbl,
1107                         '.',
1108                         &bsi->bsi_oc->bom_keycol,
1109                         ',' );
1110
1111         if ( !BER_BVISNULL( &bi->sql_strcast_func ) ) {
1112                 backsql_strfcat( &bsi->bsi_sel, "blbl",
1113                                 &bi->sql_strcast_func,
1114                                 (ber_len_t)STRLENOF( "('" /* ') */ ),
1115                                         "('" /* ') */ ,
1116                                 &bsi->bsi_oc->bom_oc->soc_cname,
1117                                 (ber_len_t)STRLENOF( /* (' */ "')" ),
1118                                         /* (' */ "')" );
1119         } else {
1120                 backsql_strfcat( &bsi->bsi_sel, "cbc",
1121                                 '\'',
1122                                 &bsi->bsi_oc->bom_oc->soc_cname,
1123                                 '\'' );
1124         }
1125 #ifdef BACKSQL_ALIASING_QUOTE
1126         backsql_strfcat( &bsi->bsi_sel, "lclcl",
1127                         (ber_len_t)STRLENOF( " " BACKSQL_ALIASING ),
1128                                 " " BACKSQL_ALIASING,
1129                         BACKSQL_ALIASING_QUOTE,
1130                         (ber_len_t)STRLENOF( "objectClass" ),
1131                                 "objectClass",
1132                         BACKSQL_ALIASING_QUOTE,
1133                         (ber_len_t)STRLENOF( ",ldap_entries.dn " BACKSQL_ALIASING "dn" ),
1134                                 ",ldap_entries.dn " BACKSQL_ALIASING "dn" );
1135 #else /* ! BACKSQL_ALIASING_QUOTE */
1136         backsql_strfcat( &bsi->bsi_sel, "l",
1137                         (ber_len_t)STRLENOF( " " BACKSQL_ALIASING "objectClass,ldap_entries.dn " BACKSQL_ALIASING "dn" ),
1138                                 " " BACKSQL_ALIASING "objectClass,ldap_entries.dn " BACKSQL_ALIASING "dn" );
1139 #endif /* ! BACKSQL_ALIASING_QUOTE */
1140
1141         backsql_strfcat( &bsi->bsi_from, "lb",
1142                         (ber_len_t)STRLENOF( " FROM ldap_entries," ),
1143                                 " FROM ldap_entries,",
1144                         &bsi->bsi_oc->bom_keytbl );
1145
1146         backsql_strfcat( &bsi->bsi_join_where, "lbcbl",
1147                         (ber_len_t)STRLENOF( " WHERE " ), " WHERE ",
1148                         &bsi->bsi_oc->bom_keytbl,
1149                         '.',
1150                         &bsi->bsi_oc->bom_keycol,
1151                         (ber_len_t)STRLENOF( "=ldap_entries.keyval AND ldap_entries.oc_map_id=? AND " ),
1152                                 "=ldap_entries.keyval AND ldap_entries.oc_map_id=? AND " );
1153
1154         switch ( bsi->bsi_scope ) {
1155         case LDAP_SCOPE_BASE:
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)=?" ),
1160                                                 "(ldap_entries.dn)=?" );
1161                 } else {
1162                         backsql_strfcat( &bsi->bsi_join_where, "l",
1163                                         (ber_len_t)STRLENOF( "ldap_entries.dn=?" ),
1164                                                 "ldap_entries.dn=?" );
1165                 }
1166                 break;
1167
1168         case BACKSQL_SCOPE_BASE_LIKE:
1169                 if ( BACKSQL_CANUPPERCASE( bi ) ) {
1170                         backsql_strfcat( &bsi->bsi_join_where, "bl",
1171                                         &bi->sql_upper_func,
1172                                         (ber_len_t)STRLENOF( "(ldap_entries.dn) LIKE ?" ),
1173                                                 "(ldap_entries.dn) LIKE ?" );
1174                 } else {
1175                         backsql_strfcat( &bsi->bsi_join_where, "l",
1176                                         (ber_len_t)STRLENOF( "ldap_entries.dn LIKE ?" ),
1177                                                 "ldap_entries.dn LIKE ?" );
1178                 }
1179                 break;
1180
1181         case LDAP_SCOPE_ONELEVEL:
1182                 backsql_strfcat( &bsi->bsi_join_where, "l",
1183                                 (ber_len_t)STRLENOF( "ldap_entries.parent=?" ),
1184                                         "ldap_entries.parent=?" );
1185                 break;
1186
1187 #ifdef LDAP_SCOPE_SUBORDINATE
1188         case LDAP_SCOPE_SUBORDINATE:
1189 #endif /* LDAP_SCOPE_SUBORDINATE */
1190         case LDAP_SCOPE_SUBTREE:
1191                 if ( BACKSQL_CANUPPERCASE( bi ) ) {
1192                         backsql_strfcat( &bsi->bsi_join_where, "bl",
1193                                         &bi->sql_upper_func,
1194                                         (ber_len_t)STRLENOF( "(ldap_entries.dn) LIKE ?" ),
1195                                                 "(ldap_entries.dn) LIKE ?"  );
1196                 } else {
1197                         backsql_strfcat( &bsi->bsi_join_where, "l",
1198                                         (ber_len_t)STRLENOF( "ldap_entries.dn LIKE ?" ),
1199                                                 "ldap_entries.dn LIKE ?" );
1200                 }
1201
1202                 break;
1203
1204         default:
1205                 assert( 0 );
1206         }
1207
1208         rc = backsql_process_filter( bsi, bsi->bsi_filter );
1209         if ( rc > 0 ) {
1210                 struct berbuf   bb = BB_NULL;
1211
1212                 backsql_strfcat( &bb, "bbblb",
1213                                 &bsi->bsi_sel.bb_val,
1214                                 &bsi->bsi_from.bb_val,
1215                                 &bsi->bsi_join_where.bb_val,
1216                                 (ber_len_t)STRLENOF( " AND " ), " AND ",
1217                                 &bsi->bsi_flt_where.bb_val );
1218
1219                 *query = bb.bb_val;
1220
1221         } else if ( rc < 0 ) {
1222                 /*
1223                  * Indicates that there's no possible way the filter matches
1224                  * anything.  No need to issue the query
1225                  */
1226                 free( query->bv_val );
1227                 BER_BVZERO( query );
1228         }
1229
1230         free( bsi->bsi_sel.bb_val.bv_val );
1231         BER_BVZERO( &bsi->bsi_sel.bb_val );
1232         bsi->bsi_sel.bb_len = 0;
1233         free( bsi->bsi_from.bb_val.bv_val );
1234         BER_BVZERO( &bsi->bsi_from.bb_val );
1235         bsi->bsi_from.bb_len = 0;
1236         free( bsi->bsi_join_where.bb_val.bv_val );
1237         BER_BVZERO( &bsi->bsi_join_where.bb_val );
1238         bsi->bsi_join_where.bb_len = 0;
1239         free( bsi->bsi_flt_where.bb_val.bv_val );
1240         BER_BVZERO( &bsi->bsi_flt_where.bb_val );
1241         bsi->bsi_flt_where.bb_len = 0;
1242
1243         Debug( LDAP_DEBUG_TRACE, "<==backsql_srch_query() returns %s\n",
1244                 query->bv_val ? query->bv_val : "NULL", 0, 0 );
1245
1246         return ( rc <= 0 ? 1 : 0 );
1247 }
1248
1249 static int
1250 backsql_oc_get_candidates( void *v_oc, void *v_bsi )
1251 {
1252         backsql_oc_map_rec      *oc = v_oc;
1253         backsql_srch_info       *bsi = v_bsi;
1254         backsql_info            *bi = (backsql_info *)bsi->bsi_op->o_bd->be_private;
1255         struct berval           query;
1256         SQLHSTMT                sth;
1257         RETCODE                 rc;
1258         int                     res;
1259         BACKSQL_ROW_NTS         row;
1260         int                     i;
1261         int                     j;
1262         int                     n_candidates = bsi->bsi_n_candidates;
1263
1264         /*
1265          * + 1 because we need room for '%';
1266          * + 1 because we need room for ',' for LDAP_SCOPE_SUBORDINATE;
1267          * this makes a subtree
1268          * search for a DN BACKSQL_MAX_DN_LEN long legal
1269          * if it returns that DN only
1270          */
1271         char                    tmp_base_ndn[ BACKSQL_MAX_DN_LEN + 1 + 1 ];
1272
1273         bsi->bsi_status = LDAP_SUCCESS;
1274
1275         Debug( LDAP_DEBUG_TRACE, "==>backsql_oc_get_candidates(): oc=\"%s\"\n",
1276                         BACKSQL_OC_NAME( oc ), 0, 0 );
1277
1278         if ( bsi->bsi_n_candidates == -1 ) {
1279                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
1280                         "unchecked limit has been overcome\n", 0, 0, 0 );
1281                 /* should never get here */
1282                 assert( 0 );
1283                 bsi->bsi_status = LDAP_ADMINLIMIT_EXCEEDED;
1284                 return BACKSQL_AVL_STOP;
1285         }
1286
1287         bsi->bsi_oc = oc;
1288         res = backsql_srch_query( bsi, &query );
1289         if ( res ) {
1290                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
1291                         "error while constructing query for objectclass \"%s\"\n",
1292                         oc->bom_oc->soc_cname.bv_val, 0, 0 );
1293                 /*
1294                  * FIXME: need to separate errors from legally
1295                  * impossible filters
1296                  */
1297                 switch ( bsi->bsi_status ) {
1298                 case LDAP_SUCCESS:
1299                 case LDAP_UNDEFINED_TYPE:
1300                 case LDAP_NO_SUCH_OBJECT:
1301                         /* we are conservative... */
1302                 default:
1303                         bsi->bsi_status = LDAP_SUCCESS;
1304                         /* try next */
1305                         return BACKSQL_AVL_CONTINUE;
1306
1307                 case LDAP_ADMINLIMIT_EXCEEDED:
1308                 case LDAP_OTHER:
1309                         /* don't try any more */
1310                         return BACKSQL_AVL_STOP;
1311                 }
1312         }
1313
1314         if ( BER_BVISNULL( &query ) ) {
1315                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
1316                         "could not construct query for objectclass \"%s\"\n",
1317                         oc->bom_oc->soc_cname.bv_val, 0, 0 );
1318                 bsi->bsi_status = LDAP_SUCCESS;
1319                 return BACKSQL_AVL_CONTINUE;
1320         }
1321
1322         Debug( LDAP_DEBUG_TRACE, "Constructed query: %s\n",
1323                         query.bv_val, 0, 0 );
1324
1325         rc = backsql_Prepare( bsi->bsi_dbh, &sth, query.bv_val, 0 );
1326         free( query.bv_val );
1327         BER_BVZERO( &query );
1328         if ( rc != SQL_SUCCESS ) {
1329                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
1330                         "error preparing query\n", 0, 0, 0 );
1331                 backsql_PrintErrors( bi->sql_db_env, bsi->bsi_dbh, sth, rc );
1332                 bsi->bsi_status = LDAP_OTHER;
1333                 return BACKSQL_AVL_CONTINUE;
1334         }
1335
1336         Debug( LDAP_DEBUG_TRACE, "id: '%ld'\n", bsi->bsi_oc->bom_id, 0, 0 );
1337
1338         rc = backsql_BindParamInt( sth, 1, SQL_PARAM_INPUT,
1339                         &bsi->bsi_oc->bom_id );
1340         if ( rc != SQL_SUCCESS ) {
1341                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
1342                         "error binding objectclass id parameter\n", 0, 0, 0 );
1343                 bsi->bsi_status = LDAP_OTHER;
1344                 return BACKSQL_AVL_CONTINUE;
1345         }
1346
1347         switch ( bsi->bsi_scope ) {
1348         case LDAP_SCOPE_BASE:
1349         case BACKSQL_SCOPE_BASE_LIKE:
1350                 /*
1351                  * We do not accept DNs longer than BACKSQL_MAX_DN_LEN;
1352                  * however this should be handled earlier
1353                  */
1354                 if ( bsi->bsi_base_ndn->bv_len > BACKSQL_MAX_DN_LEN ) {
1355                         bsi->bsi_status = LDAP_OTHER;
1356                         return BACKSQL_AVL_CONTINUE;
1357                 }
1358
1359                 AC_MEMCPY( tmp_base_ndn, bsi->bsi_base_ndn->bv_val,
1360                                 bsi->bsi_base_ndn->bv_len + 1 );
1361
1362                 /* uppercase DN only if the stored DN can be uppercased
1363                  * for comparison */
1364                 if ( BACKSQL_CANUPPERCASE( bi ) ) {
1365                         ldap_pvt_str2upper( tmp_base_ndn );
1366                 }
1367
1368                 Debug( LDAP_DEBUG_TRACE, "(base)dn: \"%s\"\n",
1369                                 tmp_base_ndn, 0, 0 );
1370
1371                 rc = backsql_BindParamStr( sth, 2, SQL_PARAM_INPUT,
1372                                 tmp_base_ndn, BACKSQL_MAX_DN_LEN );
1373                 if ( rc != SQL_SUCCESS ) {
1374                         Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
1375                                 "error binding base_ndn parameter\n", 0, 0, 0 );
1376                         backsql_PrintErrors( bi->sql_db_env, bsi->bsi_dbh,
1377                                         sth, rc );
1378                         bsi->bsi_status = LDAP_OTHER;
1379                         return BACKSQL_AVL_CONTINUE;
1380                 }
1381                 break;
1382
1383 #ifdef LDAP_SCOPE_SUBORDINATE
1384         case LDAP_SCOPE_SUBORDINATE:
1385 #endif /* LDAP_SCOPE_SUBORDINATE */
1386         case LDAP_SCOPE_SUBTREE:
1387         {
1388                 /*
1389                  * We do not accept DNs longer than BACKSQL_MAX_DN_LEN;
1390                  * however this should be handled earlier
1391                  */
1392                 if ( bsi->bsi_base_ndn->bv_len > BACKSQL_MAX_DN_LEN ) {
1393                         bsi->bsi_status = LDAP_OTHER;
1394                         return BACKSQL_AVL_CONTINUE;
1395                 }
1396
1397                 /*
1398                  * Sets the parameters for the SQL built earlier
1399                  * NOTE that all the databases could actually use
1400                  * the TimesTen version, which would be cleaner
1401                  * and would also eliminate the need for the
1402                  * subtree_cond line in the configuration file.
1403                  * For now, I'm leaving it the way it is,
1404                  * so non-TimesTen databases use the original code.
1405                  * But at some point this should get cleaned up.
1406                  *
1407                  * If "dn" is being used, do a suffix search.
1408                  * If "dn_ru" is being used, do a prefix search.
1409                  */
1410                 if ( BACKSQL_HAS_LDAPINFO_DN_RU( bi ) ) {
1411                         tmp_base_ndn[ 0 ] = '\0';
1412
1413                         for ( i = 0, j = bsi->bsi_base_ndn->bv_len - 1;
1414                                         j >= 0; i++, j--) {
1415                                 tmp_base_ndn[ i ] = bsi->bsi_base_ndn->bv_val[ j ];
1416                         }
1417
1418 #ifdef LDAP_SCOPE_SUBORDINATE
1419                         if ( bsi->bsi_scope == LDAP_SCOPE_SUBORDINATE ) {
1420                                 tmp_base_ndn[ i++ ] = ',';
1421                         }
1422 #endif /* LDAP_SCOPE_SUBORDINATE */
1423
1424                         tmp_base_ndn[ i ] = '%';
1425                         tmp_base_ndn[ i + 1 ] = '\0';
1426
1427                 } else {
1428                         i = 0;
1429
1430                         tmp_base_ndn[ i++ ] = '%';
1431
1432 #ifdef LDAP_SCOPE_SUBORDINATE
1433                         if ( bsi->bsi_scope == LDAP_SCOPE_SUBORDINATE ) {
1434                                 tmp_base_ndn[ i++ ] = ',';
1435                         }
1436 #endif /* LDAP_SCOPE_SUBORDINATE */
1437
1438                         AC_MEMCPY( &tmp_base_ndn[ i ], bsi->bsi_base_ndn->bv_val,
1439                                 bsi->bsi_base_ndn->bv_len + 1 );
1440                 }
1441
1442                 /* uppercase DN only if the stored DN can be uppercased
1443                  * for comparison */
1444                 if ( BACKSQL_CANUPPERCASE( bi ) ) {
1445                         ldap_pvt_str2upper( tmp_base_ndn );
1446                 }
1447
1448 #ifdef LDAP_SCOPE_SUBORDINATE
1449                 if ( bsi->bsi_scope == LDAP_SCOPE_SUBORDINATE ) {
1450                         Debug( LDAP_DEBUG_TRACE, "(children)dn: \"%s\"\n",
1451                                 tmp_base_ndn, 0, 0 );
1452                 } else
1453 #endif /* LDAP_SCOPE_SUBORDINATE */
1454                 {
1455                         Debug( LDAP_DEBUG_TRACE, "(sub)dn: \"%s\"\n",
1456                                 tmp_base_ndn, 0, 0 );
1457                 }
1458
1459                 rc = backsql_BindParamStr( sth, 2, SQL_PARAM_INPUT,
1460                                 tmp_base_ndn, BACKSQL_MAX_DN_LEN );
1461                 if ( rc != SQL_SUCCESS ) {
1462                         Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
1463                                 "error binding base_ndn parameter (2)\n",
1464                                 0, 0, 0 );
1465                         backsql_PrintErrors( bi->sql_db_env, bsi->bsi_dbh,
1466                                         sth, rc );
1467                         bsi->bsi_status = LDAP_OTHER;
1468                         return BACKSQL_AVL_CONTINUE;
1469                 }
1470                 break;
1471         }
1472
1473         case LDAP_SCOPE_ONELEVEL:
1474                 assert( !BER_BVISNULL( &bsi->bsi_base_id.eid_ndn ) );
1475
1476 #ifdef BACKSQL_ARBITRARY_KEY
1477                 Debug( LDAP_DEBUG_TRACE, "(one)id: \"%s\"\n",
1478                                 bsi->bsi_base_id.eid_id.bv_val, 0, 0 );
1479 #else /* ! BACKSQL_ARBITRARY_KEY */
1480                 Debug( LDAP_DEBUG_TRACE, "(one)id: '%lu'\n",
1481                                 bsi->bsi_base_id.eid_id, 0, 0 );
1482 #endif /* ! BACKSQL_ARBITRARY_KEY */
1483                 rc = backsql_BindParamID( sth, 2, SQL_PARAM_INPUT,
1484                                 &bsi->bsi_base_id.eid_id );
1485                 if ( rc != SQL_SUCCESS ) {
1486                         Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
1487                                 "error binding base id parameter\n", 0, 0, 0 );
1488                         bsi->bsi_status = LDAP_OTHER;
1489                         return BACKSQL_AVL_CONTINUE;
1490                 }
1491                 break;
1492         }
1493
1494         rc = SQLExecute( sth );
1495         if ( !BACKSQL_SUCCESS( rc ) ) {
1496                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
1497                         "error executing query\n", 0, 0, 0 );
1498                 backsql_PrintErrors( bi->sql_db_env, bsi->bsi_dbh, sth, rc );
1499                 SQLFreeStmt( sth, SQL_DROP );
1500                 bsi->bsi_status = LDAP_OTHER;
1501                 return BACKSQL_AVL_CONTINUE;
1502         }
1503
1504         backsql_BindRowAsStrings( sth, &row );
1505         rc = SQLFetch( sth );
1506         for ( ; BACKSQL_SUCCESS( rc ); rc = SQLFetch( sth ) ) {
1507                 struct berval           dn, pdn, ndn;
1508                 backsql_entryID         *c_id = NULL;
1509                 int                     ret;
1510
1511                 ber_str2bv( row.cols[ 3 ], 0, 0, &dn );
1512
1513                 if ( backsql_api_odbc2dn( bsi->bsi_op, bsi->bsi_rs, &dn ) ) {
1514                         continue;
1515                 }
1516
1517                 ret = dnPrettyNormal( NULL, &dn, &pdn, &ndn, NULL );
1518                 if ( dn.bv_val != row.cols[ 3 ] ) {
1519                         free( dn.bv_val );
1520                 }
1521
1522                 if ( ret != LDAP_SUCCESS ) {
1523                         continue;
1524                 }
1525
1526                 if ( bi->sql_baseObject && dn_match( &ndn, &bi->sql_baseObject->e_nname ) ) {
1527                         free( pdn.bv_val );
1528                         free( ndn.bv_val );
1529                         continue;
1530                 }
1531
1532                 c_id = (backsql_entryID *)ch_calloc( 1,
1533                                 sizeof( backsql_entryID ) );
1534 #ifdef BACKSQL_ARBITRARY_KEY
1535                 ber_str2bv( row.cols[ 0 ], 0, 1, &c_id->eid_id );
1536                 ber_str2bv( row.cols[ 1 ], 0, 1, &c_id->eid_keyval );
1537 #else /* ! BACKSQL_ARBITRARY_KEY */
1538                 c_id->eid_id = strtol( row.cols[ 0 ], NULL, 0 );
1539                 c_id->eid_keyval = strtol( row.cols[ 1 ], NULL, 0 );
1540 #endif /* ! BACKSQL_ARBITRARY_KEY */
1541                 c_id->eid_oc_id = bsi->bsi_oc->bom_id;
1542
1543                 c_id->eid_dn = pdn;
1544                 c_id->eid_ndn = ndn;
1545
1546                 /* append at end of list ... */
1547                 c_id->eid_next = NULL;
1548                 *bsi->bsi_id_listtail = c_id;
1549                 bsi->bsi_id_listtail = &c_id->eid_next;
1550
1551 #ifdef BACKSQL_ARBITRARY_KEY
1552                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
1553                         "added entry id=%s, keyval=%s dn=\"%s\"\n",
1554                         c_id->eid_id.bv_val, c_id->eid_keyval.bv_val,
1555                         row.cols[ 3 ] );
1556 #else /* ! BACKSQL_ARBITRARY_KEY */
1557                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
1558                         "added entry id=%ld, keyval=%ld dn=\"%s\"\n",
1559                         c_id->eid_id, c_id->eid_keyval, row.cols[ 3 ] );
1560 #endif /* ! BACKSQL_ARBITRARY_KEY */
1561
1562                 /* count candidates, for unchecked limit */
1563                 bsi->bsi_n_candidates--;
1564                 if ( bsi->bsi_n_candidates == -1 ) {
1565                         break;
1566                 }
1567         }
1568         backsql_FreeRow( &row );
1569         SQLFreeStmt( sth, SQL_DROP );
1570
1571         Debug( LDAP_DEBUG_TRACE, "<==backsql_oc_get_candidates(): %d\n",
1572                         n_candidates - bsi->bsi_n_candidates, 0, 0 );
1573
1574         return ( bsi->bsi_n_candidates == -1 ? BACKSQL_AVL_STOP : BACKSQL_AVL_CONTINUE );
1575 }
1576
1577 int
1578 backsql_search( Operation *op, SlapReply *rs )
1579 {
1580         backsql_info            *bi = (backsql_info *)op->o_bd->be_private;
1581         SQLHDBC                 dbh;
1582         int                     sres;
1583         Entry                   user_entry = { 0 };
1584         int                     manageDSAit;
1585         time_t                  stoptime = 0;
1586         backsql_srch_info       bsi;
1587         backsql_entryID         *eid = NULL;
1588         struct berval           nbase = BER_BVNULL;
1589
1590         manageDSAit = get_manageDSAit( op );
1591
1592         Debug( LDAP_DEBUG_TRACE, "==>backsql_search(): "
1593                 "base=\"%s\", filter=\"%s\", scope=%d,",
1594                 op->o_req_ndn.bv_val,
1595                 op->ors_filterstr.bv_val,
1596                 op->ors_scope );
1597         Debug( LDAP_DEBUG_TRACE, " deref=%d, attrsonly=%d, "
1598                 "attributes to load: %s\n",
1599                 op->ors_deref,
1600                 op->ors_attrsonly,
1601                 op->ors_attrs == NULL ? "all" : "custom list" );
1602
1603         if ( op->o_req_ndn.bv_len > BACKSQL_MAX_DN_LEN ) {
1604                 Debug( LDAP_DEBUG_TRACE, "backsql_search(): "
1605                         "search base length (%ld) exceeds max length (%d)\n",
1606                         op->o_req_ndn.bv_len, BACKSQL_MAX_DN_LEN, 0 );
1607                 /*
1608                  * FIXME: a LDAP_NO_SUCH_OBJECT could be appropriate
1609                  * since it is impossible that such a long DN exists
1610                  * in the backend
1611                  */
1612                 rs->sr_err = LDAP_ADMINLIMIT_EXCEEDED;
1613                 send_ldap_result( op, rs );
1614                 return 1;
1615         }
1616
1617         sres = backsql_get_db_conn( op, &dbh );
1618         if ( sres != LDAP_SUCCESS ) {
1619                 Debug( LDAP_DEBUG_TRACE, "backsql_search(): "
1620                         "could not get connection handle - exiting\n",
1621                         0, 0, 0 );
1622                 rs->sr_err = sres;
1623                 rs->sr_text = sres == LDAP_OTHER ?  "SQL-backend error" : NULL;
1624                 send_ldap_result( op, rs );
1625                 return 1;
1626         }
1627
1628         /* compute it anyway; root does not use it */
1629         stoptime = op->o_time + op->ors_tlimit;
1630
1631         nbase = op->o_req_ndn;
1632         if ( backsql_api_dn2odbc( op, rs, &nbase ) ) {
1633                 Debug( LDAP_DEBUG_TRACE, "backsql_search(): "
1634                         "backsql_api_dn2odbc failed\n",
1635                         0, 0, 0 );
1636                 rs->sr_err = LDAP_OTHER;
1637                 rs->sr_text = "SQL-backend error";
1638                 send_ldap_result( op, rs );
1639                 goto done;
1640         }
1641
1642         /* init search */
1643         rs->sr_err = backsql_init_search( &bsi, &nbase,
1644                         op->ors_scope,
1645                         op->ors_slimit, op->ors_tlimit,
1646                         stoptime, op->ors_filter,
1647                         dbh, op, rs, op->ors_attrs, 1 );
1648         if ( rs->sr_err != LDAP_SUCCESS ) {
1649                 send_ldap_result( op, rs );
1650                 goto done;
1651         }
1652
1653         bsi.bsi_n_candidates =
1654                 ( op->ors_limit == NULL /* isroot == TRUE */ ? -2 :
1655                 ( op->ors_limit->lms_s_unchecked == -1 ? -2 :
1656                 ( op->ors_limit->lms_s_unchecked ) ) );
1657
1658         switch ( bsi.bsi_scope ) {
1659         case LDAP_SCOPE_BASE:
1660         case BACKSQL_SCOPE_BASE_LIKE:
1661                 /*
1662                  * probably already found...
1663                  */
1664                 bsi.bsi_id_list = &bsi.bsi_base_id;
1665                 bsi.bsi_id_listtail = &bsi.bsi_base_id.eid_next;
1666                 break;
1667
1668         case LDAP_SCOPE_SUBTREE:
1669                 /*
1670                  * if baseObject is defined, and if it is the root
1671                  * of the search, add it to the candidate list
1672                  */
1673                 if ( bi->sql_baseObject && BACKSQL_IS_BASEOBJECT_ID( &bsi.bsi_base_id.eid_id ) )
1674                 {
1675                         bsi.bsi_id_list = &bsi.bsi_base_id;
1676                         bsi.bsi_id_listtail = &bsi.bsi_base_id.eid_next;
1677                 }
1678
1679                 /* FALLTHRU */
1680         default:
1681
1682                 /*
1683                  * for each objectclass we try to construct query which gets IDs
1684                  * of entries matching LDAP query filter and scope (or at least
1685                  * candidates), and get the IDs
1686                  */
1687                 avl_apply( bi->sql_oc_by_oc, backsql_oc_get_candidates,
1688                                 &bsi, BACKSQL_AVL_STOP, AVL_INORDER );
1689         }
1690
1691         if ( op->ors_limit != NULL      /* isroot == FALSE */
1692                         && op->ors_limit->lms_s_unchecked != -1
1693                         && bsi.bsi_n_candidates == -1 )
1694         {
1695                 rs->sr_err = LDAP_ADMINLIMIT_EXCEEDED;
1696                 send_ldap_result( op, rs );
1697                 goto done;
1698         }
1699
1700         /*
1701          * now we load candidate entries (only those attributes
1702          * mentioned in attrs and filter), test it against full filter
1703          * and then send to client; don't free entry_id if baseObject...
1704          */
1705         for ( eid = bsi.bsi_id_list;
1706                         eid != NULL;
1707                         eid = backsql_free_entryID( eid, eid == &bsi.bsi_base_id ? 0 : 1 ) )
1708         {
1709                 int             rc;
1710                 Attribute       *a_hasSubordinate = NULL,
1711                                 *a_entryUUID = NULL,
1712                                 *a_entryCSN = NULL,
1713                                 **ap = NULL;
1714                 Entry           *e = NULL;
1715
1716                 /* check for abandon */
1717                 if ( op->o_abandon ) {
1718                         break;
1719                 }
1720
1721                 /* check time limit */
1722                 if ( op->ors_tlimit != SLAP_NO_LIMIT
1723                                 && slap_get_time() > stoptime )
1724                 {
1725                         rs->sr_err = LDAP_TIMELIMIT_EXCEEDED;
1726                         rs->sr_ctrls = NULL;
1727                         rs->sr_ref = rs->sr_v2ref;
1728                         rs->sr_err = (rs->sr_v2ref == NULL) ? LDAP_SUCCESS
1729                                 : LDAP_REFERRAL;
1730                         send_ldap_result( op, rs );
1731                         goto end_of_search;
1732                 }
1733
1734 #ifdef BACKSQL_ARBITRARY_KEY
1735                 Debug(LDAP_DEBUG_TRACE, "backsql_search(): loading data "
1736                         "for entry id=%s, oc_id=%ld, keyval=%s\n",
1737                         eid->eid_id.bv_val, eid->eid_oc_id,
1738                         eid->eid_keyval.bv_val );
1739 #else /* ! BACKSQL_ARBITRARY_KEY */
1740                 Debug(LDAP_DEBUG_TRACE, "backsql_search(): loading data "
1741                         "for entry id=%ld, oc_id=%ld, keyval=%ld\n",
1742                         eid->eid_id, eid->eid_oc_id, eid->eid_keyval );
1743 #endif /* ! BACKSQL_ARBITRARY_KEY */
1744
1745                 /* check scope */
1746                 switch ( op->ors_scope ) {
1747                 case LDAP_SCOPE_BASE:
1748                 case BACKSQL_SCOPE_BASE_LIKE:
1749                         if ( !dn_match( &eid->eid_ndn, &op->o_req_ndn ) ) {
1750                                 goto next_entry2;
1751                         }
1752                         break;
1753
1754                 case LDAP_SCOPE_ONE:
1755                 {
1756                         struct berval   rdn = eid->eid_ndn;
1757
1758                         rdn.bv_len -= op->o_req_ndn.bv_len + STRLENOF( "," );
1759                         if ( !dnIsOneLevelRDN( &rdn ) ) {
1760                                 goto next_entry2;
1761                         }
1762                         /* fall thru */
1763                 }
1764
1765 #ifdef LDAP_SCOPE_SUBORDINATE
1766                 case LDAP_SCOPE_SUBORDINATE:
1767                         /* discard the baseObject entry */
1768                         if ( dn_match( &eid->eid_ndn, &op->o_req_ndn ) ) {
1769                                 goto next_entry2;
1770                         }
1771                 /* FALLTHRU */
1772 #endif /* LDAP_SCOPE_SUBORDINATE */
1773
1774                 case LDAP_SCOPE_SUBTREE:
1775                         /* FIXME: this should never fail... */
1776                         if ( !dnIsSuffix( &eid->eid_ndn, &op->o_req_ndn ) ) {
1777                                 goto next_entry2;
1778                         }
1779                         break;
1780                 }
1781
1782                 /* don't recollect baseObject ... */
1783                 if ( BACKSQL_IS_BASEOBJECT_ID( &eid->eid_id ) ) {
1784                         e = bi->sql_baseObject;
1785
1786                 } else {
1787                         bsi.bsi_e = &user_entry;
1788                         rc = backsql_id2entry( &bsi, eid );
1789                         if ( rc != LDAP_SUCCESS ) {
1790                                 Debug( LDAP_DEBUG_TRACE, "backsql_search(): "
1791                                         "error %d in backsql_id2entry() "
1792                                         "- skipping\n", rc, 0, 0 );
1793                                 continue;
1794                         }
1795
1796                         e = &user_entry;
1797                 }
1798
1799                 if ( !manageDSAit &&
1800                                 op->ors_scope != LDAP_SCOPE_BASE &&
1801                                 op->ors_scope != BACKSQL_SCOPE_BASE_LIKE &&
1802                                 is_entry_referral( e ) )
1803                 {
1804                         BerVarray refs;
1805
1806                         refs = get_entry_referrals( op, e );
1807                         if ( !refs ) {
1808                                 backsql_srch_info       bsi2 = { 0 };
1809                                 Entry                   user_entry2 = { 0 };
1810
1811                                 /* retry with the full entry... */
1812                                 (void)backsql_init_search( &bsi2,
1813                                                 &e->e_nname,
1814                                                 LDAP_SCOPE_BASE,
1815                                                 -1, -1, -1, NULL,
1816                                                 dbh, op, rs, NULL, 0 );
1817                                 bsi2.bsi_e = &user_entry2;
1818                                 rc = backsql_id2entry( &bsi2, eid );
1819                                 if ( rc == LDAP_SUCCESS ) {
1820                                         if ( is_entry_referral( &user_entry2 ) )
1821                                         {
1822                                                 refs = get_entry_referrals( op,
1823                                                                 &user_entry2 );
1824                                         } /* else: FIXME: inconsistency! */
1825                                         entry_clean( &user_entry2 );
1826                                 }
1827                         }
1828
1829                         if ( refs ) {
1830                                 rs->sr_ref = referral_rewrite( refs,
1831                                                 &e->e_name,
1832                                                 &op->o_req_dn,
1833                                                 op->ors_scope );
1834                                 ber_bvarray_free( refs );
1835                         }
1836
1837                         if ( !rs->sr_ref ) {
1838                                 rs->sr_text = "bad_referral object";
1839                         }
1840
1841                         rs->sr_entry = e;
1842                         rs->sr_err = LDAP_REFERRAL;
1843                         rs->sr_matched = user_entry.e_name.bv_val;
1844                         send_search_reference( op, rs );
1845
1846                         ber_bvarray_free( rs->sr_ref );
1847                         rs->sr_ref = NULL;
1848                         rs->sr_matched = NULL;
1849                         rs->sr_entry = NULL;
1850
1851                         goto next_entry;
1852                 }
1853
1854                 /*
1855                  * We use this flag since we need to parse the filter
1856                  * anyway; we should have used the frontend API function
1857                  * filter_has_subordinates()
1858                  */
1859                 if ( bsi.bsi_flags & BSQL_SF_FILTER_HASSUBORDINATE ) {
1860                         rc = backsql_has_children( bi, dbh, &e->e_nname );
1861
1862                         switch ( rc ) {
1863                         case LDAP_COMPARE_TRUE:
1864                         case LDAP_COMPARE_FALSE:
1865                                 a_hasSubordinate = slap_operational_hasSubordinate( rc == LDAP_COMPARE_TRUE );
1866                                 if ( a_hasSubordinate != NULL ) {
1867                                         for ( ap = &user_entry.e_attrs;
1868                                                         *ap;
1869                                                         ap = &(*ap)->a_next );
1870
1871                                         *ap = a_hasSubordinate;
1872                                 }
1873                                 rc = 0;
1874                                 break;
1875
1876                         default:
1877                                 Debug(LDAP_DEBUG_TRACE,
1878                                         "backsql_search(): "
1879                                         "has_children failed( %d)\n",
1880                                         rc, 0, 0 );
1881                                 rc = 1;
1882                                 goto next_entry;
1883                         }
1884                 }
1885
1886                 if ( bsi.bsi_flags & BSQL_SF_FILTER_ENTRYUUID ) {
1887                         a_entryUUID = backsql_operational_entryUUID( bi, eid );
1888                         if ( a_entryUUID != NULL ) {
1889                                 if ( ap == NULL ) {
1890                                         ap = &user_entry.e_attrs;
1891                                 }
1892
1893                                 for ( ; *ap; ap = &(*ap)->a_next );
1894
1895                                 *ap = a_entryUUID;
1896                         }
1897                 }
1898
1899                 if ( bsi.bsi_flags & BSQL_SF_FILTER_ENTRYCSN ) {
1900                         a_entryCSN = backsql_operational_entryCSN( op );
1901                         if ( a_entryCSN != NULL ) {
1902                                 if ( ap == NULL ) {
1903                                         ap = &user_entry.e_attrs;
1904                                 }
1905
1906                                 for ( ; *ap; ap = &(*ap)->a_next );
1907
1908                                 *ap = a_entryCSN;
1909                         }
1910                 }
1911
1912                 if ( test_filter( op, e, op->ors_filter ) == LDAP_COMPARE_TRUE )
1913                 {
1914                         rs->sr_attrs = op->ors_attrs;
1915                         rs->sr_operational_attrs = NULL;
1916                         rs->sr_entry = e;
1917                         if ( e == &user_entry ) {
1918                                 rs->sr_flags = REP_ENTRY_MODIFIABLE;
1919                         }
1920                         sres = send_search_entry( op, rs );
1921                         rs->sr_entry = NULL;
1922                         rs->sr_attrs = NULL;
1923                         rs->sr_operational_attrs = NULL;
1924
1925                         switch ( sres ) {
1926                         case 0:
1927                                 break;
1928
1929                         default:
1930                                 /*
1931                                  * FIXME: send_search_entry failed;
1932                                  * better stop
1933                                  */
1934                         case -1:
1935                                 Debug( LDAP_DEBUG_TRACE, "backsql_search(): "
1936                                         "connection lost\n", 0, 0, 0 );
1937                                 goto end_of_search;
1938                         }
1939                 }
1940
1941 next_entry:;
1942                 entry_clean( &user_entry );
1943
1944 next_entry2:;
1945                 if ( op->ors_slimit != SLAP_NO_LIMIT
1946                                 && rs->sr_nentries >= op->ors_slimit )
1947                 {
1948                         rs->sr_err = LDAP_SIZELIMIT_EXCEEDED;
1949                         send_ldap_result( op, rs );
1950                         goto end_of_search;
1951                 }
1952         }
1953
1954 end_of_search:;
1955         /* in case we got here accidentally */
1956         entry_clean( &user_entry );
1957
1958         if ( rs->sr_nentries > 0 ) {
1959                 rs->sr_ref = rs->sr_v2ref;
1960                 rs->sr_err = (rs->sr_v2ref == NULL) ? LDAP_SUCCESS
1961                         : LDAP_REFERRAL;
1962
1963         } else {
1964                 rs->sr_err = bsi.bsi_status;
1965         }
1966         send_ldap_result( op, rs );
1967
1968         if ( rs->sr_v2ref ) {
1969                 ber_bvarray_free( rs->sr_v2ref );
1970                 rs->sr_v2ref = NULL;
1971         }
1972
1973 done:;
1974         if ( !BER_BVISNULL( &bsi.bsi_base_id.eid_ndn ) ) {
1975                 (void)backsql_free_entryID( &bsi.bsi_base_id, 0 );
1976         }
1977
1978         if ( bsi.bsi_attrs ) {
1979                 ch_free( bsi.bsi_attrs );
1980         }
1981
1982         if ( !BER_BVISNULL( &nbase )
1983                         && nbase.bv_val != op->o_req_ndn.bv_val )
1984         {
1985                 ch_free( nbase.bv_val );
1986         }
1987
1988         /* restore scope ... FIXME: this should be done before ANY
1989          * frontend call that uses op */
1990         if ( op->ors_scope == BACKSQL_SCOPE_BASE_LIKE ) {
1991                 op->ors_scope = LDAP_SCOPE_BASE;
1992         }
1993
1994         Debug( LDAP_DEBUG_TRACE, "<==backsql_search()\n", 0, 0, 0 );
1995         return 0;
1996 }
1997
1998 /* return LDAP_SUCCESS IFF we can retrieve the specified entry.
1999  */
2000 int
2001 backsql_entry_get(
2002                 Operation               *op,
2003                 struct berval           *ndn,
2004                 ObjectClass             *oc,
2005                 AttributeDescription    *at,
2006                 int                     rw,
2007                 Entry                   **ent )
2008 {
2009         backsql_srch_info       bsi;
2010         SQLHDBC                 dbh;
2011         int                     rc;
2012         SlapReply               rs = { 0 };
2013         AttributeName           anlist[ 2 ];
2014
2015         rc = backsql_get_db_conn( op, &dbh );
2016         if ( !dbh ) {
2017                 return LDAP_OTHER;
2018         }
2019
2020         if ( at ) {
2021                 anlist[ 0 ].an_name = at->ad_cname;
2022                 anlist[ 0 ].an_desc = at;
2023                 BER_BVZERO( &anlist[ 1 ].an_name );
2024         }
2025
2026         rc = backsql_init_search( &bsi,
2027                         ndn,
2028                         LDAP_SCOPE_BASE,
2029                         SLAP_NO_LIMIT, SLAP_NO_LIMIT, -1, NULL,
2030                         dbh, op, &rs, at ? anlist : NULL, 1 );
2031         if ( rc != LDAP_SUCCESS ) {
2032                 return rc;
2033         }
2034
2035         bsi.bsi_e = ch_malloc( sizeof( Entry ) );
2036         rc = backsql_id2entry( &bsi, &bsi.bsi_base_id );
2037
2038         if ( !BER_BVISNULL( &bsi.bsi_base_id.eid_ndn ) ) {
2039                 (void)backsql_free_entryID( &bsi.bsi_base_id, 0 );
2040         }
2041
2042         if ( rc == LDAP_SUCCESS ) {
2043
2044 #if 0 /* not supported at present */
2045                 /* find attribute values */
2046                 if ( is_entry_alias( bsi.bsi_e ) ) {
2047                         Debug( LDAP_DEBUG_ACL,
2048                                 "<= backsql_entry_get: entry is an alias\n",
2049                                 0, 0, 0 );
2050                         rc = LDAP_ALIAS_PROBLEM;
2051                         goto return_results;
2052                 }
2053 #endif
2054
2055                 if ( is_entry_referral( bsi.bsi_e ) ) {
2056                         Debug( LDAP_DEBUG_ACL,
2057                                 "<= backsql_entry_get: entry is a referral\n",
2058                                 0, 0, 0 );
2059                         rc = LDAP_REFERRAL;
2060                         goto return_results;
2061                 }
2062
2063                 if ( oc && !is_entry_objectclass( bsi.bsi_e, oc, 0 ) ) {
2064                         Debug( LDAP_DEBUG_ACL,
2065                                         "<= backsql_entry_get: "
2066                                         "failed to find objectClass\n",
2067                                         0, 0, 0 );
2068                         rc = LDAP_NO_SUCH_ATTRIBUTE;
2069                         goto return_results;
2070                 }
2071
2072                 *ent = bsi.bsi_e;
2073         }
2074
2075 return_results:;
2076         if ( rc != LDAP_SUCCESS ) {
2077                 if ( bsi.bsi_e ) {
2078                         entry_free( bsi.bsi_e );
2079                 }
2080         }
2081
2082         return rc;
2083 }
2084