X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fsets.c;h=9a626947b30d43f778f662217feca4c942af5371;hb=021443bd5d355b8171dcbe4650c67507b9e1b83b;hp=622249377dae54bf2ef749f17c66f441d34b1754;hpb=3705a26f2d003cc3126ef9e2d9df9a7dca75aa3c;p=openldap

diff --git a/servers/slapd/sets.c b/servers/slapd/sets.c
index 622249377d..9a626947b3 100644
--- a/servers/slapd/sets.c
+++ b/servers/slapd/sets.c
@@ -1,387 +1,580 @@
 /* $OpenLDAP$ */
-/*
- * Copyright 2000 The OpenLDAP Foundation, All Rights Reserved.
- * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
+/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
+ *
+ * Copyright 2000-2005 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"
+
+#include <stdio.h>
 #include <ac/string.h>
 
+#include "slap.h"
 #include "sets.h"
 
-static char **set_join (char **lset, int op, char **rset);
-static char **set_chase (SET_GATHER gatherer, void *cookie, char **set, char *attr, int attrlen, int closure);
-static int set_samedn (char *dn1, char *dn2);
+static BerVarray set_chase( SLAP_SET_GATHER gatherer,
+	SetCookie *cookie, BerVarray set, AttributeDescription *desc, int closure );
 
-long
-set_size (char **set)
+static long
+slap_set_size( BerVarray set )
 {
-	int i;
+	long	i;
 
 	i = 0;
-	if (set != NULL) {
-		while (set[i])
+	if ( set != NULL ) {
+		while ( !BER_BVISNULL( &set[ i ] ) ) {
 			i++;
+		}
+	}
+	return i;
+}
+
+static int
+slap_set_isempty( BerVarray set )
+{
+	if ( set == NULL ) {
+		return 1;
+	}
+
+	if ( !BER_BVISNULL( &set[ 0 ] ) ) {
+		return 0;
 	}
-	return(i);
+
+	return 1;
 }
 
-void
-set_dispose (char **set)
+static void
+slap_set_dispose( SetCookie *cp, BerVarray set, unsigned flags )
 {
-	int i;
+	if ( flags & SLAP_SET_REFVAL ) {
+		if ( ! ( flags & SLAP_SET_REFARR ) ) {
+			cp->op->o_tmpfree( set, cp->op->o_tmpmemctx );
+		}
 
-	if (set != NULL) {
-		for (i = 0; set[i]; i++)
-			ch_free(set[i]);
-		ch_free(set);
+	} else {
+		ber_bvarray_free_x( set, cp->op->o_tmpmemctx );
 	}
 }
 
-static char **
-set_join (char **lset, int op, char **rset)
+static BerVarray
+set_dup( SetCookie *cp, BerVarray set, unsigned flags )
 {
-	char **set;
-	long i, j, last;
+	BerVarray	newset = NULL;
+
+	if ( set == NULL ) {
+		return NULL;
+	}
+
+	if ( flags & SLAP_SET_REFARR ) {
+		int	i;
+
+		for ( i = 0; !BER_BVISNULL( &set[ i ] ); i++ )
+			;
+		newset = cp->op->o_tmpcalloc( i + 1,
+				sizeof(struct berval), 
+				cp->op->o_tmpmemctx );
+		if ( newset == NULL ) {
+			return NULL;
+		}
+
+		if ( flags & SLAP_SET_REFVAL ) {
+			for ( i = 0; !BER_BVISNULL( &set[ i ] ); i++ ) {
+				ber_dupbv_x( &newset[ i ], &set[ i ],
+						cp->op->o_tmpmemctx );
+			}
+
+		} else {
+			AC_MEMCPY( newset, set, ( i + 1 ) * sizeof( struct berval ) );
+		}
+		
+	} else {
+		newset = set;
+	}
+
+	return newset;
+}
+
+BerVarray
+slap_set_join(
+	SetCookie	*cp,
+	BerVarray	lset,
+	unsigned	op_flags,
+	BerVarray	rset )
+{
+	BerVarray	set;
+	long		i, j, last;
+	unsigned	op = ( op_flags & SLAP_SET_OPMASK );
 
 	set = NULL;
-	if (op == '|') {
-		if (lset == NULL || *lset == NULL) {
-			if (rset == NULL) {
-				if (lset == NULL)
-					return(ch_calloc(1, sizeof(char *)));
-				return(lset);
+	switch ( op ) {
+	case '|':	/* union */
+		if ( lset == NULL || BER_BVISNULL( lset ) ) {
+			if ( rset == NULL ) {
+				if ( lset == NULL ) {
+					set = cp->op->o_tmpcalloc( 1,
+							sizeof(struct berval),
+							cp->op->o_tmpmemctx );
+					BER_BVZERO( set );
+					return set;
+				}
+				return set_dup( cp, lset, SLAP_SET_LREF2REF( op_flags ) );
 			}
-			set_dispose(lset);
-			return(rset);
+			slap_set_dispose( cp, lset, SLAP_SET_LREF2REF( op_flags ) );
+			return set_dup( cp, rset, SLAP_SET_RREF2REF( op_flags ) );
 		}
