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 static int
  27 backsql_attrlist_add( backsql_srch_info *bsi, AttributeDescription *ad )
  28 {
  29         int             n_attrs = 0;
  30         AttributeName   *an = NULL;
  31
  32         if ( bsi->attrs == NULL ) {
  33                 return 1;
  34         }
  35
  36         for ( ; bsi->attrs[ n_attrs ].an_name.bv_val; n_attrs++ ) {
  37                 an = &bsi->attrs[ n_attrs ];
  38
  39                 Debug( LDAP_DEBUG_TRACE, "==>backsql_attrlist_add(): "
  40                         "attribute '%s' is in list\n",
  41                         an->an_name.bv_val, 0, 0 );
  42                 /*
  43                  * We can live with strcmp because the attribute
  44                  * list has been normalized before calling be_search
  45                  */
  46                 if ( !BACKSQL_NCMP( &an->an_name, &ad->ad_cname ) ) {
  47                         return 1;
  48                 }
  49         }
  50
  51         Debug( LDAP_DEBUG_TRACE, "==>backsql_attrlist_add(): "
  52                 "adding '%s' to list\n", ad->ad_cname.bv_val, 0, 0 );
  53
  54         an = (AttributeName *)ch_realloc( bsi->attrs,
  55                         sizeof( AttributeName ) * ( n_attrs + 2 ) );
  56         if ( an == NULL ) {
  57                 return -1;
  58         }
  59
  60         an[ n_attrs ].an_name = ad->ad_cname;
  61         an[ n_attrs ].an_desc = ad;
  62         an[ n_attrs + 1 ].an_name.bv_val = NULL;
  63         an[ n_attrs + 1 ].an_name.bv_len = 0;
  64
  65         bsi->attrs = an;
  66
  67         return 1;
  68 }
  69
  70 void
  71 backsql_init_search(
  72         backsql_srch_info       *bsi,
  73         backsql_info            *bi,
  74         struct berval           *nbase,
  75         int                     scope,
  76         int                     slimit,
  77         int                     tlimit,
  78         time_t                  stoptime,
  79         Filter                  *filter,
  80         SQLHDBC                 dbh,
  81         BackendDB               *be,
  82         Connection              *conn,
  83         Operation               *op,
  84         AttributeName           *attrs )
  85 {
  86         AttributeName           *p;
  87
  88         bsi->base_dn = nbase;
  89         bsi->scope = scope;
  90         bsi->slimit = slimit;
  91         bsi->tlimit = tlimit;
  92         bsi->filter = filter;
  93         bsi->dbh = dbh;
  94         bsi->be = be;
  95         bsi->conn = conn;
  96         bsi->op = op;
  97         bsi->attr_flags = 0;
  98
  99         /*
 100          * FIXME: need to discover how to deal with 1.1 (NoAttrs)
 101          */
 102
 103         /*
 104          * handle "*"
 105          */
 106         if ( attrs == NULL || an_find( attrs, &AllUser ) ) {
 107                 bsi->attrs = NULL;
 108
 109         } else {
 110                 bsi->attrs = (AttributeName *)ch_calloc( 1,
 111                                 sizeof( AttributeName ) );
 112                 bsi->attrs[ 0 ].an_name.bv_val = NULL;
 113                 bsi->attrs[ 0 ].an_name.bv_len = 0;
 114
 115                 for ( p = attrs; p->an_name.bv_val; p++ ) {
 116                         /*
 117                          * ignore "+"
 118                          */
 119                         if ( BACKSQL_NCMP( &p->an_name, &AllOper ) == 0 ) {
 120                                 continue;
 121
 122                         } else if ( BACKSQL_NCMP( &p->an_name, &NoAttrs ) == 0 ) {
 123                                 bsi->attr_flags |= BSQL_SF_ALL_OPER;
 124                                 continue;
 125                         }
 126
 127                         backsql_attrlist_add( bsi, p->an_desc );
 128                 }
 129         }
 130
 131         bsi->abandon = 0;
 132         bsi->id_list = NULL;
 133         bsi->n_candidates = 0;
 134         bsi->stoptime = stoptime;
 135         bsi->bi = bi;
 136         bsi->sel.bv_val = NULL;
 137         bsi->sel.bv_len = 0;
 138         bsi->sel_len = 0;
 139         bsi->from.bv_val = NULL;
 140         bsi->from.bv_len = 0;
 141         bsi->from_len = 0;
 142         bsi->join_where.bv_val = NULL;
 143         bsi->join_where.bv_len = 0;
 144         bsi->jwhere_len = 0;
 145         bsi->flt_where.bv_val = NULL;
 146         bsi->flt_where.bv_len = 0;
 147         bsi->fwhere_len = 0;
 148
 149         bsi->status = LDAP_SUCCESS;
 150 }
 151
 152 int
 153 backsql_process_filter_list( backsql_srch_info *bsi, Filter *f, int op )
 154 {
 155         int             res;
 156
 157         if ( !f ) {
 158                 return 0;
 159         }
 160
 161         backsql_strfcat( &bsi->flt_where, &bsi->fwhere_len, "c", '(' /* ) */  );
 162
 163         while ( 1 ) {
 164                 res = backsql_process_filter( bsi, f );
 165                 if ( res < 0 ) {
 166                         /*
 167                          * TimesTen : If the query has no answers,
 168                          * don't bother to run the query.
 169                          */
 170                         return -1;
 171                 }
 172
 173                 f = f->f_next;
 174                 if ( f == NULL ) {
 175                         break;
 176                 }
 177
 178                 switch ( op ) {
 179                 case LDAP_FILTER_AND:
 180                         backsql_strfcat( &bsi->flt_where, &bsi->fwhere_len, "l",
 181                                         (ber_len_t)sizeof( " AND " ) - 1,
 182                                                 " AND " );
 183                         break;
 184
 185                 case LDAP_FILTER_OR:
 186                         backsql_strfcat( &bsi->flt_where, &bsi->fwhere_len, "l",
 187                                         (ber_len_t)sizeof( " OR " ) - 1,
 188                                                 " OR " );
 189                         break;
 190                 }
 191         }
 192
 193         backsql_strfcat( &bsi->flt_where, &bsi->fwhere_len, "c", /* ( */ ')' );
 194
 195         return 1;
 196 }
 197
 198 int
 199 backsql_process_sub_filter( backsql_srch_info *bsi, Filter *f )
 200 {
 201         int                     i;
 202         backsql_at_map_rec      *at;
 203
 204         if ( !f ) {
 205                 return 0;
 206         }
 207
 208         at = backsql_ad2at( bsi->oc, f->f_sub_desc );
 209
 210         assert( at );
 211
 212         /*
 213          * When dealing with case-sensitive strings
 214          * we may omit normalization; however, normalized
 215          * SQL filters are more liberal.
 216          */
 217
 218         backsql_strfcat( &bsi->flt_where, &bsi->fwhere_len, "c", '(' /* ) */  );
 219
 220         /* TimesTen */
 221         Debug( LDAP_DEBUG_TRACE, "expr: '%s' '%s'\n", at->sel_expr.bv_val,
 222                 at->sel_expr_u.bv_val ? at->sel_expr_u.bv_val : "<NULL>", 0 );
 223         if ( bsi->bi->upper_func.bv_val ) {
 224                 /*
 225                  * If a pre-upper-cased version of the column exists, use it
 226                  */
 227                 if ( at->sel_expr_u.bv_val ) {
 228                         backsql_strfcat( &bsi->flt_where, &bsi->fwhere_len,
 229                                         "bl",
 230                                         &at->sel_expr_u,
 231                                         (ber_len_t)sizeof( " LIKE '" ) - 1,
 232                                                 " LIKE '" );
 233                 } else {
 234                         backsql_strfcat( &bsi->flt_where, &bsi->fwhere_len,
 235                                         "bcbcl",
 236                                         &bsi->bi->upper_func,
 237                                         '(',
 238                                         &at->sel_expr,
 239                                         ')',
 240                                         (ber_len_t)sizeof( " LIKE '" ) - 1,
 241                                                 " LIKE '" );
 242                 }
 243         } else {
 244                 backsql_strfcat( &bsi->flt_where, &bsi->fwhere_len, "bl",
 245                                 &at->sel_expr,
 246                                 (ber_len_t)sizeof( " LIKE '" ) - 1, " LIKE '" );
 247         }
 248
 249         if ( f->f_sub_initial.bv_val != NULL ) {
 250                 size_t  start;
 251
 252                 start = bsi->flt_where.bv_len;
 253                 backsql_strfcat( &bsi->flt_where, &bsi->fwhere_len, "b",
 254                                 &f->f_sub_initial );
 255                 if ( bsi->bi->upper_func.bv_val ) {
 256                         ldap_pvt_str2upper( &bsi->flt_where.bv_val[ start ] );
 257                 }
 258         }
 259
 260         backsql_strfcat( &bsi->flt_where, &bsi->fwhere_len, "c", '%' );
 261
 262         if ( f->f_sub_any != NULL ) {
 263                 for ( i = 0; f->f_sub_any[ i ].bv_val != NULL; i++ ) {
 264                         size_t  start;
 265
 266 #ifdef BACKSQL_TRACE
 267                         Debug( LDAP_DEBUG_TRACE,
 268                                 "==>backsql_process_sub_filter(): "
 269                                 "sub_any='%s'\n", f->f_sub_any[ i ].bv_val,
 270                                 0, 0 );
 271 #endif /* BACKSQL_TRACE */
 272
 273                         start = bsi->flt_where.bv_len;
 274                         backsql_strfcat( &bsi->flt_where, &bsi->fwhere_len,
 275                                         "bc",
 276                                         &f->f_sub_any[ i ],
 277                                         '%' );
 278                         if ( bsi->bi->upper_func.bv_val ) {
 279                                 /*
 280                                  * Note: toupper('%') = '%'
 281                                  */
 282                                 ldap_pvt_str2upper( &bsi->flt_where.bv_val[ start ] );
 283                         }
 284                 }
 285
 286                 if ( f->f_sub_final.bv_val != NULL ) {
 287                         size_t  start;
 288
 289                         start = bsi->flt_where.bv_len;
 290                         backsql_strfcat( &bsi->flt_where, &bsi->fwhere_len, "b",
 291                                         &f->f_sub_final );
 292                         if ( bsi->bi->upper_func.bv_val ) {
 293                                 ldap_pvt_str2upper( &bsi->flt_where.bv_val[ start ] );
 294                         }
 295                 }
 296         }
 297
 298         backsql_strfcat( &bsi->flt_where, &bsi->fwhere_len, "l",
 299                         (ber_len_t)sizeof( /* (' */ "')" ) - 1, /* ( */ "')" );
 300
 301         return 1;
 302 }
 303
 304 int
 305 backsql_process_filter( backsql_srch_info *bsi, Filter *f )
 306 {
 307         backsql_at_map_rec      *at;
 308         backsql_at_map_rec      oc_attr = {
 309                 slap_schema.si_ad_objectClass, BER_BVC(""), BER_BVC(""),
 310                 { 0, NULL }, NULL, NULL, NULL };
 311         AttributeDescription    *ad = NULL;
 312         int                     done = 0;
 313         ber_len_t               len = 0;
 314         /* TimesTen */
 315         int                     rc = 0;
 316
 317         Debug( LDAP_DEBUG_TRACE, "==>backsql_process_filter()\n", 0, 0, 0 );
 318         if ( f == NULL || f->f_choice == SLAPD_FILTER_COMPUTED ) {
 319                 return 0;
 320         }
 321
 322         switch( f->f_choice ) {
 323         case LDAP_FILTER_OR:
 324                 rc = backsql_process_filter_list( bsi, f->f_or,
 325                                 LDAP_FILTER_OR );
 326                 done = 1;
 327                 break;
 328
 329         case LDAP_FILTER_AND:
 330                 rc = backsql_process_filter_list( bsi, f->f_and,
 331                                 LDAP_FILTER_AND);
 332                 done = 1;
 333                 break;
 334
 335         case LDAP_FILTER_NOT:
 336                 backsql_strfcat( &bsi->flt_where, &bsi->fwhere_len, "l",
 337                                 (ber_len_t)sizeof( "NOT (" /* ) */ ) - 1,
 338                                         "NOT (" /* ) */ );
 339                 rc = backsql_process_filter( bsi, f->f_not );
 340                 backsql_strfcat( &bsi->flt_where, &bsi->fwhere_len, "c",
 341                                 /* ( */ ')' );
 342                 done = 1;
 343                 break;
 344
 345         case LDAP_FILTER_PRESENT:
 346                 ad = f->f_desc;
 347                 break;
 348
 349         default:
 350                 ad = f->f_av_desc;
 351                 break;
 352         }
 353
 354         if ( rc == -1 ) {
 355                 /* TimesTen : Don't run the query */
 356                 goto impossible;
 357         }
 358
 359         if ( done ) {
 360                 goto done;
 361         }
 362
 363         if ( ad != slap_schema.si_ad_objectClass ) {
 364                 at = backsql_ad2at( bsi->oc, ad );
 365
 366         } else {
 367                 at = &oc_attr;
 368                 backsql_strfcat( &at->sel_expr, &len, "cbc",
 369                                 '\'',
 370                                 &bsi->oc->name,
 371                                 '\'' );
 372         }
 373
 374         if ( at == NULL ) {
 375                 Debug( LDAP_DEBUG_TRACE, "backsql_process_filter(): "
 376                         "attribute '%s' is not defined for objectclass '%s'\n",
 377                         ad->ad_cname.bv_val, bsi->oc->name.bv_val, 0 );
 378                 backsql_strfcat( &bsi->flt_where, &bsi->fwhere_len, "l",
 379                                 (ber_len_t)sizeof( " 1=0 " ) - 1, " 1=0 " );
 380                 goto impossible;
 381         }
 382
 383         backsql_merge_from_clause( &bsi->from, &bsi->from_len,
 384                         &at->from_tbls );
 385         /*
 386          * need to add this attribute to list of attrs to load,
 387          * so that we could do test_filter() later
 388          */
 389         backsql_attrlist_add( bsi, ad );
 390
 391         if ( at->join_where.bv_val != NULL
 392                         && strstr( bsi->join_where.bv_val, at->join_where.bv_val ) == NULL ) {
 393                 backsql_strfcat( &bsi->join_where, &bsi->jwhere_len, "lb",
 394                                 (ber_len_t)sizeof( " AND " ) - 1, " AND ",
 395                                 &at->join_where );
 396         }
 397
 398 #if 0
 399         /*
 400          * FIXME: this is not required any more; however, note that
 401          * attribute name syntax might collide with SQL legal aliases
 402          */
 403         if ( at != &oc_attr ) {
 404                 backsql_strfcat( &bsi->sel, &bsi->sel_len, "cblb",
 405                                 ',',
 406                                 &at->sel_expr,
 407                                 (ber_len_t)sizeof( " AS " ) - 1, " AS ",
 408                                 &at->name );
 409         }
 410 #endif
 411
 412         switch ( f->f_choice ) {
 413         case LDAP_FILTER_EQUALITY:
 414                 /*
 415                  * maybe we should check type of at->sel_expr here somehow,
 416                  * to know whether upper_func is applicable, but for now
 417                  * upper_func stuff is made for Oracle, where UPPER is
 418                  * safely applicable to NUMBER etc.
 419                  */
 420                 if ( bsi->bi->upper_func.bv_val ) {
 421                         size_t  start;
 422
 423                         if ( at->sel_expr_u.bv_val ) {
 424                                 backsql_strfcat( &bsi->flt_where,
 425                                                 &bsi->fwhere_len, "cbl",
 426                                                 '(',
 427                                                 &at->sel_expr_u,
 428                                                 (ber_len_t)sizeof( "='" ) - 1,
 429                                                         "='" );
 430                         } else {
 431                                 backsql_strfcat( &bsi->flt_where,
 432                                                 &bsi->fwhere_len, "cbcbl",
 433                                                 '(' /* ) */ ,
 434                                                 &bsi->bi->upper_func,
 435                                                 '(' /* ) */ ,
 436                                                 &at->sel_expr,
 437                                                 (ber_len_t)sizeof( /* ( */ ")='" ) - 1,
 438                                                         /* ( */ ")='" );
 439                         }
 440
 441                         start = bsi->flt_where.bv_len;
 442
 443                         backsql_strfcat( &bsi->flt_where, &bsi->fwhere_len,
 444                                         "bl",
 445                                         &f->f_av_value,
 446                                         (ber_len_t)sizeof( /* (' */ "')" ) - 1,
 447                                                 /* (' */ "')" );
 448
 449                         ldap_pvt_str2upper( &bsi->flt_where.bv_val[ start ] );
 450
 451                 } else {
 452                         backsql_strfcat( &bsi->flt_where, &bsi->fwhere_len,
 453                                         "cblbl",
 454                                         '(',
 455                                         &at->sel_expr,
 456                                         (ber_len_t)sizeof( "='" ) - 1, "='",
 457                                         &f->f_av_value,
 458                                         (ber_len_t)sizeof( /* (' */ "')" ) - 1,
 459                                                 /* (' */ "')" );
 460                 }
 461                 break;
 462
 463         case LDAP_FILTER_GE:
 464                 backsql_strfcat( &bsi->flt_where, &bsi->fwhere_len, "cblbc",
 465                                 '(' /* ) */ ,
 466                                 &at->sel_expr,
 467                                 (ber_len_t)sizeof( ">=" ) - 1, ">=",
 468                                 &f->f_av_value,
 469                                 /* ( */ ')' );
 470                 break;
 471
 472         case LDAP_FILTER_LE:
 473                 backsql_strfcat( &bsi->flt_where, &bsi->fwhere_len, "cblbc",
 474                                 '(' /* ) */ ,
 475                                 &at->sel_expr,
 476                                 (ber_len_t)sizeof( "<=" ) - 1, "<=",
 477                                 &f->f_av_value,
 478                                 /* ( */ ')' );
 479                 break;
 480
 481         case LDAP_FILTER_PRESENT:
 482                 backsql_strfcat( &bsi->flt_where, &bsi->fwhere_len, "lbl",
 483                                 (ber_len_t)sizeof( "NOT (" ) - 1, "NOT (",
 484                                 &at->sel_expr,
 485                                 (ber_len_t)sizeof( " IS NULL)" ) - 1, " IS NULL)" );
 486                 break;
 487
 488         case LDAP_FILTER_SUBSTRINGS:
 489                 backsql_process_sub_filter( bsi, f );
 490                 break;
 491         }
 492
 493 done:
 494         if ( oc_attr.sel_expr.bv_val != NULL ) {
 495                 free( oc_attr.sel_expr.bv_val );
 496         }
 497
 498         Debug( LDAP_DEBUG_TRACE, "<==backsql_process_filter()\n", 0, 0, 0 );
 499         return 1;
 500
 501 impossible:
 502         if ( oc_attr.sel_expr.bv_val != NULL ) {
 503                 free( oc_attr.sel_expr.bv_val );
 504         }
 505         Debug( LDAP_DEBUG_TRACE, "<==backsql_process_filter() returns -1\n",
 506                         0, 0, 0 );
 507         return -1;
 508 }
 509
 510 static int
 511 backsql_srch_query( backsql_srch_info *bsi, struct berval *query )
 512 {
 513         backsql_info    *bi = (backsql_info *)bsi->be->be_private;
 514         ber_len_t       q_len = 0;
 515         int             rc;
 516
 517         assert( query );
 518         query->bv_val = NULL;
 519         query->bv_len = 0;
 520
 521         Debug( LDAP_DEBUG_TRACE, "==>backsql_srch_query()\n", 0, 0, 0 );
 522         bsi->sel.bv_val = NULL;
 523         bsi->sel.bv_len = 0;
 524         bsi->sel_len = 0;
 525         bsi->from.bv_val = NULL;
 526         bsi->from.bv_len = 0;
 527         bsi->from_len = 0;
 528         bsi->join_where.bv_val = NULL;
 529         bsi->join_where.bv_len = 0;
 530         bsi->jwhere_len = 0;
 531         bsi->flt_where.bv_val = NULL;
 532         bsi->flt_where.bv_len = 0;
 533         bsi->fwhere_len = 0;
 534
 535 #if 0
 536         /*
 537          * FIXME: this query has been split in case a string cast function
 538          * is defined; more sophisticated (pattern based) function should
 539          * be used
 540          */
 541         backsql_strcat( &bsi->sel, &bsi->sel_len,
 542                         "SELECT DISTINCT ldap_entries.id,",
 543                         bsi->oc->keytbl.bv_val, ".", bsi->oc->keycol.bv_val,
 544                         ",'", bsi->oc->name.bv_val, "' AS objectClass",
 545                         ",ldap_entries.dn AS dn", NULL );
 546 #endif
 547
 548         backsql_strfcat( &bsi->sel, &bsi->sel_len, "lbcbc",
 549                         (ber_len_t)sizeof( "SELECT DISTINCT ldap_entries.id," ) - 1,
 550                                 "SELECT DISTINCT ldap_entries.id,",
 551                         &bsi->oc->keytbl,
 552                         '.',
 553                         &bsi->oc->keycol,
 554                         ',' );
 555
 556         if ( bi->strcast_func.bv_val ) {
 557                 backsql_strfcat( &bsi->sel, &bsi->sel_len, "blbl",
 558                                 &bi->strcast_func,
 559                                 (ber_len_t)sizeof( "('" /* ') */ ) - 1,
 560                                         "('" /* ') */ ,
 561                                 &bsi->oc->name,
 562                                 (ber_len_t)sizeof( /* (' */ "')" ) - 1,
 563                                         /* (' */ "')" );
 564         } else {
 565                 backsql_strfcat( &bsi->sel, &bsi->sel_len, "cbc",
 566                                 '\'',
 567                                 &bsi->oc->name,
 568                                 '\'' );
 569         }
 570         backsql_strfcat( &bsi->sel, &bsi->sel_len, "l",
 571                         (ber_len_t)sizeof( " AS objectClass,ldap_entries.dn AS dn" ) - 1,
 572                         " AS objectClass,ldap_entries.dn AS dn" );
 573
 574         backsql_strfcat( &bsi->from, &bsi->from_len, "lb",
 575                         (ber_len_t)sizeof( " FROM ldap_entries," ) - 1,
 576                                 " FROM ldap_entries,",
 577                         &bsi->oc->keytbl );
 578
 579         backsql_strfcat( &bsi->join_where, &bsi->jwhere_len, "lbcbl",
 580                         (ber_len_t)sizeof( " WHERE " ) - 1, " WHERE ",
 581                         &bsi->oc->keytbl,
 582                         '.',
 583                         &bsi->oc->keycol,
 584                         (ber_len_t)sizeof( "=ldap_entries.keyval AND ldap_entries.oc_map_id=? AND " ) - 1,
 585                                 "=ldap_entries.keyval AND ldap_entries.oc_map_id=? AND " );
 586
 587         switch ( bsi->scope ) {
 588         case LDAP_SCOPE_BASE:
 589                 if ( bsi->bi->upper_func.bv_val ) {
 590                         backsql_strfcat( &bsi->join_where, &bsi->jwhere_len,
 591                                         "blbcb",
 592                                         &bsi->bi->upper_func,
 593                                         (ber_len_t)sizeof( "(ldap_entries.dn)=" ) - 1,
 594                                                 "(ldap_entries.dn)=",
 595                                         &bsi->bi->upper_func_open,
 596                                         '?',
 597                                         &bsi->bi->upper_func_close );
 598                 } else {
 599                         backsql_strfcat( &bsi->join_where, &bsi->jwhere_len,
 600                                         "l",
 601                                         (ber_len_t)sizeof( "ldap_entries.dn=?" ) - 1,
 602                                                 "ldap_entries.dn=?" );
 603                 }
 604                 break;
 605
 606         case LDAP_SCOPE_ONELEVEL:
 607                 backsql_strfcat( &bsi->join_where, &bsi->jwhere_len, "l",
 608                                 (ber_len_t)sizeof( "ldap_entries.parent=?" ) - 1,
 609                                         "ldap_entries.parent=?" );
 610                 break;
 611
 612         case LDAP_SCOPE_SUBTREE:
 613                 backsql_strfcat( &bsi->join_where, &bsi->jwhere_len, "b",
 614                                 &bsi->bi->subtree_cond );
 615                 break;
 616
 617         default:
 618                 assert( 0 );
 619         }
 620
 621         rc = backsql_process_filter( bsi, bsi->filter );
 622         if ( rc > 0 ) {
 623                 backsql_strfcat( query, &q_len, "bbblb",
 624                                 &bsi->sel,
 625                                 &bsi->from,
 626                                 &bsi->join_where,
 627                                 (ber_len_t)sizeof( " AND " ) - 1, " AND ",
 628                                 &bsi->flt_where );
 629
 630         } else if ( rc < 0 ) {
 631                 /*
 632                  * Indicates that there's no possible way the filter matches
 633                  * anything.  No need to issue the query
 634                  */
 635                 Debug( LDAP_DEBUG_TRACE,
 636                         "<==backsql_srch_query() returns NULL\n", 0, 0, 0 );
 637                 free( query->bv_val );
 638                 query->bv_val = NULL;
 639         }
 640
 641         free( bsi->sel.bv_val );
 642         bsi->sel.bv_len = 0;
 643         bsi->sel_len = 0;
 644         free( bsi->from.bv_val );
 645         bsi->from.bv_len = 0;
 646         bsi->from_len = 0;
 647         free( bsi->join_where.bv_val );
 648         bsi->join_where.bv_len = 0;
 649         bsi->jwhere_len = 0;
 650         free( bsi->flt_where.bv_val );
 651         bsi->flt_where.bv_len = 0;
 652         bsi->fwhere_len = 0;
 653
 654         Debug( LDAP_DEBUG_TRACE, "<==backsql_srch_query()\n", 0, 0, 0 );
 655
 656         return ( query->bv_val == NULL ? 1 : 0 );
 657 }
 658
 659 int
 660 backsql_oc_get_candidates( backsql_oc_map_rec *oc, backsql_srch_info *bsi )
 661 {
 662         struct berval           query;
 663         SQLHSTMT                sth;
 664         RETCODE                 rc;
 665         backsql_entryID         base_id, *c_id;
 666         int                     res;
 667         BACKSQL_ROW_NTS         row;
 668         int                     i;
 669         int                     j;
 670
 671         Debug(  LDAP_DEBUG_TRACE, "==>backsql_oc_get_candidates(): oc='%s'\n",
 672                         oc->name.bv_val, 0, 0 );
 673
 674         if ( bsi->n_candidates == -1 ) {
 675                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
 676                         "unchecked limit has been overcome\n", 0, 0, 0 );
 677                 return 1;
 678         }
 679
 680         bsi->oc = oc;
 681         if ( backsql_srch_query( bsi, &query ) ) {
 682                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
 683                         "could not construct query for objectclass\n",
 684                         0, 0, 0 );
 685                 return 1;
 686         }
 687
 688         Debug( LDAP_DEBUG_TRACE, "Constructed query: %s\n",
 689                         query.bv_val, 0, 0 );
 690
 691         rc = backsql_Prepare( bsi->dbh, &sth, query.bv_val, 0 );
 692         free( query.bv_val );
 693         if ( rc != SQL_SUCCESS ) {
 694                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
 695                         "error preparing query\n", 0, 0, 0 );
 696                 backsql_PrintErrors( bsi->bi->db_env, bsi->dbh, sth, rc );
 697                 return 1;
 698         }
 699
 700         if ( backsql_BindParamID( sth, 1, &bsi->oc->id ) != SQL_SUCCESS ) {
 701                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
 702                         "error binding objectclass id parameter\n", 0, 0, 0 );
 703                 return 1;
 704         }
 705
 706         switch ( bsi->scope ) {
 707         case LDAP_SCOPE_BASE:
 708                 rc = backsql_BindParamStr( sth, 2, bsi->base_dn->bv_val,
 709                                 BACKSQL_MAX_DN_LEN );
 710                 if ( rc != SQL_SUCCESS ) {
 711                         Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
 712                                 "error binding base_dn parameter\n", 0, 0, 0 );
 713                         backsql_PrintErrors( bsi->bi->db_env, bsi->dbh,
 714                                         sth, rc );
 715                         return 1;
 716                 }
 717                 break;
 718
 719         case LDAP_SCOPE_SUBTREE: {
 720
 721                 /*
 722                  * + 1 because we need room for '%'; this makes a subtree
 723                  * search for a DN BACKSQL_MAX_DN_LEN long legal
 724                  * if it returns that DN only
 725                  */
 726                 char            temp_base_dn[ BACKSQL_MAX_DN_LEN + 1 + 1 ];
 727
 728                 /*
 729                  * We do not accept DNs longer than BACKSQL_MAX_DN_LEN;
 730                  * however this should be handled earlier
 731                  */
 732                 assert( bsi->base_dn->bv_len <= BACKSQL_MAX_DN_LEN );
 733
 734                 /*
 735                  * Sets the parameters for the SQL built earlier
 736                  * NOTE that all the databases could actually use
 737                  * the TimesTen version, which would be cleaner
 738                  * and would also eliminate the need for the
 739                  * subtree_cond line in the configuration file.
 740                  * For now, I'm leaving it the way it is,
 741                  * so non-TimesTen databases use the original code.
 742                  * But at some point this should get cleaned up.
 743                  *
 744                  * If "dn" is being used, do a suffix search.
 745                  * If "dn_ru" is being used, do a prefix search.
 746                  */
 747                 if ( BACKSQL_HAS_LDAPINFO_DN_RU( bsi->bi ) ) {
 748                         temp_base_dn[ 0 ] = '\0';
 749                         for ( i = 0, j = bsi->base_dn->bv_len - 1;
 750                                         j >= 0; i++, j--) {
 751                                 temp_base_dn[ i ] = bsi->base_dn->bv_val[ j ];
 752                         }
 753                         temp_base_dn[ i ] = '%';
 754                         temp_base_dn[ i + 1 ] = '\0';
 755                         ldap_pvt_str2upper( temp_base_dn );
 756
 757                 } else {
 758                         temp_base_dn[ 0 ] = '%';
 759                         AC_MEMCPY( &temp_base_dn[ 1 ], bsi->base_dn->bv_val,
 760                                 bsi->base_dn->bv_len + 1 );
 761                         ldap_pvt_str2upper( &temp_base_dn[ 1 ] );
 762                 }
 763
 764                 Debug( LDAP_DEBUG_TRACE, "dn '%s'\n", temp_base_dn, 0, 0 );
 765
 766                 rc = backsql_BindParamStr( sth, 2, temp_base_dn,
 767                                 BACKSQL_MAX_DN_LEN );
 768                 if ( rc != SQL_SUCCESS ) {
 769                         Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
 770                                 "error binding base_dn parameter (2)\n",
 771                                 0, 0, 0 );
 772                         backsql_PrintErrors( bsi->bi->db_env, bsi->dbh,
 773                                         sth, rc );
 774                         return 1;
 775                 }
 776                 break;
 777         }
 778
 779         case LDAP_SCOPE_ONELEVEL:
 780                 res = backsql_dn2id( bsi->bi, &base_id,
 781                                 bsi->dbh, bsi->base_dn );
 782                 if ( res != LDAP_SUCCESS ) {
 783                         Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
 784                                 "could not retrieve base_dn id%s\n",
 785                                 res == LDAP_NO_SUCH_OBJECT ? ": no such entry"
 786                                 : "", 0, 0 );
 787                         bsi->status = res;
 788                         return 0;
 789                 }
 790
 791                 rc = backsql_BindParamID( sth, 2, &base_id.id );
 792                 backsql_free_entryID( &base_id, 0 );
 793                 if ( rc != SQL_SUCCESS ) {
 794                         Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
 795                                 "error binding base id parameter\n", 0, 0, 0 );
 796                         return 1;
 797                 }
 798                 break;
 799         }
 800
 801         rc = SQLExecute( sth );
 802         if ( !BACKSQL_SUCCESS( rc ) ) {
 803                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
 804                         "error executing query\n", 0, 0, 0 );
 805                 backsql_PrintErrors( bsi->bi->db_env, bsi->dbh, sth, rc );
 806                 SQLFreeStmt( sth, SQL_DROP );
 807                 return 1;
 808         }
 809
 810         backsql_BindRowAsStrings( sth, &row );
 811         rc = SQLFetch( sth );
 812         for ( ; BACKSQL_SUCCESS( rc ); rc = SQLFetch( sth ) ) {
 813                 c_id = (backsql_entryID *)ch_calloc( 1,
 814                                 sizeof( backsql_entryID ) );
 815                 c_id->id = strtol( row.cols[ 0 ], NULL, 0 );
 816                 c_id->keyval = strtol( row.cols[ 1 ], NULL, 0 );
 817                 c_id->oc_id = bsi->oc->id;
 818                 ber_str2bv( row.cols[ 3 ], 0, 1, &c_id->dn );
 819                 c_id->next = bsi->id_list;
 820                 bsi->id_list = c_id;
 821                 bsi->n_candidates--;
 822
 823                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
 824                         "added entry id=%ld, keyval=%ld dn='%s'\n",
 825                         c_id->id, c_id->keyval, row.cols[ 3 ] );
 826
 827                 if ( bsi->n_candidates == -1 ) {
 828                         break;
 829                 }
 830         }
 831         backsql_FreeRow( &row );
 832         SQLFreeStmt( sth, SQL_DROP );
 833
 834         Debug( LDAP_DEBUG_TRACE, "<==backsql_oc_get_candidates()\n", 0, 0, 0 );
 835
 836         return 1;
 837 }
 838
 839 int
 840 backsql_search(
 841         BackendDB       *be,
 842         Connection      *conn,
 843         Operation       *op,
 844         struct berval   *base,
 845         struct berval   *nbase,
 846         int             scope,
 847         int             deref,
 848         int             slimit,
 849         int             tlimit,
 850         Filter          *filter,
 851         struct berval   *filterstr,
 852         AttributeName   *attrs,
 853         int             attrsonly )
 854 {
 855         backsql_info            *bi = (backsql_info *)be->be_private;
 856         SQLHDBC                 dbh;
 857         int                     sres;
 858         int                     nentries;
 859         Entry                   *entry, *res;
 860         int                     manageDSAit = get_manageDSAit( op );
 861         BerVarray               v2refs = NULL;
 862         time_t                  stoptime = 0;
 863         backsql_srch_info       srch_info;
 864         backsql_entryID         *eid = NULL;
 865         struct slap_limits_set  *limit = NULL;
 866         int                     isroot = 0;
 867
 868         Debug( LDAP_DEBUG_TRACE, "==>backsql_search(): "
 869                 "base='%s', filter='%s', scope=%d,",
 870                 nbase->bv_val, filterstr->bv_val, scope );
 871         Debug( LDAP_DEBUG_TRACE, " deref=%d, attrsonly=%d, "
 872                 "attributes to load: %s\n",
 873                 deref, attrsonly, attrs == NULL ? "all" : "custom list" );
 874
 875         if ( nbase->bv_len > BACKSQL_MAX_DN_LEN ) {
 876                 Debug( LDAP_DEBUG_TRACE, "backsql_search(): "
 877                         "search base length (%ld) exceeds max length (%ld)\n",
 878                         nbase->bv_len, BACKSQL_MAX_DN_LEN, 0 );
 879                 /*
 880                  * FIXME: a LDAP_NO_SUCH_OBJECT could be appropriate
 881                  * since it is impossible that such a long DN exists
 882                  * in the backend
 883                  */
 884                 send_ldap_result( conn, op, LDAP_ADMINLIMIT_EXCEEDED,
 885                                 "", NULL, NULL, NULL );
 886                 return 1;
 887         }
 888
 889         sres = backsql_get_db_conn( be, conn, &dbh );
 890         if ( sres != LDAP_SUCCESS ) {
 891                 Debug( LDAP_DEBUG_TRACE, "backsql_search(): "
 892                         "could not get connection handle - exiting\n",
 893                         0, 0, 0 );
 894                 send_ldap_result( conn, op, sres, "",
 895                                 sres == LDAP_OTHER ?  "SQL-backend error" : "",
 896                                 NULL, NULL );
 897                 return 1;
 898         }
 899
 900         /* TimesTen : Pass it along to the lower level routines */
 901         srch_info.use_reverse_dn = BACKSQL_USE_REVERSE_DN( bi );
 902
 903         /* if not root, get appropriate limits */
 904         if ( be_isroot( be, &op->o_ndn ) ) {
 905                 isroot = 1;
 906         } else {
 907                 ( void ) get_limits( be, &op->o_ndn, &limit );
 908         }
 909
 910         /* The time/size limits come first because they require very little
 911          * effort, so there's no chance the candidates are selected and then
 912          * the request is not honored only because of time/size constraints */
 913
 914         /* if no time limit requested, use soft limit (unless root!) */
 915         if ( isroot ) {
 916                 if ( tlimit == 0 ) {
 917                         tlimit = -1;    /* allow root to set no limit */
 918                 }
 919
 920                 if ( slimit == 0 ) {
 921                         slimit = -1;
 922                 }
 923
 924         } else {
 925                 /* if no limit is required, use soft limit */
 926                 if ( tlimit <= 0 ) {
 927                         tlimit = limit->lms_t_soft;
 928
 929                 /* if requested limit higher than hard limit, abort */
 930                 } else if ( tlimit > limit->lms_t_hard ) {
 931                         /* no hard limit means use soft instead */
 932                         if ( limit->lms_t_hard == 0 && tlimit > limit->lms_t_soft ) {
 933                                 tlimit = limit->lms_t_soft;
 934
 935                         /* positive hard limit means abort */
 936                         } else if ( limit->lms_t_hard > 0 ) {
 937                                 send_search_result( conn, op,
 938                                                 LDAP_UNWILLING_TO_PERFORM,
 939                                                 NULL, NULL, NULL, NULL, 0 );
 940                                 return 0;
 941                         }
 942
 943                         /* negative hard limit means no limit */
 944                 }
 945
 946                 /* if no limit is required, use soft limit */
 947                 if ( slimit <= 0 ) {
 948                         slimit = limit->lms_s_soft;
 949
 950                 /* if requested limit higher than hard limit, abort */
 951                 } else if ( slimit > limit->lms_s_hard ) {
 952                         /* no hard limit means use soft instead */
 953                         if ( limit->lms_s_hard == 0 && slimit > limit->lms_s_soft ) {
 954                                 slimit = limit->lms_s_soft;
 955
 956                         /* positive hard limit means abort */
 957                         } else if ( limit->lms_s_hard > 0 ) {
 958                                 send_search_result( conn, op,
 959                                                 LDAP_UNWILLING_TO_PERFORM,
 960                                                 NULL, NULL, NULL, NULL, 0 );
 961                                 return 0;
 962                         }
 963
 964                         /* negative hard limit means no limit */
 965                 }
 966         }
 967
 968         /* compute it anyway; root does not use it */
 969         stoptime = op->o_time + tlimit;
 970
 971         backsql_init_search( &srch_info, bi, nbase, scope,
 972                         slimit, tlimit, stoptime, filter, dbh,
 973                         be, conn, op, attrs );
 974
 975         /*
 976          * for each objectclass we try to construct query which gets IDs
 977          * of entries matching LDAP query filter and scope (or at least
 978          * candidates), and get the IDs
 979          */
 980         srch_info.n_candidates = ( isroot ? -2 : limit->lms_s_unchecked == -1
 981                         ? -2 : limit->lms_s_unchecked );
 982         avl_apply( bi->oc_by_oc, (AVL_APPLY)backsql_oc_get_candidates,
 983                         &srch_info, 0, AVL_INORDER );
 984         if ( !isroot && limit->lms_s_unchecked != -1 ) {
 985                 if ( srch_info.n_candidates == -1 ) {
 986                         send_search_result( conn, op,
 987                                         LDAP_ADMINLIMIT_EXCEEDED,
 988                                         NULL, NULL, NULL, NULL, 0 );
 989                         goto done;
 990                 }
 991         }
 992
 993         nentries = 0;
 994         /*
 995          * now we load candidate entries (only those attributes
 996          * mentioned in attrs and filter), test it against full filter
 997          * and then send to client
 998          */
 999         for ( eid = srch_info.id_list; eid != NULL;
1000                         eid = backsql_free_entryID( eid, 1 ) ) {
1001
1002                 /* check for abandon */
1003                 if ( op->o_abandon ) {
1004                         break;
1005                 }
1006
1007                 /* check time limit */
1008                 if ( tlimit != -1 && slap_get_time() > stoptime ) {
1009                         send_search_result( conn, op, LDAP_TIMELIMIT_EXCEEDED,
1010                                 NULL, NULL, v2refs, NULL, nentries );
1011                         goto end_of_search;
1012                 }
1013
1014                 Debug(LDAP_DEBUG_TRACE, "backsql_search(): loading data "
1015                         "for entry id=%ld, oc_id=%ld, keyval=%ld\n",
1016                         eid->id, eid->oc_id, eid->keyval );
1017
1018                 entry = (Entry *)ch_calloc( sizeof( Entry ), 1 );
1019                 res = backsql_id2entry( &srch_info, entry, eid );
1020                 if ( res == NULL ) {
1021                         Debug( LDAP_DEBUG_TRACE, "backsql_search(): "
1022                                 "error in backsql_id2entry() "
1023                                 "- skipping entry\n", 0, 0, 0 );
1024                         continue;
1025                 }
1026
1027                 if ( !manageDSAit && scope != LDAP_SCOPE_BASE &&
1028                         is_entry_referral( entry ) ) {
1029                         BerVarray refs = get_entry_referrals( be, conn,
1030                                         op, entry );
1031
1032                         send_search_reference( be, conn, op, entry, refs,
1033                                         NULL, &v2refs );
1034                         ber_bvarray_free( refs );
1035                         continue;
1036                 }
1037
1038                 if ( test_filter( be, conn, op, entry, filter )
1039                                 == LDAP_COMPARE_TRUE ) {
1040                         sres = send_search_entry( be, conn, op, entry,
1041                                         attrs, attrsonly, NULL );
1042                         switch ( sres ) {
1043                         case 0:
1044                                 nentries++;
1045                                 break;
1046
1047                         case -1:
1048                                 Debug( LDAP_DEBUG_TRACE, "backsql_search(): "
1049                                         "connection lost\n", 0, 0, 0 );
1050                                 goto end_of_search;
1051
1052                         default:
1053                                 /*
1054                                  * FIXME: send_search_entry failed;
1055                                  * better stop
1056                                  */
1057                                 break;
1058                         }
1059                 }
1060                 entry_free( entry );
1061
1062                 if ( slimit != -1 && nentries >= slimit ) {
1063                         send_search_result( conn, op, LDAP_SIZELIMIT_EXCEEDED,
1064                                 NULL, NULL, v2refs, NULL, nentries );
1065                         goto end_of_search;
1066                 }
1067         }
1068
1069 end_of_search:;
1070
1071         if ( nentries > 0 ) {
1072                 send_search_result( conn, op,
1073                         v2refs == NULL ? LDAP_SUCCESS : LDAP_REFERRAL,
1074                         NULL, NULL, v2refs, NULL, nentries );
1075         } else {
1076                 send_ldap_result( conn, op, srch_info.status,
1077                                 NULL, NULL, NULL, 0 );
1078         }
1079
1080 done:;
1081         ch_free( srch_info.attrs );
1082
1083         Debug( LDAP_DEBUG_TRACE, "<==backsql_search()\n", 0, 0, 0 );
1084         return 0;
1085 }
1086
1087 #endif /* SLAPD_SQL */
1088