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

diff --git a/servers/slapd/back-ldbm/search.c b/servers/slapd/back-ldbm/search.c
index c61b921ac6..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-2002 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;
 
@@ -58,8 +54,7 @@ ldbm_back_search(
 	int isroot = 0;
 		
 #ifdef NEW_LOGGING
-	LDAP_LOG(( "backend", LDAP_LEVEL_ENTRY,
-		"ldbm_back_search: enter\n" ));
+	LDAP_LOG( BACK_LDBM, ENTRY, "ldbm_back_search: enter\n", 0, 0, 0 );
 #else
 	Debug(LDAP_DEBUG_TRACE, "=> ldbm_back_search\n", 0, 0, 0);
 #endif
@@ -67,84 +62,85 @@ 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);
 
 #ifdef NEW_LOGGING
-		LDAP_LOG(( "backend", LDAP_LEVEL_INFO,
+		LDAP_LOG( BACK_LDBM, INFO,
 			"ldbm_search: entry (%s) is a referral.\n",
-			e->e_dn ));
+			e->e_dn, 0, 0 );
 #else
 		Debug( LDAP_DEBUG_TRACE,
 			"ldbm_search: entry is referral\n",
@@ -152,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 */
@@ -198,65 +196,71 @@ searchit:
 	if ( candidates == NULL ) {
 		/* no candidates */
 #ifdef NEW_LOGGING
-		LDAP_LOG(( "backend", LDAP_LEVEL_INFO,
-			"ldbm_search: no candidates\n" ));
+		LDAP_LOG( BACK_LDBM, INFO,
+			"ldbm_search: no candidates\n" , 0, 0, 0);
 #else
 		Debug( LDAP_DEBUG_TRACE, "ldbm_search: no candidates\n",
 			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_UNWILLING_TO_PERFORM,
-					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 ) {
-				tlimit = limit->lms_t_soft;
+			if ( limit->lms_t_hard == 0
+					&& limit->lms_t_soft > -1
+					&& 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, 
-						LDAP_UNWILLING_TO_PERFORM,
-						NULL, NULL, NULL, NULL, 0 );
-				rc = 0; 
+				send_ldap_error( op, rs,
+						LDAP_ADMINLIMIT_EXCEEDED,
+						NULL );
+				rc = LDAP_SUCCESS; 
 				goto done;
 			}
 
@@ -264,21 +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 ) {
-				slimit = limit->lms_s_soft;
+			if ( limit->lms_s_hard == 0
+					&& limit->lms_s_soft > -1
+					&& 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,
-						LDAP_UNWILLING_TO_PERFORM,
-						NULL, NULL, NULL, NULL, 0 );
-				rc = 0;
+				send_ldap_error( op, rs,
+						LDAP_ADMINLIMIT_EXCEEDED,
+						NULL );
+				rc = LDAP_SUCCESS;
 				goto done;
 			}
 
@@ -287,39 +293,36 @@ 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 ) )
 	{
 		int scopeok = 0;
+		int result = 0;
 
 		/* check for abandon */
-		ldap_pvt_thread_mutex_lock( &op->o_abandonmutex );
-
 		if ( op->o_abandon ) {
-			ldap_pvt_thread_mutex_unlock( &op->o_abandonmutex );
-			rc = 0;
+			rc = LDAP_SUCCESS;
 			goto done;
 		}
 
-		ldap_pvt_thread_mutex_unlock( &op->o_abandonmutex );
-
 		/* 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
-			LDAP_LOG(( "backend", LDAP_LEVEL_INFO,
-				"ldbm_search: candidate %ld not found.\n", id ));
+			LDAP_LOG( BACK_LDBM, INFO,
+				"ldbm_search: candidate %ld not found.\n", id, 0, 0 );
 #else
 			Debug( LDAP_DEBUG_TRACE,
 				"ldbm_search: candidate %ld not found\n",
@@ -329,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;
@@ -347,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 ) ) {
@@ -357,8 +381,8 @@ searchit:
 			} else if ( dnIsSuffix( &e->e_nname, &realbase ) ) {
 				/* alias is within scope */
 #ifdef NEW_LOGGING
-				LDAP_LOG(( "backend", LDAP_LEVEL_DETAIL1,
-					"ldbm_search: alias \"%s\" in subtree\n", e->e_dn ));
+				LDAP_LOG( BACK_LDBM, DETAIL1,
+					"ldbm_search: alias \"%s\" in subtree\n", e->e_dn, 0, 0 );
 #else
 				Debug( LDAP_DEBUG_TRACE,
 					"ldbm_search: alias \"%s\" in subtree\n",
@@ -368,6 +392,8 @@ searchit:
 				goto loop_continue;
 			}
 
+			rs->sr_entry = e;
+
 			scopeok = 1;
 		}
 
