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

   1 /* $OpenLDAP$ */
   2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   3  *
   4  * Copyright 1999-2005 The OpenLDAP Foundation.
   5  * Portions Copyright 1999 Dmitry Kovalev.
   6  * Portions Copyright 2004 Mark Adamson.
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted only as authorized by the OpenLDAP
  11  * Public License.
  12  *
  13  * A copy of this license is available in the file LICENSE in the
  14  * top-level directory of the distribution or, alternatively, at
  15  * <http://www.OpenLDAP.org/license.html>.
  16  */
  17 /* ACKNOWLEDGEMENTS:
  18  * This work was initially developed by Dmitry Kovalev for inclusion
  19  * by OpenLDAP Software.
  20  */
  21
  22 #include "portable.h"
  23
  24 #include <stdio.h>
  25 #include <sys/types.h>
  26 #include "ac/string.h"
  27 #include "ac/ctype.h"
  28
  29 #include "slap.h"
  30 #include "proto-sql.h"
  31
  32 static int backsql_process_filter( backsql_srch_info *bsi, Filter *f );
  33 static int backsql_process_filter_eq( backsql_srch_info *bsi,
  34                 backsql_at_map_rec *at,
  35                 int casefold, struct berval *filter_value );
  36 static int backsql_process_filter_like( backsql_srch_info *bsi,
  37                 backsql_at_map_rec *at,
  38                 int casefold, struct berval *filter_value );
  39 static int backsql_process_filter_attr( backsql_srch_info *bsi, Filter *f,
  40                 backsql_at_map_rec *at );
  41
  42 static int
  43 backsql_attrlist_add( backsql_srch_info *bsi, AttributeDescription *ad )
  44 {
  45         int             n_attrs = 0;
  46         AttributeName   *an = NULL;
  47
  48         if ( bsi->bsi_attrs == NULL ) {
  49                 return 1;
  50         }
  51
  52         /*
  53          * clear the list (retrieve all attrs)
  54          */
  55         if ( ad == NULL ) {
  56                 ch_free( bsi->bsi_attrs );
  57                 bsi->bsi_attrs = NULL;
  58                 bsi->bsi_flags |= BSQL_SF_ALL_ATTRS;
  59                 return 1;
  60         }
  61
  62         for ( ; !BER_BVISNULL( &bsi->bsi_attrs[ n_attrs ].an_name ); n_attrs++ ) {
  63                 an = &bsi->bsi_attrs[ n_attrs ];
  64
  65                 Debug( LDAP_DEBUG_TRACE, "==>backsql_attrlist_add(): "
  66                         "attribute \"%s\" is in list\n",
  67                         an->an_name.bv_val, 0, 0 );
  68                 /*
  69                  * We can live with strcmp because the attribute
  70                  * list has been normalized before calling be_search
  71                  */
  72                 if ( !BACKSQL_NCMP( &an->an_name, &ad->ad_cname ) ) {
  73                         return 1;
  74                 }
  75         }
  76
  77         Debug( LDAP_DEBUG_TRACE, "==>backsql_attrlist_add(): "
  78                 "adding \"%s\" to list\n", ad->ad_cname.bv_val, 0, 0 );
  79
  80         an = (AttributeName *)ch_realloc( bsi->bsi_attrs,
  81                         sizeof( AttributeName ) * ( n_attrs + 2 ) );
  82         if ( an == NULL ) {
  83                 return -1;
  84         }
  85
  86         an[ n_attrs ].an_name = ad->ad_cname;
  87         an[ n_attrs ].an_desc = ad;
  88         BER_BVZERO( &an[ n_attrs + 1 ].an_name );
  89
  90         bsi->bsi_attrs = an;
  91
  92         return 1;
  93 }
  94
  95 /*
  96  * Initializes the search structure.
  97  *
  98  * If get_base_id != 0, the field bsi_base_id is filled
  99  * with the entryID of bsi_base_ndn; it must be freed
 100  * by backsql_free_entryID() when no longer required.
 101  *
 102  * NOTE: base must be normalized
 103  */
 104 int
 105 backsql_init_search(
 106         backsql_srch_info       *bsi,
 107         struct berval           *nbase,
 108         int                     scope,
 109         int                     slimit,
 110         int                     tlimit,
 111         time_t                  stoptime,
 112         Filter                  *filter,
 113         SQLHDBC                 dbh,
 114         Operation               *op,
 115         SlapReply               *rs,
 116         AttributeName           *attrs,
 117         unsigned                flags )
 118 {
 119         AttributeName           *p;
 120         int                     rc = LDAP_SUCCESS;
 121
 122         bsi->bsi_base_ndn = nbase;
 123         bsi->bsi_use_subtree_shortcut = 0;
 124         BER_BVZERO( &bsi->bsi_base_id.eid_dn );
 125         BER_BVZERO( &bsi->bsi_base_id.eid_ndn );
 126         bsi->bsi_scope = scope;
 127         bsi->bsi_slimit = slimit;
 128         bsi->bsi_tlimit = tlimit;
 129         bsi->bsi_filter = filter;
 130         bsi->bsi_dbh = dbh;
 131         bsi->bsi_op = op;
 132         bsi->bsi_rs = rs;
 133         bsi->bsi_flags = BSQL_SF_NONE;
 134
 135         /*
 136          * handle "*"
 137          */
 138         if ( attrs == NULL ) {
 139                 /* also add request for all operational */
 140                 bsi->bsi_attrs = NULL;
 141                 bsi->bsi_flags |= BSQL_SF_ALL_USER;
 142
 143         } else {
 144                 int     got_oc = 0;
 145
 146                 bsi->bsi_attrs = (AttributeName *)ch_calloc( 1,
 147                                 sizeof( AttributeName ) );
 148                 BER_BVZERO( &bsi->bsi_attrs[ 0 ].an_name );
 149
 150                 for ( p = attrs; !BER_BVISNULL( &p->an_name ); p++ ) {
 151                         /*
 152                          * ignore "1.1"; handle "+"
 153                          */
 154                         if ( BACKSQL_NCMP( &p->an_name, &AllUser ) == 0 ) {
 155                                 bsi->bsi_flags |= BSQL_SF_ALL_USER;
 156                                 continue;
 157
 158                         } else if ( BACKSQL_NCMP( &p->an_name, &AllOper ) == 0 ) {
 159                                 bsi->bsi_flags |= BSQL_SF_ALL_OPER;
 160                                 continue;
 161
 162                         } else if ( BACKSQL_NCMP( &p->an_name, &NoAttrs ) == 0 ) {
 163                                 continue;
 164
 165                         } else if ( p->an_desc == slap_schema.si_ad_objectClass ) {
 166                                 got_oc = 1;
 167                         }
 168
 169                         backsql_attrlist_add( bsi, p->an_desc );
 170                 }
 171
 172                 if ( got_oc == 0 ) {
 173                         /* add objectClass if not present,
 174                          * because it is required to understand
 175                          * if an entry is a referral, an alias
 176                          * or so... */
 177                         backsql_attrlist_add( bsi, slap_schema.si_ad_objectClass );
 178                 }
 179         }
 180
 181         bsi->bsi_abandon = 0;
 182         bsi->bsi_id_list = NULL;
 183         bsi->bsi_id_listtail = &bsi->bsi_id_list;
 184         bsi->bsi_n_candidates = 0;
 185         bsi->bsi_stoptime = stoptime;
 186         BER_BVZERO( &bsi->bsi_sel.bb_val );
 187         bsi->bsi_sel.bb_len = 0;
 188         BER_BVZERO( &bsi->bsi_from.bb_val );
 189         bsi->bsi_from.bb_len = 0;
 190         BER_BVZERO( &bsi->bsi_join_where.bb_val );
 191         bsi->bsi_join_where.bb_len = 0;
 192         BER_BVZERO( &bsi->bsi_flt_where.bb_val );
 193         bsi->bsi_flt_where.bb_len = 0;
 194         bsi->bsi_filter_oc = NULL;
 195
 196         if ( flags & BACKSQL_ISF_GET_ID ) {
 197                 assert( op->o_bd->be_private );
 198
 199                 rc = backsql_dn2id( op, rs, &bsi->bsi_base_id, dbh, nbase, 1 );
 200         }
 201
 202         return ( bsi->bsi_status = rc );
 203 }
 204
 205 static int
 206 backsql_process_filter_list( backsql_srch_info *bsi, Filter *f, int op )
 207 {
 208         int             res;
 209
 210         if ( !f ) {
 211                 return 0;
 212         }
 213
 214         backsql_strfcat( &bsi->bsi_flt_where, "c", '(' /* ) */  );
 215
 216         while ( 1 ) {
 217                 res = backsql_process_filter( bsi, f );
 218                 if ( res < 0 ) {
 219                         /*
 220                          * TimesTen : If the query has no answers,
 221                          * don't bother to run the query.
 222                          */
 223                         return -1;
 224                 }
 225
 226                 f = f->f_next;
 227                 if ( f == NULL ) {
 228                         break;
 229                 }
 230
 231                 switch ( op ) {
 232                 case LDAP_FILTER_AND:
 233                         backsql_strfcat( &bsi->bsi_flt_where, "l",
 234                                         (ber_len_t)STRLENOF( " AND " ),
 235                                                 " AND " );
 236                         break;
 237
 238                 case LDAP_FILTER_OR:
 239                         backsql_strfcat( &bsi->bsi_flt_where, "l",
 240                                         (ber_len_t)STRLENOF( " OR " ),
 241                                                 " OR " );
 242                         break;
 243                 }
 244         }
 245
 246         backsql_strfcat( &bsi->bsi_flt_where, "c", /* ( */ ')' );
 247
 248         return 1;
 249 }
 250
 251 static int
 252 backsql_process_sub_filter( backsql_srch_info *bsi, Filter *f,
 253         backsql_at_map_rec *at )
 254 {
 255         backsql_info            *bi = (backsql_info *)bsi->bsi_op->o_bd->be_private;
 256         int                     i;
 257         int                     casefold = 0;
 258
 259         if ( !f ) {
 260                 return 0;
 261         }
 262
 263         /* always uppercase strings by now */
 264 #ifdef BACKSQL_UPPERCASE_FILTER
 265         if ( f->f_sub_desc->ad_type->sat_substr &&
 266                         SLAP_MR_ASSOCIATED( f->f_sub_desc->ad_type->sat_substr,
 267                                 bi->sql_caseIgnoreMatch ) )
 268 #endif /* BACKSQL_UPPERCASE_FILTER */
 269         {
 270                 casefold = 1;
 271         }
 272
 273         if ( f->f_sub_desc->ad_type->sat_substr &&
 274                         SLAP_MR_ASSOCIATED( f->f_sub_desc->ad_type->sat_substr,
 275                                 bi->sql_telephoneNumberMatch ) )
 276         {
 277
 278                 struct berval   bv;
 279                 ber_len_t       i, s, a;
 280
 281                 /*
 282                  * to check for matching telephone numbers
 283                  * with intermixed chars, e.g. val='1234'
 284                  * use
 285                  *
 286                  * val LIKE '%1%2%3%4%'
 287                  */
 288
 289                 BER_BVZERO( &bv );
 290                 if ( f->f_sub_initial.bv_val ) {
 291                         bv.bv_len += f->f_sub_initial.bv_len;
 292                 }
 293                 if ( f->f_sub_any != NULL ) {
 294                         for ( a = 0; f->f_sub_any[ a ].bv_val != NULL; a++ ) {
 295                                 bv.bv_len += f->f_sub_any[ a ].bv_len;
 296                         }
 297                 }
 298                 if ( f->f_sub_final.bv_val ) {
 299                         bv.bv_len += f->f_sub_final.bv_len;
 300                 }
 301                 bv.bv_len = 2 * bv.bv_len - 1;
 302                 bv.bv_val = ch_malloc( bv.bv_len + 1 );
 303
 304                 s = 0;
 305                 if ( !BER_BVISNULL( &f->f_sub_initial ) ) {
 306                         bv.bv_val[ s ] = f->f_sub_initial.bv_val[ 0 ];
 307                         for ( i = 1; i < f->f_sub_initial.bv_len; i++ ) {
 308                                 bv.bv_val[ s + 2 * i - 1 ] = '%';
 309                                 bv.bv_val[ s + 2 * i ] = f->f_sub_initial.bv_val[ i ];
 310                         }
 311                         bv.bv_val[ s + 2 * i - 1 ] = '%';
 312                         s += 2 * i;
 313                 }
 314
 315                 if ( f->f_sub_any != NULL ) {
 316                         for ( a = 0; !BER_BVISNULL( &f->f_sub_any[ a ] ); a++ ) {
 317                                 bv.bv_val[ s ] = f->f_sub_any[ a ].bv_val[ 0 ];
 318                                 for ( i = 1; i < f->f_sub_any[ a ].bv_len; i++ ) {
 319                                         bv.bv_val[ s + 2 * i - 1 ] = '%';
 320                                         bv.bv_val[ s + 2 * i ] = f->f_sub_any[ a ].bv_val[ i ];
 321                                 }
 322                                 bv.bv_val[ s + 2 * i - 1 ] = '%';
 323                                 s += 2 * i;
 324                         }
 325                 }
 326
 327                 if ( !BER_BVISNULL( &f->f_sub_final ) ) {
 328                         bv.bv_val[ s ] = f->f_sub_final.bv_val[ 0 ];
 329                         for ( i = 1; i < f->f_sub_final.bv_len; i++ ) {
 330                                 bv.bv_val[ s + 2 * i - 1 ] = '%';
 331                                 bv.bv_val[ s + 2 * i ] = f->f_sub_final.bv_val[ i ];
 332                         }
 333                                 bv.bv_val[ s + 2 * i - 1 ] = '%';
 334                         s += 2 * i;
 335                 }
 336
 337                 bv.bv_val[ s - 1 ] = '\0';
 338
 339                 (void)backsql_process_filter_like( bsi, at, casefold, &bv );
 340                 ch_free( bv.bv_val );
 341
 342                 return 1;
 343         }
 344
 345         /*
 346          * When dealing with case-sensitive strings
 347          * we may omit normalization; however, normalized
 348          * SQL filters are more liberal.
 349          */
 350
 351         backsql_strfcat( &bsi->bsi_flt_where, "c", '(' /* ) */  );
 352
 353         /* TimesTen */
 354         Debug( LDAP_DEBUG_TRACE, "backsql_process_sub_filter(%s):\n",
 355                 at->bam_ad->ad_cname.bv_val, 0, 0 );
 356         Debug(LDAP_DEBUG_TRACE, "   expr: '%s%s%s'\n", at->bam_sel_expr.bv_val,
 357                 at->bam_sel_expr_u.bv_val ? "' '" : "",
 358                 at->bam_sel_expr_u.bv_val ? at->bam_sel_expr_u.bv_val : "" );
 359         if ( casefold && BACKSQL_AT_CANUPPERCASE( at ) ) {
 360                 /*
 361                  * If a pre-upper-cased version of the column
 362                  * or a precompiled upper function exists, use it
 363                  */
 364                 backsql_strfcat( &bsi->bsi_flt_where,
 365                                 "bl",
 366                                 &at->bam_sel_expr_u,
 367                                 (ber_len_t)STRLENOF( " LIKE '" ),
 368                                         " LIKE '" );
 369
 370         } else {
 371                 backsql_strfcat( &bsi->bsi_flt_where, "bl",
 372                                 &at->bam_sel_expr,
 373                                 (ber_len_t)STRLENOF( " LIKE '" ), " LIKE '" );
 374         }
 375
 376         if ( !BER_BVISNULL( &f->f_sub_initial ) ) {
 377                 ber_len_t       start;
 378
 379 #ifdef BACKSQL_TRACE
 380                 Debug( LDAP_DEBUG_TRACE,
 381                         "==>backsql_process_sub_filter(%s): "
 382                         "sub_initial=\"%s\"\n", at->bam_ad->ad_cname.bv_val,
 383                         f->f_sub_initial.bv_val, 0 );
 384 #endif /* BACKSQL_TRACE */
 385
 386                 start = bsi->bsi_flt_where.bb_val.bv_len;
 387                 backsql_strfcat( &bsi->bsi_flt_where, "b",
 388                                 &f->f_sub_initial );
 389                 if ( casefold && BACKSQL_AT_CANUPPERCASE( at ) ) {
 390                         ldap_pvt_str2upper( &bsi->bsi_flt_where.bb_val.bv_val[ start ] );
 391                 }
 392         }
 393
 394         backsql_strfcat( &bsi->bsi_flt_where, "c", '%' );
 395
 396         if ( f->f_sub_any != NULL ) {
 397                 for ( i = 0; !BER_BVISNULL( &f->f_sub_any[ i ] ); i++ ) {
 398                         ber_len_t       start;
 399
 400 #ifdef BACKSQL_TRACE
 401                         Debug( LDAP_DEBUG_TRACE,
 402                                 "==>backsql_process_sub_filter(%s): "
 403                                 "sub_any[%d]=\"%s\"\n", at->bam_ad->ad_cname.bv_val,
 404                                 i, f->f_sub_any[ i ].bv_val );
 405 #endif /* BACKSQL_TRACE */
 406
 407                         start = bsi->bsi_flt_where.bb_val.bv_len;
 408                         backsql_strfcat( &bsi->bsi_flt_where,
 409                                         "bc",
 410                                         &f->f_sub_any[ i ],
 411                                         '%' );
 412                         if ( casefold && BACKSQL_AT_CANUPPERCASE( at ) ) {
 413                                 /*
 414                                  * Note: toupper('%') = '%'
 415                                  */
 416                                 ldap_pvt_str2upper( &bsi->bsi_flt_where.bb_val.bv_val[ start ] );
 417                         }
 418                 }
 419         }
 420
 421         if ( !BER_BVISNULL( &f->f_sub_final ) ) {
 422                 ber_len_t       start;
 423
 424 #ifdef BACKSQL_TRACE
 425                 Debug( LDAP_DEBUG_TRACE,
 426                         "==>backsql_process_sub_filter(%s): "
 427                         "sub_final=\"%s\"\n", at->bam_ad->ad_cname.bv_val,
 428                         f->f_sub_final.bv_val, 0 );
 429 #endif /* BACKSQL_TRACE */
 430
 431                 start = bsi->bsi_flt_where.bb_val.bv_len;
 432                 backsql_strfcat( &bsi->bsi_flt_where, "b",
 433                                 &f->f_sub_final );
 434                 if ( casefold && BACKSQL_AT_CANUPPERCASE( at ) ) {
 435                         ldap_pvt_str2upper( &bsi->bsi_flt_where.bb_val.bv_val[ start ] );
 436                 }
 437         }
 438
 439         backsql_strfcat( &bsi->bsi_flt_where, "l",
 440                         (ber_len_t)STRLENOF( /* (' */ "')" ), /* (' */ "')" );
 441
 442         return 1;
 443 }
 444
 445 static int
 446 backsql_merge_from_tbls( backsql_srch_info *bsi, struct berval *from_tbls )
 447 {
 448         if ( BER_BVISNULL( from_tbls ) ) {
 449                 return LDAP_SUCCESS;
 450         }
 451
 452         if ( !BER_BVISNULL( &bsi->bsi_from.bb_val ) ) {
 453                 char    *start, *end, *tmp;
 454
 455                 tmp = ch_strdup( from_tbls->bv_val );
 456
 457                 for ( start = tmp, end = strchr( start, ',' ); start; ) {
 458                         if ( end ) {
 459                                 end[0] = '\0';
 460                         }
 461
 462                         if ( strstr( bsi->bsi_from.bb_val.bv_val, start) == NULL )
 463                         {
 464                                 backsql_strfcat( &bsi->bsi_from, "cs", ',', start );
 465                         }
 466
 467                         if ( end ) {
 468                                 /* in case there are spaces after the comma... */
 469                                 for ( start = &end[1]; isspace( start[0] ); start++ );
 470                                 if ( start[0] ) {
 471                                         end = strchr( start, ',' );
 472                                 } else {
 473                                         start = NULL;
 474                                 }
 475                         } else {
 476                                 start = NULL;
 477                         }
 478                 }
 479
 480                 ch_free( tmp );
 481
 482         } else {
 483                 backsql_strfcat( &bsi->bsi_from, "b", from_tbls );
 484         }
 485
 486         return LDAP_SUCCESS;
 487 }
 488
 489 static int
 490 backsql_process_filter( backsql_srch_info *bsi, Filter *f )
 491 {
 492         backsql_at_map_rec      **vat = NULL;
 493         AttributeDescription    *ad = NULL;
 494         unsigned                i;
 495         int                     done = 0;
 496         int                     rc = 0;
 497
 498         Debug( LDAP_DEBUG_TRACE, "==>backsql_process_filter()\n", 0, 0, 0 );
 499         if ( f->f_choice == SLAPD_FILTER_COMPUTED ) {
 500                 Debug( LDAP_DEBUG_TRACE, "backsql_process_filter(): "
 501                         "invalid filter\n", 0, 0, 0 );
 502                 rc = -1;
 503                 goto done;
 504         }
 505
 506         switch( f->f_choice ) {
 507         case LDAP_FILTER_OR:
 508                 rc = backsql_process_filter_list( bsi, f->f_or,
 509                                 LDAP_FILTER_OR );
 510                 done = 1;
 511                 break;
 512
 513         case LDAP_FILTER_AND:
 514                 rc = backsql_process_filter_list( bsi, f->f_and,
 515                                 LDAP_FILTER_AND );
 516                 done = 1;
 517                 break;
 518
 519         case LDAP_FILTER_NOT:
 520                 backsql_strfcat( &bsi->bsi_flt_where, "l",
 521                                 (ber_len_t)STRLENOF( "NOT (" /* ) */ ),
 522                                         "NOT (" /* ) */ );
 523                 rc = backsql_process_filter( bsi, f->f_not );
 524                 backsql_strfcat( &bsi->bsi_flt_where, "c", /* ( */ ')' );
 525                 done = 1;
 526                 break;
 527
 528         case LDAP_FILTER_PRESENT:
 529                 ad = f->f_desc;
 530                 break;
 531
 532         case LDAP_FILTER_EXT:
 533                 ad = f->f_mra->ma_desc;
 534                 if ( f->f_mr_dnattrs ) {
 535                         /*
 536                          * if dn attrs filtering is requested, better return
 537                          * success and let test_filter() deal with candidate
 538                          * selection; otherwise we'd need to set conditions
 539                          * on the contents of the DN, e.g. "SELECT ... FROM
 540                          * ldap_entries AS attributeName WHERE attributeName.dn
 541                          * like '%attributeName=value%'"
 542                          */
 543                         backsql_strfcat( &bsi->bsi_flt_where, "l",
 544                                         (ber_len_t)STRLENOF( "1=1" ), "1=1" );
 545                         bsi->bsi_status = LDAP_SUCCESS;
 546                         rc = 1;
 547                         goto done;
 548                 }
 549                 break;
 550
 551         default:
 552                 ad = f->f_av_desc;
 553                 break;
 554         }
 555
 556         if ( rc == -1 ) {
 557                 goto done;
 558         }
 559
 560         if ( done ) {
 561                 rc = 1;
 562                 goto done;
 563         }
 564
 565         /*
 566          * Turn structuralObjectClass into objectClass
 567          */
 568         if ( ad == slap_schema.si_ad_objectClass
 569                         || ad == slap_schema.si_ad_structuralObjectClass )
 570         {
 571                 /*
 572                  * If the filter is LDAP_FILTER_PRESENT, then it's done;
 573                  * otherwise, let's see if we are lucky: filtering
 574                  * for "structural" objectclass or ancestor...
 575                  */
 576                 switch ( f->f_choice ) {
 577                 case LDAP_FILTER_EQUALITY:
 578                 {
 579                         ObjectClass     *oc = oc_bvfind( &f->f_av_value );
 580
 581                         if ( oc == NULL ) {
 582                                 Debug( LDAP_DEBUG_TRACE,
 583                                                 "backsql_process_filter(): "
 584                                                 "unknown objectClass \"%s\" "
 585                                                 "in filter\n",
 586                                                 f->f_av_value.bv_val, 0, 0 );
 587                                 bsi->bsi_status = LDAP_OTHER;
 588                                 rc = -1;
 589                                 goto done;
 590                         }
 591
 592                         /*
 593                          * "structural" objectClass inheritance:
 594                          * - a search for "person" will also return
 595                          *   "inetOrgPerson"
 596                          * - a search for "top" will return everything
 597                          */
 598                         if ( is_object_subclass( oc, bsi->bsi_oc->bom_oc ) ) {
 599                                 static struct berval ldap_entry_objclasses = BER_BVC( "ldap_entry_objclasses" );
 600
 601                                 backsql_merge_from_tbls( bsi, &ldap_entry_objclasses );
 602
 603                                 backsql_strfcat( &bsi->bsi_flt_where, "lbl",
 604                                                 (ber_len_t)STRLENOF( "2=2 OR (ldap_entries.id=ldap_entry_objclasses.entry_id AND ldap_entry_objclasses.oc_name='" /* ') */ ),
 605                                                         "2=2 OR (ldap_entries.id=ldap_entry_objclasses.entry_id AND ldap_entry_objclasses.oc_name='" /* ') */,
 606                                                 &bsi->bsi_oc->bom_oc->soc_cname,
 607                                                 (ber_len_t)STRLENOF( /* (' */ "')" ),
 608                                                         /* (' */ "')" );
 609                                 bsi->bsi_status = LDAP_SUCCESS;
 610                                 rc = 1;
 611                                 goto done;
 612                         }
 613
 614                         break;
 615                 }
 616
 617                 case LDAP_FILTER_PRESENT:
 618                         backsql_strfcat( &bsi->bsi_flt_where, "l",
 619                                         (ber_len_t)STRLENOF( "3=3" ), "3=3" );
 620                         bsi->bsi_status = LDAP_SUCCESS;
 621                         rc = 1;
 622                         goto done;
 623
 624                         /* FIXME: LDAP_FILTER_EXT? */
 625
 626                 default:
 627                         Debug( LDAP_DEBUG_TRACE,
 628                                         "backsql_process_filter(): "
 629                                         "illegal/unhandled filter "
 630                                         "on objectClass attribute",
 631                                         0, 0, 0 );
 632                         bsi->bsi_status = LDAP_OTHER;
 633                         rc = -1;
 634                         goto done;
 635                 }
 636
 637         } else if ( ad == slap_schema.si_ad_entryUUID ) {
 638                 unsigned long   oc_id;
 639 #ifdef BACKSQL_ARBITRARY_KEY
 640                 struct berval   keyval;
 641 #else /* ! BACKSQL_ARBITRARY_KEY */
 642                 unsigned long   keyval;
 643                 char            keyvalbuf[] = "18446744073709551615";
 644 #endif /* ! BACKSQL_ARBITRARY_KEY */
 645
 646                 switch ( f->f_choice ) {
 647                 case LDAP_FILTER_EQUALITY:
 648                         backsql_entryUUID_decode( &f->f_av_value, &oc_id, &keyval );
 649
 650                         if ( oc_id != bsi->bsi_oc->bom_id ) {
 651                                 bsi->bsi_status = LDAP_SUCCESS;
 652                                 rc = -1;
 653                                 goto done;
 654                         }
 655
 656 #ifdef BACKSQL_ARBITRARY_KEY
 657                         backsql_strfcat( &bsi->bsi_flt_where, "bcblbc",
 658                                         &bsi->bsi_oc->bom_keytbl, '.',
 659                                         &bsi->bsi_oc->bom_keycol,
 660                                         STRLENOF( " LIKE '" ), " LIKE '",
 661                                         &keyval, '\'' );
 662 #else /* ! BACKSQL_ARBITRARY_KEY */
 663                         snprintf( keyvalbuf, sizeof( keyvalbuf ), "%lu", keyval );
 664                         backsql_strfcat( &bsi->bsi_flt_where, "bcbcs",
 665                                         &bsi->bsi_oc->bom_keytbl, '.',
 666                                         &bsi->bsi_oc->bom_keycol, '=', keyvalbuf );
 667 #endif /* ! BACKSQL_ARBITRARY_KEY */
 668                         break;
 669
 670                 case LDAP_FILTER_PRESENT:
 671                         backsql_strfcat( &bsi->bsi_flt_where, "l",
 672                                         (ber_len_t)STRLENOF( "4=4" ), "4=4" );
 673                         break;
 674
 675                 default:
 676                         rc = -1;
 677                         goto done;
 678                 }
 679
 680                 bsi->bsi_flags |= BSQL_SF_FILTER_ENTRYUUID;
 681                 rc = 1;
 682                 goto done;
 683
 684 #ifdef BACKSQL_SYNCPROV
 685         } else if ( ad == slap_schema.si_ad_entryCSN ) {
 686                 /*
 687                  * TODO: introduce appropriate entryCSN filtering
 688                  * to support syncrepl as producer...
 689                  */
 690                 if ( !bsi->bsi_op->o_sync ) {
 691                         /* unsupported at present... */
 692                         bsi->bsi_status = LDAP_OTHER;
 693                         rc = -1;
 694                         goto done;
 695                 }
 696
 697                 bsi->bsi_flags |= ( BSQL_SF_FILTER_ENTRYCSN | BSQL_SF_RETURN_ENTRYUUID);
 698
 699                 /* if doing a syncrepl, try to return as much as possible,
 700                  * and always match the filter */
 701                 backsql_strfcat( &bsi->bsi_flt_where, "l",
 702                                 (ber_len_t)STRLENOF( "5=5" ), "5=5" );
 703
 704                 /* save for later use in operational attributes */
 705                 /* FIXME: saves only the first occurrence, because
 706                  * the filter during updates is written as
 707                  * "(&(entryCSN<={contextCSN})(entryCSN>={oldContextCSN})({filter}))"
 708                  * so we want our fake entryCSN to match the greatest
 709                  * value
 710                  */
 711                 if ( bsi->bsi_op->o_private == NULL ) {
 712                         bsi->bsi_op->o_private = &f->f_av_value;
 713                 }
 714                 bsi->bsi_status = LDAP_SUCCESS;
 715
 716                 rc = 1;
 717                 goto done;
 718 #endif /* BACKSQL_SYNCPROV */
 719
 720         } else if ( ad == slap_schema.si_ad_hasSubordinates || ad == NULL ) {
 721                 /*
 722                  * FIXME: this is not robust; e.g. a filter
 723                  * '(!(hasSubordinates=TRUE))' fails because
 724                  * in SQL it would read 'NOT (1=1)' instead
 725                  * of no condition.
 726                  * Note however that hasSubordinates is boolean,
 727                  * so a more appropriate filter would be
 728                  * '(hasSubordinates=FALSE)'
 729                  *
 730                  * A more robust search for hasSubordinates
 731                  * would * require joining the ldap_entries table
 732                  * selecting if there are descendants of the
 733                  * candidate.
 734                  */
 735                 backsql_strfcat( &bsi->bsi_flt_where, "l",
 736                                 (ber_len_t)STRLENOF( "6=6" ), "6=6" );
 737                 if ( ad == slap_schema.si_ad_hasSubordinates ) {
 738                         /*
 739                          * instruct candidate selection algorithm
 740                          * and attribute list to try to detect
 741                          * if an entry has subordinates
 742                          */
 743                         bsi->bsi_flags |= BSQL_SF_FILTER_HASSUBORDINATE;
 744
 745                 } else {
 746                         /*
 747                          * clear attributes to fetch, to require ALL
 748                          * and try extended match on all attributes
 749                          */
 750                         backsql_attrlist_add( bsi, NULL );
 751                 }
 752                 rc = 1;
 753                 goto done;
 754         }
 755
 756         /*
 757          * attribute inheritance:
 758          */
 759         if ( backsql_supad2at( bsi->bsi_oc, ad, &vat ) ) {
 760                 bsi->bsi_status = LDAP_OTHER;
 761                 rc = -1;
 762                 goto done;
 763         }
 764
 765         if ( vat == NULL ) {
 766                 /* search anyway; other parts of the filter
 767                  * may succeeed */
 768                 backsql_strfcat( &bsi->bsi_flt_where, "l",
 769                                 (ber_len_t)STRLENOF( "7=7" ), "7=7" );
 770                 bsi->bsi_status = LDAP_SUCCESS;
 771                 rc = 1;
 772                 goto done;
 773         }
 774
 775         /* if required, open extra level of parens */
 776         done = 0;
 777         if ( vat[0]->bam_next || vat[1] ) {
 778                 backsql_strfcat( &bsi->bsi_flt_where, "c", '(' );
 779                 done = 1;
 780         }
 781
 782         i = 0;
 783 next:;
 784         /* apply attr */
 785         if ( backsql_process_filter_attr( bsi, f, vat[i] ) == -1 ) {
 786                 return -1;
 787         }
 788
 789         /* if more definitions of the same attr, apply */
 790         if ( vat[i]->bam_next ) {
 791                 backsql_strfcat( &bsi->bsi_flt_where, "l",
 792                         STRLENOF( " OR " ), " OR " );
 793                 vat[i] = vat[i]->bam_next;
 794                 goto next;
 795         }
 796
 797         /* if more descendants of the same attr, apply */
 798         i++;
 799         if ( vat[i] ) {
 800                 backsql_strfcat( &bsi->bsi_flt_where, "l",
 801                         STRLENOF( " OR " ), " OR " );
 802                 goto next;
 803         }
 804
 805         /* if needed, close extra level of parens */
 806         if ( done ) {
 807                 backsql_strfcat( &bsi->bsi_flt_where, "c", ')' );
 808         }
 809
 810         rc = 1;
 811
 812 done:;
 813         if ( vat ) {
 814                 ch_free( vat );
 815         }
 816
 817         Debug( LDAP_DEBUG_TRACE,
 818                         "<==backsql_process_filter() %s\n",
 819                         rc == 1 ? "succeeded" : "failed", 0, 0);
 820
 821         return rc;
 822 }
 823
 824 static int
 825 backsql_process_filter_eq( backsql_srch_info *bsi, backsql_at_map_rec *at,
 826                 int casefold, struct berval *filter_value )
 827 {
 828         /*
 829          * maybe we should check type of at->sel_expr here somehow,
 830          * to know whether upper_func is applicable, but for now
 831          * upper_func stuff is made for Oracle, where UPPER is
 832          * safely applicable to NUMBER etc.
 833          */
 834         if ( casefold && BACKSQL_AT_CANUPPERCASE( at ) ) {
 835                 ber_len_t       start;
 836
 837                 backsql_strfcat( &bsi->bsi_flt_where, "cbl",
 838                                 '(', /* ) */
 839                                 &at->bam_sel_expr_u,
 840                                 (ber_len_t)STRLENOF( "='" ),
 841                                         "='" );
 842
 843                 start = bsi->bsi_flt_where.bb_val.bv_len;
 844
 845                 backsql_strfcat( &bsi->bsi_flt_where, "bl",
 846                                 filter_value,
 847                                 (ber_len_t)STRLENOF( /* (' */ "')" ),
 848                                         /* (' */ "')" );
 849
 850                 ldap_pvt_str2upper( &bsi->bsi_flt_where.bb_val.bv_val[ start ] );
 851
 852         } else {
 853                 backsql_strfcat( &bsi->bsi_flt_where, "cblbl",
 854                                 '(', /* ) */
 855                                 &at->bam_sel_expr,
 856                                 (ber_len_t)STRLENOF( "='" ), "='",
 857                                 filter_value,
 858                                 (ber_len_t)STRLENOF( /* (' */ "')" ),
 859                                         /* (' */ "')" );
 860         }
 861
 862         return 1;
 863 }
 864
 865 static int
 866 backsql_process_filter_like( backsql_srch_info *bsi, backsql_at_map_rec *at,
 867                 int casefold, struct berval *filter_value )
 868 {
 869         /*
 870          * maybe we should check type of at->sel_expr here somehow,
 871          * to know whether upper_func is applicable, but for now
 872          * upper_func stuff is made for Oracle, where UPPER is
 873          * safely applicable to NUMBER etc.
 874          */
 875         if ( casefold && BACKSQL_AT_CANUPPERCASE( at ) ) {
 876                 ber_len_t       start;
 877
 878                 backsql_strfcat( &bsi->bsi_flt_where, "cbl",
 879                                 '(', /* ) */
 880                                 &at->bam_sel_expr_u,
 881                                 (ber_len_t)STRLENOF( " LIKE '%" ),
 882                                         " LIKE '%" );
 883
 884                 start = bsi->bsi_flt_where.bb_val.bv_len;
 885
 886                 backsql_strfcat( &bsi->bsi_flt_where, "bl",
 887                                 filter_value,
 888                                 (ber_len_t)STRLENOF( /* (' */ "%')" ),
 889                                         /* (' */ "%')" );
 890
 891                 ldap_pvt_str2upper( &bsi->bsi_flt_where.bb_val.bv_val[ start ] );
 892
 893         } else {
 894                 backsql_strfcat( &bsi->bsi_flt_where, "cblbl",
 895                                 '(', /* ) */
 896                                 &at->bam_sel_expr,
 897                                 (ber_len_t)STRLENOF( " LIKE '%" ),
 898                                         " LIKE '%",
 899                                 filter_value,
 900                                 (ber_len_t)STRLENOF( /* (' */ "%')" ),
 901                                         /* (' */ "%')" );
 902         }
 903
 904         return 1;
 905 }
 906
 907 static int
 908 backsql_process_filter_attr( backsql_srch_info *bsi, Filter *f, backsql_at_map_rec *at )
 909 {
 910         backsql_info            *bi = (backsql_info *)bsi->bsi_op->o_bd->be_private;
 911         int                     casefold = 0;
 912         struct berval           *filter_value = NULL;
 913         MatchingRule            *matching_rule = NULL;
 914         struct berval           ordering = BER_BVC("<=");
 915
 916         Debug( LDAP_DEBUG_TRACE, "==>backsql_process_filter_attr(%s)\n",
 917                 at->bam_ad->ad_cname.bv_val, 0, 0 );
 918
 919         /*
 920          * need to add this attribute to list of attrs to load,
 921          * so that we can do test_filter() later
 922          */
 923         backsql_attrlist_add( bsi, at->bam_ad );
 924
 925         backsql_merge_from_tbls( bsi, &at->bam_from_tbls );
 926
 927         if ( !BER_BVISNULL( &at->bam_join_where )
 928                         && strstr( bsi->bsi_join_where.bb_val.bv_val,
 929                                 at->bam_join_where.bv_val ) == NULL )
 930         {
 931                 backsql_strfcat( &bsi->bsi_join_where, "lb",
 932                                 (ber_len_t)STRLENOF( " AND " ), " AND ",
 933                                 &at->bam_join_where );
 934         }
 935
 936         switch ( f->f_choice ) {
 937         case LDAP_FILTER_EQUALITY:
 938                 filter_value = &f->f_av_value;
 939                 matching_rule = at->bam_ad->ad_type->sat_equality;
 940
 941                 goto equality_match;
 942
 943                 /* fail over into next case */
 944
 945         case LDAP_FILTER_EXT:
 946                 filter_value = &f->f_mra->ma_value;
 947                 matching_rule = f->f_mr_rule;
 948
 949 equality_match:;
 950                 /* always uppercase strings by now */
 951 #ifdef BACKSQL_UPPERCASE_FILTER
 952                 if ( SLAP_MR_ASSOCIATED( matching_rule,
 953                                         bi->sql_caseIgnoreMatch ) )
 954 #endif /* BACKSQL_UPPERCASE_FILTER */
 955                 {
 956                         casefold = 1;
 957                 }
 958
 959                 if ( SLAP_MR_ASSOCIATED( matching_rule,
 960                                         bi->sql_telephoneNumberMatch ) )
 961                 {
 962                         struct berval   bv;
 963                         ber_len_t       i;
 964
 965                         /*
 966                          * to check for matching telephone numbers
 967                          * with intermized chars, e.g. val='1234'
 968                          * use
 969                          *
 970                          * val LIKE '%1%2%3%4%'
 971                          */
 972
 973                         bv.bv_len = 2 * filter_value->bv_len - 1;
 974                         bv.bv_val = ch_malloc( bv.bv_len + 1 );
 975
 976                         bv.bv_val[ 0 ] = filter_value->bv_val[ 0 ];
 977                         for ( i = 1; i < filter_value->bv_len; i++ ) {
 978                                 bv.bv_val[ 2 * i - 1 ] = '%';
 979                                 bv.bv_val[ 2 * i ] = filter_value->bv_val[ i ];
 980                         }
 981                         bv.bv_val[ 2 * i - 1 ] = '\0';
 982
 983                         (void)backsql_process_filter_like( bsi, at, casefold, &bv );
 984                         ch_free( bv.bv_val );
 985
 986                         break;
 987                 }
 988
 989                 /* NOTE: this is required by objectClass inheritance
 990                  * and auxiliary objectClass use in filters for slightly
 991                  * more efficient candidate selection. */
 992                 /* FIXME: a bit too many specializations to deal with
 993                  * very specific cases... */
 994                 if ( at->bam_ad == slap_schema.si_ad_objectClass
 995                                 || at->bam_ad == slap_schema.si_ad_structuralObjectClass )
 996                 {
 997                         backsql_strfcat( &bsi->bsi_flt_where, "lbl",
 998                                         (ber_len_t)STRLENOF( "(ldap_entries.id=ldap_entry_objclasses.entry_id AND ldap_entry_objclasses.oc_name='" /* ') */ ),
 999                                                 "(ldap_entries.id=ldap_entry_objclasses.entry_id AND ldap_entry_objclasses.oc_name='" /* ') */,
1000                                         filter_value,
1001                                         (ber_len_t)STRLENOF( /* (' */ "')" ),
1002                                                 /* (' */ "')" );
1003                         break;
1004                 }
1005
1006                 /*
1007                  * maybe we should check type of at->sel_expr here somehow,
1008                  * to know whether upper_func is applicable, but for now
1009                  * upper_func stuff is made for Oracle, where UPPER is
1010                  * safely applicable to NUMBER etc.
1011                  */
1012                 (void)backsql_process_filter_eq( bsi, at, casefold, filter_value );
1013                 break;
1014
1015         case LDAP_FILTER_GE:
1016                 ordering.bv_val = ">=";
1017
1018                 /* fall thru to next case */
1019
1020         case LDAP_FILTER_LE:
1021                 filter_value = &f->f_av_value;
1022
1023                 /* always uppercase strings by now */
1024 #ifdef BACKSQL_UPPERCASE_FILTER
1025                 if ( at->bam_ad->ad_type->sat_ordering &&
1026                                 SLAP_MR_ASSOCIATED( at->bam_ad->ad_type->sat_ordering,
1027                                         bi->sql_caseIgnoreMatch ) )
1028 #endif /* BACKSQL_UPPERCASE_FILTER */
1029                 {
1030                         casefold = 1;
1031                 }
1032
1033                 /*
1034                  * FIXME: should we uppercase the operands?
1035                  */
1036                 if ( casefold && BACKSQL_AT_CANUPPERCASE( at ) ) {
1037                         ber_len_t       start;
1038
1039                         backsql_strfcat( &bsi->bsi_flt_where, "cbbc",
1040                                         '(', /* ) */
1041                                         &at->bam_sel_expr_u,
1042                                         &ordering,
1043                                         '\'' );
1044
1045                         start = bsi->bsi_flt_where.bb_val.bv_len;
1046
1047                         backsql_strfcat( &bsi->bsi_flt_where, "bl",
1048                                         filter_value,
1049                                         (ber_len_t)STRLENOF( /* (' */ "')" ),
1050                                                 /* (' */ "')" );
1051
1052                         ldap_pvt_str2upper( &bsi->bsi_flt_where.bb_val.bv_val[ start ] );
1053
1054                 } else {
1055                         backsql_strfcat( &bsi->bsi_flt_where, "cbbcbl",
1056                                         '(' /* ) */ ,
1057                                         &at->bam_sel_expr,
1058                                         &ordering,
1059                                         '\'',
1060                                         &f->f_av_value,
1061                                         (ber_len_t)STRLENOF( /* (' */ "')" ),
1062                                                 /* ( */ "')" );
1063                 }
1064                 break;
1065
1066         case LDAP_FILTER_PRESENT:
1067                 backsql_strfcat( &bsi->bsi_flt_where, "lbl",
1068                                 (ber_len_t)STRLENOF( "NOT (" /* ) */),
1069                                         "NOT (", /* ) */
1070                                 &at->bam_sel_expr,
1071                                 (ber_len_t)STRLENOF( /* ( */ " IS NULL)" ),
1072                                         /* ( */ " IS NULL)" );
1073                 break;
1074
1075         case LDAP_FILTER_SUBSTRINGS:
1076                 backsql_process_sub_filter( bsi, f, at );
1077                 break;
1078
1079         case LDAP_FILTER_APPROX:
1080                 /* we do our best */
1081
1082                 /*
1083                  * maybe we should check type of at->sel_expr here somehow,
1084                  * to know whether upper_func is applicable, but for now
1085                  * upper_func stuff is made for Oracle, where UPPER is
1086                  * safely applicable to NUMBER etc.
1087                  */
1088                 (void)backsql_process_filter_like( bsi, at, 1, &f->f_av_value );
1089                 break;
1090
1091         default:
1092                 /* unhandled filter type; should not happen */
1093                 assert( 0 );
1094                 backsql_strfcat( &bsi->bsi_flt_where, "l",
1095                                 (ber_len_t)STRLENOF( "8=8" ), "8=8" );
1096                 break;
1097
1098         }
1099
1100         Debug( LDAP_DEBUG_TRACE, "<==backsql_process_filter_attr(%s)\n",
1101                 at->bam_ad->ad_cname.bv_val, 0, 0 );
1102
1103         return 1;
1104 }
1105
1106 static int
1107 backsql_srch_query( backsql_srch_info *bsi, struct berval *query )
1108 {
1109         backsql_info    *bi = (backsql_info *)bsi->bsi_op->o_bd->be_private;
1110         int             rc;
1111
1112         assert( query );
1113         BER_BVZERO( query );
1114
1115         bsi->bsi_use_subtree_shortcut = 0;
1116
1117         Debug( LDAP_DEBUG_TRACE, "==>backsql_srch_query()\n", 0, 0, 0 );
1118         BER_BVZERO( &bsi->bsi_sel.bb_val );
1119         BER_BVZERO( &bsi->bsi_sel.bb_val );
1120         bsi->bsi_sel.bb_len = 0;
1121         BER_BVZERO( &bsi->bsi_from.bb_val );
1122         bsi->bsi_from.bb_len = 0;
1123         BER_BVZERO( &bsi->bsi_join_where.bb_val );
1124         bsi->bsi_join_where.bb_len = 0;
1125         BER_BVZERO( &bsi->bsi_flt_where.bb_val );
1126         bsi->bsi_flt_where.bb_len = 0;
1127
1128         backsql_strfcat( &bsi->bsi_sel, "lbcbc",
1129                         (ber_len_t)STRLENOF( "SELECT DISTINCT ldap_entries.id," ),
1130                                 "SELECT DISTINCT ldap_entries.id,",
1131                         &bsi->bsi_oc->bom_keytbl,
1132                         '.',
1133                         &bsi->bsi_oc->bom_keycol,
1134                         ',' );
1135
1136         if ( !BER_BVISNULL( &bi->sql_strcast_func ) ) {
1137                 backsql_strfcat( &bsi->bsi_sel, "blbl",
1138                                 &bi->sql_strcast_func,
1139                                 (ber_len_t)STRLENOF( "('" /* ') */ ),
1140                                         "('" /* ') */ ,
1141                                 &bsi->bsi_oc->bom_oc->soc_cname,
1142                                 (ber_len_t)STRLENOF( /* (' */ "')" ),
1143                                         /* (' */ "')" );
1144         } else {
1145                 backsql_strfcat( &bsi->bsi_sel, "cbc",
1146                                 '\'',
1147                                 &bsi->bsi_oc->bom_oc->soc_cname,
1148                                 '\'' );
1149         }
1150 #ifdef BACKSQL_ALIASING_QUOTE
1151         backsql_strfcat( &bsi->bsi_sel, "lclcl",
1152                         (ber_len_t)STRLENOF( " " BACKSQL_ALIASING ),
1153                                 " " BACKSQL_ALIASING,
1154                         BACKSQL_ALIASING_QUOTE,
1155                         (ber_len_t)STRLENOF( "objectClass" ),
1156                                 "objectClass",
1157                         BACKSQL_ALIASING_QUOTE,
1158                         (ber_len_t)STRLENOF( ",ldap_entries.dn " BACKSQL_ALIASING "dn" ),
1159                                 ",ldap_entries.dn " BACKSQL_ALIASING "dn" );
1160 #else /* ! BACKSQL_ALIASING_QUOTE */
1161         backsql_strfcat( &bsi->bsi_sel, "l",
1162                         (ber_len_t)STRLENOF( " " BACKSQL_ALIASING "objectClass,ldap_entries.dn " BACKSQL_ALIASING "dn" ),
1163                                 " " BACKSQL_ALIASING "objectClass,ldap_entries.dn " BACKSQL_ALIASING "dn" );
1164 #endif /* ! BACKSQL_ALIASING_QUOTE */
1165
1166         backsql_strfcat( &bsi->bsi_from, "lb",
1167                         (ber_len_t)STRLENOF( " FROM ldap_entries," ),
1168                                 " FROM ldap_entries,",
1169                         &bsi->bsi_oc->bom_keytbl );
1170
1171         backsql_strfcat( &bsi->bsi_join_where, "lbcbl",
1172                         (ber_len_t)STRLENOF( " WHERE " ), " WHERE ",
1173                         &bsi->bsi_oc->bom_keytbl,
1174                         '.',
1175                         &bsi->bsi_oc->bom_keycol,
1176                         (ber_len_t)STRLENOF( "=ldap_entries.keyval AND ldap_entries.oc_map_id=? AND " ),
1177                                 "=ldap_entries.keyval AND ldap_entries.oc_map_id=? AND " );
1178
1179         switch ( bsi->bsi_scope ) {
1180         case LDAP_SCOPE_BASE:
1181                 if ( BACKSQL_CANUPPERCASE( bi ) ) {
1182                         backsql_strfcat( &bsi->bsi_join_where, "bl",
1183                                         &bi->sql_upper_func,
1184                                         (ber_len_t)STRLENOF( "(ldap_entries.dn)=?" ),
1185                                                 "(ldap_entries.dn)=?" );
1186                 } else {
1187                         backsql_strfcat( &bsi->bsi_join_where, "l",
1188                                         (ber_len_t)STRLENOF( "ldap_entries.dn=?" ),
1189                                                 "ldap_entries.dn=?" );
1190                 }
1191                 break;
1192
1193         case BACKSQL_SCOPE_BASE_LIKE:
1194                 if ( BACKSQL_CANUPPERCASE( bi ) ) {
1195                         backsql_strfcat( &bsi->bsi_join_where, "bl",
1196                                         &bi->sql_upper_func,
1197                                         (ber_len_t)STRLENOF( "(ldap_entries.dn) LIKE ?" ),
1198                                                 "(ldap_entries.dn) LIKE ?" );
1199                 } else {
1200                         backsql_strfcat( &bsi->bsi_join_where, "l",
1201                                         (ber_len_t)STRLENOF( "ldap_entries.dn LIKE ?" ),
1202                                                 "ldap_entries.dn LIKE ?" );
1203                 }
1204                 break;
1205
1206         case LDAP_SCOPE_ONELEVEL:
1207                 backsql_strfcat( &bsi->bsi_join_where, "l",
1208                                 (ber_len_t)STRLENOF( "ldap_entries.parent=?" ),
1209                                         "ldap_entries.parent=?" );
1210                 break;
1211
1212 #ifdef LDAP_SCOPE_SUBORDINATE
1213         case LDAP_SCOPE_SUBORDINATE:
1214 #endif /* LDAP_SCOPE_SUBORDINATE */
1215         case LDAP_SCOPE_SUBTREE:
1216                 if ( BACKSQL_USE_SUBTREE_SHORTCUT( bi ) ) {
1217                         int             i;
1218                         BackendDB       *bd = bsi->bsi_op->o_bd;
1219
1220                         assert( bd->be_nsuffix );
1221
1222                         for ( i = 0; !BER_BVISNULL( &bd->be_nsuffix[ i ] ); i++ )
1223                         {
1224                                 if ( dn_match( &bd->be_nsuffix[ i ],
1225                                                         bsi->bsi_base_ndn ) )
1226                                 {
1227                                         /* pass this to the candidate selection
1228                                          * routine so that the DN is not bound
1229                                          * to the select statement */
1230                                         bsi->bsi_use_subtree_shortcut = 1;
1231                                         break;
1232                                 }
1233                         }
1234                 }
1235
1236                 if ( bsi->bsi_use_subtree_shortcut ) {
1237                         /* Skip the base DN filter, as every entry will match it */
1238                         backsql_strfcat( &bsi->bsi_join_where, "l",
1239                                         (ber_len_t)STRLENOF( "9=9"), "9=9");
1240
1241                 } else if ( !BER_BVISNULL( &bi->sql_subtree_cond ) ) {
1242                         backsql_strfcat( &bsi->bsi_join_where, "b", &bi->sql_subtree_cond );
1243
1244                 } else if ( BACKSQL_CANUPPERCASE( bi ) ) {
1245                         backsql_strfcat( &bsi->bsi_join_where, "bl",
1246                                         &bi->sql_upper_func,
1247                                         (ber_len_t)STRLENOF( "(ldap_entries.dn) LIKE ?" ),
1248                                                 "(ldap_entries.dn) LIKE ?"  );
1249
1250                 } else {
1251                         backsql_strfcat( &bsi->bsi_join_where, "l",
1252                                         (ber_len_t)STRLENOF( "ldap_entries.dn LIKE ?" ),
1253                                                 "ldap_entries.dn LIKE ?" );
1254                 }
1255
1256                 break;
1257
1258         default:
1259                 assert( 0 );
1260         }
1261
1262         rc = backsql_process_filter( bsi, bsi->bsi_filter );
1263         if ( rc > 0 ) {
1264                 struct berbuf   bb = BB_NULL;
1265
1266                 backsql_strfcat( &bb, "bbblb",
1267                                 &bsi->bsi_sel.bb_val,
1268                                 &bsi->bsi_from.bb_val,
1269                                 &bsi->bsi_join_where.bb_val,
1270                                 (ber_len_t)STRLENOF( " AND " ), " AND ",
1271                                 &bsi->bsi_flt_where.bb_val );
1272
1273                 *query = bb.bb_val;
1274
1275         } else if ( rc < 0 ) {
1276                 /*
1277                  * Indicates that there's no possible way the filter matches
1278                  * anything.  No need to issue the query
1279                  */
1280                 free( query->bv_val );
1281                 BER_BVZERO( query );
1282         }
1283
1284         free( bsi->bsi_sel.bb_val.bv_val );
1285         BER_BVZERO( &bsi->bsi_sel.bb_val );
1286         bsi->bsi_sel.bb_len = 0;
1287         free( bsi->bsi_from.bb_val.bv_val );
1288         BER_BVZERO( &bsi->bsi_from.bb_val );
1289         bsi->bsi_from.bb_len = 0;
1290         free( bsi->bsi_join_where.bb_val.bv_val );
1291         BER_BVZERO( &bsi->bsi_join_where.bb_val );
1292         bsi->bsi_join_where.bb_len = 0;
1293         free( bsi->bsi_flt_where.bb_val.bv_val );
1294         BER_BVZERO( &bsi->bsi_flt_where.bb_val );
1295         bsi->bsi_flt_where.bb_len = 0;
1296
1297         Debug( LDAP_DEBUG_TRACE, "<==backsql_srch_query() returns %s\n",
1298                 query->bv_val ? query->bv_val : "NULL", 0, 0 );
1299
1300         return ( rc <= 0 ? 1 : 0 );
1301 }
1302
1303 static int
1304 backsql_oc_get_candidates( void *v_oc, void *v_bsi )
1305 {
1306         backsql_oc_map_rec      *oc = v_oc;
1307         backsql_srch_info       *bsi = v_bsi;
1308         backsql_info            *bi = (backsql_info *)bsi->bsi_op->o_bd->be_private;
1309         struct berval           query;
1310         SQLHSTMT                sth = SQL_NULL_HSTMT;
1311         RETCODE                 rc;
1312         int                     res;
1313         BACKSQL_ROW_NTS         row;
1314         int                     i;
1315         int                     j;
1316         int                     n_candidates = bsi->bsi_n_candidates;
1317
1318         /*
1319          * + 1 because we need room for '%';
1320          * + 1 because we need room for ',' for LDAP_SCOPE_SUBORDINATE;
1321          * this makes a subtree
1322          * search for a DN BACKSQL_MAX_DN_LEN long legal
1323          * if it returns that DN only
1324          */
1325         char                    tmp_base_ndn[ BACKSQL_MAX_DN_LEN + 1 + 1 ];
1326
1327         bsi->bsi_status = LDAP_SUCCESS;
1328
1329         Debug( LDAP_DEBUG_TRACE, "==>backsql_oc_get_candidates(): oc=\"%s\"\n",
1330                         BACKSQL_OC_NAME( oc ), 0, 0 );
1331
1332         if ( bsi->bsi_n_candidates == -1 ) {
1333                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
1334                         "unchecked limit has been overcome\n", 0, 0, 0 );
1335                 /* should never get here */
1336                 assert( 0 );
1337                 bsi->bsi_status = LDAP_ADMINLIMIT_EXCEEDED;
1338                 return BACKSQL_AVL_STOP;
1339         }
1340
1341         bsi->bsi_oc = oc;
1342         res = backsql_srch_query( bsi, &query );
1343         if ( res ) {
1344                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
1345                         "error while constructing query for objectclass \"%s\"\n",
1346                         oc->bom_oc->soc_cname.bv_val, 0, 0 );
1347                 /*
1348                  * FIXME: need to separate errors from legally
1349                  * impossible filters
1350                  */
1351                 switch ( bsi->bsi_status ) {
1352                 case LDAP_SUCCESS:
1353                 case LDAP_UNDEFINED_TYPE:
1354                 case LDAP_NO_SUCH_OBJECT:
1355                         /* we are conservative... */
1356                 default:
1357                         bsi->bsi_status = LDAP_SUCCESS;
1358                         /* try next */
1359                         return BACKSQL_AVL_CONTINUE;
1360
1361                 case LDAP_ADMINLIMIT_EXCEEDED:
1362                 case LDAP_OTHER:
1363                         /* don't try any more */
1364                         return BACKSQL_AVL_STOP;
1365                 }
1366         }
1367
1368         if ( BER_BVISNULL( &query ) ) {
1369                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
1370                         "could not construct query for objectclass \"%s\"\n",
1371                         oc->bom_oc->soc_cname.bv_val, 0, 0 );
1372                 bsi->bsi_status = LDAP_SUCCESS;
1373                 return BACKSQL_AVL_CONTINUE;
1374         }
1375
1376         Debug( LDAP_DEBUG_TRACE, "Constructed query: %s\n",
1377                         query.bv_val, 0, 0 );
1378
1379         rc = backsql_Prepare( bsi->bsi_dbh, &sth, query.bv_val, 0 );
1380         free( query.bv_val );
1381         BER_BVZERO( &query );
1382         if ( rc != SQL_SUCCESS ) {
1383                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
1384                         "error preparing query\n", 0, 0, 0 );
1385                 backsql_PrintErrors( bi->sql_db_env, bsi->bsi_dbh, sth, rc );
1386                 bsi->bsi_status = LDAP_OTHER;
1387                 return BACKSQL_AVL_CONTINUE;
1388         }
1389
1390         Debug( LDAP_DEBUG_TRACE, "id: '%ld'\n", bsi->bsi_oc->bom_id, 0, 0 );
1391
1392         rc = backsql_BindParamInt( sth, 1, SQL_PARAM_INPUT,
1393                         &bsi->bsi_oc->bom_id );
1394         if ( rc != SQL_SUCCESS ) {
1395                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
1396                         "error binding objectclass id parameter\n", 0, 0, 0 );
1397                 bsi->bsi_status = LDAP_OTHER;
1398                 return BACKSQL_AVL_CONTINUE;
1399         }
1400
1401         switch ( bsi->bsi_scope ) {
1402         case LDAP_SCOPE_BASE:
1403         case BACKSQL_SCOPE_BASE_LIKE:
1404                 /*
1405                  * We do not accept DNs longer than BACKSQL_MAX_DN_LEN;
1406                  * however this should be handled earlier
1407                  */
1408                 if ( bsi->bsi_base_ndn->bv_len > BACKSQL_MAX_DN_LEN ) {
1409                         bsi->bsi_status = LDAP_OTHER;
1410                         return BACKSQL_AVL_CONTINUE;
1411                 }
1412
1413                 AC_MEMCPY( tmp_base_ndn, bsi->bsi_base_ndn->bv_val,
1414                                 bsi->bsi_base_ndn->bv_len + 1 );
1415
1416                 /* uppercase DN only if the stored DN can be uppercased
1417                  * for comparison */
1418                 if ( BACKSQL_CANUPPERCASE( bi ) ) {
1419                         ldap_pvt_str2upper( tmp_base_ndn );
1420                 }
1421
1422                 Debug( LDAP_DEBUG_TRACE, "(base)dn: \"%s\"\n",
1423                                 tmp_base_ndn, 0, 0 );
1424
1425                 rc = backsql_BindParamStr( sth, 2, SQL_PARAM_INPUT,
1426                                 tmp_base_ndn, BACKSQL_MAX_DN_LEN );
1427                 if ( rc != SQL_SUCCESS ) {
1428                         Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
1429                                 "error binding base_ndn parameter\n", 0, 0, 0 );
1430                         backsql_PrintErrors( bi->sql_db_env, bsi->bsi_dbh,
1431                                         sth, rc );
1432                         bsi->bsi_status = LDAP_OTHER;
1433                         return BACKSQL_AVL_CONTINUE;
1434                 }
1435                 break;
1436
1437 #ifdef LDAP_SCOPE_SUBORDINATE
1438         case LDAP_SCOPE_SUBORDINATE:
1439 #endif /* LDAP_SCOPE_SUBORDINATE */
1440         case LDAP_SCOPE_SUBTREE:
1441         {
1442                 /* if short-cutting the search base,
1443                  * don't bind any parameter */
1444                 if ( bsi->bsi_use_subtree_shortcut ) {
1445                         break;
1446                 }
1447
1448                 /*
1449                  * We do not accept DNs longer than BACKSQL_MAX_DN_LEN;
1450                  * however this should be handled earlier
1451                  */
1452                 if ( bsi->bsi_base_ndn->bv_len > BACKSQL_MAX_DN_LEN ) {
1453                         bsi->bsi_status = LDAP_OTHER;
1454                         return BACKSQL_AVL_CONTINUE;
1455                 }
1456
1457                 /*
1458                  * Sets the parameters for the SQL built earlier
1459                  * NOTE that all the databases could actually use
1460                  * the TimesTen version, which would be cleaner
1461                  * and would also eliminate the need for the
1462                  * subtree_cond line in the configuration file.
1463                  * For now, I'm leaving it the way it is,
1464                  * so non-TimesTen databases use the original code.
1465                  * But at some point this should get cleaned up.
1466                  *
1467                  * If "dn" is being used, do a suffix search.
1468                  * If "dn_ru" is being used, do a prefix search.
1469                  */
1470                 if ( BACKSQL_HAS_LDAPINFO_DN_RU( bi ) ) {
1471                         tmp_base_ndn[ 0 ] = '\0';
1472
1473                         for ( i = 0, j = bsi->bsi_base_ndn->bv_len - 1;
1474                                         j >= 0; i++, j--) {
1475                                 tmp_base_ndn[ i ] = bsi->bsi_base_ndn->bv_val[ j ];
1476                         }
1477
1478 #ifdef LDAP_SCOPE_SUBORDINATE
1479                         if ( bsi->bsi_scope == LDAP_SCOPE_SUBORDINATE ) {
1480                                 tmp_base_ndn[ i++ ] = ',';
1481                         }
1482 #endif /* LDAP_SCOPE_SUBORDINATE */
1483
1484                         tmp_base_ndn[ i ] = '%';
1485                         tmp_base_ndn[ i + 1 ] = '\0';
1486
1487                 } else {
1488                         i = 0;
1489
1490                         tmp_base_ndn[ i++ ] = '%';
1491
1492 #ifdef LDAP_SCOPE_SUBORDINATE
1493                         if ( bsi->bsi_scope == LDAP_SCOPE_SUBORDINATE ) {
1494                                 tmp_base_ndn[ i++ ] = ',';
1495                         }
1496 #endif /* LDAP_SCOPE_SUBORDINATE */
1497
1498                         AC_MEMCPY( &tmp_base_ndn[ i ], bsi->bsi_base_ndn->bv_val,
1499                                 bsi->bsi_base_ndn->bv_len + 1 );
1500                 }
1501
1502                 /* uppercase DN only if the stored DN can be uppercased
1503                  * for comparison */
1504                 if ( BACKSQL_CANUPPERCASE( bi ) ) {
1505                         ldap_pvt_str2upper( tmp_base_ndn );
1506                 }
1507
1508 #ifdef LDAP_SCOPE_SUBORDINATE
1509                 if ( bsi->bsi_scope == LDAP_SCOPE_SUBORDINATE ) {
1510                         Debug( LDAP_DEBUG_TRACE, "(children)dn: \"%s\"\n",
1511                                 tmp_base_ndn, 0, 0 );
1512                 } else
1513 #endif /* LDAP_SCOPE_SUBORDINATE */
1514                 {
1515                         Debug( LDAP_DEBUG_TRACE, "(sub)dn: \"%s\"\n",
1516                                 tmp_base_ndn, 0, 0 );
1517                 }
1518
1519                 rc = backsql_BindParamStr( sth, 2, SQL_PARAM_INPUT,
1520                                 tmp_base_ndn, BACKSQL_MAX_DN_LEN );
1521                 if ( rc != SQL_SUCCESS ) {
1522                         Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
1523                                 "error binding base_ndn parameter (2)\n",
1524                                 0, 0, 0 );
1525                         backsql_PrintErrors( bi->sql_db_env, bsi->bsi_dbh,
1526                                         sth, rc );
1527                         bsi->bsi_status = LDAP_OTHER;
1528                         return BACKSQL_AVL_CONTINUE;
1529                 }
1530                 break;
1531         }
1532
1533         case LDAP_SCOPE_ONELEVEL:
1534                 assert( !BER_BVISNULL( &bsi->bsi_base_id.eid_ndn ) );
1535
1536 #ifdef BACKSQL_ARBITRARY_KEY
1537                 Debug( LDAP_DEBUG_TRACE, "(one)id: \"%s\"\n",
1538                                 bsi->bsi_base_id.eid_id.bv_val, 0, 0 );
1539 #else /* ! BACKSQL_ARBITRARY_KEY */
1540                 Debug( LDAP_DEBUG_TRACE, "(one)id: '%lu'\n",
1541                                 bsi->bsi_base_id.eid_id, 0, 0 );
1542 #endif /* ! BACKSQL_ARBITRARY_KEY */
1543                 rc = backsql_BindParamID( sth, 2, SQL_PARAM_INPUT,
1544                                 &bsi->bsi_base_id.eid_id );
1545                 if ( rc != SQL_SUCCESS ) {
1546                         Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
1547                                 "error binding base id parameter\n", 0, 0, 0 );
1548                         bsi->bsi_status = LDAP_OTHER;
1549                         return BACKSQL_AVL_CONTINUE;
1550                 }
1551                 break;
1552         }
1553
1554         rc = SQLExecute( sth );
1555         if ( !BACKSQL_SUCCESS( rc ) ) {
1556                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
1557                         "error executing query\n", 0, 0, 0 );
1558                 backsql_PrintErrors( bi->sql_db_env, bsi->bsi_dbh, sth, rc );
1559                 SQLFreeStmt( sth, SQL_DROP );
1560                 bsi->bsi_status = LDAP_OTHER;
1561                 return BACKSQL_AVL_CONTINUE;
1562         }
1563
1564         backsql_BindRowAsStrings( sth, &row );
1565         rc = SQLFetch( sth );
1566         for ( ; BACKSQL_SUCCESS( rc ); rc = SQLFetch( sth ) ) {
1567                 struct berval           dn, pdn, ndn;
1568                 backsql_entryID         *c_id = NULL;
1569                 int                     ret;
1570
1571                 ber_str2bv( row.cols[ 3 ], 0, 0, &dn );
1572
1573                 if ( backsql_api_odbc2dn( bsi->bsi_op, bsi->bsi_rs, &dn ) ) {
1574                         continue;
1575                 }
1576
1577                 ret = dnPrettyNormal( NULL, &dn, &pdn, &ndn, NULL );
1578                 if ( dn.bv_val != row.cols[ 3 ] ) {
1579                         free( dn.bv_val );
1580                 }
1581
1582                 if ( ret != LDAP_SUCCESS ) {
1583                         continue;
1584                 }
1585
1586                 if ( bi->sql_baseObject && dn_match( &ndn, &bi->sql_baseObject->e_nname ) ) {
1587                         free( pdn.bv_val );
1588                         free( ndn.bv_val );
1589                         continue;
1590                 }
1591
1592                 c_id = (backsql_entryID *)ch_calloc( 1,
1593                                 sizeof( backsql_entryID ) );
1594 #ifdef BACKSQL_ARBITRARY_KEY
1595                 ber_str2bv( row.cols[ 0 ], 0, 1, &c_id->eid_id );
1596                 ber_str2bv( row.cols[ 1 ], 0, 1, &c_id->eid_keyval );
1597 #else /* ! BACKSQL_ARBITRARY_KEY */
1598                 c_id->eid_id = strtol( row.cols[ 0 ], NULL, 0 );
1599                 c_id->eid_keyval = strtol( row.cols[ 1 ], NULL, 0 );
1600 #endif /* ! BACKSQL_ARBITRARY_KEY */
1601                 c_id->eid_oc_id = bsi->bsi_oc->bom_id;
1602
1603                 c_id->eid_dn = pdn;
1604                 c_id->eid_ndn = ndn;
1605
1606                 /* append at end of list ... */
1607                 c_id->eid_next = NULL;
1608                 *bsi->bsi_id_listtail = c_id;
1609                 bsi->bsi_id_listtail = &c_id->eid_next;
1610
1611 #ifdef BACKSQL_ARBITRARY_KEY
1612                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
1613                         "added entry id=%s, keyval=%s dn=\"%s\"\n",
1614                         c_id->eid_id.bv_val, c_id->eid_keyval.bv_val,
1615                         row.cols[ 3 ] );
1616 #else /* ! BACKSQL_ARBITRARY_KEY */
1617                 Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_candidates(): "
1618                         "added entry id=%ld, keyval=%ld dn=\"%s\"\n",
1619                         c_id->eid_id, c_id->eid_keyval, row.cols[ 3 ] );
1620 #endif /* ! BACKSQL_ARBITRARY_KEY */
1621
1622                 /* count candidates, for unchecked limit */
1623                 bsi->bsi_n_candidates--;
1624                 if ( bsi->bsi_n_candidates == -1 ) {
1625                         break;
1626                 }
1627         }
1628         backsql_FreeRow( &row );
1629         SQLFreeStmt( sth, SQL_DROP );
1630
1631         Debug( LDAP_DEBUG_TRACE, "<==backsql_oc_get_candidates(): %d\n",
1632                         n_candidates - bsi->bsi_n_candidates, 0, 0 );
1633
1634         return ( bsi->bsi_n_candidates == -1 ? BACKSQL_AVL_STOP : BACKSQL_AVL_CONTINUE );
1635 }
1636
1637 int
1638 backsql_search( Operation *op, SlapReply *rs )
1639 {
1640         backsql_info            *bi = (backsql_info *)op->o_bd->be_private;
1641         SQLHDBC                 dbh = SQL_NULL_HDBC;
1642         int                     sres;
1643         Entry                   user_entry = { 0 };
1644         int                     manageDSAit;
1645         time_t                  stoptime = 0;
1646         backsql_srch_info       bsi;
1647         backsql_entryID         *eid = NULL;
1648         struct berval           nbase = BER_BVNULL,
1649                                 realndn = BER_BVNULL;
1650
1651         manageDSAit = get_manageDSAit( op );
1652
1653         Debug( LDAP_DEBUG_TRACE, "==>backsql_search(): "
1654                 "base=\"%s\", filter=\"%s\", scope=%d,",
1655                 op->o_req_ndn.bv_val,
1656                 op->ors_filterstr.bv_val ? op->ors_filterstr.bv_val : "(no filter)",
1657                 op->ors_scope );
1658         Debug( LDAP_DEBUG_TRACE, " deref=%d, attrsonly=%d, "
1659                 "attributes to load: %s\n",
1660                 op->ors_deref,
1661                 op->ors_attrsonly,
1662                 op->ors_attrs == NULL ? "all" : "custom list" );
1663
1664         if ( op->o_req_ndn.bv_len > BACKSQL_MAX_DN_LEN ) {
1665                 Debug( LDAP_DEBUG_TRACE, "backsql_search(): "
1666                         "search base length (%ld) exceeds max length (%d)\n",
1667                         op->o_req_ndn.bv_len, BACKSQL_MAX_DN_LEN, 0 );
1668                 /*
1669                  * FIXME: a LDAP_NO_SUCH_OBJECT could be appropriate
1670                  * since it is impossible that such a long DN exists
1671                  * in the backend
1672                  */
1673                 rs->sr_err = LDAP_ADMINLIMIT_EXCEEDED;
1674                 send_ldap_result( op, rs );
1675                 return 1;
1676         }
1677
1678         sres = backsql_get_db_conn( op, &dbh );
1679         if ( sres != LDAP_SUCCESS ) {
1680                 Debug( LDAP_DEBUG_TRACE, "backsql_search(): "
1681                         "could not get connection handle - exiting\n",
1682                         0, 0, 0 );
1683                 rs->sr_err = sres;
1684                 rs->sr_text = sres == LDAP_OTHER ?  "SQL-backend error" : NULL;
1685                 send_ldap_result( op, rs );
1686                 return 1;
1687         }
1688
1689         /* compute it anyway; root does not use it */
1690         stoptime = op->o_time + op->ors_tlimit;
1691
1692         realndn = op->o_req_ndn;
1693         if ( backsql_api_dn2odbc( op, rs, &realndn ) ) {
1694                 Debug( LDAP_DEBUG_TRACE, "   backsql_search(\"%s\"): "
1695                         "backsql_api_dn2odbc(\"%s\") failed\n",
1696                         op->o_req_ndn.bv_val, realndn.bv_val, 0 );
1697                 rs->sr_err = LDAP_OTHER;
1698                 rs->sr_text = "SQL-backend error";
1699                 send_ldap_result( op, rs );
1700                 goto done;
1701         }
1702
1703         /* init search */
1704         rs->sr_err = backsql_init_search( &bsi, &realndn,
1705                         op->ors_scope,
1706                         op->ors_slimit, op->ors_tlimit,
1707                         stoptime, op->ors_filter,
1708                         dbh, op, rs, op->ors_attrs,
1709                         BACKSQL_ISF_GET_ID );
1710         if ( rs->sr_err != LDAP_SUCCESS ) {
1711                 send_ldap_result( op, rs );
1712                 goto done;
1713         }
1714
1715         bsi.bsi_n_candidates =
1716                 ( op->ors_limit == NULL /* isroot == TRUE */ ? -2 :
1717                 ( op->ors_limit->lms_s_unchecked == -1 ? -2 :
1718                 ( op->ors_limit->lms_s_unchecked ) ) );
1719
1720         switch ( bsi.bsi_scope ) {
1721         case LDAP_SCOPE_BASE:
1722         case BACKSQL_SCOPE_BASE_LIKE:
1723                 /*
1724                  * probably already found...
1725                  */
1726                 bsi.bsi_id_list = &bsi.bsi_base_id;
1727                 bsi.bsi_id_listtail = &bsi.bsi_base_id.eid_next;
1728                 break;
1729
1730         case LDAP_SCOPE_SUBTREE:
1731                 /*
1732                  * if baseObject is defined, and if it is the root
1733                  * of the search, add it to the candidate list
1734                  */
1735                 if ( bi->sql_baseObject && BACKSQL_IS_BASEOBJECT_ID( &bsi.bsi_base_id.eid_id ) )
1736                 {
1737                         bsi.bsi_id_list = &bsi.bsi_base_id;
1738                         bsi.bsi_id_listtail = &bsi.bsi_base_id.eid_next;
1739                 }
1740
1741                 /* FALLTHRU */
1742         default:
1743
1744                 /*
1745                  * for each objectclass we try to construct query which gets IDs
1746                  * of entries matching LDAP query filter and scope (or at least
1747                  * candidates), and get the IDs
1748                  */
1749                 avl_apply( bi->sql_oc_by_oc, backsql_oc_get_candidates,
1750                                 &bsi, BACKSQL_AVL_STOP, AVL_INORDER );
1751         }
1752
1753         if ( op->ors_limit != NULL      /* isroot == FALSE */
1754                         && op->ors_limit->lms_s_unchecked != -1
1755                         && bsi.bsi_n_candidates == -1 )
1756         {
1757                 rs->sr_err = LDAP_ADMINLIMIT_EXCEEDED;
1758                 send_ldap_result( op, rs );
1759                 goto done;
1760         }
1761
1762         /*
1763          * now we load candidate entries (only those attributes
1764          * mentioned in attrs and filter), test it against full filter
1765          * and then send to client; don't free entry_id if baseObject...
1766          */
1767         for ( eid = bsi.bsi_id_list;
1768                         eid != NULL;
1769                         eid = backsql_free_entryID( eid, eid == &bsi.bsi_base_id ? 0 : 1 ) )
1770         {
1771                 int             rc;
1772                 Attribute       *a_hasSubordinate = NULL,
1773                                 *a_entryUUID = NULL,
1774                                 *a_entryCSN = NULL,
1775                                 **ap = NULL;
1776                 Entry           *e = NULL;
1777
1778                 /* check for abandon */
1779                 if ( op->o_abandon ) {
1780                         break;
1781                 }
1782
1783                 /* check time limit */
1784                 if ( op->ors_tlimit != SLAP_NO_LIMIT
1785                                 && slap_get_time() > stoptime )
1786                 {
1787                         rs->sr_err = LDAP_TIMELIMIT_EXCEEDED;
1788                         rs->sr_ctrls = NULL;
1789                         rs->sr_ref = rs->sr_v2ref;
1790                         rs->sr_err = (rs->sr_v2ref == NULL) ? LDAP_SUCCESS
1791                                 : LDAP_REFERRAL;
1792                         send_ldap_result( op, rs );
1793                         goto end_of_search;
1794                 }
1795
1796 #ifdef BACKSQL_ARBITRARY_KEY
1797                 Debug(LDAP_DEBUG_TRACE, "backsql_search(): loading data "
1798                         "for entry id=%s, oc_id=%ld, keyval=%s\n",
1799                         eid->eid_id.bv_val, eid->eid_oc_id,
1800                         eid->eid_keyval.bv_val );
1801 #else /* ! BACKSQL_ARBITRARY_KEY */
1802                 Debug(LDAP_DEBUG_TRACE, "backsql_search(): loading data "
1803                         "for entry id=%ld, oc_id=%ld, keyval=%ld\n",
1804                         eid->eid_id, eid->eid_oc_id, eid->eid_keyval );
1805 #endif /* ! BACKSQL_ARBITRARY_KEY */
1806
1807                 /* check scope */
1808                 switch ( op->ors_scope ) {
1809                 case LDAP_SCOPE_BASE:
1810                 case BACKSQL_SCOPE_BASE_LIKE:
1811                         if ( !dn_match( &eid->eid_ndn, &op->o_req_ndn ) ) {
1812                                 goto next_entry2;
1813                         }
1814                         break;
1815
1816                 case LDAP_SCOPE_ONE:
1817                 {
1818                         struct berval   rdn = eid->eid_ndn;
1819
1820                         rdn.bv_len -= op->o_req_ndn.bv_len + STRLENOF( "," );
1821                         if ( !dnIsOneLevelRDN( &rdn ) ) {
1822                                 goto next_entry2;
1823                         }
1824                         /* fall thru */
1825                 }
1826
1827 #ifdef LDAP_SCOPE_SUBORDINATE
1828                 case LDAP_SCOPE_SUBORDINATE:
1829                         /* discard the baseObject entry */
1830                         if ( dn_match( &eid->eid_ndn, &op->o_req_ndn ) ) {
1831                                 goto next_entry2;
1832                         }
1833                 /* FALLTHRU */
1834 #endif /* LDAP_SCOPE_SUBORDINATE */
1835
1836                 case LDAP_SCOPE_SUBTREE:
1837                         /* FIXME: this should never fail... */
1838                         if ( !dnIsSuffix( &eid->eid_ndn, &op->o_req_ndn ) ) {
1839                                 goto next_entry2;
1840                         }
1841                         break;
1842                 }
1843
1844                 /* don't recollect baseObject ... */
1845                 if ( BACKSQL_IS_BASEOBJECT_ID( &eid->eid_id ) ) {
1846                         e = bi->sql_baseObject;
1847
1848                 } else {
1849                         bsi.bsi_e = &user_entry;
1850                         rc = backsql_id2entry( &bsi, eid );
1851                         if ( rc != LDAP_SUCCESS ) {
1852                                 Debug( LDAP_DEBUG_TRACE, "backsql_search(): "
1853                                         "error %d in backsql_id2entry() "
1854                                         "- skipping\n", rc, 0, 0 );
1855                                 continue;
1856                         }
1857
1858                         e = &user_entry;
1859                 }
1860
1861                 if ( !manageDSAit &&
1862                                 op->ors_scope != LDAP_SCOPE_BASE &&
1863                                 op->ors_scope != BACKSQL_SCOPE_BASE_LIKE &&
1864                                 is_entry_referral( e ) )
1865                 {
1866                         BerVarray refs;
1867
1868                         refs = get_entry_referrals( op, e );
1869                         if ( !refs ) {
1870                                 backsql_srch_info       bsi2 = { 0 };
1871                                 Entry                   user_entry2 = { 0 };
1872
1873                                 /* retry with the full entry... */
1874                                 (void)backsql_init_search( &bsi2,
1875                                                 &e->e_nname,
1876                                                 LDAP_SCOPE_BASE,
1877                                                 SLAP_NO_LIMIT, SLAP_NO_LIMIT,
1878                                                 (time_t)(-1), NULL,
1879                                                 dbh, op, rs, NULL, 0 );
1880                                 bsi2.bsi_e = &user_entry2;
1881                                 rc = backsql_id2entry( &bsi2, eid );
1882                                 if ( rc == LDAP_SUCCESS ) {
1883                                         if ( is_entry_referral( &user_entry2 ) )
1884                                         {
1885                                                 refs = get_entry_referrals( op,
1886                                                                 &user_entry2 );
1887                                         } /* else: FIXME: inconsistency! */
1888                                         entry_clean( &user_entry2 );
1889                                 }
1890                         }
1891
1892                         if ( refs ) {
1893                                 rs->sr_ref = referral_rewrite( refs,
1894                                                 &e->e_name,
1895                                                 &op->o_req_dn,
1896                                                 op->ors_scope );
1897                                 ber_bvarray_free( refs );
1898                         }
1899
1900                         if ( !rs->sr_ref ) {
1901                                 rs->sr_text = "bad_referral object";
1902                         }
1903
1904                         rs->sr_entry = e;
1905                         rs->sr_err = LDAP_REFERRAL;
1906                         rs->sr_matched = user_entry.e_name.bv_val;
1907                         send_search_reference( op, rs );
1908
1909                         ber_bvarray_free( rs->sr_ref );
1910                         rs->sr_ref = NULL;
1911                         rs->sr_matched = NULL;
1912                         rs->sr_entry = NULL;
1913
1914                         goto next_entry;
1915                 }
1916
1917                 /*
1918                  * We use this flag since we need to parse the filter
1919                  * anyway; we should have used the frontend API function
1920                  * filter_has_subordinates()
1921                  */
1922                 if ( bsi.bsi_flags & BSQL_SF_FILTER_HASSUBORDINATE ) {
1923                         rc = backsql_has_children( bi, dbh, &e->e_nname );
1924
1925                         switch ( rc ) {
1926                         case LDAP_COMPARE_TRUE:
1927                         case LDAP_COMPARE_FALSE:
1928                                 a_hasSubordinate = slap_operational_hasSubordinate( rc == LDAP_COMPARE_TRUE );
1929                                 if ( a_hasSubordinate != NULL ) {
1930                                         for ( ap = &user_entry.e_attrs;
1931                                                         *ap;
1932                                                         ap = &(*ap)->a_next );
1933
1934                                         *ap = a_hasSubordinate;
1935                                 }
1936                                 rc = 0;
1937                                 break;
1938
1939                         default:
1940                                 Debug(LDAP_DEBUG_TRACE,
1941                                         "backsql_search(): "
1942                                         "has_children failed( %d)\n",
1943                                         rc, 0, 0 );
1944                                 rc = 1;
1945                                 goto next_entry;
1946                         }
1947                 }
1948
1949                 if ( bsi.bsi_flags & BSQL_SF_FILTER_ENTRYUUID ) {
1950                         a_entryUUID = backsql_operational_entryUUID( bi, eid );
1951                         if ( a_entryUUID != NULL ) {
1952                                 if ( ap == NULL ) {
1953                                         ap = &user_entry.e_attrs;
1954                                 }
1955
1956                                 for ( ; *ap; ap = &(*ap)->a_next );
1957
1958                                 *ap = a_entryUUID;
1959                         }
1960                 }
1961
1962 #ifdef BACKSQL_SYNCPROV
1963                 if ( bsi.bsi_flags & BSQL_SF_FILTER_ENTRYCSN ) {
1964                         a_entryCSN = backsql_operational_entryCSN( op );
1965                         if ( a_entryCSN != NULL ) {
1966                                 if ( ap == NULL ) {
1967                                         ap = &user_entry.e_attrs;
1968                                 }
1969
1970                                 for ( ; *ap; ap = &(*ap)->a_next );
1971
1972                                 *ap = a_entryCSN;
1973                         }
1974                 }
1975 #endif /* BACKSQL_SYNCPROV */
1976
1977                 if ( test_filter( op, e, op->ors_filter ) == LDAP_COMPARE_TRUE )
1978                 {
1979                         rs->sr_attrs = op->ors_attrs;
1980                         rs->sr_operational_attrs = NULL;
1981                         rs->sr_entry = e;
1982                         if ( e == &user_entry ) {
1983                                 rs->sr_flags = REP_ENTRY_MODIFIABLE;
1984                         }
1985                         sres = send_search_entry( op, rs );
1986                         rs->sr_entry = NULL;
1987                         rs->sr_attrs = NULL;
1988                         rs->sr_operational_attrs = NULL;
1989
1990                         switch ( sres ) {
1991                         case 0:
1992                                 break;
1993
1994                         default:
1995                                 /*
1996                                  * FIXME: send_search_entry failed;
1997                                  * better stop
1998                                  */
1999                         case -1:
2000                                 Debug( LDAP_DEBUG_TRACE, "backsql_search(): "
2001                                         "connection lost\n", 0, 0, 0 );
2002                                 goto end_of_search;
2003                         }
2004                 }
2005
2006 next_entry:;
2007                 entry_clean( &user_entry );
2008
2009 next_entry2:;
2010                 if ( op->ors_slimit != SLAP_NO_LIMIT
2011                                 && rs->sr_nentries >= op->ors_slimit )
2012                 {
2013                         rs->sr_err = LDAP_SIZELIMIT_EXCEEDED;
2014                         send_ldap_result( op, rs );
2015                         goto end_of_search;
2016                 }
2017         }
2018
2019 end_of_search:;
2020         /* in case we got here accidentally */
2021         entry_clean( &user_entry );
2022
2023         if ( rs->sr_nentries > 0 ) {
2024                 rs->sr_ref = rs->sr_v2ref;
2025                 rs->sr_err = (rs->sr_v2ref == NULL) ? LDAP_SUCCESS
2026                         : LDAP_REFERRAL;
2027
2028         } else {
2029                 rs->sr_err = bsi.bsi_status;
2030         }
2031         send_ldap_result( op, rs );
2032
2033         if ( rs->sr_v2ref ) {
2034                 ber_bvarray_free( rs->sr_v2ref );
2035                 rs->sr_v2ref = NULL;
2036         }
2037
2038 #ifdef BACKSQL_SYNCPROV
2039         if ( op->o_sync ) {
2040                 Operation       op2 = *op;
2041                 SlapReply       rs2 = { 0 };
2042                 Entry           e = { 0 };
2043                 slap_callback   cb = { 0 };
2044
2045                 op2.o_tag = LDAP_REQ_ADD;
2046                 op2.o_bd = select_backend( &op->o_bd->be_nsuffix[0], 0, 0 );
2047                 op2.ora_e = &e;
2048                 op2.o_callback = &cb;
2049
2050                 e.e_name = op->o_bd->be_suffix[0];
2051                 e.e_nname = op->o_bd->be_nsuffix[0];
2052
2053                 cb.sc_response = slap_null_cb;
2054
2055                 op2.o_bd->be_add( &op2, &rs2 );
2056         }
2057 #endif /* BACKSQL_SYNCPROV */
2058
2059 done:;
2060         if ( !BER_BVISNULL( &realndn ) && realndn.bv_val != op->o_req_ndn.bv_val ) {
2061                 ch_free( realndn.bv_val );
2062         }
2063
2064         if ( !BER_BVISNULL( &bsi.bsi_base_id.eid_ndn ) ) {
2065                 (void)backsql_free_entryID( &bsi.bsi_base_id, 0 );
2066         }
2067
2068         if ( bsi.bsi_attrs ) {
2069                 ch_free( bsi.bsi_attrs );
2070         }
2071
2072         if ( !BER_BVISNULL( &nbase )
2073                         && nbase.bv_val != op->o_req_ndn.bv_val )
2074         {
2075                 ch_free( nbase.bv_val );
2076         }
2077
2078         /* restore scope ... FIXME: this should be done before ANY
2079          * frontend call that uses op */
2080         if ( op->ors_scope == BACKSQL_SCOPE_BASE_LIKE ) {
2081                 op->ors_scope = LDAP_SCOPE_BASE;
2082         }
2083
2084         Debug( LDAP_DEBUG_TRACE, "<==backsql_search()\n", 0, 0, 0 );
2085         return 0;
2086 }
2087
2088 /* return LDAP_SUCCESS IFF we can retrieve the specified entry.
2089  */
2090 int
2091 backsql_entry_get(
2092                 Operation               *op,
2093                 struct berval           *ndn,
2094                 ObjectClass             *oc,
2095                 AttributeDescription    *at,
2096                 int                     rw,
2097                 Entry                   **ent )
2098 {
2099         backsql_srch_info       bsi;
2100         SQLHDBC                 dbh = SQL_NULL_HDBC;
2101         int                     rc;
2102         SlapReply               rs = { 0 };
2103         AttributeName           anlist[ 2 ];
2104
2105         rc = backsql_get_db_conn( op, &dbh );
2106         if ( !dbh ) {
2107                 return LDAP_OTHER;
2108         }
2109
2110         if ( at ) {
2111                 anlist[ 0 ].an_name = at->ad_cname;
2112                 anlist[ 0 ].an_desc = at;
2113                 BER_BVZERO( &anlist[ 1 ].an_name );
2114         }
2115
2116         rc = backsql_init_search( &bsi,
2117                         ndn,
2118                         LDAP_SCOPE_BASE,
2119                         SLAP_NO_LIMIT, SLAP_NO_LIMIT,
2120                         (time_t)(-1), NULL,
2121                         dbh, op, &rs, at ? anlist : NULL,
2122                         BACKSQL_ISF_GET_ID );
2123         if ( rc != LDAP_SUCCESS ) {
2124                 return rc;
2125         }
2126
2127         bsi.bsi_e = ch_malloc( sizeof( Entry ) );
2128         rc = backsql_id2entry( &bsi, &bsi.bsi_base_id );
2129
2130         if ( !BER_BVISNULL( &bsi.bsi_base_id.eid_ndn ) ) {
2131                 (void)backsql_free_entryID( &bsi.bsi_base_id, 0 );
2132         }
2133
2134         if ( rc == LDAP_SUCCESS ) {
2135
2136 #if 0 /* not supported at present */
2137                 /* find attribute values */
2138                 if ( is_entry_alias( bsi.bsi_e ) ) {
2139                         Debug( LDAP_DEBUG_ACL,
2140                                 "<= backsql_entry_get: entry is an alias\n",
2141                                 0, 0, 0 );
2142                         rc = LDAP_ALIAS_PROBLEM;
2143                         goto return_results;
2144                 }
2145 #endif
2146
2147                 if ( is_entry_referral( bsi.bsi_e ) ) {
2148                         Debug( LDAP_DEBUG_ACL,
2149                                 "<= backsql_entry_get: entry is a referral\n",
2150                                 0, 0, 0 );
2151                         rc = LDAP_REFERRAL;
2152                         goto return_results;
2153                 }
2154
2155                 if ( oc && !is_entry_objectclass( bsi.bsi_e, oc, 0 ) ) {
2156                         Debug( LDAP_DEBUG_ACL,
2157                                         "<= backsql_entry_get: "
2158                                         "failed to find objectClass\n",
2159                                         0, 0, 0 );
2160                         rc = LDAP_NO_SUCH_ATTRIBUTE;
2161                         goto return_results;
2162                 }
2163
2164                 *ent = bsi.bsi_e;
2165         }
2166
2167 return_results:;
2168         if ( rc != LDAP_SUCCESS ) {
2169                 if ( bsi.bsi_e ) {
2170                         entry_free( bsi.bsi_e );
2171                 }
2172         }
2173
2174         return rc;
2175 }
2176