remove cruft

[openldap] / servers / slapd / filterentry.c

diff --git a/servers/slapd/filterentry.c b/servers/slapd/filterentry.c
index fe8a9f66f8e217b6ea7e9377c76f8e251415864d..34b8bc784f0643b34a7f48bc06ba85b52fb1e083 100644 (file)
--- a/servers/slapd/filterentry.c
+++ b/servers/slapd/filterentry.c
@@ -186,7 +186,7 @@ static int test_mra_filter(
                        const char *text;
 
                        rc = value_match( &ret, slap_schema.si_ad_entryDN, mra->ma_rule,
-                               0, &e->e_nname, &mra->ma_value, &text );
+                               SLAP_MR_EXT, &e->e_nname, &mra->ma_value, &text );
        
        
                        if( rc != LDAP_SUCCESS ) return rc;
@@ -264,7 +264,8 @@ static int test_mra_filter(
                                        if ( !a->a_comp_data->cd_tree[i] ) {
                                                return LDAP_OPERATIONS_ERROR;
                                        }
-                                       rc = value_match( &ret, a->a_desc, mra->ma_rule, 0,
+                                       rc = value_match( &ret, a->a_desc, mra->ma_rule,
+                                               SLAP_MR_COMPONENT,
                                                (struct berval*)a->a_comp_data->cd_tree[i++],
                                                (void*)mra, &text );
                                } else 
@@ -308,8 +309,8 @@ static int test_mra_filter(
                                                nbv = *bv;
                                        }
 
-                                       rc = value_match( &ret, a->a_desc, mra->ma_rule, 0,
-                                               &nbv, &mra->ma_value, &text );
+                                       rc = value_match( &ret, a->a_desc, mra->ma_rule,
+                                               SLAP_MR_EXT, &nbv, &mra->ma_value, &text );
 
                                        if ( nbv.bv_val != bv->bv_val ) {
                                                memfree( nbv.bv_val, memctx );
@@ -356,7 +357,8 @@ static int test_mra_filter(
                        {
                                int ret;
 
-                               rc = value_match( &ret, a->a_desc, mra->ma_rule, 0,
+                               rc = value_match( &ret, a->a_desc, mra->ma_rule,
+                                       SLAP_MR_COMPONENT,
                                        (struct berval*)a, (void*)mra, &text );
                                if ( rc != LDAP_SUCCESS ) break;
        
@@ -397,8 +399,8 @@ static int test_mra_filter(
                                        nbv = *bv;
                                }
 
-                               rc = value_match( &ret, a->a_desc, mra->ma_rule, 0,
-                                       &nbv, &value, &text );
+                               rc = value_match( &ret, a->a_desc, mra->ma_rule,
+                                       SLAP_MR_EXT, &nbv, &value, &text );
 
                                if ( nbv.bv_val != bv->bv_val ) {
                                        memfree( nbv.bv_val, memctx );
@@ -434,13 +436,15 @@ static int test_mra_filter(
 
                        for ( iAVA = 0; rdn[ iAVA ]; iAVA++ ) {
                                LDAPAVA         *ava = rdn[ iAVA ];
-                               struct berval   *bv = &ava->la_value, value;
+                               struct berval   *bv = &ava->la_value,
+                                               value = BER_BVNULL,
+                                               nbv = BER_BVNULL;
                                AttributeDescription *ad =
                                        (AttributeDescription *)ava->la_private;
-                               int ret;
-                               const char *text;
+                               int             ret;
+                               const char      *text;
 
-                               assert( ad );
+                               assert( ad != NULL );
 
                                if ( mra->ma_desc ) {
                                        /* have a mra type? check for subtype */
@@ -473,13 +477,37 @@ static int test_mra_filter(
                                        }
                                }
 
+                               if ( mra->ma_rule->smr_normalize ) {
+                                       /* see comment above */
+                                       if ( mra->ma_rule->smr_normalize(
+                                                       SLAP_MR_VALUE_OF_ATTRIBUTE_SYNTAX,
+                                                       mra->ma_rule->smr_syntax,
+                                                       mra->ma_rule,
+                                                       bv, &nbv, memctx ) != LDAP_SUCCESS )
+                                       {
+                                               /* FIXME: stop processing? */
+                                               rc = LDAP_SUCCESS;
+                                               ret = -1;
+                                               goto cleanup;
+                                       }
+
+                               } else {
+                                       nbv = *bv;
+                               }
+
                                /* check match */
-                               rc = value_match( &ret, ad, mra->ma_rule, 0,
-                                       bv, &value, &text );
-                               if ( value.bv_val != mra->ma_value.bv_val ) {
+                               rc = value_match( &ret, ad, mra->ma_rule, SLAP_MR_EXT,
+                                       &nbv, &value, &text );
+
+cleanup:;
+                               if ( !BER_BVISNULL( &value ) && value.bv_val != mra->ma_value.bv_val ) {
                                        memfree( value.bv_val, memctx );
                                }
 
+                               if ( !BER_BVISNULL( &nbv ) && nbv.bv_val != bv->bv_val ) {
+                                       memfree( nbv.bv_val, memctx );
+                               }
+
                                if ( rc == LDAP_SUCCESS && ret == 0 ) rc = LDAP_COMPARE_TRUE;
 
                                if ( rc != LDAP_SUCCESS ) {
@@ -504,7 +532,7 @@ test_ava_filter(
        int rc;
        Attribute       *a;
 #ifdef LDAP_COMP_MATCH
-       int i, num_attr_vals;
+       int i, num_attr_vals = 0;
        AttributeAliasing *a_alias = NULL;
 #endif
 
@@ -560,10 +588,10 @@ test_ava_filter(
                }
 
                mr = slap_schema.si_ad_entryDN->ad_type->sat_equality;
-               assert( mr );
+               assert( mr != NULL );
 
-               rc = value_match( &match, slap_schema.si_ad_entryDN, mr, 0,
-                       &e->e_nname, &ava->aa_value, &text );
+               rc = value_match( &match, slap_schema.si_ad_entryDN, mr,
+                       SLAP_MR_EXT, &e->e_nname, &ava->aa_value, &text );
 
                if( rc != LDAP_SUCCESS ) return rc;
                if( match == 0 ) return LDAP_COMPARE_TRUE;
@@ -587,6 +615,7 @@ test_ava_filter(
                a != NULL;
                a = attrs_find( a->a_next, ava->aa_desc ) )
        {
+               int use;
                MatchingRule *mr;
                struct berval *bv;
 
@@ -597,19 +626,24 @@ test_ava_filter(
                        continue;
                }
 
+               use = SLAP_MR_EQUALITY;
+
                switch ( type ) {
                case LDAP_FILTER_APPROX:
+                       use = SLAP_MR_EQUALITY_APPROX;
                        mr = a->a_desc->ad_type->sat_approx;
                        if( mr != NULL ) break;
 
-                       /* use EQUALITY matching rule if no APPROX rule */
+                       /* fallthru: use EQUALITY matching rule if no APPROX rule */
 
                case LDAP_FILTER_EQUALITY:
+                       /* use variable set above so fall thru use is not clobbered */
                        mr = a->a_desc->ad_type->sat_equality;
                        break;
 
                case LDAP_FILTER_GE:
                case LDAP_FILTER_LE:
+                       use = SLAP_MR_ORDERING;
                        mr = a->a_desc->ad_type->sat_ordering;
                        break;
 
@@ -645,7 +679,6 @@ test_ava_filter(
 
                        a->a_comp_data->cd_mem_op = nibble_mem_allocator ( 1024*10*(num_attr_vals-1), 1024 );
                        if ( a->a_comp_data->cd_mem_op == NULL ) {
-                               fprintf(stderr,"nibble mem allocation error\n");
                                free ( a->a_comp_data );
                                a->a_comp_data = NULL;
                                return LDAP_OPERATIONS_ERROR;
@@ -675,8 +708,10 @@ test_ava_filter(
                                        return LDAP_OPERATIONS_ERROR;
                                }
 
-                               ret = value_match( &match, a->a_desc, cf_mr, 0,
-                                       (struct berval*)a->a_comp_data->cd_tree[i++], (void*)&mra, &text );
+                               ret = value_match( &match, a->a_desc, cf_mr,
+                                       SLAP_MR_COMPONENT,
+                                       (struct berval*)a->a_comp_data->cd_tree[i++],
+                                       (void*)&mra, &text );
                                if ( ret == LDAP_INAPPROPRIATE_MATCHING ) {
                                        /* cached component tree is broken, just remove it */
                                        free_ComponentData ( a );
@@ -684,12 +719,11 @@ test_ava_filter(
                                }
                                if ( a_alias )
                                        ava->aa_desc = a_alias->aa_aliasing_ad;
-                       }
-                       else 
+
+                       } else 
 #endif
                        {
-
-                               ret = value_match( &match, a->a_desc, mr, 0,
+                               ret = value_match( &match, a->a_desc, mr, use,
                                        bv, &ava->aa_value, &text );
                        }
 
@@ -884,7 +918,7 @@ test_substrings_filter(
                        int ret, match;
                        const char *text;
 
-                       ret = value_match( &match, a->a_desc, mr, 0,
+                       ret = value_match( &match, a->a_desc, mr, SLAP_MR_SUBSTR,
                                bv, f->f_sub, &text );
 
                        if( ret != LDAP_SUCCESS ) {