int
mdb_filter_candidates(
Operation *op,
MDB_txn *rtxn,
Filter *f,
ID *ids,
ID *tmp,
ID *stack )
{
int rc = 0;
#ifdef LDAP_COMP_MATCH
AttributeAliasing *aa;
#endif
Debug( LDAP_DEBUG_FILTER, "=> mdb_filter_candidates\n", 0, 0, 0 );
if ( f->f_choice & SLAPD_FILTER_UNDEFINED ) {
MDB_IDL_ZERO( ids );
goto out;
}
switch ( f->f_choice ) {
case SLAPD_FILTER_COMPUTED:
switch( f->f_result ) {
case SLAPD_COMPARE_UNDEFINED:
/* This technically is not the same as FALSE, but it
* certainly will produce no matches.
*/
/* FALL THRU */
case LDAP_COMPARE_FALSE:
MDB_IDL_ZERO( ids );
break;
case LDAP_COMPARE_TRUE:
MDB_IDL_ALL( ids );
break;
case LDAP_SUCCESS:
/* this is a pre-computed scope, leave it alone */
break;
}
break;
case LDAP_FILTER_PRESENT:
Debug( LDAP_DEBUG_FILTER, "\tPRESENT\n", 0, 0, 0 );
rc = presence_candidates( op, rtxn, f->f_desc, ids );
break;
case LDAP_FILTER_EQUALITY:
Debug( LDAP_DEBUG_FILTER, "\tEQUALITY\n", 0, 0, 0 );
#ifdef LDAP_COMP_MATCH
if ( is_aliased_attribute && ( aa = is_aliased_attribute ( f->f_ava->aa_desc ) ) ) {
rc = ava_comp_candidates ( op, rtxn, f->f_ava, aa, ids, tmp, stack );
}
else
#endif
{
rc = equality_candidates( op, rtxn, f->f_ava, ids, tmp );
}
break;
case LDAP_FILTER_APPROX:
Debug( LDAP_DEBUG_FILTER, "\tAPPROX\n", 0, 0, 0 );
rc = approx_candidates( op, rtxn, f->f_ava, ids, tmp );
break;
case LDAP_FILTER_SUBSTRINGS:
Debug( LDAP_DEBUG_FILTER, "\tSUBSTRINGS\n", 0, 0, 0 );
rc = substring_candidates( op, rtxn, f->f_sub, ids, tmp );
break;
case LDAP_FILTER_GE:
/* if no GE index, use pres */
Debug( LDAP_DEBUG_FILTER, "\tGE\n", 0, 0, 0 );
if( f->f_ava->aa_desc->ad_type->sat_ordering &&
( f->f_ava->aa_desc->ad_type->sat_ordering->smr_usage & SLAP_MR_ORDERED_INDEX ) )
rc = inequality_candidates( op, rtxn, f->f_ava, ids, tmp, LDAP_FILTER_GE );
else
rc = presence_candidates( op, rtxn, f->f_ava->aa_desc, ids );
break;
case LDAP_FILTER_LE:
/* if no LE index, use pres */
Debug( LDAP_DEBUG_FILTER, "\tLE\n", 0, 0, 0 );
if( f->f_ava->aa_desc->ad_type->sat_ordering &&
( f->f_ava->aa_desc->ad_type->sat_ordering->smr_usage & SLAP_MR_ORDERED_INDEX ) )
rc = inequality_candidates( op, rtxn, f->f_ava, ids, tmp, LDAP_FILTER_LE );
else
rc = presence_candidates( op, rtxn, f->f_ava->aa_desc, ids );
break;
case LDAP_FILTER_NOT:
/* no indexing to support NOT filters */
Debug( LDAP_DEBUG_FILTER, "\tNOT\n", 0, 0, 0 );
MDB_IDL_ALL( ids );
break;
case LDAP_FILTER_AND:
Debug( LDAP_DEBUG_FILTER, "\tAND\n", 0, 0, 0 );
rc = list_candidates( op, rtxn,
f->f_and, LDAP_FILTER_AND, ids, tmp, stack );
break;
case LDAP_FILTER_OR:
Debug( LDAP_DEBUG_FILTER, "\tOR\n", 0, 0, 0 );
rc = list_candidates( op, rtxn,
f->f_or, LDAP_FILTER_OR, ids, tmp, stack );
break;
case LDAP_FILTER_EXT:
Debug( LDAP_DEBUG_FILTER, "\tEXT\n", 0, 0, 0 );
rc = ext_candidates( op, rtxn, f->f_mra, ids, tmp, stack );
break;
default:
Debug( LDAP_DEBUG_FILTER, "\tUNKNOWN %lu\n",
(unsigned long) f->f_choice, 0, 0 );
/* Must not return NULL, otherwise extended filters break */
MDB_IDL_ALL( ids );
}
out:
Debug( LDAP_DEBUG_FILTER,
"<= mdb_filter_candidates: id=%ld first=%ld last=%ld\n",
(long) ids[0],
(long) MDB_IDL_FIRST( ids ),
(long) MDB_IDL_LAST( ids ) );
return rc;
}
static int
equality_candidates(
Operation *op,
MDB_txn *rtxn,
AttributeAssertion *ava,
ID *ids,
ID *tmp )
{
MDB_dbi dbi;
int i;
int rc;
slap_mask_t mask;
struct berval prefix = {0, NULL};
struct berval *keys = NULL;
MatchingRule *mr;
Debug( LDAP_DEBUG_TRACE, "=> mdb_equality_candidates (%s)\n",
ava->aa_desc->ad_cname.bv_val, 0, 0 );
if ( ava->aa_desc == slap_schema.si_ad_entryDN ) {
ID id;
rc = mdb_dn2id( op, rtxn, NULL, &ava->aa_value, &id, NULL, NULL, NULL );
if ( rc == LDAP_SUCCESS ) {
/* exactly one ID can match */
ids[0] = 1;
ids[1] = id;
}
if ( rc == MDB_NOTFOUND ) {
MDB_IDL_ZERO( ids );
rc = 0;
}
return rc;
}
MDB_IDL_ALL( ids );
rc = mdb_index_param( op->o_bd, ava->aa_desc, LDAP_FILTER_EQUALITY,
&dbi, &mask, &prefix );
if ( rc == LDAP_INAPPROPRIATE_MATCHING ) {
Debug( LDAP_DEBUG_ANY,
"<= mdb_equality_candidates: (%s) not indexed\n",
ava->aa_desc->ad_cname.bv_val, 0, 0 );
return 0;
}
if( rc != LDAP_SUCCESS ) {
Debug( LDAP_DEBUG_ANY,
"<= mdb_equality_candidates: (%s) "
"index_param failed (%d)\n",
ava->aa_desc->ad_cname.bv_val, rc, 0 );
return 0;
}
mr = ava->aa_desc->ad_type->sat_equality;
if( !mr ) {
return 0;
}
if( !mr->smr_filter ) {
return 0;
}
rc = (mr->smr_filter)(
LDAP_FILTER_EQUALITY,
mask,
ava->aa_desc->ad_type->sat_syntax,
mr,
&prefix,
&ava->aa_value,
&keys, op->o_tmpmemctx );
if( rc != LDAP_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE,
"<= mdb_equality_candidates: (%s, %s) "
"MR filter failed (%d)\n",
prefix.bv_val, ava->aa_desc->ad_cname.bv_val, rc );
return 0;
}
if( keys == NULL ) {
Debug( LDAP_DEBUG_TRACE,
"<= mdb_equality_candidates: (%s) no keys\n",
ava->aa_desc->ad_cname.bv_val, 0, 0 );
return 0;
}
for ( i= 0; keys[i].bv_val != NULL; i++ ) {
rc = mdb_key_read( op->o_bd, rtxn, dbi, &keys[i], tmp, NULL, 0 );
if( rc == MDB_NOTFOUND ) {
MDB_IDL_ZERO( ids );
rc = 0;
break;
} else if( rc != LDAP_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE,
"<= mdb_equality_candidates: (%s) "
"key read failed (%d)\n",
ava->aa_desc->ad_cname.bv_val, rc, 0 );
break;
}
if( MDB_IDL_IS_ZERO( tmp ) ) {
Debug( LDAP_DEBUG_TRACE,
"<= mdb_equality_candidates: (%s) NULL\n",
ava->aa_desc->ad_cname.bv_val, 0, 0 );
MDB_IDL_ZERO( ids );
break;
}
if ( i == 0 ) {
MDB_IDL_CPY( ids, tmp );
} else {
mdb_idl_intersection( ids, tmp );
}
if( MDB_IDL_IS_ZERO( ids ) )
break;
}
ber_bvarray_free_x( keys, op->o_tmpmemctx );
Debug( LDAP_DEBUG_TRACE,
"<= mdb_equality_candidates: id=%ld, first=%ld, last=%ld\n",
(long) ids[0],
(long) MDB_IDL_FIRST(ids),
(long) MDB_IDL_LAST(ids) );
return( rc );
}
static int
substring_candidates(
Operation *op,
MDB_txn *rtxn,
SubstringsAssertion *sub,
ID *ids,
ID *tmp )
{
MDB_dbi dbi;
int i;
int rc;
slap_mask_t mask;
struct berval prefix = {0, NULL};
struct berval *keys = NULL;
MatchingRule *mr;
Debug( LDAP_DEBUG_TRACE, "=> mdb_substring_candidates (%s)\n",
sub->sa_desc->ad_cname.bv_val, 0, 0 );
MDB_IDL_ALL( ids );
rc = mdb_index_param( op->o_bd, sub->sa_desc, LDAP_FILTER_SUBSTRINGS,
&dbi, &mask, &prefix );
if ( rc == LDAP_INAPPROPRIATE_MATCHING ) {
Debug( LDAP_DEBUG_ANY,
"<= mdb_substring_candidates: (%s) not indexed\n",
sub->sa_desc->ad_cname.bv_val, 0, 0 );
return 0;
}
if( rc != LDAP_SUCCESS ) {
Debug( LDAP_DEBUG_ANY,
"<= mdb_substring_candidates: (%s) "
"index_param failed (%d)\n",
sub->sa_desc->ad_cname.bv_val, rc, 0 );
return 0;
}
mr = sub->sa_desc->ad_type->sat_substr;
if( !mr ) {
return 0;
}
if( !mr->smr_filter ) {
return 0;
}
rc = (mr->smr_filter)(
LDAP_FILTER_SUBSTRINGS,
mask,
sub->sa_desc->ad_type->sat_syntax,
mr,
&prefix,
sub,
&keys, op->o_tmpmemctx );
if( rc != LDAP_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE,
"<= mdb_substring_candidates: (%s) "
"MR filter failed (%d)\n",
sub->sa_desc->ad_cname.bv_val, rc, 0 );
return 0;
}
if( keys == NULL ) {
Debug( LDAP_DEBUG_TRACE,
"<= mdb_substring_candidates: (0x%04lx) no keys (%s)\n",
mask, sub->sa_desc->ad_cname.bv_val, 0 );
return 0;
}
for ( i= 0; keys[i].bv_val != NULL; i++ ) {
rc = mdb_key_read( op->o_bd, rtxn, dbi, &keys[i], tmp, NULL, 0 );
if( rc == MDB_NOTFOUND ) {
MDB_IDL_ZERO( ids );
rc = 0;
break;
} else if( rc != LDAP_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE,
"<= mdb_substring_candidates: (%s) "
"key read failed (%d)\n",
sub->sa_desc->ad_cname.bv_val, rc, 0 );
break;
}
if( MDB_IDL_IS_ZERO( tmp ) ) {
Debug( LDAP_DEBUG_TRACE,
"<= mdb_substring_candidates: (%s) NULL\n",
sub->sa_desc->ad_cname.bv_val, 0, 0 );
MDB_IDL_ZERO( ids );
break;
}
if ( i == 0 ) {
MDB_IDL_CPY( ids, tmp );
} else {
mdb_idl_intersection( ids, tmp );
}
if( MDB_IDL_IS_ZERO( ids ) )
break;
}
ber_bvarray_free_x( keys, op->o_tmpmemctx );
Debug( LDAP_DEBUG_TRACE, "<= mdb_substring_candidates: %ld, first=%ld, last=%ld\n",
(long) ids[0],
(long) MDB_IDL_FIRST(ids),
(long) MDB_IDL_LAST(ids) );
return( rc );
}
static int
list_candidates(
Operation *op,
MDB_txn *rtxn,
Filter *flist,
int ftype,
ID *ids,
ID *tmp,
ID *save )
{
int rc = 0;
Filter *f;
Debug( LDAP_DEBUG_FILTER, "=> mdb_list_candidates 0x%x\n", ftype, 0, 0 );
for ( f = flist; f != NULL; f = f->f_next ) {
/* ignore precomputed scopes */
if ( f->f_choice == SLAPD_FILTER_COMPUTED &&
f->f_result == LDAP_SUCCESS ) {
continue;
}
MDB_IDL_ZERO( save );
rc = mdb_filter_candidates( op, rtxn, f, save, tmp,
save+MDB_IDL_UM_SIZE );
if ( rc != 0 ) {
if ( ftype == LDAP_FILTER_AND ) {
rc = 0;
continue;
}
break;
}
if ( ftype == LDAP_FILTER_AND ) {
if ( f == flist ) {
MDB_IDL_CPY( ids, save );
} else {
mdb_idl_intersection( ids, save );
}
if( MDB_IDL_IS_ZERO( ids ) )
break;
} else {
if ( f == flist ) {
MDB_IDL_CPY( ids, save );
} else {
mdb_idl_union( ids, save );
}
}
}
if( rc == LDAP_SUCCESS ) {
Debug( LDAP_DEBUG_FILTER,
"<= mdb_list_candidates: id=%ld first=%ld last=%ld\n",
(long) ids[0],
(long) MDB_IDL_FIRST(ids),
(long) MDB_IDL_LAST(ids) );
} else {
Debug( LDAP_DEBUG_FILTER,
"<= mdb_list_candidates: undefined rc=%d\n",
rc, 0, 0 );
}
return rc;
}
static int
presence_candidates(
Operation *op,
MDB_txn *rtxn,
AttributeDescription *desc,
ID *ids )
{
MDB_dbi dbi;
int rc;
slap_mask_t mask;
struct berval prefix = {0, NULL};
Debug( LDAP_DEBUG_TRACE, "=> mdb_presence_candidates (%s)\n",
desc->ad_cname.bv_val, 0, 0 );
MDB_IDL_ALL( ids );
if( desc == slap_schema.si_ad_objectClass ) {
return 0;
}
rc = mdb_index_param( op->o_bd, desc, LDAP_FILTER_PRESENT,
&dbi, &mask, &prefix );
if( rc == LDAP_INAPPROPRIATE_MATCHING ) {
/* not indexed */
Debug( LDAP_DEBUG_TRACE,
"<= mdb_presence_candidates: (%s) not indexed\n",
desc->ad_cname.bv_val, 0, 0 );
return 0;
}
if( rc != LDAP_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE,
"<= mdb_presence_candidates: (%s) index_param "
"returned=%d\n",
desc->ad_cname.bv_val, rc, 0 );
return 0;
}
if( prefix.bv_val == NULL ) {
Debug( LDAP_DEBUG_TRACE,
"<= mdb_presence_candidates: (%s) no prefix\n",
desc->ad_cname.bv_val, 0, 0 );
return -1;
}
rc = mdb_key_read( op->o_bd, rtxn, dbi, &prefix, ids, NULL, 0 );
if( rc == MDB_NOTFOUND ) {
MDB_IDL_ZERO( ids );
rc = 0;
} else if( rc != LDAP_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE,
"<= mdb_presense_candidates: (%s) "
"key read failed (%d)\n",
desc->ad_cname.bv_val, rc, 0 );
goto done;
}
Debug(LDAP_DEBUG_TRACE,
"<= mdb_presence_candidates: id=%ld first=%ld last=%ld\n",
(long) ids[0],
(long) MDB_IDL_FIRST(ids),
(long) MDB_IDL_LAST(ids) );
done:
return rc;
}
static int
comp_equality_candidates (
Operation *op,
MDB_txn *rtxn,
MatchingRuleAssertion *mra,
ComponentAssertion *ca,
ID *ids,
ID *tmp,
ID *stack)
{
MDB_dbi dbi;
int i;
int rc;
slap_mask_t mask;
struct berval prefix = {0, NULL};
struct berval *keys = NULL;
MatchingRule *mr = mra->ma_rule;
Syntax *sat_syntax;
ComponentReference* cr_list, *cr;
AttrInfo *ai;
MDB_IDL_ALL( ids );
if ( !ca->ca_comp_ref )
return 0;
ai = mdb_attr_mask( op->o_bd->be_private, mra->ma_desc );
if( ai ) {
cr_list = ai->ai_cr;
}
else {
return 0;
}
/* find a component reference to be indexed */
sat_syntax = ca->ca_ma_rule->smr_syntax;
for ( cr = cr_list ; cr ; cr = cr->cr_next ) {
if ( cr->cr_string.bv_len == ca->ca_comp_ref->cr_string.bv_len &&
strncmp( cr->cr_string.bv_val, ca->ca_comp_ref->cr_string.bv_val,cr->cr_string.bv_len ) == 0 )
break;
}
if ( !cr )
return 0;
rc = mdb_index_param( op->o_bd, mra->ma_desc, LDAP_FILTER_EQUALITY,
&dbi, &mask, &prefix );
if( rc != LDAP_SUCCESS ) {
return 0;
}
if( !mr ) {
return 0;
}
if( !mr->smr_filter ) {
return 0;
}
rc = (ca->ca_ma_rule->smr_filter)(
LDAP_FILTER_EQUALITY,
cr->cr_indexmask,
sat_syntax,
ca->ca_ma_rule,
&prefix,
&ca->ca_ma_value,
&keys, op->o_tmpmemctx );
if( rc != LDAP_SUCCESS ) {
return 0;
}
if( keys == NULL ) {
return 0;
}
for ( i= 0; keys[i].bv_val != NULL; i++ ) {
rc = mdb_key_read( op->o_bd, rtxn, dbi, &keys[i], tmp, NULL, 0 );
if( rc == MDB_NOTFOUND ) {
MDB_IDL_ZERO( ids );
rc = 0;
break;
} else if( rc != LDAP_SUCCESS ) {
break;
}
if( MDB_IDL_IS_ZERO( tmp ) ) {
MDB_IDL_ZERO( ids );
break;
}
if ( i == 0 ) {
MDB_IDL_CPY( ids, tmp );
} else {
mdb_idl_intersection( ids, tmp );
}
if( MDB_IDL_IS_ZERO( ids ) )
break;
}
ber_bvarray_free_x( keys, op->o_tmpmemctx );
Debug( LDAP_DEBUG_TRACE,
"<= comp_equality_candidates: id=%ld, first=%ld, last=%ld\n",
(long) ids[0],
(long) MDB_IDL_FIRST(ids),
(long) MDB_IDL_LAST(ids) );
return( rc );
}
static int
ext_candidates(
Operation *op,
MDB_txn *rtxn,
MatchingRuleAssertion *mra,
ID *ids,
ID *tmp,
ID *stack)
{
#ifdef LDAP_COMP_MATCH
/*
* Currently Only Component Indexing for componentFilterMatch is supported
* Indexing for an extensible filter is not supported yet
*/
if ( mra->ma_cf ) {
return comp_candidates ( op, rtxn, mra, mra->ma_cf, ids, tmp, stack);
}
#endif
if ( mra->ma_desc == slap_schema.si_ad_entryDN ) {
int rc;
ID id;
MDB_IDL_ZERO( ids );
if ( mra->ma_rule == slap_schema.si_mr_distinguishedNameMatch ) {
base:
rc = mdb_dn2id( op, rtxn, NULL, &mra->ma_value, &id, NULL, NULL, NULL );
if ( rc == MDB_SUCCESS ) {
mdb_idl_insert( ids, id );
}
return 0;
} else if ( mra->ma_rule && mra->ma_rule->smr_match ==
dnRelativeMatch && dnIsSuffix( &mra->ma_value,
op->o_bd->be_nsuffix )) {
int scope;
if ( mra->ma_rule == slap_schema.si_mr_dnSuperiorMatch ) {
mdb_dn2sups( op, rtxn, &mra->ma_value, ids );
return 0;
}
if ( mra->ma_rule == slap_schema.si_mr_dnSubtreeMatch )
scope = LDAP_SCOPE_SUBTREE;
else if ( mra->ma_rule == slap_schema.si_mr_dnOneLevelMatch )
scope = LDAP_SCOPE_ONELEVEL;
else if ( mra->ma_rule == slap_schema.si_mr_dnSubordinateMatch )
scope = LDAP_SCOPE_SUBORDINATE;
else
goto base; /* scope = LDAP_SCOPE_BASE; */
#if 0
if ( scope > LDAP_SCOPE_BASE ) {
ei = NULL;
rc = mdb_cache_find_ndn( op, rtxn, &mra->ma_value, &ei );
if ( ei )
mdb_cache_entryinfo_unlock( ei );
if ( rc == LDAP_SUCCESS ) {
int sc = op->ors_scope;
op->ors_scope = scope;
rc = mdb_dn2idl( op, rtxn, &mra->ma_value, ei, ids,
stack );
op->ors_scope = sc;
}
return 0;
}
#endif
}
}
MDB_IDL_ALL( ids );
return 0;
}
static int
inequality_candidates(
Operation *op,
MDB_txn *rtxn,
AttributeAssertion *ava,
ID *ids,
ID *tmp,
int gtorlt )
{
MDB_dbi dbi;
int rc;
slap_mask_t mask;
struct berval prefix = {0, NULL};
struct berval *keys = NULL;
MatchingRule *mr;
MDB_cursor *cursor = NULL;
Debug( LDAP_DEBUG_TRACE, "=> mdb_inequality_candidates (%s)\n",
ava->aa_desc->ad_cname.bv_val, 0, 0 );
MDB_IDL_ALL( ids );
rc = mdb_index_param( op->o_bd, ava->aa_desc, LDAP_FILTER_EQUALITY,
&dbi, &mask, &prefix );
if ( rc == LDAP_INAPPROPRIATE_MATCHING ) {
Debug( LDAP_DEBUG_ANY,
"<= mdb_inequality_candidates: (%s) not indexed\n",
ava->aa_desc->ad_cname.bv_val, 0, 0 );
return 0;
}
if( rc != LDAP_SUCCESS ) {
Debug( LDAP_DEBUG_ANY,
"<= mdb_inequality_candidates: (%s) "
"index_param failed (%d)\n",
ava->aa_desc->ad_cname.bv_val, rc, 0 );
return 0;
}
mr = ava->aa_desc->ad_type->sat_equality;
if( !mr ) {
return 0;
}
if( !mr->smr_filter ) {
return 0;
}
rc = (mr->smr_filter)(
LDAP_FILTER_EQUALITY,
mask,
ava->aa_desc->ad_type->sat_syntax,
mr,
&prefix,
&ava->aa_value,
&keys, op->o_tmpmemctx );
if( rc != LDAP_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE,
"<= mdb_inequality_candidates: (%s, %s) "
"MR filter failed (%d)\n",
prefix.bv_val, ava->aa_desc->ad_cname.bv_val, rc );
return 0;
}
if( keys == NULL ) {
Debug( LDAP_DEBUG_TRACE,
"<= mdb_inequality_candidates: (%s) no keys\n",
ava->aa_desc->ad_cname.bv_val, 0, 0 );
return 0;
}
MDB_IDL_ZERO( ids );
while(1) {
rc = mdb_key_read( op->o_bd, rtxn, dbi, &keys[0], tmp, &cursor, gtorlt );
if( rc == MDB_NOTFOUND ) {
rc = 0;
break;
} else if( rc != LDAP_SUCCESS ) {
Debug( LDAP_DEBUG_TRACE,
"<= mdb_inequality_candidates: (%s) "
"key read failed (%d)\n",
ava->aa_desc->ad_cname.bv_val, rc, 0 );
break;
}
if( MDB_IDL_IS_ZERO( tmp ) ) {
Debug( LDAP_DEBUG_TRACE,
"<= mdb_inequality_candidates: (%s) NULL\n",
ava->aa_desc->ad_cname.bv_val, 0, 0 );
break;
}
mdb_idl_union( ids, tmp );
if( op->ors_limit && op->ors_limit->lms_s_unchecked != -1 &&
MDB_IDL_N( ids ) >= (unsigned) op->ors_limit->lms_s_unchecked ) {
mdb_cursor_close( cursor );
break;
}
}
ber_bvarray_free_x( keys, op->o_tmpmemctx );
Debug( LDAP_DEBUG_TRACE,
"<= mdb_inequality_candidates: id=%ld, first=%ld, last=%ld\n",
(long) ids[0],
(long) MDB_IDL_FIRST(ids),
(long) MDB_IDL_LAST(ids) );
return( rc );
}
int
mdb_search( Operation *op, SlapReply *rs )
{
struct mdb_info *mdb = (struct mdb_info *) op->o_bd->be_private;
ID id, cursor, nsubs, ncand, cscope;
ID lastid = NOID;
ID candidates[MDB_IDL_UM_SIZE];
ID iscopes[MDB_IDL_DB_SIZE];
ID2 *scopes;
void *stack;
Entry *e = NULL, *base = NULL;
Entry *matched = NULL;
AttributeName *attrs;
slap_mask_t mask;
time_t stoptime;
int manageDSAit;
int tentries = 0;
IdScopes isc;
MDB_cursor *mci, *mcd;
ww_ctx wwctx;
slap_callback cb = { 0 };
mdb_op_info opinfo = {{{0}}}, *moi = &opinfo;
MDB_txn *ltid = NULL;
Debug( LDAP_DEBUG_TRACE, "=> " LDAP_XSTRING(mdb_search) "\n", 0, 0, 0);
attrs = op->oq_search.rs_attrs;
manageDSAit = get_manageDSAit( op );
rs->sr_err = mdb_opinfo_get( op, mdb, 1, &moi );
switch(rs->sr_err) {
case 0:
break;
default:
send_ldap_error( op, rs, LDAP_OTHER, "internal error" );
return rs->sr_err;
}
ltid = moi->moi_txn;
rs->sr_err = mdb_cursor_open( ltid, mdb->mi_id2entry, &mci );
if ( rs->sr_err ) {
send_ldap_error( op, rs, LDAP_OTHER, "internal error" );
return rs->sr_err;
}
rs->sr_err = mdb_cursor_open( ltid, mdb->mi_dn2id, &mcd );
if ( rs->sr_err ) {
mdb_cursor_close( mci );
send_ldap_error( op, rs, LDAP_OTHER, "internal error" );
return rs->sr_err;
}
scopes = scope_chunk_get( op );
stack = search_stack( op );
isc.mt = ltid;
isc.mc = mcd;
isc.scopes = scopes;
isc.oscope = op->ors_scope;
isc.sctmp = stack;
if ( op->ors_deref & LDAP_DEREF_FINDING ) {
MDB_IDL_ZERO(candidates);
}
dn2entry_retry:
/* get entry with reader lock */
rs->sr_err = mdb_dn2entry( op, ltid, mcd, &op->o_req_ndn, &e, &nsubs, 1 );
switch(rs->sr_err) {
case MDB_NOTFOUND:
matched = e;
e = NULL;
break;
case 0:
break;
case LDAP_BUSY:
send_ldap_error( op, rs, LDAP_BUSY, "ldap server busy" );
goto done;
default:
send_ldap_error( op, rs, LDAP_OTHER, "internal error" );
goto done;
}
if ( op->ors_deref & LDAP_DEREF_FINDING ) {
if ( matched && is_entry_alias( matched )) {
struct berval stub;
stub.bv_val = op->o_req_ndn.bv_val;
stub.bv_len = op->o_req_ndn.bv_len - matched->e_nname.bv_len - 1;
e = deref_base( op, rs, matched, &matched, ltid,
candidates, NULL );
if ( e ) {
build_new_dn( &op->o_req_ndn, &e->e_nname, &stub,
op->o_tmpmemctx );
mdb_entry_return(op, e);
matched = NULL;
goto dn2entry_retry;
}
} else if ( e && is_entry_alias( e )) {
e = deref_base( op, rs, e, &matched, ltid,
candidates, NULL );
}
}
if ( e == NULL ) {
struct berval matched_dn = BER_BVNULL;
if ( matched != NULL ) {
BerVarray erefs = NULL;
/* return referral only if "disclose"
* is granted on the object */
if ( ! access_allowed( op, matched,
slap_schema.si_ad_entry,
NULL, ACL_DISCLOSE, NULL ) )
{
rs->sr_err = LDAP_NO_SUCH_OBJECT;
} else {
ber_dupbv( &matched_dn, &matched->e_name );
erefs = is_entry_referral( matched )
? get_entry_referrals( op, matched )
: NULL;
if ( rs->sr_err == MDB_NOTFOUND )
rs->sr_err = LDAP_REFERRAL;
rs->sr_matched = matched_dn.bv_val;
}
mdb_entry_return(op, matched);
matched = NULL;
if ( erefs ) {
rs->sr_ref = referral_rewrite( erefs, &matched_dn,
&op->o_req_dn, op->oq_search.rs_scope );
ber_bvarray_free( erefs );
}
} else {
rs->sr_ref = referral_rewrite( default_referral,
NULL, &op->o_req_dn, op->oq_search.rs_scope );
rs->sr_err = rs->sr_ref != NULL ? LDAP_REFERRAL : LDAP_NO_SUCH_OBJECT;
}
send_ldap_result( op, rs );
if ( rs->sr_ref ) {
ber_bvarray_free( rs->sr_ref );
rs->sr_ref = NULL;
}
if ( !BER_BVISNULL( &matched_dn ) ) {
ber_memfree( matched_dn.bv_val );
rs->sr_matched = NULL;
}
goto done;
}
/* NOTE: __NEW__ "search" access is required
* on searchBase object */
if ( ! access_allowed_mask( op, e, slap_schema.si_ad_entry,
NULL, ACL_SEARCH, NULL, &mask ) )
{
if ( !ACL_GRANT( mask, ACL_DISCLOSE ) ) {
rs->sr_err = LDAP_NO_SUCH_OBJECT;
} else {
rs->sr_err = LDAP_INSUFFICIENT_ACCESS;
}
mdb_entry_return( op,e);
send_ldap_result( op, rs );
goto done;
}
if ( !manageDSAit && is_entry_referral( e ) ) {
/* entry is a referral */
struct berval matched_dn = BER_BVNULL;
BerVarray erefs = NULL;
ber_dupbv( &matched_dn, &e->e_name );
erefs = get_entry_referrals( op, e );
rs->sr_err = LDAP_REFERRAL;
mdb_entry_return( op, e );
e = NULL;
if ( erefs ) {
rs->sr_ref = referral_rewrite( erefs, &matched_dn,
&op->o_req_dn, op->oq_search.rs_scope );
ber_bvarray_free( erefs );
if ( !rs->sr_ref ) {
rs->sr_text = "bad_referral object";
}
}
Debug( LDAP_DEBUG_TRACE,
LDAP_XSTRING(mdb_search) ": entry is referral\n",
0, 0, 0 );
rs->sr_matched = matched_dn.bv_val;
send_ldap_result( op, rs );
ber_bvarray_free( rs->sr_ref );
rs->sr_ref = NULL;
ber_memfree( matched_dn.bv_val );
rs->sr_matched = NULL;
goto done;
}
if ( get_assert( op ) &&
( test_filter( op, e, get_assertion( op )) != LDAP_COMPARE_TRUE ))
{
rs->sr_err = LDAP_ASSERTION_FAILED;
mdb_entry_return( op,e);
send_ldap_result( op, rs );
goto done;
}
/* compute it anyway; root does not use it */
stoptime = op->o_time + op->ors_tlimit;
base = e;
e = NULL;
/* select candidates */
if ( op->oq_search.rs_scope == LDAP_SCOPE_BASE ) {
rs->sr_err = base_candidate( op->o_bd, base, candidates );
scopes[0].mid = 0;
ncand = 1;
} else {
if ( op->ors_scope == LDAP_SCOPE_ONELEVEL ) {
size_t nkids;
MDB_val key, data;
key.mv_data = &base->e_id;
key.mv_size = sizeof( ID );
mdb_cursor_get( mcd, &key, &data, MDB_SET );
mdb_cursor_count( mcd, &nkids );
nsubs = nkids - 1;
} else if ( !base->e_id ) {
/* we don't maintain nsubs for entryID 0.
* just grab entry count from id2entry stat
*/
MDB_stat ms;
mdb_stat( ltid, mdb->mi_id2entry, &ms );
nsubs = ms.ms_entries;
}
MDB_IDL_ZERO( candidates );
scopes[0].mid = 1;
scopes[1].mid = base->e_id;
scopes[1].mval.mv_data = NULL;
rs->sr_err = search_candidates( op, rs, base,
&isc, mci, candidates, stack );
ncand = MDB_IDL_N( candidates );
if ( !base->e_id || ncand == NOID ) {
/* grab entry count from id2entry stat
*/
MDB_stat ms;
mdb_stat( ltid, mdb->mi_id2entry, &ms );
if ( !base->e_id )
nsubs = ms.ms_entries;
if ( ncand == NOID )
ncand = ms.ms_entries;
}
}
/* start cursor at beginning of candidates.
*/
cursor = 0;
if ( candidates[0] == 0 ) {
Debug( LDAP_DEBUG_TRACE,
LDAP_XSTRING(mdb_search) ": no candidates\n",
0, 0, 0 );
goto nochange;
}
/* if not root and candidates exceed to-be-checked entries, abort */
if ( op->ors_limit /* isroot == FALSE */ &&
op->ors_limit->lms_s_unchecked != -1 &&
ncand > (unsigned) op->ors_limit->lms_s_unchecked )
{
rs->sr_err = LDAP_ADMINLIMIT_EXCEEDED;
send_ldap_result( op, rs );
rs->sr_err = LDAP_SUCCESS;
goto done;
}
if ( op->ors_limit == NULL /* isroot == TRUE */ ||
!op->ors_limit->lms_s_pr_hide )
{
tentries = ncand;
}
wwctx.flag = 0;
/* If we're running in our own read txn */
if ( moi == &opinfo ) {
cb.sc_writewait = mdb_writewait;
cb.sc_private = &wwctx;
wwctx.txn = ltid;
wwctx.mcd = NULL;
cb.sc_next = op->o_callback;
op->o_callback = &cb;
}
if ( get_pagedresults( op ) > SLAP_CONTROL_IGNORED ) {
PagedResultsState *ps = op->o_pagedresults_state;
/* deferred cookie parsing */
rs->sr_err = parse_paged_cookie( op, rs );
if ( rs->sr_err != LDAP_SUCCESS ) {
send_ldap_result( op, rs );
goto done;
}
cursor = (ID) ps->ps_cookie;
if ( cursor && ps->ps_size == 0 ) {
rs->sr_err = LDAP_SUCCESS;
rs->sr_text = "search abandoned by pagedResult size=0";
send_ldap_result( op, rs );
goto done;
}
id = mdb_idl_first( candidates, &cursor );
if ( id == NOID ) {
Debug( LDAP_DEBUG_TRACE,
LDAP_XSTRING(mdb_search)
": no paged results candidates\n",
0, 0, 0 );
send_paged_response( op, rs, &lastid, 0 );
rs->sr_err = LDAP_OTHER;
goto done;
}
if ( id == (ID)ps->ps_cookie )
id = mdb_idl_next( candidates, &cursor );
nsubs = ncand; /* always bypass scope'd search */
goto loop_begin;
}
if ( nsubs < ncand ) {
int rc;
/* Do scope-based search */
/* if any alias scopes were set, save them */
if (scopes[0].mid > 1) {
cursor = 1;
for (cscope = 1; cscope <= scopes[0].mid; cscope++) {
/* Ignore the original base */
if (scopes[cscope].mid == base->e_id)
continue;
iscopes[cursor++] = scopes[cscope].mid;
}
iscopes[0] = scopes[0].mid - 1;
} else {
iscopes[0] = 0;
}
wwctx.mcd = mcd;
isc.id = base->e_id;
isc.numrdns = 0;
rc = mdb_dn2id_walk( op, &isc );
if ( rc )
id = NOID;
else
id = isc.id;
cscope = 0;
} else {
id = mdb_idl_first( candidates, &cursor );
}
while (id != NOID)
{
int scopeok;
MDB_val edata;
loop_begin:
/* check for abandon */
if ( op->o_abandon ) {
rs->sr_err = SLAPD_ABANDON;
send_ldap_result( op, rs );
goto done;
}
/* mostly needed by internal searches,
* e.g. related to syncrepl, for whom
* abandon does not get set... */
if ( slapd_shutdown ) {
rs->sr_err = LDAP_UNAVAILABLE;
send_ldap_disconnect( op, rs );
goto done;
}
/* check time limit */
if ( op->ors_tlimit != SLAP_NO_LIMIT
&& slap_get_time() > stoptime )
{
rs->sr_err = LDAP_TIMELIMIT_EXCEEDED;
rs->sr_ref = rs->sr_v2ref;
send_ldap_result( op, rs );
rs->sr_err = LDAP_SUCCESS;
goto done;
}
if ( nsubs < ncand ) {
unsigned i;
/* Is this entry in the candidate list? */
scopeok = 0;
if (MDB_IDL_IS_RANGE( candidates )) {
if ( id >= MDB_IDL_RANGE_FIRST( candidates ) &&
id <= MDB_IDL_RANGE_LAST( candidates ))
scopeok = 1;
} else {
i = mdb_idl_search( candidates, id );
if ( candidates[i] == id )
scopeok = 1;
}
if ( scopeok )
goto scopeok;
goto loop_continue;
}
/* Does this candidate actually satisfy the search scope?
*/
scopeok = 0;
isc.numrdns = 0;
switch( op->ors_scope ) {
case LDAP_SCOPE_BASE:
/* This is always true, yes? */
if ( id == base->e_id ) scopeok = 1;
break;
#ifdef LDAP_SCOPE_CHILDREN
case LDAP_SCOPE_CHILDREN:
if ( id == base->e_id ) break;
/* Fall-thru */
#endif
case LDAP_SCOPE_SUBTREE:
if ( id == base->e_id ) {
scopeok = 1;
break;
}
/* Fall-thru */
case LDAP_SCOPE_ONELEVEL:
isc.id = id;
isc.nscope = 0;
rs->sr_err = mdb_idscopes( op, &isc );
if ( rs->sr_err == MDB_SUCCESS ) {
if ( isc.nscope )
scopeok = 1;
} else {
if ( rs->sr_err == MDB_NOTFOUND )
goto notfound;
}
break;
}
/* Not in scope, ignore it */
if ( !scopeok )
{
Debug( LDAP_DEBUG_TRACE,
LDAP_XSTRING(mdb_search)
": %ld scope not okay\n",
(long) id, 0, 0 );
goto loop_continue;
}
scopeok:
if ( id == base->e_id ) {
e = base;
} else {
/* get the entry */
rs->sr_err = mdb_id2edata( op, mci, id, &edata );
if ( rs->sr_err == MDB_NOTFOUND ) {
notfound:
if( nsubs < ncand )
goto loop_continue;
if( !MDB_IDL_IS_RANGE(candidates) ) {
/* only complain for non-range IDLs */
Debug( LDAP_DEBUG_TRACE,
LDAP_XSTRING(mdb_search)
": candidate %ld not found\n",
(long) id, 0, 0 );
} else {
/* get the next ID from the DB */
rs->sr_err = mdb_get_nextid( mci, &cursor );
if ( rs->sr_err == MDB_NOTFOUND ) {
break;
}
if ( rs->sr_err ) {
rs->sr_err = LDAP_OTHER;
rs->sr_text = "internal error in get_nextid";
send_ldap_result( op, rs );
goto done;
}
cursor--;
}
goto loop_continue;
} else if ( rs->sr_err ) {
rs->sr_err = LDAP_OTHER;
rs->sr_text = "internal error in mdb_id2edata";
send_ldap_result( op, rs );
goto done;
}
rs->sr_err = mdb_entry_decode( op, ltid, &edata, &e );
if ( rs->sr_err ) {
rs->sr_err = LDAP_OTHER;
rs->sr_text = "internal error in mdb_entry_decode";
send_ldap_result( op, rs );
goto done;
}
e->e_id = id;
e->e_name.bv_val = NULL;
e->e_nname.bv_val = NULL;
}
if ( is_entry_subentry( e ) ) {
if( op->oq_search.rs_scope != LDAP_SCOPE_BASE ) {
if(!get_subentries_visibility( op )) {
/* only subentries are visible */
goto loop_continue;
}
} else if ( get_subentries( op ) &&
!get_subentries_visibility( op ))
{
/* only subentries are visible */
goto loop_continue;
}
} else if ( get_subentries_visibility( op )) {
/* only subentries are visible */
goto loop_continue;
}
/* aliases were already dereferenced in candidate list */
if ( op->ors_deref & LDAP_DEREF_SEARCHING ) {
/* but if the search base is an alias, and we didn't
* deref it when finding, return it.
*/
if ( is_entry_alias(e) &&
((op->ors_deref & LDAP_DEREF_FINDING) || e != base ))
{
goto loop_continue;
}
}
if ( !manageDSAit && is_entry_glue( e )) {
goto loop_continue;
}
if (e != base) {
struct berval pdn, pndn;
char *d, *n;
int i;
/* child of base, just append RDNs to base->e_name */
if ( nsubs < ncand || isc.scopes[isc.nscope].mid == base->e_id ) {
pdn = base->e_name;
pndn = base->e_nname;
} else {
mdb_id2name( op, ltid, &isc.mc, scopes[isc.nscope].mid, &pdn, &pndn );
}
e->e_name.bv_len = pdn.bv_len;
e->e_nname.bv_len = pndn.bv_len;
for (i=0; i<isc.numrdns; i++) {
e->e_name.bv_len += isc.rdns[i].bv_len + 1;
e->e_nname.bv_len += isc.nrdns[i].bv_len + 1;
}
e->e_name.bv_val = op->o_tmpalloc(e->e_name.bv_len + 1, op->o_tmpmemctx);
e->e_nname.bv_val = op->o_tmpalloc(e->e_nname.bv_len + 1, op->o_tmpmemctx);
d = e->e_name.bv_val;
n = e->e_nname.bv_val;
if (nsubs < ncand) {
/* RDNs are in top-down order */
for (i=isc.numrdns-1; i>=0; i--) {
memcpy(d, isc.rdns[i].bv_val, isc.rdns[i].bv_len);
d += isc.rdns[i].bv_len;
*d++ = ',';
memcpy(n, isc.nrdns[i].bv_val, isc.nrdns[i].bv_len);
n += isc.nrdns[i].bv_len;
*n++ = ',';
}
} else {
/* RDNs are in bottom-up order */
for (i=0; i<isc.numrdns; i++) {
memcpy(d, isc.rdns[i].bv_val, isc.rdns[i].bv_len);
d += isc.rdns[i].bv_len;
*d++ = ',';
memcpy(n, isc.nrdns[i].bv_val, isc.nrdns[i].bv_len);
n += isc.nrdns[i].bv_len;
*n++ = ',';
}
}
if (pdn.bv_len) {
memcpy(d, pdn.bv_val, pdn.bv_len+1);
memcpy(n, pndn.bv_val, pndn.bv_len+1);
} else {
*--d = '\0';
*--n = '\0';
e->e_name.bv_len--;
e->e_nname.bv_len--;
}
if (pndn.bv_val != base->e_nname.bv_val) {
op->o_tmpfree(pndn.bv_val, op->o_tmpmemctx);
op->o_tmpfree(pdn.bv_val, op->o_tmpmemctx);
}
}
/*
* if it's a referral, add it to the list of referrals. only do
* this for non-base searches, and don't check the filter
* explicitly here since it's only a candidate anyway.
*/
if ( !manageDSAit && op->oq_search.rs_scope != LDAP_SCOPE_BASE
&& is_entry_referral( e ) )
{
BerVarray erefs = get_entry_referrals( op, e );
rs->sr_ref = referral_rewrite( erefs, &e->e_name, NULL,
op->oq_search.rs_scope == LDAP_SCOPE_ONELEVEL
? LDAP_SCOPE_BASE : LDAP_SCOPE_SUBTREE );
rs->sr_entry = e;
rs->sr_flags = 0;
send_search_reference( op, rs );
if (e != base)
mdb_entry_return( op, e );
rs->sr_entry = NULL;
e = NULL;
ber_bvarray_free( rs->sr_ref );
ber_bvarray_free( erefs );
rs->sr_ref = NULL;
if ( wwctx.flag ) {
rs->sr_err = mdb_waitfixup( op, &wwctx, mci, mcd );
if ( rs->sr_err ) {
send_ldap_result( op, rs );
goto done;
}
}
goto loop_continue;
}
/* if it matches the filter and scope, send it */
rs->sr_err = test_filter( op, e, op->oq_search.rs_filter );
if ( rs->sr_err == LDAP_COMPARE_TRUE ) {
/* check size limit */
if ( get_pagedresults(op) > SLAP_CONTROL_IGNORED ) {
if ( rs->sr_nentries >= ((PagedResultsState *)op->o_pagedresults_state)->ps_size ) {
mdb_entry_return( op, e );
e = NULL;
send_paged_response( op, rs, &lastid, tentries );
goto done;
}
lastid = id;
}
if (e) {
/* safe default */
rs->sr_attrs = op->oq_search.rs_attrs;
rs->sr_operational_attrs = NULL;
rs->sr_ctrls = NULL;
rs->sr_entry = e;
RS_ASSERT( e->e_private != NULL );
rs->sr_flags = 0;
rs->sr_err = LDAP_SUCCESS;
rs->sr_err = send_search_entry( op, rs );
rs->sr_attrs = NULL;
rs->sr_entry = NULL;
if (e != base)
mdb_entry_return( op, e );
e = NULL;
switch ( rs->sr_err ) {
case LDAP_SUCCESS: /* entry sent ok */
break;
default: /* entry not sent */
break;
case LDAP_BUSY:
send_ldap_result( op, rs );
goto done;
case LDAP_UNAVAILABLE:
case LDAP_SIZELIMIT_EXCEEDED:
if ( rs->sr_err == LDAP_SIZELIMIT_EXCEEDED ) {
rs->sr_ref = rs->sr_v2ref;
send_ldap_result( op, rs );
rs->sr_err = LDAP_SUCCESS;
} else {
rs->sr_err = LDAP_OTHER;
}
goto done;
}
if ( wwctx.flag ) {
rs->sr_err = mdb_waitfixup( op, &wwctx, mci, mcd );
if ( rs->sr_err ) {
send_ldap_result( op, rs );
goto done;
}
}
}
} else {
Debug( LDAP_DEBUG_TRACE,
LDAP_XSTRING(mdb_search)
": %ld does not match filter\n",
(long) id, 0, 0 );
}
loop_continue:
if( e != NULL ) {
if ( e != base )
mdb_entry_return( op, e );
RS_ASSERT( rs->sr_entry == NULL );
e = NULL;
rs->sr_entry = NULL;
}
if ( nsubs < ncand ) {
int rc = mdb_dn2id_walk( op, &isc );
if (rc) {
id = NOID;
/* We got to the end of a subtree. If there are any
* alias scopes left, search them too.
*/
while (iscopes[0] && cscope < iscopes[0]) {
cscope++;
isc.id = iscopes[cscope];
if ( base )
mdb_entry_return( op, base );
rs->sr_err = mdb_id2entry(op, mci, isc.id, &base);
if ( !rs->sr_err ) {
mdb_id2name( op, ltid, &isc.mc, isc.id, &base->e_name, &base->e_nname );
isc.numrdns = 0;
if (isc.oscope == LDAP_SCOPE_ONELEVEL)
isc.oscope = LDAP_SCOPE_BASE;
rc = mdb_dn2id_walk( op, &isc );
if ( !rc ) {
id = isc.id;
break;
}
}
}
} else
id = isc.id;
} else {
id = mdb_idl_next( candidates, &cursor );
}
}
nochange:
rs->sr_ctrls = NULL;
rs->sr_ref = rs->sr_v2ref;
rs->sr_err = (rs->sr_v2ref == NULL) ? LDAP_SUCCESS : LDAP_REFERRAL;
rs->sr_rspoid = NULL;
if ( get_pagedresults(op) > SLAP_CONTROL_IGNORED ) {
send_paged_response( op, rs, NULL, 0 );
} else {
send_ldap_result( op, rs );
}
rs->sr_err = LDAP_SUCCESS;
done:
if ( cb.sc_private ) {
/* remove our writewait callback */
slap_callback **scp = &op->o_callback;
while ( *scp ) {
if ( *scp == &cb ) {
*scp = cb.sc_next;
cb.sc_private = NULL;
break;
}
}
}
mdb_cursor_close( mcd );
mdb_cursor_close( mci );
if ( moi == &opinfo ) {
mdb_txn_reset( moi->moi_txn );
LDAP_SLIST_REMOVE( &op->o_extra, &moi->moi_oe, OpExtra, oe_next );
} else {
moi->moi_ref--;
}
if( rs->sr_v2ref ) {
ber_bvarray_free( rs->sr_v2ref );
rs->sr_v2ref = NULL;
}
if (base)
mdb_entry_return( op, base );
scope_chunk_ret( op, scopes );
return rs->sr_err;
}
/* Look for and dereference all aliases within the search scope.
* Requires "stack" to be able to hold 6 levels of DB_SIZE IDLs.
* Of course we're hardcoded to require a minimum of 8 UM_SIZE
* IDLs so this is never a problem.
*/
static int search_aliases(
Operation *op,
SlapReply *rs,
ID e_id,
IdScopes *isc,
MDB_cursor *mci,
ID *stack )
{
ID *aliases, *curscop, *visited, *newsubs, *oldsubs, *tmp;
ID cursora, ida, cursoro, ido;
Entry *matched, *a;
struct berval bv_alias = BER_BVC( "alias" );
AttributeAssertion aa_alias = ATTRIBUTEASSERTION_INIT;
Filter af;
int first = 1;
aliases = stack; /* IDL of all aliases in the database */
curscop = aliases + MDB_IDL_DB_SIZE; /* Aliases in the current scope */
visited = curscop + MDB_IDL_DB_SIZE; /* IDs we've seen in this search */
newsubs = visited + MDB_IDL_DB_SIZE; /* New subtrees we've added */
oldsubs = newsubs + MDB_IDL_DB_SIZE; /* Subtrees added previously */
tmp = oldsubs + MDB_IDL_DB_SIZE; /* Scratch space for deref_base() */
af.f_choice = LDAP_FILTER_EQUALITY;
af.f_ava = &aa_alias;
af.f_av_desc = slap_schema.si_ad_objectClass;
af.f_av_value = bv_alias;
af.f_next = NULL;
/* Find all aliases in database */
MDB_IDL_ZERO( aliases );
rs->sr_err = mdb_filter_candidates( op, isc->mt, &af, aliases,
curscop, visited );
if (rs->sr_err != LDAP_SUCCESS || MDB_IDL_IS_ZERO( aliases )) {
return rs->sr_err;
}
oldsubs[0] = 1;
oldsubs[1] = e_id;
MDB_IDL_ZERO( visited );
MDB_IDL_ZERO( newsubs );
cursoro = 0;
ido = mdb_idl_first( oldsubs, &cursoro );
for (;;) {
/* Set curscop to only the aliases in the current scope. Start with
* all the aliases, then get the intersection with the scope.
*/
rs->sr_err = mdb_idscope( op, isc->mt, e_id, aliases, curscop );
/* Dereference all of the aliases in the current scope. */
cursora = 0;
for (ida = mdb_idl_first(curscop, &cursora); ida != NOID;
ida = mdb_idl_next(curscop, &cursora))
{
rs->sr_err = mdb_id2entry(op, mci, ida, &a);
if (rs->sr_err != LDAP_SUCCESS) {
continue;
}
/* This should only happen if the curscop IDL has maxed out and
* turned into a range that spans IDs indiscriminately
*/
if (!is_entry_alias(a)) {
mdb_entry_return(op, a);
continue;
}
/* Actually dereference the alias */
MDB_IDL_ZERO(tmp);
a = deref_base( op, rs, a, &matched, isc->mt,
tmp, visited );
if (a) {
/* If the target was not already in our current scopes,
* make note of it in the newsubs list.
*/
ID2 mid;
mid.mid = a->e_id;
mid.mval.mv_data = NULL;
if (op->ors_scope == LDAP_SCOPE_SUBTREE) {
isc->id = a->e_id;
/* if ID is a child of any of our current scopes,
* ignore it, it's already included.
*/
if (mdb_idscopechk(op, isc))
goto skip;
}
if (mdb_id2l_insert(isc->scopes, &mid) == 0) {
mdb_idl_insert(newsubs, a->e_id);
}
skip: mdb_entry_return( op, a );
} else if (matched) {
/* Alias could not be dereferenced, or it deref'd to
* an ID we've already seen. Ignore it.
*/
mdb_entry_return( op, matched );
rs->sr_text = NULL;
rs->sr_err = 0;
}
}
/* If this is a OneLevel search, we're done; oldsubs only had one
* ID in it. For a Subtree search, oldsubs may be a list of scope IDs.
*/
if ( op->ors_scope == LDAP_SCOPE_ONELEVEL ) break;
nextido:
ido = mdb_idl_next( oldsubs, &cursoro );
/* If we're done processing the old scopes, did we add any new
* scopes in this iteration? If so, go back and do those now.
*/
if (ido == NOID) {
if (MDB_IDL_IS_ZERO(newsubs)) break;
MDB_IDL_CPY(oldsubs, newsubs);
MDB_IDL_ZERO(newsubs);
cursoro = 0;
ido = mdb_idl_first( oldsubs, &cursoro );
}
/* Find the entry corresponding to the next scope. If it can't
* be found, ignore it and move on. This should never happen;
* we should never see the ID of an entry that doesn't exist.
*/
{
MDB_val edata;
rs->sr_err = mdb_id2edata(op, mci, ido, &edata);
if ( rs->sr_err != MDB_SUCCESS ) {
goto nextido;
}
e_id = ido;
}
}
return rs->sr_err;
}
/* Find each id in ids that is a child of base and move it to res.
*/
int
mdb_idscope(
Operation *op,
MDB_txn *txn,
ID base,
ID *ids,
ID *res )
{
struct mdb_info *mdb = (struct mdb_info *) op->o_bd->be_private;
MDB_dbi dbi = mdb->mi_dn2id;
MDB_val key, data;
MDB_cursor *cursor;
ID ida, id, cid = 0, ci0 = 0, idc = 0;
char *ptr;
int rc, copy;
key.mv_size = sizeof(ID);
MDB_IDL_ZERO( res );
rc = mdb_cursor_open( txn, dbi, &cursor );
if ( rc ) return rc;
ida = mdb_idl_first( ids, &cid );
/* Don't bother moving out of ids if it's a range */
if (!MDB_IDL_IS_RANGE(ids)) {
idc = ids[0];
ci0 = cid;
}
while (ida != NOID) {
copy = 1;
id = ida;
while (id) {
key.mv_data = &id;
rc = mdb_cursor_get( cursor, &key, &data, MDB_SET );
if ( rc ) {
/* not found, drop this from ids */
copy = 0;
break;
}
ptr = data.mv_data;
ptr += data.mv_size - sizeof(ID);
memcpy( &id, ptr, sizeof(ID) );
if ( id == base ) {
if ( res[0] >= MDB_IDL_DB_SIZE-1 ) {
/* too many aliases in scope. Fallback to range */
MDB_IDL_RANGE( res, MDB_IDL_FIRST( ids ), MDB_IDL_LAST( ids ));
goto leave;
}
res[0]++;
res[res[0]] = ida;
copy = 0;
break;
}
if ( op->ors_scope == LDAP_SCOPE_ONELEVEL )
break;
}
if (idc) {
if (copy) {
if (ci0 != cid)
ids[ci0] = ids[cid];
ci0++;
} else
idc--;
}
ida = mdb_idl_next( ids, &cid );
}
if (!MDB_IDL_IS_RANGE( ids ))
ids[0] = idc;
leave:
mdb_cursor_close( cursor );
return rc;
}
/* Find each id in ids that is a child of base and move it to res.
*/
int
mdb_idscope(
Operation *op,
MDB_txn *txn,
ID base,
ID *ids,
ID *res )
{
struct mdb_info *mdb = (struct mdb_info *) op->o_bd->be_private;
MDB_dbi dbi = mdb->mi_dn2id;
MDB_val key, data;
MDB_cursor *cursor;
ID ida, id, cid, ci0, idc = 0;
char *ptr;
int rc;
key.mv_size = sizeof(ID);
MDB_IDL_ZERO( res );
rc = mdb_cursor_open( txn, dbi, &cursor );
if ( rc ) return rc;
ida = mdb_idl_first( ids, &cid );
/* Don't bother moving out of ids if it's a range */
if (!MDB_IDL_IS_RANGE(ids)) {
idc = ids[0];
ci0 = cid;
}
while (ida != NOID) {
id = ida;
while (id) {
key.mv_data = &id;
rc = mdb_cursor_get( cursor, &key, &data, MDB_SET );
if ( rc ) {
/* not found, move on to next */
if (idc) {
if (ci0 != cid)
ids[ci0] = ids[cid];
ci0++;
}
break;
}
ptr = data.mv_data;
ptr += data.mv_size - sizeof(ID);
memcpy( &id, ptr, sizeof(ID) );
if ( id == base ) {
res[0]++;
res[res[0]] = ida;
if (idc)
idc--;
break;
} else {
if (idc) {
if (ci0 != cid)
ids[ci0] = ids[cid];
ci0++;
}
}
if ( op->ors_scope == LDAP_SCOPE_ONELEVEL )
break;
}
ida = mdb_idl_next( ids, &cid );
}
if (!MDB_IDL_IS_RANGE( ids ))
ids[0] = idc;
mdb_cursor_close( cursor );
return rc;
}