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