X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fback-ldbm%2Fsearch.c;h=e2e5b113c9bbf82dc9031ab4de6ed2164026e5a3;hb=1586a68219cf85e9caaafcf2259c9bc249358077;hp=79c0d412bbe0142b485382830af90625f5cdae35;hpb=6939c531700652491f4be4688c6a1f35a1ab8a18;p=openldap

diff --git a/servers/slapd/back-ldbm/search.c b/servers/slapd/back-ldbm/search.c
index 79c0d412bb..e2e5b113c9 100644
--- a/servers/slapd/back-ldbm/search.c
+++ b/servers/slapd/back-ldbm/search.c
@@ -1,8 +1,17 @@
 /* search.c - ldbm backend search function */
 /* $OpenLDAP$ */
-/*
- * Copyright 1998-2003 The OpenLDAP Foundation, All Rights Reserved.
- * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
+ *
+ * Copyright 1998-2003 The OpenLDAP Foundation.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted only as authorized by the OpenLDAP
+ * Public License.
+ *
+ * A copy of this license is available in the file LICENSE in the
+ * top-level directory of the distribution or, alternatively, at
+ * <http://www.OpenLDAP.org/license.html>.
  */
 
 #include "portable.h"
@@ -20,37 +29,24 @@ static ID_BLOCK	*base_candidate(
 	Backend *be, Entry *e );
 
 static ID_BLOCK	*search_candidates(
-	Backend *be, Entry *e, Filter *filter,
+	Operation *op, Entry *e, Filter *filter,
 	int scope, int deref, int manageDSAit );
 
 
 int
 ldbm_back_search(
-    Backend	*be,
-    Connection	*conn,
     Operation	*op,
-    struct berval	*base,
-    struct berval	*nbase,
-    int		scope,
-    int		deref,
-    int		slimit,
-    int		tlimit,
-    Filter	*filter,
-    struct berval	*filterstr,
-    AttributeName	*attrs,
-    int		attrsonly )
+    SlapReply	*rs )
 {
-	struct ldbminfo	*li = (struct ldbminfo *) be->be_private;
+	struct ldbminfo	*li = (struct ldbminfo *) op->o_bd->be_private;
 	int		rc, err;
 	const char *text = NULL;
 	time_t		stoptime;
 	ID_BLOCK		*candidates;
 	ID		id, cursor;
 	Entry		*e;
-	BerVarray		v2refs = NULL;
 	Entry	*matched = NULL;
 	struct berval	realbase = { 0, NULL };
-	int		nentries = 0;
 	int		manageDSAit = get_manageDSAit( op );
 	int		cscope = LDAP_SCOPE_DEFAULT;
 
@@ -66,76 +62,77 @@ ldbm_back_search(
 	/* grab giant lock for reading */
 	ldap_pvt_thread_rdwr_rlock(&li->li_giant_rwlock);
 
-	if ( nbase->bv_len == 0 ) {
+	if ( op->o_req_ndn.bv_len == 0 ) {
 		/* DIT root special case */
 		e = (Entry *) &slap_entry_root;
 
 		/* need normalized dn below */
 		ber_dupbv( &realbase, &e->e_nname );
 
-		candidates = search_candidates( be, e, filter,
-		    scope, deref, manageDSAit );
+		candidates = search_candidates( op, e, op->oq_search.rs_filter,
+	    			op->oq_search.rs_scope, op->oq_search.rs_deref,
+				manageDSAit || get_domainScope(op) );
 
 		goto searchit;
 		
-	} else if ( deref & LDAP_DEREF_FINDING ) {
+	} else if ( op->oq_search.rs_deref & LDAP_DEREF_FINDING ) {
 		/* deref dn and get entry with reader lock */
-		e = deref_dn_r( be, nbase, &err, &matched, &text );
+		e = deref_dn_r( op->o_bd, &op->o_req_ndn, &rs->sr_err, &matched, &rs->sr_text );
 
-		if( err == LDAP_NO_SUCH_OBJECT ) err = LDAP_REFERRAL;
+		if( rs->sr_err == LDAP_NO_SUCH_OBJECT ) rs->sr_err = LDAP_REFERRAL;
 
 	} else {
 		/* get entry with reader lock */
-		e = dn2entry_r( be, nbase, &matched );
-		err = e != NULL ? LDAP_SUCCESS : LDAP_REFERRAL;
-		text = NULL;
+		e = dn2entry_r( op->o_bd, &op->o_req_ndn, &matched );
+		rs->sr_err = e != NULL ? LDAP_SUCCESS : LDAP_REFERRAL;
+		rs->sr_text = NULL;
 	}
 
 	if ( e == NULL ) {
 		struct berval matched_dn = { 0, NULL };
-		BerVarray refs = NULL;
 
 		if ( matched != NULL ) {
 			BerVarray erefs;
 			ber_dupbv( &matched_dn, &matched->e_name );
 
 			erefs = is_entry_referral( matched )
-				? get_entry_referrals( be, conn, op, matched )
+				? get_entry_referrals( op, matched )
 				: NULL;
 
 			cache_return_entry_r( &li->li_cache, matched );
 
 			if( erefs ) {
-				refs = referral_rewrite( erefs, &matched_dn,
-					base, scope );
+				rs->sr_ref = referral_rewrite( erefs, &matched_dn,
+					&op->o_req_dn, op->oq_search.rs_scope );
 
 				ber_bvarray_free( erefs );
 			}
 
 		} else {
-			refs = referral_rewrite( default_referral,
-				NULL, base, scope );
+			rs->sr_ref = referral_rewrite( default_referral,
+				NULL, &op->o_req_dn, op->oq_search.rs_scope );
 		}
 
 		ldap_pvt_thread_rdwr_runlock(&li->li_giant_rwlock);
 
-		send_ldap_result( conn, op, err, matched_dn.bv_val, 
-			text, refs, NULL );
+		rs->sr_matched = matched_dn.bv_val;
+		send_ldap_result( op, rs );
 
-		ber_bvarray_free( refs );
+		ber_bvarray_free( rs->sr_ref );
 		ber_memfree( matched_dn.bv_val );
-		return 1;
+		rs->sr_ref = NULL;
+		rs->sr_matched = NULL;
+		return LDAP_REFERRAL;
 	}
 
 	if (!manageDSAit && is_entry_referral( e ) ) {
 		/* entry is a referral, don't allow add */
 		struct berval matched_dn;
 		BerVarray erefs;
-		BerVarray refs;
 
 		ber_dupbv( &matched_dn, &e->e_name );
-		erefs = get_entry_referrals( be, conn, op, e );
-		refs = NULL;
+		erefs = get_entry_referrals( op, e );
+		rs->sr_ref = NULL;
 
 		cache_return_entry_r( &li->li_cache, e );
 		ldap_pvt_thread_rdwr_runlock(&li->li_giant_rwlock);
@@ -151,41 +148,43 @@ ldbm_back_search(
 #endif
 
 		if( erefs ) {
-			refs = referral_rewrite( erefs, &matched_dn,
-				base, scope );
+			rs->sr_ref = referral_rewrite( erefs, &matched_dn,
+				&op->o_req_dn, op->oq_search.rs_scope );
 
 			ber_bvarray_free( erefs );
 		}
 
-		if( refs ) {
-			send_ldap_result( conn, op, LDAP_REFERRAL,
-				matched_dn.bv_val, NULL, refs, NULL );
-			ber_bvarray_free( refs );
+		rs->sr_matched = matched_dn.bv_val;
+		if( rs->sr_ref ) {
+			rs->sr_err = LDAP_REFERRAL;
+			send_ldap_result( op, rs );
+			ber_bvarray_free( rs->sr_ref );
 
 		} else {
-			send_ldap_result( conn, op, LDAP_OTHER,
-				matched_dn.bv_val,
-			"bad referral object", NULL, NULL );
+			send_ldap_error( op, rs, LDAP_OTHER,
+			"bad referral object" );
 		}
 
 		ber_memfree( matched_dn.bv_val );
-		return 1;
+		rs->sr_ref = NULL;
+		rs->sr_matched = NULL;
+		return LDAP_OTHER;
 	}
 
 	if ( is_entry_alias( e ) ) {
 		/* don't deref */
-		deref = LDAP_DEREF_NEVER;
+		op->oq_search.rs_deref = LDAP_DEREF_NEVER;
 	}
 
-	if ( scope == LDAP_SCOPE_BASE ) {
+	if ( op->oq_search.rs_scope == LDAP_SCOPE_BASE ) {
 		cscope = LDAP_SCOPE_BASE;
-		candidates = base_candidate( be, e );
+		candidates = base_candidate( op->o_bd, e );
 
 	} else {
-		cscope = ( scope != LDAP_SCOPE_SUBTREE )
+		cscope = ( op->oq_search.rs_scope != LDAP_SCOPE_SUBTREE )
 			? LDAP_SCOPE_BASE : LDAP_SCOPE_SUBTREE;
-		candidates = search_candidates( be, e, filter,
-		    scope, deref, manageDSAit );
+		candidates = search_candidates( op, e, op->oq_search.rs_filter,
+		    op->oq_search.rs_scope, op->oq_search.rs_deref, manageDSAit );
 	}
 
 	/* need normalized dn below */
@@ -204,60 +203,64 @@ searchit:
 			0, 0, 0 );
 #endif
 
-		send_search_result( conn, op,
-			LDAP_SUCCESS,
-			NULL, NULL, NULL, NULL, 0 );
+		rs->sr_err = LDAP_SUCCESS;
+		send_ldap_result( op, rs );
 
-		rc = 1;
+		rc = LDAP_SUCCESS;
 		goto done;
 	}
 
 	/* if not root, get appropriate limits */
-	if ( be_isroot( be, &op->o_ndn ) ) {
+	if ( be_isroot( op->o_bd, &op->o_ndn ) )
+	{
+		/*
+		 * FIXME: I'd consider this dangerous if someone
+		 * uses isroot for anything but handling limits
+		 */
 		isroot = 1;
 	} else {
-		( void ) get_limits( be, &op->o_ndn, &limit );
+		( void ) get_limits( op->o_bd, &op->o_ndn, &limit );
 	}
 
 	/* if candidates exceed to-be-checked entries, abort */
 	if ( !isroot && limit->lms_s_unchecked != -1 ) {
 		if ( ID_BLOCK_NIDS( candidates ) > (unsigned) limit->lms_s_unchecked ) {
-			send_search_result( conn, op, LDAP_ADMINLIMIT_EXCEEDED,
-					NULL, NULL, NULL, NULL, 0 );
-			rc = 0;
+			send_ldap_error( op, rs, LDAP_ADMINLIMIT_EXCEEDED,
+					NULL );
+			rc = LDAP_SUCCESS;
 			goto done;
 		}
 	}
 	
 	/* if root an no specific limit is required, allow unlimited search */
 	if ( isroot ) {
-		if ( tlimit == 0 ) {
-			tlimit = -1;
+		if ( op->oq_search.rs_tlimit == 0 ) {
+			op->oq_search.rs_tlimit = -1;
 		}
 
-		if ( slimit == 0 ) {
-			slimit = -1;
+		if ( op->oq_search.rs_slimit == 0 ) {
+			op->oq_search.rs_slimit = -1;
 		}
 
 	} else {
 		/* if no limit is required, use soft limit */
-		if ( tlimit <= 0 ) {
-			tlimit = limit->lms_t_soft;
+		if ( op->oq_search.rs_tlimit <= 0 ) {
+			op->oq_search.rs_tlimit = limit->lms_t_soft;
 		
 		/* if requested limit higher than hard limit, abort */
-		} else if ( tlimit > limit->lms_t_hard ) {
+		} else if ( op->oq_search.rs_tlimit > limit->lms_t_hard ) {
 			/* no hard limit means use soft instead */
 			if ( limit->lms_t_hard == 0
 					&& limit->lms_t_soft > -1
-					&& tlimit > limit->lms_t_soft ) {
-				tlimit = limit->lms_t_soft;
+					&& op->oq_search.rs_tlimit > limit->lms_t_soft ) {
+				op->oq_search.rs_tlimit = limit->lms_t_soft;
 			
 			/* positive hard limit means abort */
 			} else if ( limit->lms_t_hard > 0 ) {
-				send_search_result( conn, op, 
+				send_ldap_error( op, rs,
 						LDAP_ADMINLIMIT_EXCEEDED,
-						NULL, NULL, NULL, NULL, 0 );
-				rc = 0; 
+						NULL );
+				rc = LDAP_SUCCESS; 
 				goto done;
 			}
 
@@ -265,23 +268,23 @@ searchit:
 		}
 
 		/* if no limit is required, use soft limit */
-		if ( slimit <= 0 ) {
-			slimit = limit->lms_s_soft;
+		if ( op->oq_search.rs_slimit <= 0 ) {
+			op->oq_search.rs_slimit = limit->lms_s_soft;
 
 		/* if requested limit higher than hard limit, abort */
-		} else if ( slimit > limit->lms_s_hard ) {
+		} else if ( op->oq_search.rs_slimit > limit->lms_s_hard ) {
 			/* no hard limit means use soft instead */
 			if ( limit->lms_s_hard == 0
 					&& limit->lms_s_soft > -1
-					&& slimit > limit->lms_s_soft ) {
-				slimit = limit->lms_s_soft;
+					&& op->oq_search.rs_slimit > limit->lms_s_soft ) {
+				op->oq_search.rs_slimit = limit->lms_s_soft;
 
 			/* positive hard limit means abort */
 			} else if ( limit->lms_s_hard > 0 ) {
-				send_search_result( conn, op,
+				send_ldap_error( op, rs,
 						LDAP_ADMINLIMIT_EXCEEDED,
-						NULL, NULL, NULL, NULL, 0 );
-				rc = 0;
+						NULL );
+				rc = LDAP_SUCCESS;
 				goto done;
 			}
 
@@ -290,7 +293,8 @@ searchit:
 	}
 
 	/* compute it anyway; root does not use it */
-	stoptime = op->o_time + tlimit;
+	stoptime = op->o_time + op->oq_search.rs_tlimit;
+	rs->sr_attrs = op->oq_search.rs_attrs;
 
 	for ( id = idl_firstid( candidates, &cursor ); id != NOID;
 	    id = idl_nextid( candidates, &cursor ) )
@@ -300,20 +304,20 @@ searchit:
 
 		/* check for abandon */
 		if ( op->o_abandon ) {
-			rc = 0;
+			rc = LDAP_SUCCESS;
 			goto done;
 		}
 
 		/* check time limit */
-		if ( tlimit != -1 && slap_get_time() > stoptime ) {
-			send_search_result( conn, op, LDAP_TIMELIMIT_EXCEEDED,
-				NULL, NULL, v2refs, NULL, nentries );
-			rc = 0;
+		if ( op->oq_search.rs_tlimit != -1 && slap_get_time() > stoptime ) {
+			rs->sr_err = LDAP_TIMELIMIT_EXCEEDED;
+			send_ldap_result( op, rs );
+			rc = LDAP_SUCCESS;
 			goto done;
 		}
 
 		/* get the entry with reader lock */
-		e = id2entry_r( be, id );
+		e = id2entry_r( op->o_bd, id );
 
 		if ( e == NULL ) {
 #ifdef NEW_LOGGING
@@ -328,12 +332,33 @@ searchit:
 			goto loop_continue;
 		}
 
-		if ( deref & LDAP_DEREF_SEARCHING && is_entry_alias( e ) ) {
+		rs->sr_entry = e;
+
+#ifdef LDBM_SUBENTRIES
+	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;
+	}
+#endif
+
+		if ( op->oq_search.rs_deref & LDAP_DEREF_SEARCHING && is_entry_alias( e ) ) {
 			Entry *matched;
 			int err;
 			const char *text;
 			
-			e = deref_entry_r( be, e, &err, &matched, &text );
+			e = deref_entry_r( op->o_bd, e, &err, &matched, &text );
 
 			if( e == NULL ) {
 				e = matched;
@@ -346,7 +371,7 @@ searchit:
 			}
 
 			/* need to skip alias which deref into scope */
-			if( scope & LDAP_SCOPE_ONELEVEL ) {
+			if( op->oq_search.rs_scope & LDAP_SCOPE_ONELEVEL ) {
 				struct berval pdn;
 				dnParent( &e->e_nname, &pdn );
 				if ( ber_bvcmp( &pdn, &realbase ) ) {
@@ -367,6 +392,8 @@ searchit:
 				goto loop_continue;
 			}
 
+			rs->sr_entry = e;
+
 			scopeok = 1;
 		}
 
@@ -375,21 +402,21 @@ searchit:
 		 * this for non-base searches, and don't check the filter
 		 * explicitly here since it's only a candidate anyway.
 		 */
-		if ( !manageDSAit && scope != LDAP_SCOPE_BASE &&
+		if ( !manageDSAit && op->oq_search.rs_scope != LDAP_SCOPE_BASE &&
 			is_entry_referral( e ) )
 		{
 			struct berval	dn;
 
 			/* check scope */
-			if ( !scopeok && scope == LDAP_SCOPE_ONELEVEL ) {
-				if ( !be_issuffix( be, &e->e_nname ) ) {
+			if ( !scopeok && op->oq_search.rs_scope == LDAP_SCOPE_ONELEVEL ) {
+				if ( !be_issuffix( op->o_bd, &e->e_nname ) ) {
 					dnParent( &e->e_nname, &dn );
 					scopeok = dn_match( &dn, &realbase );
 				} else {
 					scopeok = (realbase.bv_len == 0);
 				}
 
-			} else if ( !scopeok && scope == LDAP_SCOPE_SUBTREE ) {
+			} else if ( !scopeok && op->oq_search.rs_scope == LDAP_SCOPE_SUBTREE ) {
 				scopeok = dnIsSuffix( &e->e_nname, &realbase );
 
 			} else {
@@ -397,18 +424,17 @@ searchit:
 			}
 
 			if( scopeok ) {
-				BerVarray erefs = get_entry_referrals(
-					be, conn, op, e );
-				BerVarray refs = referral_rewrite( erefs,
+				BerVarray erefs = get_entry_referrals( op, e );
+				rs->sr_ref = referral_rewrite( erefs,
 					&e->e_name, NULL,
-					scope == LDAP_SCOPE_SUBTREE
+					op->oq_search.rs_scope == LDAP_SCOPE_SUBTREE
 						? LDAP_SCOPE_SUBTREE
 						: LDAP_SCOPE_BASE );
 
-				send_search_reference( be, conn, op,
-					e, refs, NULL, &v2refs );
+				send_search_reference( op, rs );
 
-				ber_bvarray_free( refs );
+				ber_bvarray_free( rs->sr_ref );
+				rs->sr_ref = NULL;
 
 			} else {
 #ifdef NEW_LOGGING
@@ -425,22 +451,26 @@ searchit:
 			goto loop_continue;
 		}
 
+		if ( !manageDSAit && is_entry_glue( e )) {
+			goto loop_continue;
+		}
+
 		/* if it matches the filter and scope, send it */
-		result = test_filter( be, conn, op, e, filter );
+		result = test_filter( op, e, op->oq_search.rs_filter );
 
 		if ( result == LDAP_COMPARE_TRUE ) {
 			struct berval	dn;
 
 			/* check scope */
-			if ( !scopeok && scope == LDAP_SCOPE_ONELEVEL ) {
-				if ( !be_issuffix( be, &e->e_nname ) ) {
+			if ( !scopeok && op->oq_search.rs_scope == LDAP_SCOPE_ONELEVEL ) {
+				if ( !be_issuffix( op->o_bd, &e->e_nname ) ) {
 					dnParent( &e->e_nname, &dn );
 					scopeok = dn_match( &dn, &realbase );
 				} else {
 					scopeok = (realbase.bv_len == 0);
 				}
 
-			} else if ( !scopeok && scope == LDAP_SCOPE_SUBTREE ) {
+			} else if ( !scopeok && op->oq_search.rs_scope == LDAP_SCOPE_SUBTREE ) {
 				scopeok = dnIsSuffix( &e->e_nname, &realbase );
 
 			} else {
@@ -449,28 +479,26 @@ searchit:
 
 			if ( scopeok ) {
 				/* check size limit */
-				if ( --slimit == -1 ) {
+				if ( --op->oq_search.rs_slimit == -1 ) {
 					cache_return_entry_r( &li->li_cache, e );
-					send_search_result( conn, op,
-						LDAP_SIZELIMIT_EXCEEDED, NULL, NULL,
-						v2refs, NULL, nentries );
-					rc = 0;
+					rs->sr_err = LDAP_SIZELIMIT_EXCEEDED;
+					send_ldap_result( op, rs );
+					rc = LDAP_SUCCESS;
 					goto done;
 				}
 
 				if (e) {
-					result = send_search_entry(be, conn, op,
-						e, attrs, attrsonly, NULL);
+
+					result = send_search_entry( op, rs );
 
 					switch (result) {
 					case 0:		/* entry sent ok */
-						nentries++;
 						break;
 					case 1:		/* entry not sent */
 						break;
 					case -1:	/* connection closed */
 						cache_return_entry_r( &li->li_cache, e );
-						rc = 0;
+						rc = LDAP_SUCCESS;
 						goto done;
 					}
 				}
@@ -507,11 +535,11 @@ loop_continue:
 		ldap_pvt_thread_yield();
 	}
 
-	send_search_result( conn, op,
-		v2refs == NULL ? LDAP_SUCCESS : LDAP_REFERRAL,
-		NULL, NULL, v2refs, NULL, nentries );
+	rs->sr_err = rs->sr_v2ref ? LDAP_REFERRAL : LDAP_SUCCESS;
+	rs->sr_ref = rs->sr_v2ref;
+	send_ldap_result( op, rs );
 
-	rc = 0;
+	rc = LDAP_SUCCESS;
 
 done:
 	ldap_pvt_thread_rdwr_runlock(&li->li_giant_rwlock);
@@ -519,7 +547,7 @@ done:
 	if( candidates != NULL )
 		idl_free( candidates );
 
-	if( v2refs ) ber_bvarray_free( v2refs );
+	if( rs->sr_v2ref ) ber_bvarray_free( rs->sr_v2ref );
 	if( realbase.bv_val ) free( realbase.bv_val );
 
 	return rc;
@@ -548,7 +576,7 @@ base_candidate(
 
 static ID_BLOCK *
 search_candidates(
-    Backend	*be,
+    Operation	*op,
     Entry	*e,
     Filter	*filter,
     int		scope,
@@ -560,6 +588,10 @@ search_candidates(
     AttributeAssertion aa_ref, aa_alias;
 	struct berval bv_ref = { sizeof("referral")-1, "referral" };
 	struct berval bv_alias = { sizeof("alias")-1, "alias" };
+#ifdef LDBM_SUBENTRIES
+	Filter  sf;
+	AttributeAssertion aa_subentry;
+#endif
 
 #ifdef NEW_LOGGING
 	LDAP_LOG( BACK_LDBM, DETAIL1,
@@ -605,7 +637,19 @@ search_candidates(
 	fand.f_dn = &e->e_nname;
 	fand.f_next = xf.f_or == filter ? filter : &xf ;
 
-	candidates = filter_candidates( be, &f );
+#ifdef LDBM_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 = fand.f_next;
+		fand.f_next = &sf;
+	}
+#endif
+
+	candidates = filter_candidates( op, &f );
 
 	return( candidates );
 }