X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fsets.c;h=cd4a76c5fccb168fc9c4a75af8e4a2109d68bf42;hb=ed471a4d53b9bcd2cc89410743ffb4bd58b5fc05;hp=be0a60263e81c8b7507e3f1d9a7d2338d22ff01f;hpb=1228f6defc8ca493a9e878e95b01d021749ff653;p=openldap

diff --git a/servers/slapd/sets.c b/servers/slapd/sets.c
index be0a60263e..cd4a76c5fc 100644
--- a/servers/slapd/sets.c
+++ b/servers/slapd/sets.c
@@ -1,88 +1,83 @@
 /* $OpenLDAP$ */
 /*
- * Copyright 2000 The OpenLDAP Foundation, All Rights Reserved.
+ * Copyright 2000-2002 The OpenLDAP Foundation, All Rights Reserved.
  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
  */
 
-#include "portable.h"
+#include "portable.h"
 
-#include <stdio.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 BerVarray set_join (BerVarray lset, int op, BerVarray rset);
+static BerVarray set_chase (SLAP_SET_GATHER gatherer,
+	void *cookie, BerVarray set, struct berval *attr, int closure);
 static int set_samedn (char *dn1, char *dn2);
 
 long
-set_size (char **set)
+slap_set_size (BerVarray set)
 {
-	int i;
+	long	i;
 
 	i = 0;
 	if (set != NULL) {
-		while (set[i])
+		while (set[i].bv_val)
 			i++;
 	}
-	return(i);
+	return i;
 }
 
 void
-set_dispose (char **set)
+slap_set_dispose (BerVarray set)
 {
-	int i;
-
-	if (set != NULL) {
-		for (i = 0; set[i]; i++)
-			ch_free(set[i]);
-		ch_free(set);
-	}
+	ber_bvarray_free(set);
 }
 
