X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fback-bdb%2Fsearch.c;h=34197d090b9f921cd8b33dfae5cb49bbc909fe27;hb=0006ec0a46790567d3d49fcafce5ffaae08cdbf4;hp=4fe8393a24eab562010ba97d217463832a5dd535;hpb=e8fa25a215a9f9cacdff17b395c211f3f8fc64e1;p=openldap diff --git a/servers/slapd/back-bdb/search.c b/servers/slapd/back-bdb/search.c index 4fe8393a24..34197d090b 100644 --- a/servers/slapd/back-bdb/search.c +++ b/servers/slapd/back-bdb/search.c @@ -1,7 +1,7 @@ /* search.c - search operation */ /* $OpenLDAP$ */ /* - * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved. + * Copyright 1998-2002 The OpenLDAP Foundation, All Rights Reserved. * COPYING RESTRICTIONS APPLY, see COPYRIGHT file */ @@ -20,11 +20,11 @@ static int base_candidate( ID *ids ); static int search_candidates( BackendDB *be, + Operation *op, Entry *e, Filter *filter, int scope, int deref, - int manageDSAit, ID *ids ); int @@ -39,8 +39,8 @@ bdb_search( int slimit, int tlimit, Filter *filter, - const char *filterstr, - struct berval **attrs, + struct berval *filterstr, + AttributeName *attrs, int attrsonly ) { struct bdb_info *bdb = (struct bdb_info *) be->be_private; @@ -51,9 +51,9 @@ bdb_search( ID id, cursor; ID candidates[BDB_IDL_UM_SIZE]; Entry *e = NULL; - struct berval **v2refs = NULL; + BerVarray v2refs = NULL; Entry *matched = NULL; - char *realbase = NULL; + struct berval realbase = { 0, NULL }; int nentries = 0; int manageDSAit; @@ -73,12 +73,12 @@ bdb_search( #ifdef BDB_ALIASES /* get entry with reader lock */ if ( deref & LDAP_DEREF_FINDING ) { - e = deref_dn_r( be, nbase->bv_val, &err, &matched, &text ); + e = deref_dn_r( be, nbase-, &err, &matched, &text ); } else #endif { - rc = bdb_dn2entry( be, NULL, nbase, &e, &matched, 0 ); + rc = bdb_dn2entry_r( be, NULL, nbase, &e, &matched, 0 ); } switch(rc) { @@ -86,30 +86,37 @@ bdb_search( case 0: break; default: + if (e != NULL) { + bdb_cache_return_entry_w(&bdb->bi_cache, e); + } + if (matched != NULL) { + bdb_cache_return_entry_r(&bdb->bi_cache, matched); + } send_ldap_result( conn, op, rc=LDAP_OTHER, NULL, "internal error", NULL, NULL ); return rc; } if ( e == NULL ) { - struct berval *matched_dn = NULL; - struct berval **refs = NULL; + struct berval matched_dn = { 0, NULL }; + BerVarray refs = NULL; if ( matched != NULL ) { - struct berval **erefs; - matched_dn = ber_bvdup( &matched->e_name ); + BerVarray erefs; + + ber_dupbv( &matched_dn, &matched->e_name ); erefs = is_entry_referral( matched ) ? get_entry_referrals( be, conn, op, matched ) : NULL; - bdb_entry_return( be, matched ); + bdb_cache_return_entry_r (&bdb->bi_cache, matched); matched = NULL; if( erefs ) { - refs = referral_rewrite( erefs, matched_dn, + refs = referral_rewrite( erefs, &matched_dn, base, scope ); - ber_bvecfree( erefs ); + ber_bvarray_free( erefs ); } } else { @@ -118,39 +125,41 @@ bdb_search( } send_ldap_result( conn, op, rc=LDAP_REFERRAL , - matched_dn->bv_val, text, refs, NULL ); + matched_dn.bv_val, text, refs, NULL ); - ber_bvecfree( refs ); - ber_bvfree( matched_dn ); + if ( refs ) ber_bvarray_free( refs ); + if ( matched_dn.bv_val ) ber_memfree( matched_dn.bv_val ); return rc; } if (!manageDSAit && e != &slap_entry_root && is_entry_referral( e ) ) { /* entry is a referral, don't allow add */ - struct berval *matched_dn = ber_bvdup( &e->e_name ); - struct berval **erefs = get_entry_referrals( be, - conn, op, e ); - struct berval **refs = NULL; + struct berval matched_dn; + BerVarray erefs, refs; + + ber_dupbv( &matched_dn, &e->e_name ); + erefs = get_entry_referrals( be, conn, op, e ); + refs = NULL; - bdb_entry_return( be, e ); + bdb_cache_return_entry_r( &bdb->bi_cache, e ); e = NULL; if( erefs ) { - refs = referral_rewrite( erefs, matched_dn, + refs = referral_rewrite( erefs, &matched_dn, base, scope ); - ber_bvecfree( erefs ); + ber_bvarray_free( erefs ); } Debug( LDAP_DEBUG_TRACE, "bdb_search: entry is referral\n", 0, 0, 0 ); send_ldap_result( conn, op, LDAP_REFERRAL, - matched_dn->bv_val, + matched_dn.bv_val, refs ? NULL : "bad referral object", refs, NULL ); - ber_bvecfree( refs ); - ber_bvfree( matched_dn ); + ber_bvarray_free( refs ); + ber_memfree( matched_dn.bv_val ); return 1; } @@ -230,19 +239,19 @@ bdb_search( } else { BDB_IDL_ALL( bdb, candidates ); - rc = search_candidates( be, e, filter, - scope, deref, manageDSAit, candidates ); + rc = search_candidates( be, op, e, filter, + scope, deref, candidates ); } /* need normalized dn below */ - realbase = ch_strdup( e->e_ndn ); + ber_dupbv( &realbase, &e->e_nname ); /* start cursor at base entry's id * FIXME: hack to make "" base work */ cursor = e->e_id == NOID ? 1 : e->e_id; if ( e != &slap_entry_root ) { - bdb_entry_return( be, e ); + bdb_cache_return_entry_r(&bdb->bi_cache, e); } e = NULL; @@ -293,7 +302,7 @@ bdb_search( } /* get the entry with reader lock */ - rc = bdb_id2entry( be, NULL, id, &e ); + rc = bdb_id2entry_r( be, NULL, id, &e ); if ( e == NULL ) { if( !BDB_IDL_IS_RANGE(candidates) ) { @@ -306,6 +315,27 @@ bdb_search( goto loop_continue; } +#ifdef BDB_SUBENTRIES + if ( is_entry_subentry( e ) ) { + if( 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; + } +#endif + #ifdef BDB_ALIASES if ( deref & LDAP_DEREF_SEARCHING && is_entry_alias( e ) ) { Entry *matched; @@ -326,14 +356,14 @@ bdb_search( /* need to skip alias which deref into scope */ if( scope & LDAP_SCOPE_ONELEVEL ) { - char *pdn = dn_parent( NULL, e->e_ndn ); - if ( pdn != NULL ) { - if( strcmp( pdn, realbase ) ) { - goto loop_continue; - } + struct berval pdn; + + dnParent( &e->e_nname, &pdn ): + if ( ber_bvcmp( pdn, &realbase ) ) { + goto loop_continue; } - } else if ( dn_issuffix( e->e_ndn, realbase ) ) { + } else if ( dnIsSuffix( &e->e_nname, &realbase ) ) { /* alias is within scope */ Debug( LDAP_DEBUG_TRACE, "bdb_search: \"%s\" in subtree\n", @@ -353,9 +383,9 @@ bdb_search( if ( !manageDSAit && scope != LDAP_SCOPE_BASE && is_entry_referral( e ) ) { - struct berval **erefs = get_entry_referrals( + BerVarray erefs = get_entry_referrals( be, conn, op, e ); - struct berval **refs = referral_rewrite( erefs, + BerVarray refs = referral_rewrite( erefs, &e->e_name, NULL, scope == LDAP_SCOPE_SUBTREE ? LDAP_SCOPE_SUBTREE @@ -364,7 +394,7 @@ bdb_search( send_search_reference( be, conn, op, e, refs, NULL, &v2refs ); - ber_bvecfree( refs ); + ber_bvarray_free( refs ); goto loop_continue; } @@ -372,22 +402,19 @@ bdb_search( /* if it matches the filter and scope, send it */ rc = test_filter( be, conn, op, e, filter ); if ( rc == LDAP_COMPARE_TRUE ) { - char *dn; + struct berval dn; /* check scope */ if ( !scopeok && scope == LDAP_SCOPE_ONELEVEL ) { - if ( (dn = dn_parent( be, e->e_ndn )) != NULL ) { - scopeok = (dn == realbase) - ? 1 - : (strcmp( dn, realbase ) ? 0 : 1 ); + if ( be_issuffix( be, &e->e_nname ) ) { + scopeok = (realbase.bv_len == 0); } else { - scopeok = (realbase == NULL || *realbase == '\0'); + dnParent( &e->e_nname, &dn ); + scopeok = dn_match( &dn, &realbase ); } } else if ( !scopeok && scope == LDAP_SCOPE_SUBTREE ) { - dn = ch_strdup( e->e_ndn ); - scopeok = dn_issuffix( dn, realbase ); - free( dn ); + scopeok = dnIsSuffix( &e->e_nname, &realbase ); } else { scopeok = 1; @@ -396,7 +423,7 @@ bdb_search( if ( scopeok ) { /* check size limit */ if ( --slimit == -1 ) { - bdb_entry_return( be, e ); + bdb_cache_return_entry_r (&bdb->bi_cache, e); e = NULL; send_search_result( conn, op, rc = LDAP_SIZELIMIT_EXCEEDED, NULL, NULL, @@ -405,8 +432,14 @@ bdb_search( } if (e) { - int result = send_search_entry( be, conn, op, - e, attrs, attrsonly, NULL); + int result; + + if( op->o_noop ) { + result = 0; + } else { + result = send_search_entry( be, conn, op, + e, attrs, attrsonly, NULL); + } switch (result) { case 0: /* entry sent ok */ @@ -415,7 +448,7 @@ bdb_search( case 1: /* entry not sent */ break; case -1: /* connection closed */ - bdb_entry_return( be, e ); + bdb_cache_return_entry_r(&bdb->bi_cache, e); e = NULL; rc = LDAP_OTHER; goto done; @@ -435,7 +468,8 @@ bdb_search( loop_continue: if( e != NULL ) { /* free reader lock */ - bdb_entry_return( be, e ); + bdb_cache_return_entry_r ( &bdb->bi_cache, e ); + e = NULL; } ldap_pvt_thread_yield(); @@ -447,8 +481,13 @@ loop_continue: rc = 0; done: - ber_bvecfree( v2refs ); - if( realbase ) ch_free( realbase ); + if( e != NULL ) { + /* free reader lock */ + bdb_cache_return_entry_r ( &bdb->bi_cache, e ); + } + + if( v2refs ) ber_bvarray_free( v2refs ); + if( realbase.bv_val ) ch_free( realbase.bv_val ); return rc; } @@ -502,22 +541,33 @@ static int oc_filter( static int search_candidates( BackendDB *be, + Operation *op, Entry *e, Filter *filter, int scope, int deref, - int manageDSAit, ID *ids ) { int rc; - Filter f, fand, rf, xf; + Filter f, scopef, rf, xf; ID tmp[BDB_IDL_UM_SIZE]; AttributeAssertion aa_ref; - struct bdb_info *bdb = (struct bdb_info *) be->be_private; +#ifdef BDB_SUBENTRIES + Filter sf; + AttributeAssertion aa_subentry; +#endif #ifdef BDB_ALIASES Filter af; AttributeAssertion aa_alias; #endif + struct bdb_info *bdb = (struct bdb_info *) be->be_private; + + /* + * This routine takes as input a filter (user-filter) + * and rewrites it as follows: + * (&(scope=DN)[(objectClass=subentry)] + * (|[(objectClass=referral)(objectClass=alias)](user-filter)) + */ Debug(LDAP_DEBUG_TRACE, "search_candidates: base=\"%s\" (0x%08lx) scope=%d\n", @@ -530,24 +580,24 @@ static int search_candidates( /* If the user's filter doesn't mention objectClass, or if * it just uses objectClass=*, these clauses are redundant. */ - if (oc_filter(filter)) { - if( !manageDSAit ) { /* match referrals */ - static struct berval bv_ref = { sizeof("REFERRAL")-1, "REFERRAL" }; + if (oc_filter(filter) && !get_subentries_visibility(op) ) { + if( !get_manageDSAit(op) ) { /* match referrals */ + struct berval bv_ref = { sizeof("REFERRAL")-1, "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_av_value = bv_ref; rf.f_next = xf.f_or; xf.f_or = &rf; } #ifdef BDB_ALIASES if( deref & LDAP_DEREF_SEARCHING ) { /* match aliases */ - static struct berval bv_alias = { sizeof("ALIAS")-1, "ALIAS" }; + struct berval bv_alias = { sizeof("ALIAS")-1, "ALIAS" }; 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_av_value = bv_alias; af.f_next = xf.f_or; xf.f_or = ⁡ } @@ -556,24 +606,26 @@ static int search_candidates( f.f_next = NULL; f.f_choice = LDAP_FILTER_AND; - f.f_and = &fand; - fand.f_choice = scope == LDAP_SCOPE_SUBTREE + f.f_and = &scopef; + scopef.f_choice = scope == LDAP_SCOPE_SUBTREE ? SLAPD_FILTER_DN_SUBTREE : SLAPD_FILTER_DN_ONE; - fand.f_dn = &e->e_nname; - fand.f_next = xf.f_or == filter ? filter : &xf ; - + scopef.f_dn = &e->e_nname; + scopef.f_next = xf.f_or == filter ? filter : &xf ; + +#ifdef BDB_SUBENTRIES + if( get_subentries_visibility( op ) ) { + struct berval bv_subentry = { sizeof("SUBENTRY")-1, "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 = scopef.f_next; + scopef.f_next = &sf; + } +#endif -#ifdef BDB_FILTER_INDICES rc = bdb_filter_candidates( be, &f, ids, tmp ); -#else - /* FIXME: Original code: - BDB_IDL_ID( bdb, ids, e->e_id ); - * this is a hack to make "" base work; when bdb_filter_candidates - * is used this should not be needed any more */ - BDB_IDL_ID( bdb, ids, (e->e_id == NOID ? 1 : e->e_id) ); - rc = 0; -#endif Debug(LDAP_DEBUG_TRACE, "bdb_search_candidates: id=%ld first=%ld last=%ld\n",