Fix access_allowed() error checking bug

[openldap] / servers / slapd / sets.c

diff --git a/servers/slapd/sets.c b/servers/slapd/sets.c
index 4f2f617d34383288c075e900abd7a4392b331bf1..cd4a76c5fccb168fc9c4a75af8e4a2109d68bf42 100644 (file)
--- a/servers/slapd/sets.c
+++ b/servers/slapd/sets.c
@@ -1,6 +1,6 @@
 /* $OpenLDAP$ */
 /*
- * Copyright 2000 The OpenLDAP Foundation, All Rights Reserved.
+ * Copyright 2000-2002 The OpenLDAP Foundation, All Rights Reserved.
  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
  */
 
@@ -12,34 +12,34 @@
 #include "slap.h"
 #include "sets.h"
 
-static BVarray set_join (BVarray lset, int op, BVarray rset);
-static BVarray set_chase (SLAP_SET_GATHER gatherer,
-       void *cookie, BVarray set, struct berval *attr, 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
-slap_set_size (BVarray set)
+slap_set_size (BerVarray set)
 {
-       int i;
+       long    i;
 
        i = 0;
        if (set != NULL) {
                while (set[i].bv_val)
                        i++;
        }
-       return(i);
+       return i;
 }
 
 void
-slap_set_dispose (BVarray set)
+slap_set_dispose (BerVarray set)
 {
-       bvarray_free(set);
+       ber_bvarray_free(set);
 }
 
-static BVarray
-set_join (BVarray lset, int op, BVarray rset)
+static BerVarray
+set_join (BerVarray lset, int op, BerVarray rset)
 {
-       BVarray set;
+       BerVarray set;
        long i, j, last;
 
        set = NULL;
@@ -47,7 +47,7 @@ set_join (BVarray lset, int op, BVarray rset)
                if (lset == NULL || lset->bv_val == NULL) {
                        if (rset == NULL) {
                                if (lset == NULL)
-                                       return(ch_calloc(1, sizeof(struct berval)));
+                                       return(SLAP_CALLOC(1, sizeof(struct berval)));
                                return(lset);
                        }
                        slap_set_dispose(lset);
@@ -59,7 +59,7 @@ set_join (BVarray lset, int op, BVarray rset)
                }
 
                i = slap_set_size(lset) + slap_set_size(rset) + 1;
-               set = ch_calloc(i, sizeof(struct berval));
+               set = SLAP_CALLOC(i, sizeof(struct berval));
                if (set != NULL) {
                        /* set_chase() depends on this routine to
                         * keep the first elements of the result
@@ -87,7 +87,7 @@ set_join (BVarray lset, int op, BVarray rset)
 
        if (op == '&') {
                if (lset == NULL || lset->bv_val == NULL || rset == NULL || rset->bv_val == NULL) {
-                       set = ch_calloc(1, sizeof(struct berval));
+                       set = SLAP_CALLOC(1, sizeof(struct berval));
                } else {
                        set = lset;
                        lset = NULL;
@@ -113,17 +113,20 @@ set_join (BVarray lset, int op, BVarray rset)
        return(set);
 }
 
-static BVarray
+static BerVarray
 set_chase (SLAP_SET_GATHER gatherer,
-       void *cookie, BVarray set, struct berval *attr, int closure)
+       void *cookie, BerVarray set, struct berval *attr, int closure)
 {
-       BVarray vals, nset;
+       BerVarray vals, nset;
        char attrstr[32];
-       struct berval bv = {attr->bv_len, attrstr};
+       struct berval bv;
        int i;
 
+       bv.bv_len = attr->bv_len;
+       bv.bv_val = attrstr;
+
        if (set == NULL)
-               return(ch_calloc(1, sizeof(struct berval)));
+               return(SLAP_CALLOC(1, sizeof(struct berval)));
 
        if (set->bv_val == NULL)
                return(set);
@@ -135,13 +138,13 @@ set_chase (SLAP_SET_GATHER gatherer,
        AC_MEMCPY(attrstr, attr->bv_val, attr->bv_len);
        attrstr[attr->bv_len] = 0;
 
-       nset = ch_calloc(1, sizeof(struct berval));
+       nset = SLAP_CALLOC(1, sizeof(struct berval));
        if (nset == NULL) {
                slap_set_dispose(set);
                return(NULL);
        }
        for (i = 0; set[i].bv_val; i++) {
-               vals = (gatherer)(cookie, set[i].bv_val, &bv);
+               vals = (gatherer)(cookie, &set[i], &bv);
                if (vals != NULL)
                        nset = set_join(nset, '|', vals);
        }
@@ -149,7 +152,7 @@ set_chase (SLAP_SET_GATHER gatherer,
 
        if (closure) {
                for (i = 0; nset[i].bv_val; i++) {
-                       vals = (gatherer)(cookie, nset[i].bv_val, &bv);
+                       vals = (gatherer)(cookie, &nset[i], &bv);
                        if (vals != NULL) {
                                nset = set_join(nset, '|', vals);
                                if (nset == NULL)
@@ -194,20 +197,20 @@ set_samedn (char *dn1, char *dn2)
 int
 slap_set_filter (SLAP_SET_GATHER gatherer,
        void *cookie, struct berval *fbv,
-       char *user, char *this, BVarray *results)
+       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)    do { rc = -1; goto _error; } while (0)
-#define SF_TOP()       ( (BVarray)( (stp < 0) ? 0 : stack[stp] ) )
-#define SF_POP()       ( (BVarray)( (stp < 0) ? 0 : stack[stp--] ) )
+#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] = (BVarray)(long)(x); \
+               stack[++stp] = (BerVarray)(long)(x); \
        } while (0)
 
-       BVarray set, lset;
-       BVarray stack[64];
+       BerVarray set, lset;
+       BerVarray stack[64];
        int len, op, rc, stp;
        char c, *filter = fbv->bv_val;
 
@@ -284,10 +287,10 @@ slap_set_filter (SLAP_SET_GATHER gatherer,
                        if (c == 0)
                                SF_ERROR(syntax);
                        
-                       set = ch_calloc(2, sizeof(struct berval));
+                       set = SLAP_CALLOC(2, sizeof(struct berval));
                        if (set == NULL)
                                SF_ERROR(memory);
-                       set->bv_val = ch_calloc(len + 1, sizeof(char));
+                       set->bv_val = SLAP_CALLOC(len + 1, sizeof(char));
                        if (set->bv_val == NULL)
                                SF_ERROR(memory);
                        AC_MEMCPY(set->bv_val, &filter[-len - 1], len);
@@ -328,10 +331,10 @@ slap_set_filter (SLAP_SET_GATHER gatherer,
                        {
                                if ((SF_TOP() == (void *)'/') || IS_SET(SF_TOP()))
                                        SF_ERROR(syntax);
-                               set = ch_calloc(2, sizeof(struct berval));
+                               set = SLAP_CALLOC(2, sizeof(struct berval));
                                if (set == NULL)
                                        SF_ERROR(memory);
-                               ber_str2bv( this, 0, 1, set );
+                               ber_dupbv( set, this );
                                if (set->bv_val == NULL)
                                        SF_ERROR(memory);
                        } else if (len == 4
@@ -339,10 +342,10 @@ slap_set_filter (SLAP_SET_GATHER gatherer,
                        {
                                if ((SF_TOP() == (void *)'/') || IS_SET(SF_TOP()))
                                        SF_ERROR(syntax);
-                               set = ch_calloc(2, sizeof(struct berval));
+                               set = SLAP_CALLOC(2, sizeof(struct berval));
                                if (set == NULL)
                                        SF_ERROR(memory);
-                               ber_str2bv( user, 0, 1, set );
+                               ber_dupbv( set, user );
                                if (set->bv_val == NULL)
                                        SF_ERROR(memory);
                        } else if (SF_TOP() != (void *)'/') {
@@ -381,7 +384,7 @@ slap_set_filter (SLAP_SET_GATHER gatherer,
                SF_ERROR(syntax);
        }
 
-       rc = slap_set_size(set);
+       rc = slap_set_size(set) > 0 ? 1 : 0;
        if (results) {
                *results = set;
                set = NULL;