X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fback-bdb%2Fsearch.c;h=34197d090b9f921cd8b33dfae5cb49bbc909fe27;hb=0006ec0a46790567d3d49fcafce5ffaae08cdbf4;hp=cd904105e79135f7a44832c390272a94785cae01;hpb=c83b406fdcd2305fe775911748a650d80845e3af;p=openldap diff --git a/servers/slapd/back-bdb/search.c b/servers/slapd/back-bdb/search.c index cd904105e7..34197d090b 100644 --- a/servers/slapd/back-bdb/search.c +++ b/servers/slapd/back-bdb/search.c @@ -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 @@ -51,7 +51,7 @@ bdb_search( ID id, cursor; ID candidates[BDB_IDL_UM_SIZE]; Entry *e = NULL; - BVarray v2refs = NULL; + BerVarray v2refs = NULL; Entry *matched = NULL; struct berval realbase = { 0, NULL }; int nentries = 0; @@ -78,7 +78,7 @@ bdb_search( } else #endif { - rc = bdb_dn2entry( be, NULL, nbase, &e, &matched, 0 ); + rc = bdb_dn2entry_r( be, NULL, nbase, &e, &matched, 0 ); } switch(rc) { @@ -86,6 +86,12 @@ 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; @@ -93,10 +99,10 @@ bdb_search( if ( e == NULL ) { struct berval matched_dn = { 0, NULL }; - BVarray refs = NULL; + BerVarray refs = NULL; if ( matched != NULL ) { - BVarray erefs; + BerVarray erefs; ber_dupbv( &matched_dn, &matched->e_name ); @@ -104,13 +110,13 @@ bdb_search( ? 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, base, scope ); - bvarray_free( erefs ); + ber_bvarray_free( erefs ); } } else { @@ -121,7 +127,7 @@ bdb_search( send_ldap_result( conn, op, rc=LDAP_REFERRAL , matched_dn.bv_val, text, refs, NULL ); - if ( refs ) bvarray_free( refs ); + if ( refs ) ber_bvarray_free( refs ); if ( matched_dn.bv_val ) ber_memfree( matched_dn.bv_val ); return rc; } @@ -129,19 +135,19 @@ bdb_search( if (!manageDSAit && e != &slap_entry_root && is_entry_referral( e ) ) { /* entry is a referral, don't allow add */ struct berval matched_dn; - BVarray erefs, refs; + 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, base, scope ); - bvarray_free( erefs ); + ber_bvarray_free( erefs ); } Debug( LDAP_DEBUG_TRACE, "bdb_search: entry is referral\n", @@ -152,7 +158,7 @@ bdb_search( refs ? NULL : "bad referral object", refs, NULL ); - bvarray_free( refs ); + ber_bvarray_free( refs ); ber_memfree( matched_dn.bv_val ); return 1; } @@ -233,8 +239,8 @@ 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 */ @@ -245,7 +251,7 @@ bdb_search( 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; @@ -296,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) ) { @@ -309,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; @@ -329,11 +356,11 @@ 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.bv_val ) ) { - goto loop_continue; - } + struct berval pdn; + + dnParent( &e->e_nname, &pdn ): + if ( ber_bvcmp( pdn, &realbase ) ) { + goto loop_continue; } } else if ( dnIsSuffix( &e->e_nname, &realbase ) ) { @@ -356,9 +383,9 @@ bdb_search( if ( !manageDSAit && scope != LDAP_SCOPE_BASE && is_entry_referral( e ) ) { - BVarray erefs = get_entry_referrals( + BerVarray erefs = get_entry_referrals( be, conn, op, e ); - BVarray refs = referral_rewrite( erefs, + BerVarray refs = referral_rewrite( erefs, &e->e_name, NULL, scope == LDAP_SCOPE_SUBTREE ? LDAP_SCOPE_SUBTREE @@ -367,7 +394,7 @@ bdb_search( send_search_reference( be, conn, op, e, refs, NULL, &v2refs ); - bvarray_free( refs ); + ber_bvarray_free( refs ); goto loop_continue; } @@ -375,16 +402,15 @@ 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.bv_val) - ? 1 - : (strcmp( dn, realbase.bv_val ) ? 0 : 1 ); - } else { + if ( be_issuffix( be, &e->e_nname ) ) { scopeok = (realbase.bv_len == 0); + } else { + dnParent( &e->e_nname, &dn ); + scopeok = dn_match( &dn, &realbase ); } } else if ( !scopeok && scope == LDAP_SCOPE_SUBTREE ) { @@ -397,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, @@ -406,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 */ @@ -416,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; @@ -436,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(); @@ -448,7 +481,12 @@ loop_continue: rc = 0; done: - if( v2refs ) bvarray_free( v2refs ); + 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; @@ -503,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", @@ -531,8 +580,8 @@ 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 */ + 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; @@ -557,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",