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