Install *.schema only

[openldap] / servers / slapd / value.c

diff --git a/servers/slapd/value.c b/servers/slapd/value.c
index cc42578a64db6516812e03abdf457c10c9166762..4b4ecc3bd8134ead40686440fb427242577b8fbe 100644 (file)
--- a/servers/slapd/value.c
+++ b/servers/slapd/value.c
@@ -48,11 +48,11 @@ value_add(
        }
        (*vals)[n + j] = NULL;
 
-       return( 0 );
+       return LDAP_SUCCESS;
 }
 
 #ifdef SLAPD_SCHEMA_NOT_COMPAT
-       /* not yet implemented */
+       /* not used */
 #else
 int
 value_add_fast( 
@@ -92,10 +92,66 @@ int
 value_normalize(
        AttributeDescription *ad,
        unsigned usage,
-       struct berval *val,
-       char **text )
+       struct berval *in,
+       struct berval **out,
+       const char **text )
 {
-       /* not yet implemented */
+       int rc;
+       MatchingRule *mr;
+
+       switch( usage & SLAP_MR_TYPE_MASK ) {
+       case SLAP_MR_NONE:
+       case SLAP_MR_EQUALITY:
+               mr = ad->ad_type->sat_equality;
+               break;
+       case SLAP_MR_ORDERING:
+               mr = ad->ad_type->sat_ordering;
+               break;
+       case SLAP_MR_SUBSTR:
+               mr = ad->ad_type->sat_substr;
+               break;
+       case SLAP_MR_EXT:
+       default:
+               assert( 0 );
+               *text = "internal error";
+               return LDAP_OTHER;
+       }
+
+       if( mr == NULL ) {
+               *text = "inappropriate matching request";
+               return LDAP_INAPPROPRIATE_MATCHING;
+       }
+
+       /* we only support equality matching of binary attributes */
+       if( slap_ad_is_binary( ad ) && usage != SLAP_MR_EQUALITY ) {
+               *text = "inappropriate binary matching";
+               return LDAP_INAPPROPRIATE_MATCHING;
+       }
+
+       if( mr->smr_normalize ) {
+               rc = (mr->smr_normalize)( usage,
+                       ad->ad_type->sat_syntax,
+                       mr, in, out );
+
+               if( rc != LDAP_SUCCESS ) {
+                       *text = "unable to normalize value";
+                       return LDAP_INVALID_SYNTAX;
+               }
+
+       } else if ( mr->smr_syntax->ssyn_normalize ) {
+               rc = (mr->smr_syntax->ssyn_normalize)(
+                       ad->ad_type->sat_syntax,
+                       in, out );
+
+               if( rc != LDAP_SUCCESS ) {
+                       *text = "unable to normalize value";
+                       return LDAP_INVALID_SYNTAX;
+               }
+
+       } else {
+               *out = ber_bvdup( in );
+       }
+
        return LDAP_SUCCESS;
 }
 
@@ -129,7 +185,42 @@ value_normalize(
 #endif
 
 #ifdef SLAPD_SCHEMA_NOT_COMPAT
-       /* not yet implemented */
+int
+value_match(
+       int *match,
+       AttributeDescription *ad,
+       MatchingRule *mr,
+       struct berval *v1, /* stored value */
+       void *v2, /* assertion */
+       const char ** text )
+{
+       int rc;
+       int usage = 0;
+       struct berval *nv1 = NULL;
+
+       if( !mr->smr_match ) {
+               return LDAP_INAPPROPRIATE_MATCHING;
+       }
+
+       if( ad->ad_type->sat_syntax->ssyn_normalize ) {
+               rc = ad->ad_type->sat_syntax->ssyn_normalize(
+                       ad->ad_type->sat_syntax, v1, &nv1 );
+
+               if( rc != LDAP_SUCCESS ) {
+                       return LDAP_INAPPROPRIATE_MATCHING;
+               }
+       }
+
+       rc = (mr->smr_match)( match, usage,
+               ad->ad_type->sat_syntax,
+               mr,
+               nv1 != NULL ? nv1 : v1,
+               v2 );
+       
+       ber_bvfree( nv1 );
+       return rc;
+}
+
 #else
 int
 value_cmp(
@@ -178,23 +269,58 @@ value_cmp(
 
        return( rc );
 }
+#endif
 
+#ifdef SLAPD_SCHEMA_NOT_COMPAT
+int value_find(
+       AttributeDescription *ad,
+       struct berval **vals,
+       struct berval *val )
+#else
 int
 value_find(
     struct berval      **vals,
     struct berval      *v,
     int                        syntax,
-    int                        normalize
-)
+    int                        normalize )
+#endif
 {
        int     i;
+#ifdef SLAPD_SCHEMA_NOT_COMPAT
+       int rc;
+       struct berval *nval = NULL;
+       MatchingRule *mr = ad->ad_type->sat_equality;
+
+       if( mr == NULL || !mr->smr_match ) {
+               return LDAP_INAPPROPRIATE_MATCHING;
+       }
+
+       if( mr->smr_syntax->ssyn_normalize ) {
+               rc = mr->smr_syntax->ssyn_normalize(
+                       mr->smr_syntax, val, &nval );
+
+               if( rc != LDAP_SUCCESS ) {
+                       return LDAP_INAPPROPRIATE_MATCHING;
+               }
+       }
+#endif
 
        for ( i = 0; vals[i] != NULL; i++ ) {
-               if ( value_cmp( vals[i], v, syntax, normalize ) == 0 ) {
-                       return( 0 );
+#ifdef SLAPD_SCHEMA_NOT_COMPAT
+               int match;
+               const char *text;
+
+               rc = value_match( &match, ad, mr, vals[i],
+                       nval == NULL ? val : nval, &text );
+
+               if( rc == LDAP_SUCCESS && match == 0 )
+#else
+               if ( value_cmp( vals[i], v, syntax, normalize ) == 0 )
+#endif
+               {
+                       return LDAP_SUCCESS;
                }
        }
 
-       return( 1 );
+       return LDAP_NO_SUCH_ATTRIBUTE;
 }
-#endif