-		if (rset == NULL || *rset == NULL) {
-			set_dispose(rset);
-			return(lset);
+		if ( rset == NULL || BER_BVISNULL( rset ) ) {
+			slap_set_dispose( cp, rset, SLAP_SET_RREF2REF( op_flags ) );
+			return set_dup( cp, lset, SLAP_SET_LREF2REF( op_flags ) );
 		}
 
-		i = set_size(lset) + set_size(rset) + 1;
-		set = ch_calloc(i, sizeof(char *));
-		if (set != NULL) {
+		i = slap_set_size( lset ) + slap_set_size( rset ) + 1;
+		set = cp->op->o_tmpcalloc( i, sizeof(struct berval), cp->op->o_tmpmemctx );
+		if ( set != NULL ) {
 			/* set_chase() depends on this routine to
 			 * keep the first elements of the result
 			 * set the same (and in the same order)
 			 * as the left-set.
 			 */
-			for (i = 0; lset[i]; i++)
-				set[i] = lset[i];
-			ch_free(lset);
-			for (i = 0; rset[i]; i++) {
-				for (j = 0; set[j]; j++) {
-					if (set_samedn(rset[i], set[j])) {
-						ch_free(rset[i]);
-						rset[i] = NULL;
+			for ( i = 0; !BER_BVISNULL( &lset[ i ] ); i++ ) {
+				if ( op_flags & SLAP_SET_LREFVAL ) {
+					ber_dupbv_x( &set[ i ], &lset[ i ], cp->op->o_tmpmemctx );
+
+				} else {
+					set[ i ] = lset[ i ];
+				}
+			}
+
+			last = i;
+
+			for ( i = 0; !BER_BVISNULL( &rset[ i ] ); i++ ) {
+				int	exists = 0;
+
+				for ( j = 0; !BER_BVISNULL( &set[ j ] ); j++ ) {
+					if ( bvmatch( &rset[ i ], &set[ j ] ) )
+					{
+						if ( !( op_flags & SLAP_SET_RREFVAL ) ) {
+							cp->op->o_tmpfree( rset[ i ].bv_val, cp->op->o_tmpmemctx );
+							BER_BVZERO( &rset[ i ] );
+						}
+						exists = 1;
 						break;		
 					}	
 				}
-				if (rset[i])
-					set[j] = rset[i];
+
+				if ( !exists ) {
+					if ( op_flags & SLAP_SET_RREFVAL ) {
+						ber_dupbv_x( &set[ last ], &rset[ i ], cp->op->o_tmpmemctx );
+
+					} else {
+						set[ last ] = rset[ i ];
+					}
+					last++;
+				}
 			}
-			ch_free(rset);
+			BER_BVZERO( &set[ last ] );
 		}
-		return(set);
-	}
+		break;
+
+	case '&':	/* intersection */
+		if ( lset == NULL || BER_BVISNULL( lset )
+				|| rset == NULL || BER_BVISNULL( rset ) )
+		{
+			set = cp->op->o_tmpcalloc( 1, sizeof(struct berval),
+					cp->op->o_tmpmemctx );
+			BER_BVZERO( set );
 
-	if (op == '&') {
-		if (lset == NULL || *lset == NULL || rset == NULL || *rset == NULL) {
-			set = ch_calloc(1, sizeof(char *));
 		} else {
-			set = lset;
+			set = set_dup( cp, lset, SLAP_SET_LREF2REF( op_flags ) );
+			if ( set == NULL ) {
+				break;
+			}
 			lset = NULL;
-			last = set_size(set) - 1;
-			for (i = 0; set[i]; i++) {
-				for (j = 0; rset[j]; j++) {
-					if (set_samedn(set[i], rset[j]))
+			last = slap_set_size( set ) - 1;
+			for ( i = 0; !BER_BVISNULL( &set[ i ] ); i++ ) {
+				for ( j = 0; !BER_BVISNULL( &rset[ j ] ); j++ ) {
+					if ( bvmatch( &set[ i ], &rset[ j ] ) ) {
 						break;
+					}
 				}
-				if (rset[j] == NULL) {
-					ch_free(set[i]);
-					set[i] = set[last];
-					set[last] = NULL;
+
+				if ( BER_BVISNULL( &rset[ j ] ) ) {
+					cp->op->o_tmpfree( set[ i ].bv_val, cp->op->o_tmpmemctx );
+					set[ i ] = set[ last ];
+					BER_BVZERO( &set[ last ] );
 					last--;
 					i--;
 				}
 			}
 		}
-	}
+		break;
 
-	set_dispose(lset);
-	set_dispose(rset);
-	return(set);
-}
+	case '+':	/* string concatenation */
+		i = slap_set_size( rset );
+		j = slap_set_size( lset );
 
-static char **
-set_chase (SET_GATHER gatherer, void *cookie, char **set, char *attr, int attrlen, int closure)
-{
-	char **vals, **nset;
-	char attrstr[32];
-	int i;
+		set = cp->op->o_tmpcalloc( i * j + 1, sizeof(struct berval),
+				cp->op->o_tmpmemctx );
+		if ( set == NULL ) {
+			break;
+		}
 
-	if (set == NULL)
-		return(ch_calloc(1, sizeof(char *)));
+		for ( last = 0, i = 0; !BER_BVISNULL( &lset[ i ] ); i++ ) {
+			for ( j = 0; !BER_BVISNULL( &rset[ j ] ); j++ ) {
+				struct berval	bv;
+				long		k;
+
+				bv.bv_len = lset[ i ].bv_len + rset[ j ].bv_len;
+				bv.bv_val = cp->op->o_tmpalloc( bv.bv_len + 1,
+						cp->op->o_tmpmemctx );
+				if ( bv.bv_val == NULL ) {
+					slap_set_dispose( cp, set, 0 );
+					set = NULL;
+					goto done;
+				}
+				AC_MEMCPY( bv.bv_val, lset[ i ].bv_val, lset[ i ].bv_len );
+				AC_MEMCPY( &bv.bv_val[ lset[ i ].bv_len ], rset[ j ].bv_val, rset[ j ].bv_len );
+				bv.bv_val[ bv.bv_len ] = '\0';
 
-	if (*set == NULL)
-		return(set);
+				for ( k = 0; k < last; k++ ) {
+					if ( bvmatch( &set[ k ], &bv ) ) {
+						cp->op->o_tmpfree( bv.bv_val, cp->op->o_tmpmemctx );
+						break;
+					}
+				}
 
-	if (attrlen > (sizeof(attrstr) - 1)) {
-		set_dispose(set);
-		return(NULL);
-	}
-	memcpy(attrstr, attr, attrlen);
-	attrstr[attrlen] = 0;
+				if ( k == last ) {
+					set[ last++ ] = bv;
+				}
+			}
+		}
+		BER_BVZERO( &set[ last ] );
+		break;
 
-	nset = ch_calloc(1, sizeof(char *));
-	if (nset == NULL) {
-		set_dispose(set);
-		return(NULL);
+	default:
+		break;
 	}
-	for (i = 0; set[i]; i++) {
-		vals = (gatherer)(cookie, set[i], attrstr);
-		if (vals != NULL)
-			nset = set_join(nset, '|', vals);
+
+done:;
+	if ( !( op_flags & SLAP_SET_LREFARR ) && lset != NULL ) {
+		cp->op->o_tmpfree( lset, cp->op->o_tmpmemctx );
 	}
-	set_dispose(set);
-
-	if (closure) {
-		for (i = 0; nset[i]; i++) {
-			vals = (gatherer)(cookie, nset[i], attrstr);
-			if (vals != NULL) {
-				nset = set_join(nset, '|', vals);
-				if (nset == NULL)
-					break;
-			}
-		}
+
+	if ( !( op_flags & SLAP_SET_RREFARR ) && rset != NULL ) {
+		cp->op->o_tmpfree( rset, cp->op->o_tmpmemctx );
 	}
-	return(nset);
+
+	return set;
 }
 
-static int
-set_samedn (char *dn1, char *dn2)
+static BerVarray
+set_chase( SLAP_SET_GATHER gatherer,
+	SetCookie *cp, BerVarray set, AttributeDescription *desc, int closure )
 {
-	char c1, c2;
+	BerVarray	vals, nset;
+	int		i;
+
+	if ( set == NULL ) {
+		set = cp->op->o_tmpcalloc( 1, sizeof(struct berval),
+				cp->op->o_tmpmemctx );
+		BER_BVZERO( set );
+		return set;
+	}
 
-	while (*dn1 == ' ') dn1++;
-	while (*dn2 == ' ') dn2++;
-	while (*dn1 || *dn2) {
-		if (*dn1 != '=' && *dn1 != ','
-			&& *dn2 != '=' && *dn2 != ',')
-		{
-			c1 = *dn1++;
-			c2 = *dn2++;
-			if (c1 >= 'a' && c1 <= 'z')
-				c1 -= 'a' - 'A';
-			if (c2 >= 'a' && c2 <= 'z')
-				c2 -= 'a' - 'A';
-			if (c1 != c2)
-				return(0);
-		} else {
-			while (*dn1 == ' ') dn1++;
-			while (*dn2 == ' ') dn2++;
-			if (*dn1++ != *dn2++)
-				return(0);
-			while (*dn1 == ' ') dn1++;
-			while (*dn2 == ' ') dn2++;
+	if ( BER_BVISNULL( set ) ) {
+		return set;
+	}
+
+	nset = cp->op->o_tmpcalloc( 1, sizeof(struct berval), cp->op->o_tmpmemctx );
+	if ( nset == NULL ) {
+		slap_set_dispose( cp, set, 0 );
+		return NULL;
+	}
+	for ( i = 0; !BER_BVISNULL( &set[ i ] ); i++ ) {
+		vals = (gatherer)( cp, &set[ i ], desc );
+		if ( vals != NULL ) {
+			nset = slap_set_join( cp, nset, '|', vals );
+		}
+	}
+	slap_set_dispose( cp, set, 0 );
+
+	if ( closure ) {
+		for ( i = 0; !BER_BVISNULL( &nset[ i ] ); i++ ) {
+			vals = (gatherer)( cp, &nset[ i ], desc );
+			if ( vals != NULL ) {
+				nset = slap_set_join( cp, nset, '|', vals );
+				if ( nset == NULL ) {
+					break;
+				}
+			}
 		}
 	}
-	return(1);
+
+	return nset;
 }
 
 int
-set_filter (SET_GATHER gatherer, void *cookie, char *filter, char *user, char *this, char ***results)
+slap_set_filter( SLAP_SET_GATHER gatherer,
+	SetCookie *cp, struct berval *fbv,
+	struct berval *user, struct berval *target, BerVarray *results )
 {
-	#define IS_SET(x)	( (long)(x) >= 256 )
-	#define IS_OP(x)	( (long)(x) < 256 )
-	#define SF_ERROR(x)	{ rc = -1; goto _error; }
-	#define SF_TOP()	(char **)( (stp < 0) ? 0 : stack[stp] )
-	#define SF_POP()	(char **)( (stp < 0) ? 0 : stack[stp--] )
-	#define SF_PUSH(x)	{ if (stp >= 63) SF_ERROR(overflow); stack[++stp] = (char **)(long)(x); }
-	char c;
-	char **set, **lset;
-	int len, op, rc, stp;
-	char **stack[64];
-
-	if (results)
+#define STACK_SIZE	64
+#define IS_SET(x)	( (unsigned long)(x) >= 256 )
+#define IS_OP(x)	( (unsigned long)(x) < 256 )
+#define SF_ERROR(x)	do { rc = -1; goto _error; } while (0)
+#define SF_TOP()	( (BerVarray)( (stp < 0) ? 0 : stack[ stp ] ) )
+#define SF_POP()	( (BerVarray)( (stp < 0) ? 0 : stack[ stp-- ] ) )
+#define SF_PUSH(x)	do { \
+		if (stp >= (STACK_SIZE - 1)) SF_ERROR(overflow); \
+		stack[ ++stp ] = (BerVarray)(long)(x); \
+	} while (0)
+
+	BerVarray	set, lset;
+	BerVarray	stack[ STACK_SIZE ] = { 0 };
+	int		len, rc, stp;
+	unsigned	op;
+	char		c, *filter = fbv->bv_val;
+
+	if ( results ) {
 		*results = NULL;
+	}
 
 	stp = -1;
-	while (c = *filter++) {
+	while ( ( c = *filter++ ) ) {
 		set = NULL;
-		switch (c) {
+		switch ( c ) {
 		case ' ':
 		case '\t':
 		case '\x0A':
 		case '\x0D':
 			break;
 
-		case '(':
-			if (IS_SET(SF_TOP()))
-				SF_ERROR(syntax);
-			SF_PUSH(c);
+		case '(' /* ) */ :
+			if ( IS_SET( SF_TOP() ) ) {
+				SF_ERROR( syntax );
+			}
+			SF_PUSH( c );
 			break;
 
-		case ')':
+		case /* ( */ ')':
 			set = SF_POP();
-			if (IS_OP(set))
-				SF_ERROR(syntax);
-			if (SF_TOP() == (void *)'(') {
+			if ( IS_OP( set ) ) {
+				SF_ERROR( syntax );
+			}
+			if ( SF_TOP() == (void *)'(' /* ) */ ) {
 				SF_POP();
-				SF_PUSH(set);
+				SF_PUSH( set );
 				set = NULL;
-			} else if (IS_OP(SF_TOP())) {
-				op = (long)SF_POP();
+
+			} else if ( IS_OP( SF_TOP() ) ) {
+				op = (unsigned)SF_POP();
 				lset = SF_POP();
 				SF_POP();
-				set = set_join(lset, op, set);
-				if (set == NULL)
+				set = slap_set_join( cp, lset, op, set );
+				if ( set == NULL ) {
 					SF_ERROR(memory);
-				SF_PUSH(set);
+				}
+				SF_PUSH( set );
 				set = NULL;
+
 			} else {
-				SF_ERROR(syntax);
+				SF_ERROR( syntax );
 			}
 			break;
 
-		case '&':
-		case '|':
+		case '|':	/* union */
+		case '&':	/* intersection */
+		case '+':	/* string concatenation */
 			set = SF_POP();
-			if (IS_OP(set))
-				SF_ERROR(syntax);
-			if (SF_TOP() == 0 || SF_TOP() == (void *)'(') {
-				SF_PUSH(set);
+			if ( IS_OP( set ) ) {
+				SF_ERROR( syntax );
+			}
+			if ( SF_TOP() == 0 || SF_TOP() == (void *)'(' /* ) */ ) {
+				SF_PUSH( set );
 				set = NULL;
-			} else if (IS_OP(SF_TOP())) {
-				op = (long)SF_POP();
+
+			} else if ( IS_OP( SF_TOP() ) ) {
+				op = (unsigned)SF_POP();
 				lset = SF_POP();
-				set = set_join(lset, op, set);
-				if (set == NULL)
-					SF_ERROR(memory);
-				SF_PUSH(set);
+				set = slap_set_join( cp, lset, op, set );
+				if ( set == NULL ) {
+					SF_ERROR( memory );
+				}
+				SF_PUSH( set );
 				set = NULL;
+				
 			} else {
-				SF_ERROR(syntax);
+				SF_ERROR( syntax );
 			}
-			SF_PUSH(c);
+			SF_PUSH( c );
 			break;
 
-		case '[':
-			if ((SF_TOP() == (void *)'/') || IS_SET(SF_TOP()))
-				SF_ERROR(syntax);
-			for (	len = 0;
-					(c = *filter++) && (c != ']');
-					len++)
-			{ }
-			if (c == 0)
+		case '[' /* ] */:
+			if ( ( SF_TOP() == (void *)'/' ) || IS_SET( SF_TOP() ) ) {
+				SF_ERROR( syntax );
+			}
+			for ( len = 0; ( c = *filter++ ) && (c != /* [ */ ']'); len++ )
+				;
+			if ( c == 0 ) {
 				SF_ERROR(syntax);
+			}
 			
-			set = ch_calloc(2, sizeof(char *));
-			if (set == NULL)
-				SF_ERROR(memory);
-			*set = ch_calloc(len + 1, sizeof(char));
-			if (*set == NULL)
+			set = cp->op->o_tmpcalloc( 2, sizeof(struct berval),
+					cp->op->o_tmpmemctx );
+			if ( set == NULL ) {
 				SF_ERROR(memory);
-			memcpy(*set, &filter[-len - 1], len);
-			SF_PUSH(set);
+			}
+			set->bv_val = cp->op->o_tmpcalloc( len + 1, sizeof(char),
+					cp->op->o_tmpmemctx );
+			if ( BER_BVISNULL( set ) ) {
+				SF_ERROR( memory );
+			}
+			AC_MEMCPY( set->bv_val, &filter[ - len - 1 ], len );
+			set->bv_len = len;
+			SF_PUSH( set );
 			set = NULL;
 			break;
 
 		case '-':
 			c = *filter++;
-			if (c != '>')
-				SF_ERROR(syntax);
+			if ( c != '>' ) {
+				SF_ERROR( syntax );
+			}
 			/* fall through to next case */
 
 		case '/':
-			if (IS_OP(SF_TOP()))
-				SF_ERROR(syntax);
-			SF_PUSH('/');
+			if ( IS_OP( SF_TOP() ) ) {
+				SF_ERROR( syntax );
+			}
+			SF_PUSH( '/' );
 			break;
 
 		default:
-			if ((c != '_')
-				&& (c < 'A' || c > 'Z')
-				&& (c < 'a' || c > 'z'))
+			if ( ( c != '_' )
+					&& ( c < 'A' || c > 'Z' )
+					&& ( c < 'a' || c > 'z' ) )
 			{
-				SF_ERROR(syntax);
+				SF_ERROR( syntax );
 			}
 			filter--;
-			for (	len = 1;
-					(c = filter[len])
-						&& ((c >= '0' && c <= '9')
-							|| (c >= 'A' && c <= 'Z')
-							|| (c >= 'a' && c <= 'z'));
-					len++)
-			{ }
-			if (len == 4
-				&& memcmp("this", filter, len) == 0)
+			for ( len = 1;
+					( c = filter[ len ] )
+						&& ( ( c >= '0' && c <= '9' )
+							|| ( c >= 'A' && c <= 'Z' )
+							|| ( c >= 'a' && c <= 'z' ) );
+					len++ )
+				/* count */ ;
+			if ( len == 4
+				&& memcmp( "this", filter, len ) == 0 )
 			{
-				if ((SF_TOP() == (void *)'/') || IS_SET(SF_TOP()))
-					SF_ERROR(syntax);
-				set = ch_calloc(2, sizeof(char *));
-				if (set == NULL)
-					SF_ERROR(memory);
-				*set = ch_strdup(this);
-				if (*set == NULL)
-					SF_ERROR(memory);
-			} else if (len == 4
-				&& memcmp("user", filter, len) == 0) 
+				if ( ( SF_TOP() == (void *)'/' ) || IS_SET( SF_TOP() ) ) {
+					SF_ERROR( syntax );
+				}
+				set = cp->op->o_tmpcalloc( 2, sizeof(struct berval),
+						cp->op->o_tmpmemctx );
+				if ( set == NULL ) {
+					SF_ERROR( memory );
+				}
+				ber_dupbv_x( set, target, cp->op->o_tmpmemctx );
+				if ( BER_BVISNULL( set ) ) {
+					SF_ERROR( memory );
+				}
+				BER_BVZERO( &set[ 1 ] );
+				
+			} else if ( len == 4
+				&& memcmp( "user", filter, len ) == 0 ) 
 			{
-				if ((SF_TOP() == (void *)'/') || IS_SET(SF_TOP()))
-					SF_ERROR(syntax);
-				set = ch_calloc(2, sizeof(char *));
-				if (set == NULL)
-					SF_ERROR(memory);
-				*set = ch_strdup(user);
-				if (*set == NULL)
-					SF_ERROR(memory);
-			} else if (SF_TOP() != (void *)'/') {
-				SF_ERROR(syntax);
+				if ( ( SF_TOP() == (void *)'/' ) || IS_SET( SF_TOP() ) ) {
+					SF_ERROR( syntax );
+				}
+				set = cp->op->o_tmpcalloc( 2, sizeof(struct berval),
+						cp->op->o_tmpmemctx );
+				if ( set == NULL ) {
+					SF_ERROR( memory );
+				}
+				ber_dupbv_x( set, user, cp->op->o_tmpmemctx );
+				if ( BER_BVISNULL( set ) ) {
+					SF_ERROR( memory );
+				}
+				BER_BVZERO( &set[ 1 ] );
+				
+			} else if ( SF_TOP() != (void *)'/' ) {
+				SF_ERROR( syntax );
+
 			} else {
+				struct berval		fb2;
+				AttributeDescription	*ad = NULL;
+				const char		*text = NULL;
+
 				SF_POP();
-				set = set_chase(gatherer, cookie, SF_POP(), filter, len, c == '*');
-				if (set == NULL)
-					SF_ERROR(memory);
-				if (c == '*')
+				fb2.bv_val = filter;
+				fb2.bv_len = len;
+
+				if ( slap_bv2ad( &fb2, &ad, &text ) != LDAP_SUCCESS ) {
+					SF_ERROR( syntax );
+				}
+
+				/* NOTE: ad must have distinguishedName syntax
+				 * or expand in an LDAP URI if c == '*'
+				 */
+				
+				set = set_chase( gatherer,
+					cp, SF_POP(), ad, c == '*' );
+				if ( set == NULL ) {
+					SF_ERROR( memory );
+				}
+				if ( c == '*' ) {
 					len++;
+				}
 			}
 			filter += len;
-			SF_PUSH(set);
+			SF_PUSH( set );
 			set = NULL;
 			break;
 		}
 	}
 
 	set = SF_POP();
-	if (IS_OP(set))
-		SF_ERROR(syntax);
-	if (SF_TOP() == 0) {
+	if ( IS_OP( set ) ) {
+		SF_ERROR( syntax );
+	}
+	if ( SF_TOP() == 0 ) {
+		/* FIXME: ok ? */ ;
 
-	} else if (IS_OP(SF_TOP())) {
-		op = (long)SF_POP();
+	} else if ( IS_OP( SF_TOP() ) ) {
+		op = (unsigned)SF_POP();
 		lset = SF_POP();
-		set = set_join(lset, op, set);
-		if (set == NULL)
-			SF_ERROR(memory);
+		set = slap_set_join( cp, lset, op, set );
+		if ( set == NULL ) {
+			SF_ERROR( memory );
+		}
+		
 	} else {
-		SF_ERROR(syntax);
+		SF_ERROR( syntax );
 	}
 
-	rc = set_size(set);
-	if (results) {
+	rc = slap_set_isempty( set ) ? 0 : 1;
+	if ( results ) {
 		*results = set;
 		set = NULL;
 	}
 
 _error:
-	if (IS_SET(set))
-		set_dispose(set);
-	while (set = SF_POP()) {
-		if (IS_SET(set))
-			set_dispose(set);
+	if ( IS_SET( set ) ) {
+		slap_set_dispose( cp, set, 0 );
+	}
+	while ( ( set = SF_POP() ) ) {
+		if ( IS_SET( set ) ) {
+			slap_set_dispose( cp, set, 0 );
+		}
 	}
-	return(rc);
+	return rc;
 }