@@ -376,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 {
@@ -398,24 +424,23 @@ 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
-				LDAP_LOG(( "backend", LDAP_LEVEL_DETAIL2,
+				LDAP_LOG( BACK_LDBM, DETAIL2,
 					"ldbm_search: candidate referral %ld scope not okay\n",
-					id ));
+					id, 0, 0 );
 #else
 				Debug( LDAP_DEBUG_TRACE,
 					"ldbm_search: candidate referral %ld scope not okay\n",
@@ -426,20 +451,26 @@ searchit:
 			goto loop_continue;
 		}
 
+		if ( !manageDSAit && is_entry_glue( e )) {
+			goto loop_continue;
+		}
+
 		/* if it matches the filter and scope, send it */
-		if ( test_filter( be, conn, op, e, filter ) == LDAP_COMPARE_TRUE ) {
+		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 {
@@ -448,35 +479,34 @@ 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) {
-					int 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;
 					}
 				}
 			} else {
 #ifdef NEW_LOGGING
-				LDAP_LOG(( "backend", LDAP_LEVEL_DETAIL2,
-					"ldbm_search: candidate entry %ld scope not okay\n", id ));
+				LDAP_LOG( BACK_LDBM, DETAIL2,
+					"ldbm_search: candidate entry %ld scope not okay\n", 
+					id, 0, 0 );
 #else
 				Debug( LDAP_DEBUG_TRACE,
 					"ldbm_search: candidate entry %ld scope not okay\n",
@@ -486,8 +516,9 @@ searchit:
 
 		} else {
 #ifdef NEW_LOGGING
-			LDAP_LOG(( "backend", LDAP_LEVEL_DETAIL2,
-				"ldbm_search: candidate entry %ld does not match filter\n", id ));
+			LDAP_LOG( BACK_LDBM, DETAIL2,
+				"ldbm_search: candidate entry %ld does not match filter\n", 
+				id, 0, 0 );
 #else
 			Debug( LDAP_DEBUG_TRACE,
 				"ldbm_search: candidate entry %ld does not match filter\n",
@@ -504,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);
@@ -516,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;
@@ -530,8 +561,7 @@ base_candidate(
 	ID_BLOCK		*idl;
 
 #ifdef NEW_LOGGING
-	LDAP_LOG(( "backend", LDAP_LEVEL_ENTRY,
-		   "base_candidate: base (%s)\n", e->e_dn ));
+	LDAP_LOG( BACK_LDBM, ENTRY, "base_candidate: base (%s)\n", e->e_dn, 0, 0 );
 #else
 	Debug(LDAP_DEBUG_TRACE, "base_candidates: base: \"%s\"\n",
 		e->e_dn, 0, 0);
@@ -546,7 +576,7 @@ base_candidate(
 
 static ID_BLOCK *
 search_candidates(
-    Backend	*be,
+    Operation	*op,
     Entry	*e,
     Filter	*filter,
     int		scope,
@@ -556,13 +586,17 @@ search_candidates(
 	ID_BLOCK		*candidates;
 	Filter		f, fand, rf, af, xf;
     AttributeAssertion aa_ref, aa_alias;
-	struct berval bv_ref = { sizeof("REFERRAL")-1, "REFERRAL" };
-	struct berval bv_alias = { sizeof("ALIAS")-1, "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(( "backend", LDAP_LEVEL_DETAIL1,
+	LDAP_LOG( BACK_LDBM, DETAIL1,
 		   "search_candidates: base (%s) scope %d deref %d\n",
-		   e->e_ndn, scope, deref ));
+		   e->e_ndn, scope, deref );
 #else
 	Debug(LDAP_DEBUG_TRACE,
 		"search_candidates: base=\"%s\" s=%d d=%d\n",
@@ -603,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 );
 }