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