Install *.schema only

[openldap] / servers / slapd / filterentry.c

diff --git a/servers/slapd/filterentry.c b/servers/slapd/filterentry.c
index 77f191256b328e6c751665dade898498e9a6f261..a751cca054d73efb491db6b87fddab6a82a3cc6c 100644 (file)
--- a/servers/slapd/filterentry.c
+++ b/servers/slapd/filterentry.c
@@ -171,20 +171,15 @@ test_filter(
 #if SLAPD_SCHEMA_NOT_COMPAT
                rc = test_mra_filter( be, conn, op, e, f->f_mra );
 #else
-               rc = -1;
+               rc = LDAP_UNWILLING_TO_PERFORM;
 #endif
                break;
 #endif
 
-       case 0:
-               Debug( LDAP_DEBUG_FILTER, "    UNDEFINED\n", 0, 0, 0 );
-               rc = -1;
-               break;
-
        default:
                Debug( LDAP_DEBUG_ANY, "    unknown filter type %lu\n",
                    f->f_choice, 0, 0 );
-               rc = -1;
+               rc = LDAP_PROTOCOL_ERROR;
        }
 
        Debug( LDAP_DEBUG_FILTER, "<= test_filter %d\n", rc, 0, 0 );
@@ -218,13 +213,13 @@ test_ava_filter(
                ava->ava_type, &ava->ava_value, ACL_SEARCH ) )
 #endif
        {
-               return( -2 );
+               return LDAP_INSUFFICIENT_ACCESS;
        }
 
 #ifdef SLAPD_SCHEMA_NOT_COMPAT
        for(a = attrs_find( e->e_attrs, ava->aa_desc );
                a != NULL;
-               a = attrs_find( a, ava->aa_desc ) )
+               a = attrs_find( a->a_next, ava->aa_desc ) )
 #else
        a = attr_find( e->e_attrs, ava->ava_type );
        if ( a != NULL )
