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