Ditch LRU cache replacement in favor of 2nd-chance/clock.

[openldap] / servers / slapd / filterentry.c

diff --git a/servers/slapd/filterentry.c b/servers/slapd/filterentry.c
index a9d8bd17a005f3621f89bf208290c6c1dab22d2c..7f38d4d68c30efe7e7d4585e94fc33250ece1c1c 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-2005 The OpenLDAP Foundation.
+ * Copyright 1998-2006 The OpenLDAP Foundation.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -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 );
 }
@@ -158,7 +164,7 @@ static int test_mra_filter(
        void            *memctx;
        BER_MEMFREE_FN  *memfree;
 #ifdef LDAP_COMP_MATCH
-       int i, num_attr_vals;
+       int i, num_attr_vals = 0;
 #endif
 
        if ( op == NULL ) {
@@ -186,7 +192,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 +270,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 
@@ -275,14 +282,14 @@ static int test_mra_filter(
                                        if ( normalize_attribute && mra->ma_rule->smr_normalize ) {
                                                /*
                                
-                               Document: draft-ietf-ldapbis-protocol
+                               Document: RFC 4511
 
                                    4.5.1. Search Request 
                                        ...
                                    If the type field is present and the matchingRule is present, 
                                    the matchValue is compared against entry attributes of the 
                                    specified type. In this case, the matchingRule MUST be one 
-                                   suitable for use with the specified type (see [Syntaxes]), 
+                                   suitable for use with the specified type (see [RFC4517]), 
                                    otherwise the filter item is Undefined.  
 
 
@@ -308,8 +315,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 +363,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 +405,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 );
@@ -442,7 +450,7 @@ static int test_mra_filter(
                                int             ret;
                                const char      *text;
 
-                               assert( ad );
+                               assert( ad != NULL );
 
                                if ( mra->ma_desc ) {
                                        /* have a mra type? check for subtype */
@@ -494,7 +502,7 @@ static int test_mra_filter(
                                }
 
                                /* check match */
-                               rc = value_match( &ret, ad, mra->ma_rule, 0,
+                               rc = value_match( &ret, ad, mra->ma_rule, SLAP_MR_EXT,
                                        &nbv, &value, &text );
 
 cleanup:;
@@ -586,10 +594,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;
@@ -613,6 +621,7 @@ test_ava_filter(
                a != NULL;
                a = attrs_find( a->a_next, ava->aa_desc ) )
        {
+               int use;
                MatchingRule *mr;
                struct berval *bv;
 
@@ -623,19 +632,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;
 
@@ -700,8 +714,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 );
@@ -709,12 +725,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 );
                        }
 
@@ -909,7 +924,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 ) {