@@ -258,31 +253,39 @@ test_ava_filter(
 #endif
 
                for ( i = 0; a->a_vals[i] != NULL; i++ ) {
+                       int ret;
+#ifdef SLAPD_SCHEMA_NOT_COMPAT
                        int rc;
+                       const char *text;
 
-#ifdef SLAPD_SCHEMA_NOT_COMPAT
-                       rc = 0;
+                       rc = value_match( &ret, a->a_desc, mr,
+                               a->a_vals[i], ava->aa_value,
+                               &text );
+
+                       if( rc != LDAP_SUCCESS ) {
+                               return rc;
+                       }
 #else
-                       rc = value_cmp( a->a_vals[i], &ava->ava_value, a->a_syntax,
+                       ret = value_cmp( a->a_vals[i], &ava->ava_value, a->a_syntax,
                                3 );
 #endif
 
                        switch ( type ) {
                        case LDAP_FILTER_EQUALITY:
                        case LDAP_FILTER_APPROX:
-                               if ( rc == 0 ) {
+                               if ( ret == 0 ) {
                                        return LDAP_COMPARE_TRUE;
                                }
                                break;
 
                        case LDAP_FILTER_GE:
-                               if ( rc >= 0 ) {
+                               if ( ret >= 0 ) {
                                        return LDAP_COMPARE_TRUE;
                                }
                                break;
 
                        case LDAP_FILTER_LE:
-                               if ( rc <= 0 ) {
+                               if ( ret <= 0 ) {
                                        return LDAP_COMPARE_TRUE;
                                }
                                break;
@@ -310,7 +313,7 @@ test_presence_filter(
        if ( be != NULL && ! access_allowed( be, conn, op, e,
                desc, NULL, ACL_SEARCH ) )
        {
-               return( -2 );
+               return LDAP_INSUFFICIENT_ACCESS;
        }
 
 #ifdef SLAPD_SCHEMA_NOT_COMPAT
@@ -338,7 +341,7 @@ test_approx_filter(
        if ( be != NULL && ! access_allowed( be, conn, op, e,
                ava->ava_type, NULL, ACL_SEARCH ) )
        {
-               return( -2 );
+               return LDAP_INSUFFICIENT_ACCESS;
        }
 
        a = attr_find( e->e_attrs, ava->ava_type );
@@ -498,31 +501,63 @@ test_substring_filter(
     Filter     *f
 )
 {
-#ifndef SLAPD_SCHEMA_NOT_COMPAT
        Attribute       *a;
+#ifndef SLAPD_SCHEMA_NOT_COMPAT
        int             i, rc;
        char            *p, *end, *realval, *tmp;
        char            pat[BUFSIZ];
        char            buf[BUFSIZ];
        struct berval   *val;
        regex_t         re;
+#endif
 
        Debug( LDAP_DEBUG_FILTER, "begin test_substring_filter\n", 0, 0, 0 );
 
        if ( be != NULL && ! access_allowed( be, conn, op, e,
-               f->f_sub_type, NULL, ACL_SEARCH ) )
+               f->f_sub_desc, NULL, ACL_SEARCH ) )
        {
-               return( -2 );
+               return LDAP_INSUFFICIENT_ACCESS;
        }
 
-       if ( (a = attr_find( e->e_attrs, f->f_sub_type )) == NULL ) {
-               return LDAP_COMPARE_FALSE;
-       }
+#ifdef SLAPD_SCHEMA_NOT_COMPAT
+       for(a = attrs_find( e->e_attrs, f->f_sub_desc );
+               a != NULL;
+               a = attrs_find( a->a_next, f->f_sub_desc ) )
+#else
+       a = attr_find( e->e_attrs, f->f_sub_type );
+       if ( a != NULL )
+#endif
+       {
+#ifdef SLAPD_SCHEMA_NOT_COMPAT
+               int i;
+               MatchingRule *mr = a->a_desc->ad_type->sat_substr;
 
+               if( mr == NULL ) {
+                       continue;
+               }
+
+               for ( i = 0; a->a_vals[i] != NULL; i++ ) {
+                       int ret;
+                       int rc;
+                       const char *text;
+
+                       rc = value_match( &ret, a->a_desc, mr,
+                               a->a_vals[i], f->f_sub,
+                               &text );
+
+                       if( rc != LDAP_SUCCESS ) {
+                               return rc;
+                       }
+
+                       if ( ret == 0 ) {
+                               return LDAP_COMPARE_TRUE;
+                       }
+               }
+#else
        if ( a->a_syntax & SYNTAX_BIN ) {
                Debug( LDAP_DEBUG_FILTER, "test_substring_filter bin attr\n",
                    0, 0, 0 );
-               return( -1 );
+               return LDAP_INAPPROPRIATE_MATCHING;
        }
 
        /*
@@ -540,7 +575,7 @@ test_substring_filter(
                if ( p + 2 * f->f_sub_initial->bv_len > end ) {
                        Debug( LDAP_DEBUG_ANY, "not enough pattern space\n",
                            0, 0, 0 );
-                       return( -1 );
+                       return LDAP_OTHER;
                }
                strcpy_regex( p, f->f_sub_initial->bv_val );
                p = strchr( p, '\0' );
@@ -551,7 +586,7 @@ test_substring_filter(
                        if ( p + 2 * f->f_sub_any[i]->bv_len + 2 > end ) {
                                Debug( LDAP_DEBUG_ANY,
                                    "not enough pattern space\n", 0, 0, 0 );
-                               return( -1 );
+                               return LDAP_OTHER;
                        }
                        strcpy( p, ".*" );
                        p = strchr( p, '\0' );
@@ -582,7 +617,7 @@ test_substring_filter(
                regerror(rc, &re, error, sizeof(error));
                Debug( LDAP_DEBUG_ANY, "regcomp failed (%s) %s\n",
                        p, error, 0 );
-               return( -1 );
+               return LDAP_OTHER;
        }
 
        /* for each value in the attribute see if regex matches */
@@ -613,6 +648,7 @@ test_substring_filter(
 
        regfree(&re);
 #endif
+       }
 
        Debug( LDAP_DEBUG_FILTER, "end test_substring_filter 1\n", 0, 0, 0 );
        return LDAP_COMPARE_FALSE;