/* Append sorted list b to sorted list a. The result is unsorted but * a[1] is the min of the result and a[a[0]] is the max. */ int mdb_idl_append( ID *a, ID *b ) { ID ida, idb, tmp, swap = 0; if ( MDB_IDL_IS_ZERO( b ) ) { return 0; } if ( MDB_IDL_IS_ZERO( a ) ) { MDB_IDL_CPY( a, b ); return 0; } ida = MDB_IDL_LAST( a ); idb = MDB_IDL_LAST( b ); if ( MDB_IDL_IS_RANGE( a ) || MDB_IDL_IS_RANGE(b) || a[0] + b[0] >= MDB_IDL_UM_MAX ) { a[2] = IDL_MAX( ida, idb ); a[1] = IDL_MIN( a[1], b[1] ); a[0] = NOID; return 0; } if ( b[0] > 1 && ida > idb ) { swap = idb; a[a[0]] = idb; b[b[0]] = ida; } if ( b[1] < a[1] ) { tmp = a[1]; a[1] = b[1]; } else { tmp = b[1]; } a[0]++; a[a[0]] = tmp; if ( b[0] > 1 ) { int i = b[0] - 1; AC_MEMCPY(a+a[0]+1, b+2, i * sizeof(ID)); a[0] += i; } if ( swap ) { b[b[0]] = swap; } return 0; }
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 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 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 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 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 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 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 ); }
static int search_candidates( Operation *op, SlapReply *rs, Entry *e, IdScopes *isc, MDB_cursor *mci, ID *ids, ID *stack ) { struct mdb_info *mdb = (struct mdb_info *) op->o_bd->be_private; int rc, depth = 1; Filter *f, rf, xf, nf, sf; AttributeAssertion aa_ref = ATTRIBUTEASSERTION_INIT; AttributeAssertion aa_subentry = ATTRIBUTEASSERTION_INIT; /* * This routine takes as input a filter (user-filter) * and rewrites it as follows: * (&(scope=DN)[(objectClass=subentry)] * (|[(objectClass=referral)](user-filter)) */ Debug(LDAP_DEBUG_TRACE, "search_candidates: base=\"%s\" (0x%08lx) scope=%d\n", e->e_nname.bv_val, (long) e->e_id, op->oq_search.rs_scope ); f = op->oq_search.rs_filter; /* If the user's filter uses objectClass=*, * these clauses are redundant. */ if (!oc_filter(op->oq_search.rs_filter, 1, &depth) && !get_subentries_visibility(op)) { if( !get_manageDSAit(op) && !get_domainScope(op) ) { /* match referral objects */ struct berval bv_ref = BER_BVC( "referral" ); rf.f_choice = LDAP_FILTER_EQUALITY; rf.f_ava = &aa_ref; rf.f_av_desc = slap_schema.si_ad_objectClass; rf.f_av_value = bv_ref; rf.f_next = f; xf.f_or = &rf; xf.f_choice = LDAP_FILTER_OR; xf.f_next = NULL; f = &xf; depth++; } } if( get_subentries_visibility( op ) ) { struct berval bv_subentry = BER_BVC( "subentry" ); sf.f_choice = LDAP_FILTER_EQUALITY; sf.f_ava = &aa_subentry; sf.f_av_desc = slap_schema.si_ad_objectClass; sf.f_av_value = bv_subentry; sf.f_next = f; nf.f_choice = LDAP_FILTER_AND; nf.f_and = &sf; nf.f_next = NULL; f = &nf; depth++; } /* Allocate IDL stack, plus 1 more for former tmp */ if ( depth+1 > mdb->mi_search_stack_depth ) { stack = ch_malloc( (depth + 1) * MDB_IDL_UM_SIZE * sizeof( ID ) ); } if( op->ors_deref & LDAP_DEREF_SEARCHING ) { rc = search_aliases( op, rs, e->e_id, isc, mci, stack ); } else { rc = LDAP_SUCCESS; } if ( rc == LDAP_SUCCESS ) { rc = mdb_filter_candidates( op, isc->mt, f, ids, stack, stack+MDB_IDL_UM_SIZE ); } if ( depth+1 > mdb->mi_search_stack_depth ) { ch_free( stack ); } if( rc ) { Debug(LDAP_DEBUG_TRACE, "mdb_search_candidates: failed (rc=%d)\n", rc, NULL, NULL ); } else { Debug(LDAP_DEBUG_TRACE, "mdb_search_candidates: id=%ld first=%ld last=%ld\n", (long) ids[0], (long) MDB_IDL_FIRST(ids), (long) MDB_IDL_LAST(ids) ); } 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 = 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; }
/* * idl_union - return a = a union b */ int mdb_idl_union( ID *a, ID *b ) { ID ida, idb; ID cursora = 0, cursorb = 0, cursorc; if ( MDB_IDL_IS_ZERO( b ) ) { return 0; } if ( MDB_IDL_IS_ZERO( a ) ) { MDB_IDL_CPY( a, b ); return 0; } if ( MDB_IDL_IS_RANGE( a ) || MDB_IDL_IS_RANGE(b) ) { over: ida = IDL_MIN( MDB_IDL_FIRST(a), MDB_IDL_FIRST(b) ); idb = IDL_MAX( MDB_IDL_LAST(a), MDB_IDL_LAST(b) ); a[0] = NOID; a[1] = ida; a[2] = idb; return 0; } ida = mdb_idl_first( a, &cursora ); idb = mdb_idl_first( b, &cursorb ); cursorc = b[0]; /* The distinct elements of a are cat'd to b */ while( ida != NOID || idb != NOID ) { if ( ida < idb ) { if( ++cursorc > MDB_IDL_UM_MAX ) { goto over; } b[cursorc] = ida; ida = mdb_idl_next( a, &cursora ); } else { if ( ida == idb ) ida = mdb_idl_next( a, &cursora ); idb = mdb_idl_next( b, &cursorb ); } } /* b is copied back to a in sorted order */ a[0] = cursorc; cursora = 1; cursorb = 1; cursorc = b[0]+1; while (cursorb <= b[0] || cursorc <= a[0]) { if (cursorc > a[0]) idb = NOID; else idb = b[cursorc]; if (cursorb <= b[0] && b[cursorb] < idb) a[cursora++] = b[cursorb++]; else { a[cursora++] = idb; cursorc++; } } return 0; }
/* * idl_intersection - return a = a intersection b */ int mdb_idl_intersection( ID *a, ID *b ) { ID ida, idb; ID idmax, idmin; ID cursora = 0, cursorb = 0, cursorc; int swap = 0; if ( MDB_IDL_IS_ZERO( a ) || MDB_IDL_IS_ZERO( b ) ) { a[0] = 0; return 0; } idmin = IDL_MAX( MDB_IDL_FIRST(a), MDB_IDL_FIRST(b) ); idmax = IDL_MIN( MDB_IDL_LAST(a), MDB_IDL_LAST(b) ); if ( idmin > idmax ) { a[0] = 0; return 0; } else if ( idmin == idmax ) { a[0] = 1; a[1] = idmin; return 0; } if ( MDB_IDL_IS_RANGE( a ) ) { if ( MDB_IDL_IS_RANGE(b) ) { /* If both are ranges, just shrink the boundaries */ a[1] = idmin; a[2] = idmax; return 0; } else { /* Else swap so that b is the range, a is a list */ ID *tmp = a; a = b; b = tmp; swap = 1; } } /* If a range completely covers the list, the result is * just the list. If idmin to idmax is contiguous, just * turn it into a range. */ if ( MDB_IDL_IS_RANGE( b ) && MDB_IDL_RANGE_FIRST( b ) <= MDB_IDL_RANGE_FIRST( a ) && MDB_IDL_RANGE_LAST( b ) >= MDB_IDL_RANGE_LAST( a ) ) { if (idmax - idmin + 1 == a[0]) { a[0] = NOID; a[1] = idmin; a[2] = idmax; } goto done; } /* Fine, do the intersection one element at a time. * First advance to idmin in both IDLs. */ cursora = cursorb = idmin; ida = mdb_idl_first( a, &cursora ); idb = mdb_idl_first( b, &cursorb ); cursorc = 0; while( ida <= idmax || idb <= idmax ) { if( ida == idb ) { a[++cursorc] = ida; ida = mdb_idl_next( a, &cursora ); idb = mdb_idl_next( b, &cursorb ); } else if ( ida < idb ) { ida = mdb_idl_next( a, &cursora ); } else { idb = mdb_idl_next( b, &cursorb ); } } a[0] = cursorc; done: if (swap) MDB_IDL_CPY( b, a ); return 0; }