-static char **
-set_join (char **lset, int op, char **rset)
+static BerVarray
+set_join (BerVarray lset, int op, BerVarray rset)
 {
-	char **set;
+	BerVarray set;
 	long i, j, last;
 
 	set = NULL;
 	if (op == '|') {
-		if (lset == NULL || *lset == NULL) {
+		if (lset == NULL || lset->bv_val == NULL) {
 			if (rset == NULL) {
 				if (lset == NULL)
-					return(ch_calloc(1, sizeof(char *)));
+					return(SLAP_CALLOC(1, sizeof(struct berval)));
 				return(lset);
 			}
-			set_dispose(lset);
+			slap_set_dispose(lset);
 			return(rset);
 		}
-		if (rset == NULL || *rset == NULL) {
-			set_dispose(rset);
+		if (rset == NULL || rset->bv_val == NULL) {
+			slap_set_dispose(rset);
 			return(lset);
 		}
 
-		i = set_size(lset) + set_size(rset) + 1;
-		set = ch_calloc(i, sizeof(char *));
+		i = slap_set_size(lset) + slap_set_size(rset) + 1;
+		set = SLAP_CALLOC(i, sizeof(struct berval));
 		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++)
+			for (i = 0; lset[i].bv_val; 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; rset[i].bv_val; i++) {
+				for (j = 0; set[j].bv_val; j++) {
+					if (set_samedn(rset[i].bv_val, set[j].bv_val)) {
+						ch_free(rset[i].bv_val);
+						rset[i].bv_val = NULL;
 						break;		
 					}	
 				}
-				if (rset[i])
+				if (rset[i].bv_val)
 					set[j] = rset[i];
 			}
 			ch_free(rset);
@@ -91,21 +86,21 @@ set_join (char **lset, int op, char **rset)
 	}
 
 	if (op == '&') {
-		if (lset == NULL || *lset == NULL || rset == NULL || *rset == NULL) {
-			set = ch_calloc(1, sizeof(char *));
+		if (lset == NULL || lset->bv_val == NULL || rset == NULL || rset->bv_val == NULL) {
+			set = SLAP_CALLOC(1, sizeof(struct berval));
 		} else {
 			set = lset;
 			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; set[i].bv_val; i++) {
+				for (j = 0; rset[j].bv_val; j++) {
+					if (set_samedn(set[i].bv_val, rset[j].bv_val))
 						break;
 				}
-				if (rset[j] == NULL) {
-					ch_free(set[i]);
+				if (rset[j].bv_val == NULL) {
+					ch_free(set[i].bv_val);
 					set[i] = set[last];
-					set[last] = NULL;
+					set[last].bv_val = NULL;
 					last--;
 					i--;
 				}
@@ -113,46 +108,51 @@ set_join (char **lset, int op, char **rset)
 		}
 	}
 
-	set_dispose(lset);
-	set_dispose(rset);
+	slap_set_dispose(lset);
+	slap_set_dispose(rset);
 	return(set);
 }
 
-static char **
-set_chase (SET_GATHER gatherer, void *cookie, char **set, char *attr, int attrlen, int closure)
+static BerVarray
+set_chase (SLAP_SET_GATHER gatherer,
+	void *cookie, BerVarray set, struct berval *attr, int closure)
 {
-	char **vals, **nset;
+	BerVarray vals, nset;
 	char attrstr[32];
+	struct berval bv;
 	int i;
 
+	bv.bv_len = attr->bv_len;
+	bv.bv_val = attrstr;
+
 	if (set == NULL)
-		return(ch_calloc(1, sizeof(char *)));
+		return(SLAP_CALLOC(1, sizeof(struct berval)));
 
-	if (*set == NULL)
+	if (set->bv_val == NULL)
 		return(set);
 
-	if (attrlen > (sizeof(attrstr) - 1)) {
-		set_dispose(set);
+	if (attr->bv_len > (sizeof(attrstr) - 1)) {
+		slap_set_dispose(set);
 		return(NULL);
 	}
-	memcpy(attrstr, attr, attrlen);
-	attrstr[attrlen] = 0;
+	AC_MEMCPY(attrstr, attr->bv_val, attr->bv_len);
+	attrstr[attr->bv_len] = 0;
 
-	nset = ch_calloc(1, sizeof(char *));
+	nset = SLAP_CALLOC(1, sizeof(struct berval));
 	if (nset == NULL) {
-		set_dispose(set);
+		slap_set_dispose(set);
 		return(NULL);
 	}
-	for (i = 0; set[i]; i++) {
-		vals = (gatherer)(cookie, set[i], attrstr);
+	for (i = 0; set[i].bv_val; i++) {
+		vals = (gatherer)(cookie, &set[i], &bv);
 		if (vals != NULL)
 			nset = set_join(nset, '|', vals);
 	}
-	set_dispose(set);
+	slap_set_dispose(set);
 
 	if (closure) {
-		for (i = 0; nset[i]; i++) {
-			vals = (gatherer)(cookie, nset[i], attrstr);
+		for (i = 0; nset[i].bv_val; i++) {
+			vals = (gatherer)(cookie, &nset[i], &bv);
 			if (vals != NULL) {
 				nset = set_join(nset, '|', vals);
 				if (nset == NULL)
@@ -195,24 +195,30 @@ set_samedn (char *dn1, char *dn2)
 }
 
 int
-set_filter (SET_GATHER gatherer, void *cookie, char *filter, char *user, char *this, char ***results)
+slap_set_filter (SLAP_SET_GATHER gatherer,
+	void *cookie, struct berval *fbv,
+	struct berval *user, struct berval *this, 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;
+#define IS_SET(x)	( (long)(x) >= 256 )
+#define IS_OP(x)	( (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 >= 63) SF_ERROR(overflow); \
+		stack[++stp] = (BerVarray)(long)(x); \
+	} while (0)
+
+	BerVarray set, lset;
+	BerVarray stack[64];
 	int len, op, rc, stp;
-	char **stack[64];
+	char c, *filter = fbv->bv_val;
 
 	if (results)
 		*results = NULL;
 
 	stp = -1;
-	while (c = *filter++) {
+	while ((c = *filter++)) {
 		set = NULL;
 		switch (c) {
 		case ' ':
@@ -281,13 +287,14 @@ set_filter (SET_GATHER gatherer, void *cookie, char *filter, char *user, char *t
 			if (c == 0)
 				SF_ERROR(syntax);
 			
-			set = ch_calloc(2, sizeof(char *));
+			set = SLAP_CALLOC(2, sizeof(struct berval));
 			if (set == NULL)
 				SF_ERROR(memory);
-			*set = ch_calloc(len + 1, sizeof(char));
-			if (*set == NULL)
+			set->bv_val = SLAP_CALLOC(len + 1, sizeof(char));
+			if (set->bv_val == NULL)
 				SF_ERROR(memory);
-			memcpy(*set, &filter[-len - 1], len);
+			AC_MEMCPY(set->bv_val, &filter[-len - 1], len);
+			set->bv_len = len;
 			SF_PUSH(set);
 			set = NULL;
 			break;
@@ -324,28 +331,32 @@ set_filter (SET_GATHER gatherer, void *cookie, char *filter, char *user, char *t
 			{
 				if ((SF_TOP() == (void *)'/') || IS_SET(SF_TOP()))
 					SF_ERROR(syntax);
-				set = ch_calloc(2, sizeof(char *));
+				set = SLAP_CALLOC(2, sizeof(struct berval));
 				if (set == NULL)
 					SF_ERROR(memory);
-				*set = ch_strdup(this);
-				if (*set == NULL)
+				ber_dupbv( set, this );
+				if (set->bv_val == 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 = ch_calloc(2, sizeof(char *));
+				set = SLAP_CALLOC(2, sizeof(struct berval));
 				if (set == NULL)
 					SF_ERROR(memory);
-				*set = ch_strdup(user);
-				if (*set == NULL)
+				ber_dupbv( set, user );
+				if (set->bv_val == NULL)
 					SF_ERROR(memory);
 			} else if (SF_TOP() != (void *)'/') {
 				SF_ERROR(syntax);
 			} else {
+				struct berval fb2;
 				SF_POP();
-				set = set_chase(gatherer, cookie, SF_POP(), filter, len, c == '*');
+				fb2.bv_val = filter;
+				fb2.bv_len = len;
+				set = set_chase(gatherer,
+					cookie, SF_POP(), &fb2, c == '*');
 				if (set == NULL)
 					SF_ERROR(memory);
 				if (c == '*')
@@ -373,7 +384,7 @@ set_filter (SET_GATHER gatherer, void *cookie, char *filter, char *user, char *t
 		SF_ERROR(syntax);
 	}
 
-	rc = set_size(set);
+	rc = slap_set_size(set) > 0 ? 1 : 0;
 	if (results) {
 		*results = set;
 		set = NULL;
@@ -381,10 +392,10 @@ set_filter (SET_GATHER gatherer, void *cookie, char *filter, char *user, char *t
 
 _error:
 	if (IS_SET(set))
-		set_dispose(set);
-	while (set = SF_POP()) {
+		slap_set_dispose(set);
+	while ((set = SF_POP())) {
 		if (IS_SET(set))
-			set_dispose(set);
+			slap_set_dispose(set);
 	}
 	return(rc);
 }