minor naming cleanup; improvements to DN mapping layer; major docs update

[openldap] / servers / slapd / filterentry.c

diff --git a/servers/slapd/filterentry.c b/servers/slapd/filterentry.c
index e69526e43b90134ad1b36313821d4cd3cb7eef73..b09209b5e9fba762f19b2d742c4cfa70d1c950e0 100644 (file)
--- a/servers/slapd/filterentry.c
+++ b/servers/slapd/filterentry.c
@@ -2,7 +2,7 @@
 /* $OpenLDAP$ */
 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
  *
- * Copyright 1998-2004 The OpenLDAP Foundation.
+ * Copyright 1998-2005 The OpenLDAP Foundation.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -163,13 +163,6 @@ static int test_mra_filter(
                memfree = op->o_tmpfree;
        }
 
-#ifdef LDAP_COMP_MATCH
-       /* Component Matching */
-       if( mra->cf &&
-               mra->ma_rule->smr_usage & (SLAP_MR_COMPONENT) ){
-               return test_comp_filter_entry( op, e, mra );
-       }
-#endif
        if ( mra->ma_desc ) {
                /*
                 * if ma_desc is available, then we're filtering for
@@ -189,6 +182,7 @@ static int test_mra_filter(
                        rc = value_match( &ret, slap_schema.si_ad_entryDN, mra->ma_rule,
                                0, &e->e_nname, &mra->ma_value, &text );
        
+       
                        if( rc != LDAP_SUCCESS ) return rc;
                        if ( ret == 0 ) return LDAP_COMPARE_TRUE;
                        return LDAP_COMPARE_FALSE;
@@ -199,6 +193,23 @@ static int test_mra_filter(
                        a = attrs_find( a->a_next, mra->ma_desc ) )
                {
                        struct berval *bv;
+#ifdef LDAP_COMP_MATCH
+                       /* Component Matching */
+                       if( mra->ma_cf &&
+                               mra->ma_rule->smr_usage & SLAP_MR_COMPONENT )
+                       {
+                               int ret;
+                               int rc;
+                               const char *text;
+
+                               rc = value_match( &ret, a->a_desc, mra->ma_rule, 0,
+                                       (struct berval *)a,(void*) mra , &text );
+                               if ( rc != LDAP_SUCCESS ) return rc;
+                               if ( ret == 0 ) return LDAP_COMPARE_TRUE;
+                               else return LDAP_COMPARE_FALSE;
+                       }
+#endif
+
                        /* If ma_rule is not the same as the attribute's
                         * normal rule, then we can't use the a_nvals.
                         */
@@ -215,7 +226,7 @@ static int test_mra_filter(
        
                                rc = value_match( &ret, a->a_desc, mra->ma_rule, 0,
                                        bv, &mra->ma_value, &text );
-       
+
                                if( rc != LDAP_SUCCESS ) return rc;
                                if ( ret == 0 ) return LDAP_COMPARE_TRUE;
                        }
@@ -247,6 +258,24 @@ static int test_mra_filter(
                                memfree( value.bv_val, memctx );
                                continue;
                        }
+#ifdef LDAP_COMP_MATCH
+                       /* Component Matching */
+                       if( mra->ma_cf &&
+                               mra->ma_rule->smr_usage & SLAP_MR_COMPONENT)
+                       {
+                               int ret;
+
+                               rc = value_match( &ret, a->a_desc, mra->ma_rule, 0,
+                                       (struct berval*)a, (void*)mra, &text );
+                               if( rc != LDAP_SUCCESS ) break;
+       
+                               if ( ret == 0 ) {
+                                       rc = LDAP_COMPARE_TRUE;
+                                       break;
+                               }
+
+                       }
+#endif
 
                        /* check match */
                        if (mra->ma_rule == a->a_desc->ad_type->sat_equality) {
@@ -260,7 +289,7 @@ static int test_mra_filter(
        
                                rc = value_match( &ret, a->a_desc, mra->ma_rule, 0,
                                        bv, &value, &text );
-       
+
                                if( rc != LDAP_SUCCESS ) break;
        
                                if ( ret == 0 ) {
@@ -333,7 +362,6 @@ static int test_mra_filter(
                                /* check match */
                                rc = value_match( &ret, ad, mra->ma_rule, 0,
                                        bv, &value, &text );
-
                                if ( value.bv_val != mra->ma_value.bv_val ) {
                                        memfree( value.bv_val, memctx );
                                }
@@ -403,7 +431,7 @@ test_ava_filter(
 
        if ( ava->aa_desc == slap_schema.si_ad_entryDN ) {
                MatchingRule *mr;
-               int rc, ret;
+               int rc, match;
                const char *text;
 
                if( type != LDAP_FILTER_EQUALITY &&
@@ -416,11 +444,11 @@ test_ava_filter(
                mr = slap_schema.si_ad_entryDN->ad_type->sat_equality;
                assert( mr );
 
-               rc = value_match( &ret, slap_schema.si_ad_entryDN, mr, 0,
+               rc = value_match( &match, slap_schema.si_ad_entryDN, mr, 0,
                        &e->e_nname, &ava->aa_value, &text );
 
                if( rc != LDAP_SUCCESS ) return rc;
-               if( ret == 0 ) return LDAP_COMPARE_TRUE;
+               if( match == 0 ) return LDAP_COMPARE_TRUE;
                return LDAP_COMPARE_FALSE;
        }
 
@@ -466,30 +494,29 @@ test_ava_filter(
                }
 
                for ( bv = a->a_nvals; bv->bv_val != NULL; bv++ ) {
-                       int ret;
-                       int tmprc;
+                       int ret, match;
                        const char *text;
 
-                       tmprc = value_match( &ret, a->a_desc, mr, 0,
+                       ret = value_match( &match, a->a_desc, mr, 0,
                                bv, &ava->aa_value, &text );
 
-                       if( tmprc != LDAP_SUCCESS ) {
-                               rc = tmprc;
+                       if( ret != LDAP_SUCCESS ) {
+                               rc = ret;
                                break;
                        }
 
                        switch ( type ) {
                        case LDAP_FILTER_EQUALITY:
                        case LDAP_FILTER_APPROX:
-                               if ( ret == 0 ) return LDAP_COMPARE_TRUE;
+                               if ( match == 0 ) return LDAP_COMPARE_TRUE;
                                break;
 
                        case LDAP_FILTER_GE:
-                               if ( ret >= 0 ) return LDAP_COMPARE_TRUE;
+                               if ( match >= 0 ) return LDAP_COMPARE_TRUE;
                                break;
 
                        case LDAP_FILTER_LE:
-                               if ( ret <= 0 ) return LDAP_COMPARE_TRUE;
+                               if ( match <= 0 ) return LDAP_COMPARE_TRUE;
                                break;
                        }
                }
@@ -656,18 +683,17 @@ test_substrings_filter(
                }
 
                for ( bv = a->a_nvals; bv->bv_val != NULL; bv++ ) {
-                       int ret;
-                       int tmprc;
+                       int ret, match;
                        const char *text;
 
-                       tmprc = value_match( &ret, a->a_desc, mr, 0,
+                       ret = value_match( &match, a->a_desc, mr, 0,
                                bv, f->f_sub, &text );
 
-                       if( tmprc != LDAP_SUCCESS ) {
-                               rc = tmprc;
+                       if( ret != LDAP_SUCCESS ) {
+                               rc = ret;
                                break;
                        }
-                       if ( ret == 0 ) return LDAP_COMPARE_TRUE;
+                       if ( match == 0 ) return LDAP_COMPARE_TRUE;
                }
        }