--- servers/slapd/filter.c	2003/04/09 14:52:03	1.106
+++ servers/slapd/filter.c	2003/12/01 00:58:34	1.115.2.2
@@ -1,8 +1,27 @@
 /* filter.c - routines for parsing and dealing with filters */
-/* $OpenLDAP: pkg/ldap/servers/slapd/filter.c,v 1.105 2003/04/07 02:03:55 kurt Exp $ */
-/*
- * Copyright 1998-2003 The OpenLDAP Foundation, All Rights Reserved.
- * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
+/* $OpenLDAP: pkg/ldap/servers/slapd/filter.c,v 1.115.2.1 2003/10/06 14:57:29 kurt Exp $ */
+/* 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>.
+ */
+/* Portions Copyright (c) 1995 Regents of the University of Michigan.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that this notice is preserved and that due credit is given
+ * to the University of Michigan at Ann Arbor. The name of the University
+ * may not be used to endorse or promote products derived from this
+ * software without specific prior written permission. This software
+ * is provided ``as is'' without express or implied warranty.
  */
 
 #include "portable.h"
@@ -26,6 +45,11 @@ static int	get_ssa(
 	SubstringsAssertion **s,
 	const char **text );
 
+static int filter_escape_value_x(
+	struct berval *in,
+	struct berval *out,
+	void *ctx );
+
 static void simple_vrFilter2bv(
 	Operation *op,
 	ValuesReturnFilter *f,
@@ -212,6 +236,10 @@ get_filter(
 		if ( err != LDAP_SUCCESS ) {
 			break;
 		}
+		if ( f.f_and == NULL ) {
+			f.f_choice = SLAPD_FILTER_COMPUTED;
+			f.f_result = LDAP_COMPARE_TRUE;
+		}
 		/* no assert - list could be empty */
 		break;
 
@@ -226,6 +254,10 @@ get_filter(
 		if ( err != LDAP_SUCCESS ) {
 			break;
 		}
+		if ( f.f_or == NULL ) {
+			f.f_choice = SLAPD_FILTER_COMPUTED;
+			f.f_result = LDAP_COMPARE_FALSE;
+		}
 		/* no assert - list could be empty */
 		break;
 
@@ -243,6 +275,23 @@ get_filter(
 		}
 
 		assert( f.f_not != NULL );
+		if ( f.f_not->f_choice == SLAPD_FILTER_COMPUTED ) {
+			int fresult = f.f_not->f_result;
+			f.f_choice = SLAPD_FILTER_COMPUTED;
+			op->o_tmpfree( f.f_not, op->o_tmpmemctx );
+			f.f_not = NULL;
+
+			switch( fresult ) {
+			case LDAP_COMPARE_TRUE:
+				f.f_result = LDAP_COMPARE_FALSE;
+				break;
+			case LDAP_COMPARE_FALSE:
+				f.f_result = LDAP_COMPARE_TRUE;
+				break;
+			default: ;
+				/* (!Undefined) is Undefined */
+			}
+		}
 		break;
 
 	case LDAP_FILTER_EXT:
@@ -278,6 +327,7 @@ get_filter(
 
 	if( err != LDAP_SUCCESS && err != SLAPD_DISCONNECT ) {
 		/* ignore error */
+		*text = NULL;
 		f.f_choice = SLAPD_FILTER_COMPUTED;
 		f.f_result = SLAPD_COMPARE_UNDEFINED;
 		err = LDAP_SUCCESS;
@@ -372,7 +422,13 @@ get_ssa(
 	rc = slap_bv2ad( &desc, &ssa.sa_desc, text );
 
 	if( rc != LDAP_SUCCESS ) {
-		return LDAP_SUCCESS;
+		/* skip over the rest of this filter */
+		for ( tag = ber_first_element( ber, &len, &last );
+			tag != LBER_DEFAULT;
+			tag = ber_next_element( ber, &len, last ) ) {
+			ber_scanf( ber, "x" );
+		}
+		return rc;
 	}
 
 	rc = LDAP_PROTOCOL_ERROR;
@@ -426,7 +482,7 @@ get_ssa(
 		/* validate/normalize using equality matching rule validator! */
 		rc = asserted_value_validate_normalize(
 			ssa.sa_desc, ssa.sa_desc->ad_type->sat_equality,
-			usage, &value, &nvalue, text );
+			usage, &value, &nvalue, text, op->o_tmpmemctx );
 
 		if( rc != LDAP_SUCCESS ) {
 			goto return_error;
@@ -448,7 +504,7 @@ get_ssa(
 				|| ssa.sa_any != NULL 
 				|| ssa.sa_final.bv_val != NULL )
 			{
-				free( nvalue.bv_val );
+				sl_free( nvalue.bv_val, op->o_tmpmemctx );
 				goto return_error;
 			}
 
@@ -465,15 +521,11 @@ get_ssa(
 #endif
 
 			if ( ssa.sa_final.bv_val != NULL ) {
-				free( nvalue.bv_val );
+				sl_free( nvalue.bv_val, op->o_tmpmemctx );
 				goto return_error;
 			}
 
-#ifdef notyet
 			ber_bvarray_add_x( &ssa.sa_any, &nvalue, op->o_tmpmemctx );
-#else
-			ber_bvarray_add( &ssa.sa_any, &nvalue );
-#endif
 			break;
 
 		case LDAP_SUBSTRING_FINAL:
@@ -486,7 +538,7 @@ get_ssa(
 #endif
 
 			if ( ssa.sa_final.bv_val != NULL ) {
-				free( nvalue.bv_val );
+				sl_free( nvalue.bv_val, op->o_tmpmemctx );
 				goto return_error;
 			}
 
@@ -505,7 +557,7 @@ get_ssa(
 #endif
 
 			assert( 0 );
-			free( nvalue.bv_val );
+			sl_free( nvalue.bv_val, op->o_tmpmemctx );
 
 return_error:
 #ifdef NEW_LOGGING
@@ -516,9 +568,9 @@ return_error:
 			Debug( LDAP_DEBUG_FILTER, "  error=%ld\n",
 				(long) rc, 0, 0 );
 #endif
-			free( ssa.sa_initial.bv_val );
-			ber_bvarray_free( ssa.sa_any );
-			free( ssa.sa_final.bv_val );
+			sl_free( ssa.sa_initial.bv_val, op->o_tmpmemctx );
+			ber_bvarray_free_x( ssa.sa_any, op->o_tmpmemctx );
+			sl_free( ssa.sa_final.bv_val, op->o_tmpmemctx );
 			return rc;
 		}
 
@@ -562,19 +614,11 @@ filter_free_x( Operation *op, Filter *f
 
 	case LDAP_FILTER_SUBSTRINGS:
 		if ( f->f_sub_initial.bv_val != NULL ) {
-#ifdef notyet
 			op->o_tmpfree( f->f_sub_initial.bv_val, op->o_tmpmemctx );
-#else
-			ch_free( f->f_sub_initial.bv_val );
-#endif
 		}
-		ber_bvarray_free( f->f_sub_any );
+		ber_bvarray_free_x( f->f_sub_any, op->o_tmpmemctx );
 		if ( f->f_sub_final.bv_val != NULL ) {
-#ifdef notyet
 			op->o_tmpfree( f->f_sub_final.bv_val, op->o_tmpmemctx );
-#else
-			ch_free( f->f_sub_final.bv_val );
-#endif
 		}
 		op->o_tmpfree( f->f_sub, op->o_tmpmemctx );
 		break;
@@ -614,86 +658,84 @@ filter_free( Filter *f )
 {
 	Operation op;
 
-	op.o_tmpmemctx = NULL;
-	op.o_tmpfree = (BER_MEMFREE_FN *)ch_free;
+	op.o_tmpmemctx = sl_context( f );
+	op.o_tmpmfuncs = &sl_mfuncs;
 	filter_free_x( &op, f );
 }
 
 void
-filter2bv_x( Filter *f, struct berval *fstr, void *ctx )
+filter2bv_x( Operation *op, Filter *f, struct berval *fstr )
 {
 	int	i;
 	Filter	*p;
 	struct berval tmp;
 	ber_len_t len;
-	BER_MEMALLOC_FN *alloc = ctx ? sl_malloc : (BER_MEMALLOC_FN *)ch_malloc;
-	BER_MEMREALLOC_FN *reallo = ctx ? sl_realloc : (BER_MEMREALLOC_FN *)ch_realloc;
 
 	if ( f == NULL ) {
-		ber_str2bv_x( "No filter!", sizeof("No filter!")-1, 1, fstr, ctx );
+		ber_str2bv_x( "No filter!", sizeof("No filter!")-1, 1, fstr, op->o_tmpmemctx );
 		return;
 	}
 
 	switch ( f->f_choice ) {
 	case LDAP_FILTER_EQUALITY:
-		filter_escape_value_x( &f->f_av_value, &tmp, ctx );
+		filter_escape_value_x( &f->f_av_value, &tmp, op->o_tmpmemctx );
 
 		fstr->bv_len = f->f_av_desc->ad_cname.bv_len +
 			tmp.bv_len + ( sizeof("(=)") - 1 );
-		fstr->bv_val = alloc( fstr->bv_len + 1, ctx );
+		fstr->bv_val = op->o_tmpalloc( fstr->bv_len + 1, op->o_tmpmemctx );
 
 		snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s=%s)",
 			f->f_av_desc->ad_cname.bv_val,
 			tmp.bv_val );
 
-		ber_memfree_x( tmp.bv_val, ctx );
+		ber_memfree_x( tmp.bv_val, op->o_tmpmemctx );
 		break;
 
 	case LDAP_FILTER_GE:
-		filter_escape_value_x( &f->f_av_value, &tmp, ctx );
+		filter_escape_value_x( &f->f_av_value, &tmp, op->o_tmpmemctx );
 
 		fstr->bv_len = f->f_av_desc->ad_cname.bv_len +
 			tmp.bv_len + ( sizeof("(>=)") - 1 );
-		fstr->bv_val = alloc( fstr->bv_len + 1, ctx );
+		fstr->bv_val = op->o_tmpalloc( fstr->bv_len + 1, op->o_tmpmemctx );
 
 		snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s>=%s)",
 			f->f_av_desc->ad_cname.bv_val,
 			tmp.bv_val );
 
-		ber_memfree_x( tmp.bv_val, ctx );
+		ber_memfree_x( tmp.bv_val, op->o_tmpmemctx );
 		break;
 
 	case LDAP_FILTER_LE:
-		filter_escape_value_x( &f->f_av_value, &tmp, ctx );
+		filter_escape_value_x( &f->f_av_value, &tmp, op->o_tmpmemctx );
 
 		fstr->bv_len = f->f_av_desc->ad_cname.bv_len +
 			tmp.bv_len + ( sizeof("(<=)") - 1 );
-		fstr->bv_val = alloc( fstr->bv_len + 1, ctx );
+		fstr->bv_val = op->o_tmpalloc( fstr->bv_len + 1, op->o_tmpmemctx );
 
 		snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s<=%s)",
 			f->f_av_desc->ad_cname.bv_val,
 			tmp.bv_val );
 
-		ber_memfree_x( tmp.bv_val, ctx );
+		ber_memfree_x( tmp.bv_val, op->o_tmpmemctx );
 		break;
 
 	case LDAP_FILTER_APPROX:
-		filter_escape_value_x( &f->f_av_value, &tmp, ctx );
+		filter_escape_value_x( &f->f_av_value, &tmp, op->o_tmpmemctx );
 
 		fstr->bv_len = f->f_av_desc->ad_cname.bv_len +
 			tmp.bv_len + ( sizeof("(~=)") - 1 );
-		fstr->bv_val = alloc( fstr->bv_len + 1, ctx );
+		fstr->bv_val = op->o_tmpalloc( fstr->bv_len + 1, op->o_tmpmemctx );
 
 		snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s~=%s)",
 			f->f_av_desc->ad_cname.bv_val,
 			tmp.bv_val );
-		ber_memfree_x( tmp.bv_val, ctx );
+		ber_memfree_x( tmp.bv_val, op->o_tmpmemctx );
 		break;
 
 	case LDAP_FILTER_SUBSTRINGS:
 		fstr->bv_len = f->f_sub_desc->ad_cname.bv_len +
 			( sizeof("(=*)") - 1 );
-		fstr->bv_val = alloc( fstr->bv_len + 128, ctx );
+		fstr->bv_val = op->o_tmpalloc( fstr->bv_len + 128, op->o_tmpmemctx );
 
 		snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s=*)",
 			f->f_sub_desc->ad_cname.bv_val );
@@ -701,46 +743,46 @@ filter2bv_x( Filter *f, struct berval *f
 		if ( f->f_sub_initial.bv_val != NULL ) {
 			len = fstr->bv_len;
 
-			filter_escape_value_x( &f->f_sub_initial, &tmp, ctx );
+			filter_escape_value_x( &f->f_sub_initial, &tmp, op->o_tmpmemctx );
 
 			fstr->bv_len += tmp.bv_len;
-			fstr->bv_val = reallo( fstr->bv_val, fstr->bv_len + 1, ctx );
+			fstr->bv_val = op->o_tmprealloc( fstr->bv_val, fstr->bv_len + 1, op->o_tmpmemctx );
 
 			snprintf( &fstr->bv_val[len-2], tmp.bv_len+3,
 				/* "(attr=" */ "%s*)",
 				tmp.bv_val );
 
-			ber_memfree_x( tmp.bv_val, ctx );
+			ber_memfree_x( tmp.bv_val, op->o_tmpmemctx );
 		}
 
 		if ( f->f_sub_any != NULL ) {
 			for ( i = 0; f->f_sub_any[i].bv_val != NULL; i++ ) {
 				len = fstr->bv_len;
-				filter_escape_value_x( &f->f_sub_any[i], &tmp, ctx );
+				filter_escape_value_x( &f->f_sub_any[i], &tmp, op->o_tmpmemctx );
 
 				fstr->bv_len += tmp.bv_len + 1;
-				fstr->bv_val = reallo( fstr->bv_val, fstr->bv_len + 1, ctx );
+				fstr->bv_val = op->o_tmprealloc( fstr->bv_val, fstr->bv_len + 1, op->o_tmpmemctx );
 
 				snprintf( &fstr->bv_val[len-1], tmp.bv_len+3,
 					/* "(attr=[init]*[any*]" */ "%s*)",
 					tmp.bv_val );
-				ber_memfree_x( tmp.bv_val, ctx );
+				ber_memfree_x( tmp.bv_val, op->o_tmpmemctx );
 			}
 		}
 
 		if ( f->f_sub_final.bv_val != NULL ) {
 			len = fstr->bv_len;
 
-			filter_escape_value_x( &f->f_sub_final, &tmp, ctx );
+			filter_escape_value_x( &f->f_sub_final, &tmp, op->o_tmpmemctx );
 
 			fstr->bv_len += tmp.bv_len;
-			fstr->bv_val = reallo( fstr->bv_val, fstr->bv_len + 1, ctx );
+			fstr->bv_val = op->o_tmprealloc( fstr->bv_val, fstr->bv_len + 1, op->o_tmpmemctx );
 
 			snprintf( &fstr->bv_val[len-1], tmp.bv_len+3,
 				/* "(attr=[init*][any*]" */ "%s)",
 				tmp.bv_val );
 
-			ber_memfree_x( tmp.bv_val, ctx );
+			ber_memfree_x( tmp.bv_val, op->o_tmpmemctx );
 		}
 
 		break;
@@ -748,7 +790,7 @@ filter2bv_x( Filter *f, struct berval *f
 	case LDAP_FILTER_PRESENT:
 		fstr->bv_len = f->f_desc->ad_cname.bv_len +
 			( sizeof("(=*)") - 1 );
-		fstr->bv_val = alloc( fstr->bv_len + 1, ctx );
+		fstr->bv_val = op->o_tmpalloc( fstr->bv_len + 1, op->o_tmpmemctx );
 
 		snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s=*)",
 			f->f_desc->ad_cname.bv_val );
@@ -758,7 +800,7 @@ filter2bv_x( Filter *f, struct berval *f
 	case LDAP_FILTER_OR:
 	case LDAP_FILTER_NOT:
 		fstr->bv_len = sizeof("(%)") - 1;
-		fstr->bv_val = alloc( fstr->bv_len + 128, ctx );
+		fstr->bv_val = op->o_tmpalloc( fstr->bv_len + 128, op->o_tmpmemctx );
 
 		snprintf( fstr->bv_val, fstr->bv_len + 1, "(%c)",
 			f->f_choice == LDAP_FILTER_AND ? '&' :
@@ -767,22 +809,22 @@ filter2bv_x( Filter *f, struct berval *f
 		for ( p = f->f_list; p != NULL; p = p->f_next ) {
 			len = fstr->bv_len;
 
-			filter2bv( p, &tmp );
+			filter2bv_x( op, p, &tmp );
 			
 			fstr->bv_len += tmp.bv_len;
-			fstr->bv_val = reallo( fstr->bv_val, fstr->bv_len + 1, ctx );
+			fstr->bv_val = op->o_tmprealloc( fstr->bv_val, fstr->bv_len + 1, op->o_tmpmemctx );
 
 			snprintf( &fstr->bv_val[len-1], tmp.bv_len + 2, 
 				/*"("*/ "%s)", tmp.bv_val );
 
-			ch_free( tmp.bv_val );
+			op->o_tmpfree( tmp.bv_val, op->o_tmpmemctx );
 		}
 
 		break;
 
 	case LDAP_FILTER_EXT: {
 		struct berval ad;
-		filter_escape_value_x( &f->f_mr_value, &tmp, ctx );
+		filter_escape_value_x( &f->f_mr_value, &tmp, op->o_tmpmemctx );
 
 		if ( f->f_mr_desc ) {
 			ad = f->f_mr_desc->ad_cname;
@@ -795,7 +837,7 @@ filter2bv_x( Filter *f, struct berval *f
 			( f->f_mr_dnattrs ? sizeof(":dn")-1 : 0 ) +
 			( f->f_mr_rule_text.bv_len ? f->f_mr_rule_text.bv_len+1 : 0 ) +
 			tmp.bv_len + ( sizeof("(:=)") - 1 );
-		fstr->bv_val = alloc( fstr->bv_len + 1, ctx );
+		fstr->bv_val = op->o_tmpalloc( fstr->bv_len + 1, op->o_tmpmemctx );
 
 		snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s%s%s%s:=%s)",
 			ad.bv_val,
@@ -803,7 +845,7 @@ filter2bv_x( Filter *f, struct berval *f
 			f->f_mr_rule_text.bv_len ? ":" : "",
 			f->f_mr_rule_text.bv_len ? f->f_mr_rule_text.bv_val : "",
 			tmp.bv_val );
-		ber_memfree_x( tmp.bv_val, ctx );
+		ber_memfree_x( tmp.bv_val, op->o_tmpmemctx );
 		} break;
 
 	case SLAPD_FILTER_COMPUTED:
@@ -816,11 +858,12 @@ filter2bv_x( Filter *f, struct berval *f
 			f->f_result == LDAP_COMPARE_TRUE ? sizeof("(?=true)")-1 :
 			f->f_result == SLAPD_COMPARE_UNDEFINED ? sizeof("(?=undefined)")-1 :
 			sizeof("(?=error)")-1,
-			1, fstr, ctx );
+			1, fstr, op->o_tmpmemctx );
 		break;
 
 	default:
-		ber_str2bv_x( "(?=unknown)", sizeof("(?=unknown)")-1, 1, fstr, ctx );
+		ber_str2bv_x( "(?=unknown)", sizeof("(?=unknown)")-1,
+			1, fstr, op->o_tmpmemctx );
 		break;
 	}
 }
@@ -828,10 +871,14 @@ filter2bv_x( Filter *f, struct berval *f
 void
 filter2bv( Filter *f, struct berval *fstr )
 {
-	filter2bv_x( f, fstr, NULL );
+	Operation op;
+	op.o_tmpmemctx = NULL;
+	op.o_tmpmfuncs = &ch_mfuncs;
+
+	filter2bv_x( &op, f, fstr );
 }
 
-int
+static int
 filter_escape_value_x(
 	struct berval *in,
 	struct berval *out,
@@ -1148,19 +1195,11 @@ vrFilter_free( Operation *op, ValuesRetu
 
 		case LDAP_FILTER_SUBSTRINGS:
 			if ( vrf->vrf_sub_initial.bv_val != NULL ) {
-#ifdef notyet
 				op->o_tmpfree( vrf->vrf_sub_initial.bv_val, op->o_tmpmemctx );
-#else
-				ch_free( vrf->vrf_sub_initial.bv_val );
-#endif
 			}
 			ber_bvarray_free_x( vrf->vrf_sub_any, op->o_tmpmemctx );
 			if ( vrf->vrf_sub_final.bv_val != NULL ) {
-#ifdef notyet
 				op->o_tmpfree( vrf->vrf_sub_final.bv_val, op->o_tmpmemctx );
-#else
-				ch_free( vrf->vrf_sub_final.bv_val );
-#endif
 			}
 			op->o_tmpfree( vrf->vrf_sub, op->o_tmpmemctx );
 			break;
@@ -1193,11 +1232,10 @@ vrFilter2bv( Operation *op, ValuesReturn
 	ValuesReturnFilter	*p;
 	struct berval tmp;
 	ber_len_t len;
-	BER_MEMREALLOC_FN *reallo = op->o_tmpmemctx ? sl_realloc :
-		(BER_MEMREALLOC_FN *)ch_realloc;
 
 	if ( vrf == NULL ) {
-		ber_str2bv_x( "No filter!", sizeof("No filter!")-1, 1, fstr, op->o_tmpmemctx );
+		ber_str2bv_x( "No filter!", sizeof("No filter!")-1,
+			1, fstr, op->o_tmpmemctx );
 		return;
 	}
 
@@ -1212,7 +1250,7 @@ vrFilter2bv( Operation *op, ValuesReturn
 		simple_vrFilter2bv( op, p, &tmp );
 			
 		fstr->bv_len += tmp.bv_len;
-		fstr->bv_val = reallo( fstr->bv_val, fstr->bv_len + 1, op->o_tmpmemctx );
+		fstr->bv_val = op->o_tmprealloc( fstr->bv_val, fstr->bv_len + 1, op->o_tmpmemctx );
 
 		snprintf( &fstr->bv_val[len-1], tmp.bv_len + 2, 
 			/*"("*/ "%s)", tmp.bv_val );
@@ -1226,8 +1264,6 @@ simple_vrFilter2bv( Operation *op, Value
 {
 	struct berval tmp;
 	ber_len_t len;
-	BER_MEMREALLOC_FN *reallo = op->o_tmpmemctx ? sl_realloc :
-		(BER_MEMREALLOC_FN *) ch_realloc;
 
 	if ( vrf == NULL ) {
 		ber_str2bv_x( "No filter!", sizeof("No filter!")-1, 1, fstr, op->o_tmpmemctx );
@@ -1304,7 +1340,7 @@ simple_vrFilter2bv( Operation *op, Value
 			filter_escape_value_x( &vrf->vrf_sub_initial, &tmp, op->o_tmpmemctx );
 
 			fstr->bv_len += tmp.bv_len;
-			fstr->bv_val = reallo( fstr->bv_val, fstr->bv_len + 1, op->o_tmpmemctx );
+			fstr->bv_val = op->o_tmprealloc( fstr->bv_val, fstr->bv_len + 1, op->o_tmpmemctx );
 
 			snprintf( &fstr->bv_val[len-2], tmp.bv_len+3,
 				/* "(attr=" */ "%s*)",
@@ -1320,7 +1356,7 @@ simple_vrFilter2bv( Operation *op, Value
 				filter_escape_value_x( &vrf->vrf_sub_any[i], &tmp, op->o_tmpmemctx );
 
 				fstr->bv_len += tmp.bv_len + 1;
-				fstr->bv_val = reallo( fstr->bv_val, fstr->bv_len + 1, op->o_tmpmemctx );
+				fstr->bv_val = op->o_tmprealloc( fstr->bv_val, fstr->bv_len + 1, op->o_tmpmemctx );
 
 				snprintf( &fstr->bv_val[len-1], tmp.bv_len+3,
 					/* "(attr=[init]*[any*]" */ "%s*)",
@@ -1335,7 +1371,7 @@ simple_vrFilter2bv( Operation *op, Value
 			filter_escape_value_x( &vrf->vrf_sub_final, &tmp, op->o_tmpmemctx );
 
 			fstr->bv_len += tmp.bv_len;
-			fstr->bv_val = reallo( fstr->bv_val, fstr->bv_len + 1, op->o_tmpmemctx );
+			fstr->bv_val = op->o_tmprealloc( fstr->bv_val, fstr->bv_len + 1, op->o_tmpmemctx );
 
 			snprintf( &fstr->bv_val[len-1], tmp.bv_len+3,
 				/* "(attr=[init*][any*]" */ "%s)",
@@ -1396,198 +1432,8 @@ simple_vrFilter2bv( Operation *op, Value
 		break;
 
 	default:
-		ber_str2bv_x( "(?=unknown)", sizeof("(?=unknown)")-1, 1, fstr, op->o_tmpmemctx );
+		ber_str2bv_x( "(?=unknown)", sizeof("(?=unknown)")-1,
+			1, fstr, op->o_tmpmemctx );
 		break;
 	}
 }
-
-#if 0 /* unused */
-static int
-get_substring_vrFilter(
-	Operation *op,
-	BerElement	*ber,
-	ValuesReturnFilter	*vrf,
-	const char	**text )
-{
-	ber_tag_t	tag;
-	ber_len_t	len;
-	ber_tag_t	rc;
-	struct berval value;
-	char		*last;
-	struct berval bv;
-	*text = "error decoding filter";
-
-#ifdef NEW_LOGGING
-	LDAP_LOG( FILTER, ENTRY, 
-		"get_substring_filter: conn %d  begin\n", op->o_connid, 0, 0 );
-#else
-	Debug( LDAP_DEBUG_FILTER, "begin get_substring_filter\n", 0, 0, 0 );
-#endif
-	if ( ber_scanf( ber, "{m" /*}*/, &bv ) == LBER_ERROR ) {
-		return SLAPD_DISCONNECT;
-	}
-
-	vrf->vrf_sub = ch_calloc( 1, sizeof(SubstringsAssertion) );
-	vrf->vrf_sub_desc = NULL;
-	rc = slap_bv2ad( &bv, &vrf->vrf_sub_desc, text );
-
-	if( rc != LDAP_SUCCESS ) {
-		text = NULL;
-		ch_free( vrf->vrf_sub );
-		vrf->vrf_choice = SLAPD_FILTER_COMPUTED;
-		vrf->vrf_result = SLAPD_COMPARE_UNDEFINED;
-		return LDAP_SUCCESS;
-	}
-
-	vrf->vrf_sub_initial.bv_val = NULL;
-	vrf->vrf_sub_any = NULL;
-	vrf->vrf_sub_final.bv_val = NULL;
-
-	for ( tag = ber_first_element( ber, &len, &last ); tag != LBER_DEFAULT;
-		tag = ber_next_element( ber, &len, last ) )
-	{
-		unsigned usage;
-
-		rc = ber_scanf( ber, "m", &value );
-		if ( rc == LBER_ERROR ) {
-			rc = SLAPD_DISCONNECT;
-			goto return_error;
-		}
-
-		if ( value.bv_val == NULL || value.bv_len == 0 ) {
-			rc = LDAP_INVALID_SYNTAX;
-			goto return_error;
-		} 
-
-		switch ( tag ) {
-		case LDAP_SUBSTRING_INITIAL:
-			usage = SLAP_MR_SUBSTR_INITIAL;
-			break;
-
-		case LDAP_SUBSTRING_ANY:
-			usage = SLAP_MR_SUBSTR_ANY;
-			break;
-
-		case LDAP_SUBSTRING_FINAL:
-			usage = SLAP_MR_SUBSTR_FINAL;
-			break;
-
-		default:
-			rc = LDAP_PROTOCOL_ERROR;
-
-#ifdef NEW_LOGGING
-			LDAP_LOG( FILTER, ERR, 
-				"get_filter_substring: conn %d  unknown substring choice=%ld\n",
-				op->o_connid, (long)tag, 0 );
-#else
-			Debug( LDAP_DEBUG_FILTER,
-				"  unknown substring choice=%ld\n",
-				(long) tag, 0, 0 );
-#endif
-			goto return_error;
-		}
-
-		/* validate/normalize using equality matching rule validator! */
-		rc = asserted_value_validate_normalize(
-			vrf->vrf_sub_desc, vrf->vrf_sub_desc->ad_type->sat_equality,
-			usage, &value, &bv, text );
-		if( rc != LDAP_SUCCESS ) {
-			goto return_error;
-		}
-
-		value = bv;
-
-		rc = LDAP_PROTOCOL_ERROR;
-
-		switch ( tag ) {
-		case LDAP_SUBSTRING_INITIAL:
-#ifdef NEW_LOGGING
-			LDAP_LOG( FILTER, DETAIL1, 
-				"get_substring_filter: conn %d  INITIAL\n", 
-				op->o_connid, 0, 0 );
-#else
-			Debug( LDAP_DEBUG_FILTER, "  INITIAL\n", 0, 0, 0 );
-#endif
-
-			if ( vrf->vrf_sub_initial.bv_val != NULL
-				|| vrf->vrf_sub_any != NULL 
-				|| vrf->vrf_sub_final.bv_val != NULL )
-			{
-				free( value.bv_val );
-				goto return_error;
-			}
-
-			vrf->vrf_sub_initial = value;
-			break;
-
-		case LDAP_SUBSTRING_ANY:
-#ifdef NEW_LOGGING
-			LDAP_LOG( FILTER, DETAIL1, 
-				"get_substring_filter: conn %d  ANY\n", op->o_connid, 0, 0 );
-#else
-			Debug( LDAP_DEBUG_FILTER, "  ANY\n", 0, 0, 0 );
-#endif
-
-			if ( vrf->vrf_sub_final.bv_val != NULL ) {
-				free( value.bv_val );
-				goto return_error;
-			}
-
-			ber_bvarray_add( &vrf->vrf_sub_any, &value );
-			break;
-
-		case LDAP_SUBSTRING_FINAL:
-#ifdef NEW_LOGGING
-			LDAP_LOG( FILTER, DETAIL1, 
-				"get_substring_filter: conn %d  FINAL\n", op->o_connid, 0, 0 );
-#else
-			Debug( LDAP_DEBUG_FILTER, "  FINAL\n", 0, 0, 0 );
-#endif
-
-			if ( vrf->vrf_sub_final.bv_val != NULL ) {
-				free( value.bv_val );
-				goto return_error;
-			}
-
-			vrf->vrf_sub_final = value;
-			break;
-
-		default:
-#ifdef NEW_LOGGING
-			LDAP_LOG( FILTER, INFO, 
-				"get_substring_filter: conn %d  unknown substring type %ld\n",
-				op->o_connid, (long)tag, 0 );
-#else
-			Debug( LDAP_DEBUG_FILTER,
-				"  unknown substring type=%ld\n",
-				(long) tag, 0, 0 );
-#endif
-
-			free( value.bv_val );
-
-return_error:
-#ifdef NEW_LOGGING
-			LDAP_LOG( FILTER, INFO, 
-				"get_substring_filter: conn %d  error %ld\n",
-				op->o_connid, (long)rc, 0 );
-#else
-			Debug( LDAP_DEBUG_FILTER, "  error=%ld\n",
-				(long) rc, 0, 0 );
-#endif
-			free( vrf->vrf_sub_initial.bv_val );
-			ber_bvarray_free( vrf->vrf_sub_any );
-			free( vrf->vrf_sub_final.bv_val );
-			ch_free( vrf->vrf_sub );
-			return rc;
-		}
-	}
-
-#ifdef NEW_LOGGING
-	LDAP_LOG( FILTER, ENTRY, 
-		"get_substring_filter: conn %d exit\n", op->o_connid, 0, 0 );
-#else
-	Debug( LDAP_DEBUG_FILTER, "end get_substring_filter\n", 0, 0, 0 );
-#endif
-	return( LDAP_SUCCESS );
-}
-#endif /* unused */