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

   1 /*
   2  *       Copyright 1999, Dmitry Kovalev <mit@openldap.org>, All rights reserved.
   3  *
   4  *       Redistribution and use in source and binary forms are permitted only
   5  *       as authorized by the OpenLDAP Public License.  A copy of this
   6  *       license is available at http://www.OpenLDAP.org/license.html or
   7  *       in file LICENSE in the top-level directory of the distribution.
   8  */
   9
  10 #include "portable.h"
  11
  12 #ifdef SLAPD_SQL
  13
  14 #include <stdio.h>
  15 #include <sys/types.h>
  16 #include "ac/string.h"
  17 #include "slap.h"
  18 #include "lber_pvt.h"
  19 #include "ldap_pvt.h"
  20 #include "back-sql.h"
  21 #include "sql-wrap.h"
  22 #include "schema-map.h"
  23 #include "entry-id.h"
  24 #include "util.h"
  25
  26 #define BACKSQL_STOP            0
  27 #define BACKSQL_CONTINUE        1
  28
  29 static int backsql_process_filter( backsql_srch_info *bsi, Filter *f );
  30
  31 static int
  32 backsql_attrlist_add( backsql_srch_info *bsi, AttributeDescription *ad )
  33 {
  34         int             n_attrs = 0;
  35         AttributeName   *an = NULL;
  36
  37         if ( bsi->attrs == NULL ) {
  38                 return 1;
  39         }
  40
  41         /*
  42          * clear the list (retrieve all attrs)
  43          */
  44         if ( ad == NULL ) {
  45                 ch_free( bsi->attrs );
  46                 bsi->attrs = NULL;
  47                 return 1;
  48         }
  49
  50         for ( ; bsi->attrs[ n_attrs ].an_name.bv_val; n_attrs++ ) {
  51                 an = &bsi->attrs[ n_attrs ];
  52
  53                 Debug( LDAP_DEBUG_TRACE, "==>backsql_attrlist_add(): "
  54                         "attribute '%s' is in list\n",
  55                         an->an_name.bv_val, 0, 0 );
  56                 /*
  57                  * We can live with strcmp because the attribute
  58                  * list has been normalized before calling be_search
  59                  */
  60                 if ( !BACKSQL_NCMP( &an->an_name, &ad->ad_cname ) ) {
  61                         return 1;
  62                 }
  63         }
  64
  65         Debug( LDAP_DEBUG_TRACE, "==>backsql_attrlist_add(): "
  66                 "adding '%s' to list\n", ad->ad_cname.bv_val, 0, 0 );
  67
  68         an = (AttributeName *)ch_realloc( bsi->attrs,
  69                         sizeof( AttributeName ) * ( n_attrs + 2 ) );
  70         if ( an == NULL ) {
  71                 return -1;
  72         }
  73
  74         an[ n_attrs ].an_name = ad->ad_cname;
  75         an[ n_attrs ].an_desc = ad;
  76         an[ n_attrs + 1 ].an_name.bv_val = NULL;
  77         an[ n_attrs + 1 ].an_name.bv_len = 0;
  78
  79         bsi->attrs = an;
  80
  81         return 1;
  82 }
  83
  84 void
  85 backsql_init_search(
  86         backsql_srch_info       *bsi,
  87         struct berval           *base,
  88         int                     scope,
  89         int                     slimit,
  90         int                     tlimit,
  91         time_t                  stoptime,
  92         Filter                  *filter,
  93         SQLHDBC                 dbh,
  94         Operation               *op,
  95         AttributeName           *attrs )
  96 {
  97         AttributeName           *p;
  98
  99         bsi->base_dn = base;
 100         bsi->scope = scope;
 101         bsi->slimit = slimit;
 102         bsi->tlimit = tlimit;
 103         bsi->filter = filter;
 104         bsi->dbh = dbh;
 105         bsi->op = op;
 106         bsi->bsi_flags = 0;
 107
 108         /*
 109          * handle "*"
 110          */
 111         if ( attrs == NULL || an_find( attrs, &AllUser ) ) {
 112                 bsi->attrs = NULL;
 113
 114         } else {
 115                 bsi->attrs = (AttributeName *)ch_calloc( 1,
 116                                 sizeof( AttributeName ) );
 117                 bsi->attrs[ 0 ].an_name.bv_val = NULL;
 118                 bsi->attrs[ 0 ].an_name.bv_len = 0;
 119
 120                 for ( p = attrs; p->an_name.bv_val; p++ ) {
 121                         /*
 122                          * ignore "1.1"; handle "+"
 123                          */
 124                         if ( BACKSQL_NCMP( &p->an_name, &AllOper ) == 0 ) {
 125                                 bsi->bsi_flags |= BSQL_SF_ALL_OPER;
 126                                 continue;
 127
 128                         } else if ( BACKSQL_NCMP( &p->an_name, &NoAttrs ) == 0 ) {
 129                                 continue;
 130                         }
 131
 132                         backsql_attrlist_add( bsi, p->an_desc );
 133                 }
 134         }
 135
 136         bsi->abandon = 0;
 137         bsi->id_list = NULL;
 138         bsi->n_candidates = 0;
 139         bsi->stoptime = stoptime;
 140         bsi->sel.bb_val.bv_val = NULL;
 141         bsi->sel.bb_val.bv_len = 0;
 142         bsi->sel.bb_len = 0;
 143         bsi->from.bb_val.bv_val = NULL;
 144         bsi->from.bb_val.bv_len = 0;
 145         bsi->from.bb_len = 0;
 146         bsi->join_where.bb_val.bv_val = NULL;
 147         bsi->join_where.bb_val.bv_len = 0;
 148         bsi->join_where.bb_len = 0;
 149         bsi->flt_where.bb_val.bv_val = NULL;
 150         bsi->flt_where.bb_val.bv_len = 0;
 151         bsi->flt_where.bb_len = 0;
 152
 153         bsi->status = LDAP_SUCCESS;
 154 }
 155
 156 static int
 157 backsql_process_filter_list( backsql_srch_info *bsi, Filter *f, int op )
 158 {
 159         int             res;
 160
 161         if ( !f ) {
 162                 return 0;
 163         }
 164
 165         backsql_strfcat( &bsi->flt_where, "c", '(' /* ) */  );
 166
 167         while ( 1 ) {
 168                 res = backsql_process_filter( bsi, f );
 169                 if ( res < 0 ) {
 170                         /*
 171                          * TimesTen : If the query has no answers,
 172                          * don't bother to run the query.
 173                          */
 174                         return -1;
 175                 }
 176
 177                 f = f->f_next;
 178                 if ( f == NULL ) {
 179                         break;
 180                 }
 181
 182                 switch ( op ) {
 183                 case LDAP_FILTER_AND:
 184                         backsql_strfcat( &bsi->flt_where, "l",
 185                                         (ber_len_t)sizeof( " AND " ) - 1,
 186                                                 " AND " );
 187                         break;
 188
 189                 case LDAP_FILTER_OR:
 190                         backsql_strfcat( &bsi->flt_where, "l",
 191                                         (ber_len_t)sizeof( " OR " ) - 1,
 192                                                 " OR " );
 193                         break;
 194                 }
 195         }
 196
 197         backsql_strfcat( &bsi->flt_where, "c", /* ( */ ')' );
 198
 199         return 1;
 200 }
 201
 202 static int
 203 backsql_process_sub_filter( backsql_srch_info *bsi, Filter *f )
 204 {
 205         int                     i;
 206         backsql_at_map_rec      *at;
 207         backsql_info            *bi = (backsql_info *)bsi->op->o_bd->be_private;
 208         int                     casefold = 0;
 209
 210         if ( !f ) {
 211                 return 0;
 212         }
 213
 214         if ( SLAP_MR_ASSOCIATED( f->f_sub_desc->ad_type->sat_substr,
 215                         bi->bi_caseIgnoreMatch ) ) {
 216                 casefold = 1;
 217         }
 218
 219         at = backsql_ad2at( bsi->oc, f->f_sub_desc );
 220
 221         assert( at );
 222
 223         /*
 224          * When dealing with case-sensitive strings
 225          * we may omit normalization; however, normalized
 226          * SQL filters are more liberal.
 227          */
 228
 229         backsql_strfcat( &bsi->flt_where, "c", '(' /* ) */  );
 230
 231         /* TimesTen */
 232         Debug( LDAP_DEBUG_TRACE, "expr: '%s' '%s'\n", at->sel_expr.bv_val,
 233                 at->sel_expr_u.bv_val ? at->sel_expr_u.bv_val : "<NULL>", 0 );
 234         if ( casefold && bi->upper_func.bv_val ) {
 235                 /*
 236                  * If a pre-upper-cased version of the column exists, use it
 237                  */
 238                 if ( at->sel_expr_u.bv_val ) {
 239                         backsql_strfcat( &bsi->flt_where,
 240                                         "bl",
 241                                         &at->sel_expr_u,
 242                                         (ber_len_t)sizeof( " LIKE '" ) - 1,
 243                                                 " LIKE '" );
 244                 } else {
 245                         backsql_strfcat( &bsi->flt_where,
 246                                         "bcbcl",
 247                                         &bi->upper_func,
 248                                         '(',
 249                                         &at->sel_expr,
 250                                         ')',
 251                                         (ber_len_t)sizeof( " LIKE '" ) - 1,
 252                                                 " LIKE '" );
 253                 }
 254         } else {
 255                 backsql_strfcat( &bsi->flt_where, "bl",
 256                                 &at->sel_expr,
 257                                 (ber_len_t)sizeof( " LIKE '" ) - 1, " LIKE '" );
 258         }
 259
 260         if ( f->f_sub_initial.bv_val != NULL ) {
 261                 size_t  start;
 262
 263                 start = bsi->flt_where.bb_val.bv_len;
 264                 backsql_strfcat( &bsi->flt_where, "b",
 265                                 &f->f_sub_initial );
 266                 if ( casefold && bi->upper_func.bv_val ) {
 267                         ldap_pvt_str2upper( &bsi->flt_where.bb_val.bv_val[ start ] );
 268                 }
 269         }
 270
 271         backsql_strfcat( &bsi->flt_where, "c", '%' );
 272
 273         if ( f->f_sub_any != NULL ) {
 274                 for ( i = 0; f->f_sub_any[ i ].bv_val != NULL; i++ ) {
 275                         size_t  start;
 276
 277 #ifdef BACKSQL_TRACE
 278                         Debug( LDAP_DEBUG_TRACE,
 279                                 "==>backsql_process_sub_filter(): "
 280                                 "sub_any='%s'\n", f->f_sub_any[ i ].bv_val,
 281                                 0, 0 );
 282 #endif /* BACKSQL_TRACE */
 283
 284                         start = bsi->flt_where.bb_val.bv_len;
 285                         backsql_strfcat( &bsi->flt_where,
 286                                         "bc",
 287                                         &f->f_sub_any[ i ],
 288                                         '%' );
 289                         if ( casefold && bi->upper_func.bv_val ) {
 290                                 /*
 291                                  * Note: toupper('%') = '%'
 292                                  */
 293                                 ldap_pvt_str2upper( &bsi->flt_where.bb_val.bv_val[ start ] );
 294                         }
 295                 }
 296
 297                 if ( f->f_sub_final.bv_val != NULL ) {
 298                         size_t  start;
 299
 300                         start = bsi->flt_where.bb_val.bv_len;
 301                         backsql_strfcat( &bsi->flt_where, "b",
 302                                         &f->f_sub_final );
 303                         if ( casefold && bi->upper_func.bv_val ) {
 304                                 ldap_pvt_str2upper( &bsi->flt_where.bb_val.bv_val[ start ] );
 305                         }
 306                 }
 307         }
 308
 309         backsql_strfcat( &bsi->flt_where, "l",
 310                         (ber_len_t)sizeof( /* (' */ "')" ) - 1, /* ( */ "')" );
 311
 312         return 1;
 313 }
 314
 315 static int
 316 backsql_process_filter( backsql_srch_info *bsi, Filter *f )
 317 {
 318         backsql_info            *bi = (backsql_info *)bsi->op->o_bd->be_private;
 319         backsql_at_map_rec      *at;
 320         backsql_at_map_rec      oc_attr = {
 321                 slap_schema.si_ad_objectClass, BER_BVC(""), BER_BVC(""),
 322                 BER_BVNULL, NULL, NULL, NULL };
 323         AttributeDescription    *ad = NULL;
 324         int                     done = 0;
 325         int                     casefold = 0;
 326         int                     rc = 0;
 327         struct berval           *filter_value = NULL;
 328         MatchingRule            *matching_rule = NULL;
 329         struct berval           ordering = BER_BVC("<=");
 330
 331         Debug( LDAP_DEBUG_TRACE, "==>backsql_process_filter()\n", 0, 0, 0 );
 332         if ( f == NULL || f->f_choice == SLAPD_FILTER_COMPUTED ) {
 333                 return 0;
 334         }
 335
 336         switch( f->f_choice ) {
 337         case LDAP_FILTER_OR:
 338                 rc = backsql_process_filter_list( bsi, f->f_or,
 339                                 LDAP_FILTER_OR );
 340                 done = 1;
 341                 break;
 342
 343         case LDAP_FILTER_AND:
 344                 rc = backsql_process_filter_list( bsi, f->f_and,
 345                                 LDAP_FILTER_AND );
 346                 done = 1;
 347                 break;
 348
 349         case LDAP_FILTER_NOT:
 350                 backsql_strfcat( &bsi->flt_where, "l",
 351                                 (ber_len_t)sizeof( "NOT (" /* ) */ ) - 1,
 352                                         "NOT (" /* ) */ );
 353                 rc = backsql_process_filter( bsi, f->f_not );
 354                 backsql_strfcat( &bsi->flt_where, "c", /* ( */ ')' );
 355                 done = 1;
 356                 break;
 357
 358         case LDAP_FILTER_PRESENT:
 359                 ad = f->f_desc;
 360                 break;
 361
 362         case LDAP_FILTER_EXT:
 363                 ad = f->f_mra->ma_desc;
 364                 break;
 365
 366         default:
 367                 ad = f->f_av_desc;
 368                 break;
 369         }
 370
 371         if ( rc == -1 ) {
 372                 goto impossible;
 373         }
 374
 375         if ( done ) {
 376                 goto done;
 377         }
 378
 379         /*
 380          * Turn structuralObjectClass into objectClass
 381          */
 382         if ( ad == slap_schema.si_ad_objectClass
 383                         || ad == slap_schema.si_ad_structuralObjectClass ) {
 384                 struct berbuf           bb = BB_NULL;
 385
 386                 at = &oc_attr;
 387                 backsql_strfcat( &bb, "cbc",
 388                                 '\'',
 389                                 &bsi->oc->oc->soc_cname,
 390                                 '\'' );
 391                 at->sel_expr = bb.bb_val;
 392
 393         } else if ( ad == slap_schema.si_ad_hasSubordinates || ad == NULL ) {
 394                 /*
 395                  * FIXME: this is not robust; e.g. a filter
 396                  * '(!(hasSubordinates=TRUE))' fails because
 397                  * in SQL it would read 'NOT (1=1)' instead
 398                  * of no condition.
 399                  * Note however that hasSubordinates is boolean,
 400                  * so a more appropriate filter would be
 401                  * '(hasSubordinates=FALSE)'
 402                  *
 403                  * A more robust search for hasSubordinates
 404                  * would * require joining the ldap_entries table
 405                  * selecting if there are descendants of the
 406                  * candidate.
 407                  */
 408                 backsql_strfcat( &bsi->flt_where, "l",
 409                                 (ber_len_t)sizeof( "1=1" ) - 1, "1=1" );
 410                 if ( ad == slap_schema.si_ad_hasSubordinates ) {
 411                         /*
 412                          * instruct candidate selection algorithm
 413                          * and attribute list to try to detect
 414                          * if an entry has subordinates
 415                          */
 416                         bsi->bsi_flags |= BSQL_SF_FILTER_HASSUBORDINATE;
 417
 418                 } else {
 419                         /*
 420                          * clear attributes to fetch, to require ALL
 421                          * and try extended match on all attributes
 422                          */
 423                         backsql_attrlist_add( bsi, NULL );
 424                 }
 425                 goto done;
 426
 427         } else {
 428                 at = backsql_ad2at( bsi->oc, ad );
 429         }
 430
 431         if ( at == NULL ) {
 432                 Debug( LDAP_DEBUG_TRACE, "backsql_process_filter(): "
 433                         "attribute '%s' is not defined for objectclass '%s'\n",
 434                         ad->ad_cname.bv_val, BACKSQL_OC_NAME( bsi->oc ), 0 );
 435                 backsql_strfcat( &bsi->flt_where, "l",
 436                                 (ber_len_t)sizeof( "1=0" ) - 1, "1=0" );
 437                 goto impossible;
 438         }
 439
 440         backsql_merge_from_clause( &bsi->from, &at->from_tbls );
 441         /*
 442          * need to add this attribute to list of attrs to load,
 443          * so that we could do test_filter() later
 444          */
 445         backsql_attrlist_add( bsi, ad );
 446
 447         if ( at->join_where.bv_val != NULL
 448                         && strstr( bsi->join_where.bb_val.bv_val, at->join_where.bv_val ) == NULL ) {
 449                 backsql_strfcat( &bsi->join_where, "lb",
 450                                 (ber_len_t)sizeof( " AND " ) - 1, " AND ",
 451                                 &at->join_where );
 452         }
 453
 454         switch ( f->f_choice ) {
 455         case LDAP_FILTER_EQUALITY:
 456                 filter_value = &f->f_av_value;
 457                 matching_rule = ad->ad_type->sat_equality;
 458
 459                 goto equality_match;
 460
 461                 /* fail over into next case */
 462
 463         case LDAP_FILTER_EXT:
 464                 filter_value = &f->f_mra->ma_value;
 465                 matching_rule = f->f_mr_rule;
 466
 467 equality_match:;
 468                 if ( SLAP_MR_ASSOCIATED( matching_rule,
 469                                         bi->bi_caseIgnoreMatch ) ) {
 470                         casefold = 1;
 471                 }
 472
 473                 /*
 474                  * maybe we should check type of at->sel_expr here somehow,
 475                  * to know whether upper_func is applicable, but for now
 476                  * upper_func stuff is made for Oracle, where UPPER is
 477                  * safely applicable to NUMBER etc.
 478                  */
 479                 if ( casefold && bi->upper_func.bv_val ) {
 480                         size_t  start;
 481
 482                         if ( at->sel_expr_u.bv_val ) {
 483                                 backsql_strfcat( &bsi->flt_where, "cbl",
 484                                                 '(',
 485                                                 &at->sel_expr_u,
 486                                                 (ber_len_t)sizeof( "='" ) - 1,
 487                                                         "='" );
 488                         } else {
 489                                 backsql_strfcat( &bsi->flt_where, "cbcbl",
 490                                                 '(' /* ) */ ,
 491                                                 &bi->upper_func,
 492                                                 '(' /* ) */ ,
 493                                                 &at->sel_expr,
 494                                                 (ber_len_t)sizeof( /* ( */ ")='" ) - 1,
 495                                                         /* ( */ ")='" );
 496                         }
 497
 498                         start = bsi->flt_where.bb_val.bv_len;
 499
 500                         backsql_strfcat( &bsi->flt_where, "bl",
 501                                         filter_value,
 502                                         (ber_len_t)sizeof( /* (' */ "')" ) - 1,
 503                                                 /* (' */ "')" );
 504
 505                         ldap_pvt_str2upper( &bsi->flt_where.bb_val.bv_val[ start ] );
 506
 507                 } else {
 508                         backsql_strfcat( &bsi->flt_where, "cblbl",
 509                                         '(',
 510                                         &at->sel_expr,
 511                                         (ber_len_t)sizeof( "='" ) - 1, "='",
 512                                         filter_value,
 513                                         (ber_len_t)sizeof( /* (' */ "')" ) - 1,
 514                                                 /* (' */ "')" );
 515                 }
 516                 break;
 517
 518         case LDAP_FILTER_GE:
 519                 ordering.bv_val = ">=";
 520
 521                 /* fall thru to next case */
 522
 523         case LDAP_FILTER_LE:
 524                 if ( SLAP_MR_ASSOCIATED( ad->ad_type->sat_ordering,
 525                                 bi->bi_caseIgnoreMatch ) ) {
 526                         casefold = 1;
 527                 }
 528
 529                 /*
 530                  * FIXME: should we uppercase the operands?
 531                  */
 532                 if ( casefold && bi->upper_func.bv_val ) {
 533                         size_t  start;
 534
 535                         if ( at->sel_expr_u.bv_val ) {
 536                                 backsql_strfcat( &bsi->flt_where, "cbbc",
 537                                                 '(',
 538                                                 &at->sel_expr_u,
 539                                                 &ordering,
 540                                                 '\'' );
 541                         } else {
 542                                 backsql_strfcat( &bsi->flt_where, "cbcbcbc",
 543                                                 '(' /* ) */ ,
 544                                                 &bi->upper_func,
 545                                                 '(' /* ) */ ,
 546                                                 &at->sel_expr,
 547                                                 /* ( */ ')',
 548                                                 &ordering,
 549                                                 '\'' );
 550                         }
 551
 552                         start = bsi->flt_where.bb_val.bv_len;
 553
 554                         backsql_strfcat( &bsi->flt_where, "bl",
 555                                         filter_value,
 556                                         (ber_len_t)sizeof( /* (' */ "')" ) - 1,
 557                                                 /* (' */ "')" );
 558
 559                         ldap_pvt_str2upper( &bsi->flt_where.bb_val.bv_val[ start ] );
 560
 561                 } else {
 562                         backsql_strfcat( &bsi->flt_where, "cbbcbl",
 563                                         '(' /* ) */ ,
 564                                         &at->sel_expr,
 565                                         &ordering,
 566                                         '\'',
 567                                         &f->f_av_value,
 568                                         (ber_len_t)sizeof( /* (' */ "')" ) - 1,
 569                                                 /* ( */ "')" );
 570                 }
 571                 break;
 572
 573         case LDAP_FILTER_PRESENT:
 574                 backsql_strfcat( &bsi->flt_where, "lbl",
 575                                 (ber_len_t)sizeof( "NOT (" ) - 1, "NOT (",
 576                                 &at->sel_expr,
 577                                 (ber_len_t)sizeof( " IS NULL)" ) - 1, " IS NULL)" );
 578                 break;
 579
 580         case LDAP_FILTER_SUBSTRINGS:
 581                 backsql_process_sub_filter( bsi, f );
 582                 break;
 583
 584         case LDAP_FILTER_APPROX:
 585                 /* we do our best */
 586
 587                 /*
 588                  * maybe we should check type of at->sel_expr here somehow,
 589                  * to know whether upper_func is applicable, but for now
 590                  * upper_func stuff is made for Oracle, where UPPER is
 591                  * safely applicable to NUMBER etc.
 592                  */
 593                 if ( bi->upper_func.bv_val ) {
 594                         size_t  start;
 595
 596                         if ( at->sel_expr_u.bv_val ) {
 597                                 backsql_strfcat( &bsi->flt_where, "cbl",
 598                                                 '(',
 599                                                 &at->sel_expr_u,
 600                                                 (ber_len_t)sizeof( " LIKE '%" ) - 1,
 601                                                         " LIKE '%" );
 602                         } else {
 603                                 backsql_strfcat( &bsi->flt_where, "cbcbl",
 604                                                 '(' /* ) */ ,
 605                                                 &bi->upper_func,
 606                                                 '(' /* ) */ ,
 607                                                 &at->sel_expr,
 608                                                 (ber_len_t)sizeof( /* ( */ ") LIKE '%" ) - 1,
 609                                                         /* ( */ ") LIKE '%" );
 610                         }
 611
 612                         start = bsi->flt_where.bb_val.bv_len;
 613
 614                         backsql_strfcat( &bsi->flt_where, "bl",
 615                                         &f->f_av_value,
 616                                         (ber_len_t)sizeof( /* (' */ "%')" ) - 1,
 617                                                 /* (' */ "%')" );
 618
 619                         ldap_pvt_str2upper( &bsi->flt_where.bb_val.bv_val[ start ] );
 620
 621                 } else {
 622                         backsql_strfcat( &bsi->flt_where, "cblbl",
 623                                         '(',
 624                                         &at->sel_expr,
 625                                         (ber_len_t)sizeof( " LIKE '%" ) - 1,
 626                                                 " LIKE '%",
 627                                         &f->f_av_value,
 628                                         (ber_len_t)sizeof( /* (' */ "%')" ) - 1,
 629                                                 /* (' */ "%')" );
 630                 }
 631                 break;
 632
 633         default:
 634                 /* unhandled filter type; should not happen */
 635                 assert( 0 );
 636                 backsql_strfcat( &bsi->flt_where, "l",
 637                                 (ber_len_t)sizeof( "1=1" ) - 1, "1=1" );
 638                 break;
 639
 640         }
 641
 642 done:
 643         if ( oc_attr.sel_expr.bv_val != NULL ) {
 644                 free( oc_attr.sel_expr.bv_val );
 645         }
 646
 647         Debug( LDAP_DEBUG_TRACE, "<==backsql_process_filter()\n", 0, 0, 0 );
 648         return 1;
 649
 650 impossible:
 651         if ( oc_attr.sel_expr.bv_val != NULL ) {
 652                 free( oc_attr.sel_expr.bv_val );
 653         }
 654         Debug( LDAP_DEBUG_TRACE, "<==backsql_process_filter() returns -1\n",
 655                         0, 0, 0 );
 656         return -1;
 657 }
 658
 659 static int
 660 backsql_srch_query( backsql_srch_info *bsi, struct berval *query )
 661 {
 662         backsql_info    *bi = (backsql_info *)bsi->op->o_bd->be_private;
 663         int             rc;
 664
 665         assert( query );
 666         query->bv_val = NULL;
 667         query->bv_len = 0;
 668
 669         Debug( LDAP_DEBUG_TRACE, "==>backsql_srch_query()\n", 0, 0, 0 );
 670         bsi->sel.bb_val.bv_val = NULL;
 671         bsi->sel.bb_val.bv_len = 0;
 672         bsi->sel.bb_len = 0;
 673         bsi->from.bb_val.bv_val = NULL;
 674         bsi->from.bb_val.bv_len = 0;
 675         bsi->from.bb_len = 0;
 676         bsi->join_where.bb_val.bv_val = NULL;
 677         bsi->join_where.bb_val.bv_len = 0;
 678         bsi->join_where.bb_len = 0;
 679         bsi->flt_where.bb_val.bv_val = NULL;
 680         bsi->flt_where.bb_val.bv_len = 0;
 681         bsi->flt_where.bb_len = 0;
 682
 683         backsql_strfcat( &bsi->sel, "lbcbc",
 684                         (ber_len_t)sizeof( "SELECT DISTINCT ldap_entries.id," ) - 1,
 685                                 "SELECT DISTINCT ldap_entries.id,",
 686                         &bsi->oc->keytbl,
 687                         '.',
 688                         &bsi->oc->keycol,
 689                         ',' );
 690
 691         if ( bi->strcast_func.bv_val ) {
 692                 backsql_strfcat( &bsi->sel, "blbl",
 693                                 &bi->strcast_func,
 694                                 (ber_len_t)sizeof( "('" /* ') */ ) - 1,
 695                                         "('" /* ') */ ,
 696                                 &bsi->oc->oc->soc_cname,
 697                                 (ber_len_t)sizeof( /* (' */ "')" ) - 1,
 698                                         /* (' */ "')" );
 699         } else {
 700                 backsql_strfcat( &bsi->sel, "cbc",
 701                                 '\'',
 702                                 &bsi->oc->oc->soc_cname,
 703                                 '\'' );
 704         }
 705         backsql_strfcat( &bsi->sel, "l",
 706                         (ber_len_t)sizeof( " AS objectClass,ldap_entries.dn AS dn" ) - 1,
 707                         " AS objectClass,ldap_entries.dn AS dn" );
 708
 709         backsql_strfcat( &bsi->from, "lb",
 710                         (ber_len_t)sizeof( " FROM ldap_entries," ) - 1,
 711                                 " FROM ldap_entries,",
 712                         &bsi->oc->keytbl );
 713
 714         backsql_strfcat( &bsi->join_where, "lbcbl",
 715                         (ber_len_t)sizeof( " WHERE " ) - 1, " WHERE ",
 716                         &bsi->oc->keytbl,
 717                         '.',
 718                         &bsi->oc->keycol,
 719                         (ber_len_t)sizeof( "=ldap_entries.keyval AND ldap_entries.oc_map_id=? AND " ) - 1,
 720                                 "=ldap_entries.keyval AND ldap_entries.oc_map_id=? AND " );
 721
 722         switch ( bsi->scope ) {
 723         case LDAP_SCOPE_BASE:
 724                 if ( bi->upper_func.bv_val ) {
 725                         backsql_strfcat( &bsi->join_where, "blbcb",
 726                                         &bi->upper_func,
 727                                         (ber_len_t)sizeof( "(ldap_entries.dn)=" ) - 1,
 728                                                 "(ldap_entries.dn)=",
 729                                         &bi->upper_func_open,
 730                                         '?',
 731                                         &bi->upper_func_close );
 732                 } else {
 733                         backsql_strfcat( &bsi->join_where, "l",
 734                                         (ber_len_t)sizeof( "ldap_entries.dn=?" ) - 1,
 735                                                 "ldap_entries.dn=?" );
 736                 }
 737                 break;
 738
 739         case LDAP_SCOPE_ONELEVEL:
 740                 backsql_strfcat( &bsi->join_where, "l",
 741                                 (ber_len_t)sizeof( "ldap_entries.parent=?" ) - 1,
 742                                         "ldap_entries.parent=?" );
 743                 break;
 744
 745         case LDAP_SCOPE_SUBTREE:
 746                 if ( bi->upper_func.bv_val ) {
 747                         backsql_strfcat( &bsi->join_where, "blbcb",
 748                                         &bi->upper_func,
 749                                         (ber_len_t)sizeof( "(ldap_entries.dn) LIKE " ) - 1,
 750                                                 "(ldap_entries.dn) LIKE ",
 751                                         &bi->upper_func_open,
 752                                         '?',
 753                                         &bi->upper_func_close );
 754                 } else {
 755                         backsql_strfcat( &bsi->join_where, "l",
 756                                         (ber_len_t)sizeof( "ldap_entries.dn LIKE ?" ) - 1,
 757                                                 "ldap_entries.dn LIKE ?" );
 758                 }
 759
 760                 break;
 761
 762         default:
 763                 assert( 0 );
 764         }
 765
 766         rc = backsql_process_filter( bsi, bsi->filter );
 767         if ( rc > 0 ) {
 768                 struct berbuf   bb = BB_NULL;
 769
 770                 backsql_strfcat( &bb, "bbblb",
 771                                 &bsi->sel.bb_val,
 772                                 &bsi->from.bb_val,
 773                                 &bsi->join_where.bb_val,
 774                                 (ber_len_t)sizeof( " AND " ) - 1, " AND ",
 775                                 &bsi->flt_where.bb_val );
 776
 777                 *query = bb.bb_val;
 778
 779         } else if ( rc < 0 ) {
 780                 /*
 781                  * Indicates that there's no possible way the filter matches
 782                  * anything.  No need to issue the query
 783                  */
 784                 free( query->bv_val );
 785                 query->bv_val = NULL;
 786         }
 787
 788         free( bsi->sel.bb_val.bv_val );
 789         bsi->sel.bb_val.bv_len = 0;
 790         bsi->sel.bb_len = 0;
 791         free( bsi->from.bb_val.bv_val );
 792         bsi->from.bb_val.bv_len = 0;
 793         bsi->from.bb_len = 0;
 794         free( bsi->join_where.bb_val.bv_val );
 795         bsi->join_where.bb_val.bv_len = 0;
 796         bsi->join_where.bb_len = 0;
 797         free( bsi->flt_where.bb_val.bv_val );
 798         bsi->flt_where.bb_val.bv_len = 0;
 799         bsi->flt_where.bb_len = 0;
 800
 801         Debug( LDAP_DEBUG_TRACE, "<==backsql_srch_query() returns %s\n",
 802                 query->bv_val ? query->bv_val : "NULL", 0, 0 );
 803
 804         return ( rc <= 0 ? 1 : 0 );
 805 }
 806
 807 static int
 808 backsql_oc_get_candidates( void *v_oc, void *v_bsi )
 809 {
 810         backsql_oc_map_rec      *oc = v_oc;
 811         backsql_srch_info       *bsi = v_bsi;
 812         backsql_info            *bi = (backsql_info *)bsi->op->o_bd->be_private;
 813         struct berval           query;
 814         SQLHSTMT                sth;
 815         RETCODE                 rc;
 816         backsql_entryID         base_id, *c_id;
 817         int                     res;
 818         BACKSQL_ROW_NTS         row;
 819         int                     i;
 820         int                     j;
 821
 822         int                     n_candidates = bsi->n_candidates;
 823
 824         bsi->status = LDAP_SUCCESS;
 825
 826         Debug(  LDAP_DEBUG_TRACE, "==>backsql_oc_get_candidates(): oc='%s'\n",
 827                         BACKSQL_OC_NAME( oc ), 0, 0 );
 828
 829         if ( bsi->n_candidates == -1 ) {
 830                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
 831                         "unchecked limit has been overcome\n", 0, 0, 0 );
 832                 /* should never get here */
 833                 assert( 0 );
 834                 bsi->status = LDAP_ADMINLIMIT_EXCEEDED;
 835                 return BACKSQL_STOP;
 836         }
 837
 838         bsi->oc = oc;
 839         res = backsql_srch_query( bsi, &query );
 840         if ( res ) {
 841                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
 842                         "error while constructing query for objectclass '%s'\n",
 843                         oc->oc->soc_cname.bv_val, 0, 0 );
 844                 /*
 845                  * FIXME: need to separate errors from legally
 846                  * impossible filters
 847                  */
 848                 bsi->status = LDAP_SUCCESS;
 849                 return BACKSQL_CONTINUE;
 850         }
 851
 852         if ( query.bv_val == NULL ) {
 853                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
 854                         "could not construct query for objectclass '%s'\n",
 855                         oc->oc->soc_cname.bv_val, 0, 0 );
 856                 bsi->status = LDAP_SUCCESS;
 857                 return BACKSQL_CONTINUE;
 858         }
 859
 860         Debug( LDAP_DEBUG_TRACE, "Constructed query: %s\n",
 861                         query.bv_val, 0, 0 );
 862
 863         rc = backsql_Prepare( bsi->dbh, &sth, query.bv_val, 0 );
 864         free( query.bv_val );
 865         if ( rc != SQL_SUCCESS ) {
 866                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
 867                         "error preparing query\n", 0, 0, 0 );
 868                 backsql_PrintErrors( bi->db_env, bsi->dbh, sth, rc );
 869                 bsi->status = LDAP_OTHER;
 870                 return BACKSQL_CONTINUE;
 871         }
 872
 873         Debug( LDAP_DEBUG_TRACE, "id: '%ld'\n", bsi->oc->id, 0, 0 );
 874
 875         if ( backsql_BindParamID( sth, 1, &bsi->oc->id ) != SQL_SUCCESS ) {
 876                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
 877                         "error binding objectclass id parameter\n", 0, 0, 0 );
 878                 bsi->status = LDAP_OTHER;
 879                 return BACKSQL_CONTINUE;
 880         }
 881
 882         switch ( bsi->scope ) {
 883         case LDAP_SCOPE_BASE:
 884                 Debug( LDAP_DEBUG_TRACE, "(base)dn: '%s'\n",
 885                                 bsi->base_dn->bv_val, 0, 0 );
 886
 887                 rc = backsql_BindParamStr( sth, 2, bsi->base_dn->bv_val,
 888                                 BACKSQL_MAX_DN_LEN );
 889                 if ( rc != SQL_SUCCESS ) {
 890                         Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
 891                                 "error binding base_dn parameter\n", 0, 0, 0 );
 892                         backsql_PrintErrors( bi->db_env, bsi->dbh,
 893                                         sth, rc );
 894                         bsi->status = LDAP_OTHER;
 895                         return BACKSQL_CONTINUE;
 896                 }
 897                 break;
 898
 899         case LDAP_SCOPE_SUBTREE: {
 900
 901                 /*
 902                  * + 1 because we need room for '%'; this makes a subtree
 903                  * search for a DN BACKSQL_MAX_DN_LEN long legal
 904                  * if it returns that DN only
 905                  */
 906                 char            temp_base_dn[ BACKSQL_MAX_DN_LEN + 1 + 1 ];
 907
 908                 /*
 909                  * We do not accept DNs longer than BACKSQL_MAX_DN_LEN;
 910                  * however this should be handled earlier
 911                  */
 912                 assert( bsi->base_dn->bv_len <= BACKSQL_MAX_DN_LEN );
 913
 914                 /*
 915                  * Sets the parameters for the SQL built earlier
 916                  * NOTE that all the databases could actually use
 917                  * the TimesTen version, which would be cleaner
 918                  * and would also eliminate the need for the
 919                  * subtree_cond line in the configuration file.
 920                  * For now, I'm leaving it the way it is,
 921                  * so non-TimesTen databases use the original code.
 922                  * But at some point this should get cleaned up.
 923                  *
 924                  * If "dn" is being used, do a suffix search.
 925                  * If "dn_ru" is being used, do a prefix search.
 926                  */
 927                 if ( BACKSQL_HAS_LDAPINFO_DN_RU( bi ) ) {
 928                         temp_base_dn[ 0 ] = '\0';
 929                         for ( i = 0, j = bsi->base_dn->bv_len - 1;
 930                                         j >= 0; i++, j--) {
 931                                 temp_base_dn[ i ] = bsi->base_dn->bv_val[ j ];
 932                         }
 933                         temp_base_dn[ i ] = '%';
 934                         temp_base_dn[ i + 1 ] = '\0';
 935
 936                 } else {
 937                         temp_base_dn[ 0 ] = '%';
 938                         AC_MEMCPY( &temp_base_dn[ 1 ], bsi->base_dn->bv_val,
 939                                 bsi->base_dn->bv_len + 1 );
 940                 }
 941                 ldap_pvt_str2upper( temp_base_dn );
 942
 943                 Debug( LDAP_DEBUG_TRACE, "(sub)dn: '%s'\n", temp_base_dn,
 944                                 0, 0 );
 945
 946                 rc = backsql_BindParamStr( sth, 2, temp_base_dn,
 947                                 BACKSQL_MAX_DN_LEN );
 948                 if ( rc != SQL_SUCCESS ) {
 949                         Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
 950                                 "error binding base_dn parameter (2)\n",
 951                                 0, 0, 0 );
 952                         backsql_PrintErrors( bi->db_env, bsi->dbh,
 953                                         sth, rc );
 954                         bsi->status = LDAP_OTHER;
 955                         return BACKSQL_CONTINUE;
 956                 }
 957                 break;
 958         }
 959
 960         case LDAP_SCOPE_ONELEVEL:
 961                 res = backsql_dn2id( bi, &base_id,
 962                                 bsi->dbh, bsi->base_dn );
 963                 if ( res != LDAP_SUCCESS ) {
 964                         Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
 965                                 "could not retrieve base_dn id%s\n",
 966                                 res == LDAP_NO_SUCH_OBJECT ? ": no such entry"
 967                                 : "", 0, 0 );
 968                         bsi->status = res;
 969                         return BACKSQL_CONTINUE;
 970                 }
 971
 972                 Debug( LDAP_DEBUG_TRACE, "(one)id: '%s'\n", base_id.id,
 973                                 0, 0 );
 974
 975                 rc = backsql_BindParamID( sth, 2, &base_id.id );
 976                 backsql_free_entryID( &base_id, 0 );
 977                 if ( rc != SQL_SUCCESS ) {
 978                         Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
 979                                 "error binding base id parameter\n", 0, 0, 0 );
 980                         bsi->status = LDAP_OTHER;
 981                         return BACKSQL_CONTINUE;
 982                 }
 983                 break;
 984         }
 985
 986         rc = SQLExecute( sth );
 987         if ( !BACKSQL_SUCCESS( rc ) ) {
 988                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
 989                         "error executing query\n", 0, 0, 0 );
 990                 backsql_PrintErrors( bi->db_env, bsi->dbh, sth, rc );
 991                 SQLFreeStmt( sth, SQL_DROP );
 992                 bsi->status = LDAP_OTHER;
 993                 return BACKSQL_CONTINUE;
 994         }
 995
 996         backsql_BindRowAsStrings( sth, &row );
 997         rc = SQLFetch( sth );
 998         for ( ; BACKSQL_SUCCESS( rc ); rc = SQLFetch( sth ) ) {
 999                 c_id = (backsql_entryID *)ch_calloc( 1,
1000                                 sizeof( backsql_entryID ) );
1001                 c_id->id = strtol( row.cols[ 0 ], NULL, 0 );
1002                 c_id->keyval = strtol( row.cols[ 1 ], NULL, 0 );
1003                 c_id->oc_id = bsi->oc->id;
1004                 ber_str2bv( row.cols[ 3 ], 0, 1, &c_id->dn );
1005                 c_id->next = bsi->id_list;
1006                 bsi->id_list = c_id;
1007                 bsi->n_candidates--;
1008
1009                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
1010                         "added entry id=%ld, keyval=%ld dn='%s'\n",
1011                         c_id->id, c_id->keyval, row.cols[ 3 ] );
1012
1013                 if ( bsi->n_candidates == -1 ) {
1014                         break;
1015                 }
1016         }
1017         backsql_FreeRow( &row );
1018         SQLFreeStmt( sth, SQL_DROP );
1019
1020         Debug( LDAP_DEBUG_TRACE, "<==backsql_oc_get_candidates(): %d\n",
1021                         n_candidates - bsi->n_candidates, 0, 0 );
1022
1023         return ( bsi->n_candidates == -1 ? BACKSQL_STOP : BACKSQL_CONTINUE );
1024 }
1025
1026 int
1027 backsql_search( Operation *op, SlapReply *rs )
1028 {
1029         backsql_info            *bi = (backsql_info *)op->o_bd->be_private;
1030         SQLHDBC                 dbh;
1031         int                     sres;
1032         Entry                   *entry, *res;
1033         int                     manageDSAit;
1034         time_t                  stoptime = 0;
1035         backsql_srch_info       srch_info;
1036         backsql_entryID         *eid = NULL;
1037         struct slap_limits_set  *limit = NULL;
1038         int                     isroot = 0;
1039
1040         manageDSAit = get_manageDSAit( op );
1041
1042         Debug( LDAP_DEBUG_TRACE, "==>backsql_search(): "
1043                 "base='%s', filter='%s', scope=%d,",
1044                 op->o_req_ndn.bv_val,
1045                 op->oq_search.rs_filterstr.bv_val,
1046                 op->oq_search.rs_scope );
1047         Debug( LDAP_DEBUG_TRACE, " deref=%d, attrsonly=%d, "
1048                 "attributes to load: %s\n",
1049                 op->oq_search.rs_deref,
1050                 op->oq_search.rs_attrsonly,
1051                 op->oq_search.rs_attrs == NULL ? "all" : "custom list" );
1052
1053         if ( op->o_req_ndn.bv_len > BACKSQL_MAX_DN_LEN ) {
1054                 Debug( LDAP_DEBUG_TRACE, "backsql_search(): "
1055                         "search base length (%ld) exceeds max length (%ld)\n",
1056                         op->o_req_ndn.bv_len, BACKSQL_MAX_DN_LEN, 0 );
1057                 /*
1058                  * FIXME: a LDAP_NO_SUCH_OBJECT could be appropriate
1059                  * since it is impossible that such a long DN exists
1060                  * in the backend
1061                  */
1062                 rs->sr_err = LDAP_ADMINLIMIT_EXCEEDED;
1063                 send_ldap_result( op, rs );
1064                 return 1;
1065         }
1066
1067         sres = backsql_get_db_conn( op, &dbh );
1068         if ( sres != LDAP_SUCCESS ) {
1069                 Debug( LDAP_DEBUG_TRACE, "backsql_search(): "
1070                         "could not get connection handle - exiting\n",
1071                         0, 0, 0 );
1072                 rs->sr_err = sres;
1073                 rs->sr_text = sres == LDAP_OTHER ?  "SQL-backend error" : NULL;
1074                 send_ldap_result( op, rs );
1075                 return 1;
1076         }
1077
1078         /* if not root, get appropriate limits */
1079         if ( be_isroot( op->o_bd, &op->o_ndn ) ) {
1080                 isroot = 1;
1081         } else {
1082                 ( void ) get_limits( op->o_bd, &op->o_ndn, &limit );
1083         }
1084
1085         /* The time/size limits come first because they require very little
1086          * effort, so there's no chance the candidates are selected and then
1087          * the request is not honored only because of time/size constraints */
1088
1089         /* if no time limit requested, use soft limit (unless root!) */
1090         if ( isroot ) {
1091                 if ( op->oq_search.rs_tlimit == 0 ) {
1092                         op->oq_search.rs_tlimit = -1;   /* allow root to set no limit */
1093                 }
1094
1095                 if ( op->oq_search.rs_slimit == 0 ) {
1096                         op->oq_search.rs_slimit = -1;
1097                 }
1098
1099         } else {
1100                 /* if no limit is required, use soft limit */
1101                 if ( op->oq_search.rs_tlimit <= 0 ) {
1102                         op->oq_search.rs_tlimit = limit->lms_t_soft;
1103
1104                 /* if requested limit higher than hard limit, abort */
1105                 } else if ( op->oq_search.rs_tlimit > limit->lms_t_hard ) {
1106                         /* no hard limit means use soft instead */
1107                         if ( limit->lms_t_hard == 0
1108                                         && limit->lms_t_soft > -1
1109                                         && op->oq_search.rs_tlimit > limit->lms_t_soft ) {
1110                                 op->oq_search.rs_tlimit = limit->lms_t_soft;
1111
1112                         /* positive hard limit means abort */
1113                         } else if ( limit->lms_t_hard > 0 ) {
1114                                 rs->sr_err = LDAP_ADMINLIMIT_EXCEEDED;
1115                                 send_ldap_result( op, rs );
1116                                 return 0;
1117                         }
1118
1119                         /* negative hard limit means no limit */
1120                 }
1121
1122                 /* if no limit is required, use soft limit */
1123                 if ( op->oq_search.rs_slimit <= 0 ) {
1124                         op->oq_search.rs_slimit = limit->lms_s_soft;
1125
1126                 /* if requested limit higher than hard limit, abort */
1127                 } else if ( op->oq_search.rs_slimit > limit->lms_s_hard ) {
1128                         /* no hard limit means use soft instead */
1129                         if ( limit->lms_s_hard == 0
1130                                         && limit->lms_s_soft > -1
1131                                         && op->oq_search.rs_slimit > limit->lms_s_soft ) {
1132                                 op->oq_search.rs_slimit = limit->lms_s_soft;
1133
1134                         /* positive hard limit means abort */
1135                         } else if ( limit->lms_s_hard > 0 ) {
1136                                 rs->sr_err = LDAP_ADMINLIMIT_EXCEEDED;
1137                                 send_ldap_result( op, rs );
1138                                 return 0;
1139                         }
1140
1141                         /* negative hard limit means no limit */
1142                 }
1143         }
1144
1145         /* compute it anyway; root does not use it */
1146         stoptime = op->o_time + op->oq_search.rs_tlimit;
1147
1148         backsql_init_search( &srch_info, &op->o_req_dn,
1149                         op->oq_search.rs_scope,
1150                         op->oq_search.rs_slimit, op->oq_search.rs_tlimit,
1151                         stoptime, op->oq_search.rs_filter,
1152                         dbh, op, op->oq_search.rs_attrs );
1153
1154         /*
1155          * for each objectclass we try to construct query which gets IDs
1156          * of entries matching LDAP query filter and scope (or at least
1157          * candidates), and get the IDs
1158          */
1159         srch_info.n_candidates = ( isroot ? -2 : limit->lms_s_unchecked == -1
1160                         ? -2 : limit->lms_s_unchecked );
1161         avl_apply( bi->oc_by_oc, backsql_oc_get_candidates,
1162                         &srch_info, BACKSQL_STOP, AVL_INORDER );
1163         if ( !isroot && limit->lms_s_unchecked != -1 ) {
1164                 if ( srch_info.n_candidates == -1 ) {
1165                         rs->sr_err = LDAP_ADMINLIMIT_EXCEEDED;
1166                         send_ldap_result( op, rs );
1167                         goto done;
1168                 }
1169         }
1170
1171         /*
1172          * now we load candidate entries (only those attributes
1173          * mentioned in attrs and filter), test it against full filter
1174          * and then send to client
1175          */
1176         for ( eid = srch_info.id_list; eid != NULL;
1177                         eid = backsql_free_entryID( eid, 1 ) ) {
1178                 Attribute       *hasSubordinate = NULL,
1179                                 *a = NULL;
1180
1181                 /* check for abandon */
1182                 if ( op->o_abandon ) {
1183                         break;
1184                 }
1185
1186                 /* check time limit */
1187                 if ( op->oq_search.rs_tlimit != -1 && slap_get_time() > stoptime ) {
1188                         rs->sr_err = LDAP_TIMELIMIT_EXCEEDED;
1189                         rs->sr_ctrls = NULL;
1190                         rs->sr_ref = rs->sr_v2ref;
1191                         rs->sr_err = (rs->sr_v2ref == NULL) ? LDAP_SUCCESS
1192                                 : LDAP_REFERRAL;
1193                         send_ldap_result( op, rs );
1194                         goto end_of_search;
1195                 }
1196
1197                 Debug(LDAP_DEBUG_TRACE, "backsql_search(): loading data "
1198                         "for entry id=%ld, oc_id=%ld, keyval=%ld\n",
1199                         eid->id, eid->oc_id, eid->keyval );
1200
1201                 entry = (Entry *)ch_calloc( sizeof( Entry ), 1 );
1202                 res = backsql_id2entry( &srch_info, entry, eid );
1203                 if ( res == NULL ) {
1204                         Debug( LDAP_DEBUG_TRACE, "backsql_search(): "
1205                                 "error in backsql_id2entry() "
1206                                 "- skipping entry\n", 0, 0, 0 );
1207                         continue;
1208                 }
1209
1210                 if ( !manageDSAit &&
1211                                 op->oq_search.rs_scope != LDAP_SCOPE_BASE &&
1212                                 is_entry_referral( entry ) ) {
1213                         BerVarray refs;
1214                         struct berval matched_dn;
1215
1216                         ber_dupbv( &matched_dn, &entry->e_name );
1217                         refs = get_entry_referrals( op, entry );
1218                         if ( refs ) {
1219                                 rs->sr_ref = referral_rewrite( refs,
1220                                                 &matched_dn, &op->o_req_dn,
1221                                                 op->oq_search.rs_scope );
1222                                 ber_bvarray_free( refs );
1223                         }
1224
1225                         if (!rs->sr_ref) {
1226                                 rs->sr_text = "bad_referral object";
1227                         }
1228
1229                         rs->sr_err = LDAP_REFERRAL;
1230                         rs->sr_matched = matched_dn.bv_val;
1231                         send_search_reference( op, rs );
1232
1233                         ber_bvarray_free( rs->sr_ref );
1234                         rs->sr_ref = NULL;
1235                         ber_memfree( matched_dn.bv_val );
1236                         rs->sr_matched = NULL;
1237
1238                         continue;
1239                 }
1240
1241                 /*
1242                  * We use this flag since we need to parse the filter
1243                  * anyway; we should have used the frontend API function
1244                  * filter_has_subordinates()
1245                  */
1246                 if ( srch_info.bsi_flags & BSQL_SF_FILTER_HASSUBORDINATE ) {
1247                         int             rc;
1248
1249                         rc = backsql_has_children( bi, dbh, &entry->e_nname );
1250
1251                         switch( rc ) {
1252                         case LDAP_COMPARE_TRUE:
1253                         case LDAP_COMPARE_FALSE:
1254                                 hasSubordinate = slap_operational_hasSubordinate( rc == LDAP_COMPARE_TRUE );
1255                                 if ( hasSubordinate != NULL ) {
1256                                         for ( a = entry->e_attrs;
1257                                                         a && a->a_next;
1258                                                         a = a->a_next );
1259
1260                                         a->a_next = hasSubordinate;
1261                                 }
1262                                 rc = 0;
1263                                 break;
1264
1265                         default:
1266                                 Debug(LDAP_DEBUG_TRACE,
1267                                         "backsql_search(): "
1268                                         "has_children failed( %d)\n",
1269                                         rc, 0, 0 );
1270                                 rc = 1;
1271                                 break;
1272                         }
1273
1274                         if ( rc ) {
1275                                 continue;
1276                         }
1277                 }
1278
1279                 if ( test_filter( op, entry, op->oq_search.rs_filter )
1280                                 == LDAP_COMPARE_TRUE ) {
1281                         if ( hasSubordinate && !( srch_info.bsi_flags & BSQL_SF_ALL_OPER )
1282                                         && !ad_inlist( slap_schema.si_ad_hasSubordinates, op->oq_search.rs_attrs ) ) {
1283                                 a->a_next = NULL;
1284                                 attr_free( hasSubordinate );
1285                                 hasSubordinate = NULL;
1286                         }
1287
1288 #if 0   /* noop is masked SLAP_CTRL_UPDATE */
1289                         if ( op->o_noop ) {
1290                                 sres = 0;
1291                         } else {
1292 #endif
1293                                 rs->sr_attrs = op->oq_search.rs_attrs;
1294                                 rs->sr_entry = entry;
1295                                 sres = send_search_entry( op, rs );
1296                                 rs->sr_entry = NULL;
1297                                 rs->sr_attrs = NULL;
1298 #if 0
1299                         }
1300 #endif
1301
1302                         switch ( sres ) {
1303                         case 0:
1304                                 break;
1305
1306                         case -1:
1307                                 Debug( LDAP_DEBUG_TRACE, "backsql_search(): "
1308                                         "connection lost\n", 0, 0, 0 );
1309                                 goto end_of_search;
1310
1311                         default:
1312                                 /*
1313                                  * FIXME: send_search_entry failed;
1314                                  * better stop
1315                                  */
1316                                 break;
1317                         }
1318                 }
1319                 entry_free( entry );
1320
1321                 if ( op->oq_search.rs_slimit != -1
1322                                 && rs->sr_nentries >= op->oq_search.rs_slimit ) {
1323                         rs->sr_err = LDAP_SIZELIMIT_EXCEEDED;
1324                         send_ldap_result( op, rs );
1325                         goto end_of_search;
1326                 }
1327         }
1328
1329 end_of_search:;
1330
1331         if ( rs->sr_nentries > 0 ) {
1332                 rs->sr_ref = rs->sr_v2ref;
1333                 rs->sr_err = (rs->sr_v2ref == NULL) ? LDAP_SUCCESS
1334                         : LDAP_REFERRAL;
1335         } else {
1336                 rs->sr_err = srch_info.status;
1337         }
1338         send_ldap_result( op, rs );
1339
1340         if ( rs->sr_v2ref ) {
1341                 ber_bvarray_free( rs->sr_v2ref );
1342                 rs->sr_v2ref = NULL;
1343         }
1344
1345 done:;
1346         ch_free( srch_info.attrs );
1347
1348         Debug( LDAP_DEBUG_TRACE, "<==backsql_search()\n", 0, 0, 0 );
1349         return 0;
1350 }
1351
1352 #endif /* SLAPD_SQL */
1353