ITS#3707 preserve filter input, allow (and ignore) undefined attributes

diff --git a/servers/slapd/ava.c b/servers/slapd/ava.c
index 888a4404a505cbe07cd6e81e0c481cea2c71b548..653675fd2298cb6d9bf2244215e35c6a227229c2 100644 (file)
--- a/servers/slapd/ava.c
+++ b/servers/slapd/ava.c
@@ -55,7 +55,7 @@ int
 get_ava(
        Operation *op,
        BerElement      *ber,
-       AttributeAssertion      **ava,
+       Filter *f,
        unsigned usage,
        const char **text )
 {
@@ -85,8 +85,9 @@ get_ava(
        rc = slap_bv2ad( &type, &aa->aa_desc, text );
 
        if( rc != LDAP_SUCCESS ) {
-               rc = slap_bv2undef_ad( &type, &aa->aa_desc, text,
-                               SLAP_AD_PROXIED|SLAP_AD_NOINSERT );
+               f->f_choice |= SLAPD_FILTER_UNDEFINED;
+               *text = NULL;
+               rc = slap_bv2undef_ad( &type, &aa->aa_desc, text, SLAP_AD_PROXIED);
 
                if( rc != LDAP_SUCCESS ) {
                        Debug( LDAP_DEBUG_FILTER,
@@ -101,10 +102,11 @@ get_ava(
                usage, &value, &aa->aa_value, text, op->o_tmpmemctx );
 
        if( rc != LDAP_SUCCESS ) {
+               f->f_choice |= SLAPD_FILTER_UNDEFINED;
                Debug( LDAP_DEBUG_FILTER,
                "get_ava: illegal value for attributeType %s\n", type.bv_val, 0, 0 );
-               op->o_tmpfree( aa, op->o_tmpmemctx );
-               return rc;
+               ber_dupbv_x( &aa->aa_value, &value, op->o_tmpmemctx );
+               rc = LDAP_SUCCESS;
        }
 
 #ifdef LDAP_COMP_MATCH
@@ -120,6 +122,6 @@ get_ava(
                }
        }
 #endif
-       *ava = aa;
+       f->f_ava = aa;
        return LDAP_SUCCESS;
 }

diff --git a/servers/slapd/back-bdb/filterindex.c b/servers/slapd/back-bdb/filterindex.c
index 13bca595f77b093d424462a0da1652f2f1008ef4..526224918cbc7781b0f0a7393ec847abb995396a 100644 (file)
--- a/servers/slapd/back-bdb/filterindex.c
+++ b/servers/slapd/back-bdb/filterindex.c
@@ -102,6 +102,11 @@ bdb_filter_candidates(
 #endif
        Debug( LDAP_DEBUG_FILTER, "=> bdb_filter_candidates\n", 0, 0, 0 );
 
+       if ( f->f_choice & SLAPD_FILTER_UNDEFINED ) {
+               BDB_IDL_ZERO( ids );
+               goto out;
+       }
+
        switch ( f->f_choice ) {
        case SLAPD_FILTER_COMPUTED:
                switch( f->f_result ) {
@@ -204,6 +209,7 @@ bdb_filter_candidates(
                }
        }
 
+out:
        Debug( LDAP_DEBUG_FILTER,
                "<= bdb_filter_candidates: id=%ld first=%ld last=%ld\n",
                (long) ids[0],

diff --git a/servers/slapd/filter.c b/servers/slapd/filter.c
index 87cfd7193730c6672e6859cd389e18836fcce2e1..2c6274430e3d3f7f2796f36bd88a6b8b2fa6b783 100644 (file)
--- a/servers/slapd/filter.c
+++ b/servers/slapd/filter.c
@@ -42,7 +42,7 @@ static int    get_filter_list(
 static int     get_ssa(
        Operation *op,
        BerElement *ber,
-       SubstringsAssertion **s,
+       Filter *f,
        const char **text );
 
 static void simple_vrFilter2bv(
@@ -79,8 +79,8 @@ get_filter(
         *              substrings      [4]     SubstringFilter,
         *              greaterOrEqual  [5]     AttributeValueAssertion,
         *              lessOrEqual     [6]     AttributeValueAssertion,
-        *              present         [7]     AttributeType,,
-        *              approxMatch     [8]     AttributeValueAssertion
+        *              present         [7]     AttributeType,
+        *              approxMatch     [8]     AttributeValueAssertion,
         *              extensibleMatch [9]     MatchingRuleAssertion
         *      }
         *
@@ -117,7 +117,7 @@ get_filter(
        switch ( f.f_choice ) {
        case LDAP_FILTER_EQUALITY:
                Debug( LDAP_DEBUG_FILTER, "EQUALITY\n", 0, 0, 0 );
-               err = get_ava( op, ber, &f.f_ava, SLAP_MR_EQUALITY, text );
+               err = get_ava( op, ber, &f, SLAP_MR_EQUALITY, text );
                if ( err != LDAP_SUCCESS ) {
                        break;
                }
@@ -127,7 +127,7 @@ get_filter(
 
        case LDAP_FILTER_SUBSTRINGS:
                Debug( LDAP_DEBUG_FILTER, "SUBSTRINGS\n", 0, 0, 0 );
-               err = get_ssa( op, ber, &f.f_sub, text );
+               err = get_ssa( op, ber, &f, text );
                if( err != LDAP_SUCCESS ) {
                        break;
                }
@@ -136,7 +136,7 @@ get_filter(
 
        case LDAP_FILTER_GE:
                Debug( LDAP_DEBUG_FILTER, "GE\n", 0, 0, 0 );
-               err = get_ava( op, ber, &f.f_ava, SLAP_MR_ORDERING, text );
+               err = get_ava( op, ber, &f, SLAP_MR_ORDERING, text );
                if ( err != LDAP_SUCCESS ) {
                        break;
                }
@@ -145,7 +145,7 @@ get_filter(
 
        case LDAP_FILTER_LE:
                Debug( LDAP_DEBUG_FILTER, "LE\n", 0, 0, 0 );
-               err = get_ava( op, ber, &f.f_ava, SLAP_MR_ORDERING, text );
+               err = get_ava( op, ber, &f, SLAP_MR_ORDERING, text );
                if ( err != LDAP_SUCCESS ) {
                        break;
                }
@@ -166,9 +166,8 @@ get_filter(
                err = slap_bv2ad( &type, &f.f_desc, text );
 
                if( err != LDAP_SUCCESS ) {
-                       err = slap_bv2undef_ad( &type, &f.f_desc, text,
-                               SLAP_AD_PROXIED|SLAP_AD_NOINSERT );
-
+                       f.f_choice |= SLAPD_FILTER_UNDEFINED;
+                       err = slap_bv2undef_ad( &type, &f.f_desc, text, SLAP_AD_PROXIED);
                        if ( err != LDAP_SUCCESS ) {
                                /* unrecognized attribute description or other error */
                                Debug( LDAP_DEBUG_ANY, 
@@ -176,12 +175,9 @@ get_filter(
                                        "type=%s (%d)\n",
                                        op->o_connid, type.bv_val, err );
 
-                               f.f_choice = SLAPD_FILTER_COMPUTED;
-                               f.f_result = LDAP_COMPARE_FALSE;
                                err = LDAP_SUCCESS;
-                               *text = NULL;
-                               break;
                        }
+                       *text = NULL;
                }
 
                assert( f.f_desc != NULL );
@@ -189,7 +185,7 @@ get_filter(
 
        case LDAP_FILTER_APPROX:
                Debug( LDAP_DEBUG_FILTER, "APPROX\n", 0, 0, 0 );
-               err = get_ava( op, ber, &f.f_ava, SLAP_MR_EQUALITY_APPROX, text );
+               err = get_ava( op, ber, &f, SLAP_MR_EQUALITY_APPROX, text );
                if ( err != LDAP_SUCCESS ) {
                        break;
                }
@@ -253,7 +249,7 @@ get_filter(
        case LDAP_FILTER_EXT:
                Debug( LDAP_DEBUG_FILTER, "EXTENSIBLE\n", 0, 0, 0 );
 
-               err = get_mra( op, ber, &f.f_mra, text );
+               err = get_mra( op, ber, &f, text );
                if ( err != LDAP_SUCCESS ) {
                        break;
                }
@@ -320,7 +316,7 @@ static int
 get_ssa(
        Operation *op,
        BerElement      *ber,
-       SubstringsAssertion     **out,
+       Filter          *f,
        const char      **text )
 {
        ber_tag_t       tag;
@@ -331,7 +327,6 @@ get_ssa(
        SubstringsAssertion ssa;
 
        *text = "error decoding filter";
-       *out = NULL;
 
        Debug( LDAP_DEBUG_FILTER, "begin get_ssa\n", 0, 0, 0 );
        if ( ber_scanf( ber, "{m" /*}*/, &desc ) == LBER_ERROR ) {
@@ -348,9 +343,8 @@ get_ssa(
        rc = slap_bv2ad( &desc, &ssa.sa_desc, text );
 
        if( rc != LDAP_SUCCESS ) {
-               rc = slap_bv2undef_ad( &desc, &ssa.sa_desc, text,
-                       SLAP_AD_PROXIED|SLAP_AD_NOINSERT );
-
+               f->f_choice |= SLAPD_FILTER_UNDEFINED;
+               rc = slap_bv2undef_ad( &desc, &ssa.sa_desc, text, SLAP_AD_PROXIED);
                if( rc != LDAP_SUCCESS ) {
                        Debug( LDAP_DEBUG_ANY, 
                                "get_ssa: conn %lu unknown attribute type=%s (%ld)\n",
@@ -463,8 +457,8 @@ return_error:
        }
 
        if( rc == LDAP_SUCCESS ) {
-               *out = op->o_tmpalloc( sizeof( ssa ), op->o_tmpmemctx );
-               **out = ssa;
+               f->f_sub = op->o_tmpalloc( sizeof( ssa ), op->o_tmpmemctx );
+               *f->f_sub = ssa;
        }
 
        Debug( LDAP_DEBUG_FILTER, "end get_ssa\n", 0, 0, 0 );
@@ -480,6 +474,8 @@ filter_free_x( Operation *op, Filter *f )
                return;
        }
 
+       f->f_choice &= SLAPD_FILTER_MASK;
+
        switch ( f->f_choice ) {
        case LDAP_FILTER_PRESENT:
                break;
@@ -553,90 +549,64 @@ filter2bv_x( Operation *op, Filter *f, struct berval *fstr )
                        ber_bvunknown = BER_BVC( "(?=unknown)" ),
                        ber_bvnone = BER_BVC( "(?=none)" );
        ber_len_t       len;
+       ber_tag_t       choice;
+       int undef;
+       char *sign;
 
        if ( f == NULL ) {
                ber_dupbv_x( fstr, &ber_bvnone, op->o_tmpmemctx );
                return;
        }
 
-       switch ( f->f_choice ) {
-       case LDAP_FILTER_EQUALITY:
-               filter_escape_value_x( &f->f_av_value, &tmp, op->o_tmpmemctx );
-               /* NOTE: tmp can legitimately be NULL (meaning empty) 
-                * since in a Filter values in AVAs are supposed
-                * to have been normalized, meaning that an empty value
-                * is legal for that attribute's syntax */
-
-               fstr->bv_len = f->f_av_desc->ad_cname.bv_len +
-                       tmp.bv_len + STRLENOF("(=)");
-               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_len ? tmp.bv_val : "" );
-
-               ber_memfree_x( tmp.bv_val, op->o_tmpmemctx );
-               break;
+       undef = f->f_choice & SLAPD_FILTER_UNDEFINED;
+       choice = f->f_choice & SLAPD_FILTER_MASK;
 
+       switch ( choice ) {
+       case LDAP_FILTER_EQUALITY:
+               fstr->bv_len = STRLENOF("(=)");
+               sign = "=";
+               goto simple;
        case LDAP_FILTER_GE:
-               filter_escape_value_x( &f->f_av_value, &tmp, op->o_tmpmemctx );
-               /* NOTE: tmp can legitimately be NULL (meaning empty) 
-                * since in a Filter values in AVAs are supposed
-                * to have been normalized, meaning that an empty value
-                * is legal for that attribute's syntax */
-
-               fstr->bv_len = f->f_av_desc->ad_cname.bv_len +
-                       tmp.bv_len + STRLENOF("(>=)");
-               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_len ? tmp.bv_val : "");
-
-               ber_memfree_x( tmp.bv_val, op->o_tmpmemctx );
-               break;
-
+               fstr->bv_len = STRLENOF("(>=)");
+               sign = ">=";
+               goto simple;
        case LDAP_FILTER_LE:
-               filter_escape_value_x( &f->f_av_value, &tmp, op->o_tmpmemctx );
-               /* NOTE: tmp can legitimately be NULL (meaning empty) 
-                * since in a Filter values in AVAs are supposed
-                * to have been normalized, meaning that an empty value
-                * is legal for that attribute's syntax */
-
-               fstr->bv_len = f->f_av_desc->ad_cname.bv_len +
-                       tmp.bv_len + STRLENOF("(<=)");
-               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_len ? tmp.bv_val : "");
-
-               ber_memfree_x( tmp.bv_val, op->o_tmpmemctx );
-               break;
-
+               fstr->bv_len = STRLENOF("(<=)");
+               sign = "<=";
+               goto simple;
        case LDAP_FILTER_APPROX:
+               fstr->bv_len = STRLENOF("(~=)");
+               sign = "~=";
+
+simple:
                filter_escape_value_x( &f->f_av_value, &tmp, op->o_tmpmemctx );
                /* NOTE: tmp can legitimately be NULL (meaning empty) 
                 * since in a Filter values in AVAs are supposed
                 * to have been normalized, meaning that an empty value
                 * is legal for that attribute's syntax */
 
-               fstr->bv_len = f->f_av_desc->ad_cname.bv_len +
-                       tmp.bv_len + STRLENOF("(~=)");
+               fstr->bv_len += f->f_av_desc->ad_cname.bv_len + tmp.bv_len;
+               if ( undef )
+                       fstr->bv_len++;
                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_len ? tmp.bv_val : "");
+               snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s%s%s%s)",
+                       undef ? "?" : "",
+                       f->f_av_desc->ad_cname.bv_val, sign,
+                       tmp.bv_len ? tmp.bv_val : "" );
+
                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 +
                        STRLENOF("(=*)");
+               if ( undef )
+                       fstr->bv_len++;
                fstr->bv_val = op->o_tmpalloc( fstr->bv_len + 128, op->o_tmpmemctx );
 
-               snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s=*)",
+               snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s%s=*)",
+                       undef ? "?" : "",
                        f->f_sub_desc->ad_cname.bv_val );
 
                if ( f->f_sub_initial.bv_val != NULL ) {
@@ -705,9 +675,13 @@ filter2bv_x( Operation *op, Filter *f, struct berval *fstr )
        case LDAP_FILTER_PRESENT:
                fstr->bv_len = f->f_desc->ad_cname.bv_len +
                        STRLENOF("(=*)");
+               if ( undef )
+                       fstr->bv_len++;
+
                fstr->bv_val = op->o_tmpalloc( fstr->bv_len + 1, op->o_tmpmemctx );
 
-               snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s=*)",
+               snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s%s=*)",
+                       undef ? "?" : "",
                        f->f_desc->ad_cname.bv_val );
                break;
 
@@ -761,7 +735,8 @@ filter2bv_x( Operation *op, Filter *f, struct berval *fstr )
                        tmp.bv_len + STRLENOF("(:=)");
                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)",
+               snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s%s%s%s%s:=%s)",
+                       undef ? "?" : "",
                        ad.bv_val,
                        f->f_mr_dnattrs ? ":dn" : "",
                        f->f_mr_rule_text.bv_len ? ":" : "",
@@ -824,7 +799,7 @@ filter_dup( Filter *f, void *memctx )
        n->f_choice = f->f_choice;
        n->f_next = NULL;
 
-       switch( f->f_choice ) {
+       switch( f->f_choice & SLAPD_FILTER_MASK ) {
        case SLAPD_FILTER_COMPUTED:
                n->f_result = f->f_result;
                break;
@@ -915,7 +890,7 @@ get_simple_vrFilter(
        switch ( vrf.vrf_choice ) {
        case LDAP_FILTER_EQUALITY:
                Debug( LDAP_DEBUG_FILTER, "EQUALITY\n", 0, 0, 0 );
-               err = get_ava( op, ber, &vrf.vrf_ava, SLAP_MR_EQUALITY, text );
+               err = get_ava( op, ber, (Filter *)&vrf, SLAP_MR_EQUALITY, text );
                if ( err != LDAP_SUCCESS ) {
                        break;
                }
@@ -925,12 +900,12 @@ get_simple_vrFilter(
 
        case LDAP_FILTER_SUBSTRINGS:
                Debug( LDAP_DEBUG_FILTER, "SUBSTRINGS\n", 0, 0, 0 );
-               err = get_ssa( op, ber, &vrf.vrf_sub, text );
+               err = get_ssa( op, ber, (Filter *)&vrf, text );
                break;
 
        case LDAP_FILTER_GE:
                Debug( LDAP_DEBUG_FILTER, "GE\n", 0, 0, 0 );
-               err = get_ava( op, ber, &vrf.vrf_ava, SLAP_MR_ORDERING, text );
+               err = get_ava( op, ber, (Filter *)&vrf, SLAP_MR_ORDERING, text );
                if ( err != LDAP_SUCCESS ) {
                        break;
                }
@@ -938,7 +913,7 @@ get_simple_vrFilter(
 
        case LDAP_FILTER_LE:
                Debug( LDAP_DEBUG_FILTER, "LE\n", 0, 0, 0 );
-               err = get_ava( op, ber, &vrf.vrf_ava, SLAP_MR_ORDERING, text );
+               err = get_ava( op, ber, (Filter *)&vrf, SLAP_MR_ORDERING, text );
                if ( err != LDAP_SUCCESS ) {
                        break;
                }
@@ -958,8 +933,9 @@ get_simple_vrFilter(
                err = slap_bv2ad( &type, &vrf.vrf_desc, text );
 
                if( err != LDAP_SUCCESS ) {
+                       vrf.vrf_choice |= SLAPD_FILTER_UNDEFINED;
                        err = slap_bv2undef_ad( &type, &vrf.vrf_desc, text,
-                               SLAP_AD_PROXIED|SLAP_AD_NOINSERT );
+                               SLAP_AD_PROXIED);
 
                        if( err != LDAP_SUCCESS ) {
                                /* unrecognized attribute description or other error */
@@ -978,7 +954,7 @@ get_simple_vrFilter(
 
        case LDAP_FILTER_APPROX:
                Debug( LDAP_DEBUG_FILTER, "APPROX\n", 0, 0, 0 );
-               err = get_ava( op, ber, &vrf.vrf_ava, SLAP_MR_EQUALITY_APPROX, text );
+               err = get_ava( op, ber, (Filter *)&vrf, SLAP_MR_EQUALITY_APPROX, text );
                if ( err != LDAP_SUCCESS ) {
                        break;
                }
@@ -987,7 +963,7 @@ get_simple_vrFilter(
        case LDAP_FILTER_EXT:
                Debug( LDAP_DEBUG_FILTER, "EXTENSIBLE\n", 0, 0, 0 );
 
-               err = get_mra( op, ber, &vrf.vrf_mra, text );
+               err = get_mra( op, ber, (Filter *)&vrf, text );
                if ( err != LDAP_SUCCESS ) {
                        break;
                }
@@ -1103,7 +1079,7 @@ vrFilter_free( Operation *op, ValuesReturnFilter *vrf )
        for ( p = vrf; p != NULL; p = next ) {
                next = p->vrf_next;
 
-               switch ( vrf->vrf_choice ) {
+               switch ( vrf->vrf_choice & SLAPD_FILTER_MASK ) {
                case LDAP_FILTER_PRESENT:
                        break;
 
@@ -1187,13 +1163,15 @@ simple_vrFilter2bv( Operation *op, ValuesReturnFilter *vrf, struct berval *fstr
                        op->o_tmpmemctx );
                return;
        }
+       int undef = vrf->vrf_choice & SLAPD_FILTER_UNDEFINED;
 
-       switch ( vrf->vrf_choice ) {
+       switch ( vrf->vrf_choice & SLAPD_FILTER_MASK ) {
        case LDAP_FILTER_EQUALITY:
                filter_escape_value_x( &vrf->vrf_av_value, &tmp, op->o_tmpmemctx );
 
                fstr->bv_len = vrf->vrf_av_desc->ad_cname.bv_len +
                        tmp.bv_len + STRLENOF("(=)");
+               if ( undef ) fstr->bv_len++;
                fstr->bv_val = op->o_tmpalloc( fstr->bv_len + 1, op->o_tmpmemctx );
 
                snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s=%s)",
@@ -1208,6 +1186,7 @@ simple_vrFilter2bv( Operation *op, ValuesReturnFilter *vrf, struct berval *fstr
 
                fstr->bv_len = vrf->vrf_av_desc->ad_cname.bv_len +
                        tmp.bv_len + STRLENOF("(>=)");
+               if ( undef ) fstr->bv_len++;
                fstr->bv_val = op->o_tmpalloc( fstr->bv_len + 1, op->o_tmpmemctx );
 
                snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s>=%s)",
@@ -1222,6 +1201,7 @@ simple_vrFilter2bv( Operation *op, ValuesReturnFilter *vrf, struct berval *fstr
 
                fstr->bv_len = vrf->vrf_av_desc->ad_cname.bv_len +
                        tmp.bv_len + STRLENOF("(<=)");
+               if ( undef ) fstr->bv_len++;
                fstr->bv_val = op->o_tmpalloc( fstr->bv_len + 1, op->o_tmpmemctx );
 
                snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s<=%s)",
@@ -1236,6 +1216,7 @@ simple_vrFilter2bv( Operation *op, ValuesReturnFilter *vrf, struct berval *fstr
 
                fstr->bv_len = vrf->vrf_av_desc->ad_cname.bv_len +
                        tmp.bv_len + STRLENOF("(~=)");
+               if ( undef ) fstr->bv_len++;
                fstr->bv_val = op->o_tmpalloc( fstr->bv_len + 1, op->o_tmpmemctx );
 
                snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s~=%s)",
@@ -1247,6 +1228,7 @@ simple_vrFilter2bv( Operation *op, ValuesReturnFilter *vrf, struct berval *fstr
        case LDAP_FILTER_SUBSTRINGS:
                fstr->bv_len = vrf->vrf_sub_desc->ad_cname.bv_len +
                        STRLENOF("(=*)");
+               if ( undef ) fstr->bv_len++;
                fstr->bv_val = op->o_tmpalloc( fstr->bv_len + 128, op->o_tmpmemctx );
 
                snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s=*)",
@@ -1307,6 +1289,7 @@ simple_vrFilter2bv( Operation *op, ValuesReturnFilter *vrf, struct berval *fstr
        case LDAP_FILTER_PRESENT:
                fstr->bv_len = vrf->vrf_desc->ad_cname.bv_len +
                        STRLENOF("(=*)");
+               if ( undef ) fstr->bv_len++;
                fstr->bv_val = op->o_tmpalloc( fstr->bv_len + 1, op->o_tmpmemctx );
 
                snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s=*)",
@@ -1329,6 +1312,7 @@ simple_vrFilter2bv( Operation *op, ValuesReturnFilter *vrf, struct berval *fstr
                        ( vrf->vrf_mr_rule_text.bv_len
                                ? vrf->vrf_mr_rule_text.bv_len+1 : 0 ) +
                        tmp.bv_len + STRLENOF("(:=)");
+               if ( undef ) fstr->bv_len++;
                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)",

diff --git a/servers/slapd/filterentry.c b/servers/slapd/filterentry.c
index 5790b0a20974ab03e03439d797604c6f09e2219b..7f38d4d68c30efe7e7d4585e94fc33250ece1c1c 100644 (file)
--- a/servers/slapd/filterentry.c
+++ b/servers/slapd/filterentry.c
@@ -66,6 +66,12 @@ test_filter(
        int     rc;
        Debug( LDAP_DEBUG_FILTER, "=> test_filter\n", 0, 0, 0 );
 
+       if ( f->f_choice & SLAPD_FILTER_UNDEFINED ) {
+               Debug( LDAP_DEBUG_FILTER, "    UNDEFINED\n", 0, 0, 0 );
+               rc = SLAPD_COMPARE_UNDEFINED;
+               goto out;
+       }
+
        switch ( f->f_choice ) {
        case SLAPD_FILTER_COMPUTED:
                Debug( LDAP_DEBUG_FILTER, "    COMPUTED %s (%d)\n",
@@ -144,7 +150,7 @@ test_filter(
                    f->f_choice, 0, 0 );
                rc = LDAP_PROTOCOL_ERROR;
        }
-
+out:
        Debug( LDAP_DEBUG_FILTER, "<= test_filter %d\n", rc, 0, 0 );
        return( rc );
 }

diff --git a/servers/slapd/mra.c b/servers/slapd/mra.c
index 54dde3964ee2b4e8bc5527705727094148ac450c..ea3d866fc18ec39473bdd071cf407d5a19e3a483 100644 (file)
--- a/servers/slapd/mra.c
+++ b/servers/slapd/mra.c
@@ -48,7 +48,7 @@ int
 get_mra(
        Operation *op,
        BerElement      *ber,
-       MatchingRuleAssertion   **mra,
+       Filter *f,
        const char **text )
 {
        int rc;
@@ -141,8 +141,8 @@ get_mra(
        if( type.bv_val != NULL ) {
                rc = slap_bv2ad( &type, &ma.ma_desc, text );
                if( rc != LDAP_SUCCESS ) {
-                       rc = slap_bv2undef_ad( &type, &ma.ma_desc, text,
-                               SLAP_AD_PROXIED|SLAP_AD_NOINSERT );
+                       f->f_choice |= SLAPD_FILTER_UNDEFINED;
+                       rc = slap_bv2undef_ad( &type, &ma.ma_desc, text, SLAP_AD_PROXIED);
 
                        if( rc != LDAP_SUCCESS ) {
                                return rc;
@@ -214,12 +214,12 @@ get_mra(
        length = sizeof(ma);
        /* Append rule_text to end of struct */
        if (rule_text.bv_val) length += rule_text.bv_len + 1;
-       *mra = op->o_tmpalloc( length, op->o_tmpmemctx );
-       **mra = ma;
+       f->f_mra = op->o_tmpalloc( length, op->o_tmpmemctx );
+       *f->f_mra = ma;
        if (rule_text.bv_val) {
-               (*mra)->ma_rule_text.bv_len = rule_text.bv_len;
-               (*mra)->ma_rule_text.bv_val = (char *)(*mra+1);
-               AC_MEMCPY((*mra)->ma_rule_text.bv_val, rule_text.bv_val,
+               f->f_mra->ma_rule_text.bv_len = rule_text.bv_len;
+               f->f_mra->ma_rule_text.bv_val = (char *)(f->f_mra+1);
+               AC_MEMCPY(f->f_mra->ma_rule_text.bv_val, rule_text.bv_val,
                        rule_text.bv_len+1);
        }
 

diff --git a/servers/slapd/proto-slap.h b/servers/slapd/proto-slap.h
index caa1e0e57a919b2ee45635888bda972035dd7ddf..eb44ddb643303f9cacfcce0bfba5deeab0238e04 100644 (file)
--- a/servers/slapd/proto-slap.h
+++ b/servers/slapd/proto-slap.h
@@ -295,7 +295,7 @@ LDAP_SLAPD_F (int) attr_destroy LDAP_P(( void ));
 LDAP_SLAPD_F (int) get_ava LDAP_P((
        Operation *op,
        BerElement *ber,
-       AttributeAssertion **ava,
+       Filter *f,
        unsigned usage,
        const char **text ));
 LDAP_SLAPD_F (void) ava_free LDAP_P((
@@ -1190,7 +1190,7 @@ LDAP_SLAPD_F (int) mr_usable_with_at( MatchingRule *mr,
 LDAP_SLAPD_F (int) get_mra LDAP_P((
        Operation *op,
        BerElement *ber,
-       MatchingRuleAssertion **mra,
+       Filter *f,
        const char **text ));
 LDAP_SLAPD_F (void) mra_free LDAP_P((
        Operation *op,

diff --git a/servers/slapd/slap.h b/servers/slapd/slap.h
index e7dfd2a9386cee19a12743e36e8bd91e300b7277..535c362466008892bc0d6da6409409999590df92 100644 (file)
--- a/servers/slapd/slap.h
+++ b/servers/slapd/slap.h
@@ -977,7 +977,9 @@ typedef struct slap_mr_assertion {
  */
 typedef struct slap_filter {
        ber_tag_t       f_choice;       /* values taken from ldap.h, plus: */
-#define SLAPD_FILTER_COMPUTED          ((ber_tag_t) -1)
+#define SLAPD_FILTER_COMPUTED          0
+#define SLAPD_FILTER_MASK                      0x7fff
+#define SLAPD_FILTER_UNDEFINED         0x8000
 
        union f_un_u {
                /* precomputed result */