Experiment with busy loop protection...

[openldap] / servers / slapd / schema_prep.c

diff --git a/servers/slapd/schema_prep.c b/servers/slapd/schema_prep.c
index d2bcae6679da537db09f68ee39fdc5e63637ce00..4ba2607d8423a12de4bb90e4febb51c35cd07b52 100644 (file)
--- a/servers/slapd/schema_prep.c
+++ b/servers/slapd/schema_prep.c
@@ -15,6 +15,7 @@
 
 #include "slap.h"
 #include "ldap_pvt.h"
+#include "ldap_pvt_uc.h"
 
 int schema_init_done = 0;
 
@@ -26,7 +27,7 @@ struct slap_internal_schema slap_schema;
 static int
 objectClassMatch(
        int *matchp,
-       unsigned use,
+       slap_mask_t flags,
        Syntax *syntax,
        MatchingRule *mr,
        struct berval *value,
@@ -36,19 +37,88 @@ objectClassMatch(
        ObjectClass *oc = oc_find( value->bv_val );
        ObjectClass *asserted = oc_find( a->bv_val );
 
-       if( asserted == NULL || oc == NULL ) {
-               return LDAP_CONSTRAINT_VIOLATION;
+       if( asserted == NULL ) {
+               if( OID_LEADCHAR( *a->bv_val ) ) {
+                       /* OID form, return FALSE */
+                       *matchp = 1;
+                       return LDAP_SUCCESS;
+               }
+
+               /* desc form, return undefined */
+               return SLAPD_COMPARE_UNDEFINED;
+       }
+
+       if ( oc == NULL ) {
+               /* unrecognized stored value */
+               return SLAPD_COMPARE_UNDEFINED;
+       }
+
+       if( flags & SLAP_MR_MODIFY_MATCHING ) {
+               *matchp = ( asserted != oc );
+       } else {
+               *matchp = !is_object_subclass( asserted, oc );
        }
 
 #if 0
-       Debug( LDAP_DEBUG_TRACE, "objectClassMatch(%s,%s)\n",
-               value->bv_val, a->bv_val, NULL );
+#ifdef NEW_LOGGING
+       LDAP_LOG(( "schema", LDAP_LEVEL_ENTRY,
+                  "objectClassMatch(%s, %s) = %d\n",
+                  value->bv_val, a->bv_val, *matchp ));
+#else
+       Debug( LDAP_DEBUG_TRACE, "objectClassMatch(%s,%s) = %d\n",
+               value->bv_val, a->bv_val, *matchp );
+#endif
+
 #endif
 
-       *matchp = !is_object_subclass( asserted, oc );
+       return LDAP_SUCCESS;
+}
+
+#define structuralObjectClassIndexer NULL
+#define structuralObjectClassFilter NULL
+
+static int
+structuralObjectClassMatch(
+       int *matchp,
+       slap_mask_t flags,
+       Syntax *syntax,
+       MatchingRule *mr,
+       struct berval *value,
+       void *assertedValue )
+{
+       struct berval *a = (struct berval *) assertedValue;
+       ObjectClass *oc = oc_find( value->bv_val );
+       ObjectClass *asserted = oc_find( a->bv_val );
+
+       if( asserted == NULL ) {
+               if( OID_LEADCHAR( *a->bv_val ) ) {
+                       /* OID form, return FALSE */
+                       *matchp = 1;
+                       return LDAP_SUCCESS;
+               }
+
+               /* desc form, return undefined */
+               return SLAPD_COMPARE_UNDEFINED;
+       }
+
+       if ( oc == NULL ) {
+               /* unrecognized stored value */
+               return SLAPD_COMPARE_UNDEFINED;
+       }
+
+       *matchp = ( asserted != oc );
 
-       Debug( LDAP_DEBUG_TRACE, "\treturns %d\n",
-               *matchp, NULL, NULL );
+#if 0
+#ifdef NEW_LOGGING
+       LDAP_LOG(( "schema", LDAP_LEVEL_ENTRY,
+                  "structuralObjectClassMatch( %s, %s ) = %d\n",
+                  value->bv_val, a->bv_val, *matchp ));
+#else
+       Debug( LDAP_DEBUG_TRACE, "structuralObjectClassMatch(%s,%s) = %d\n",
+               value->bv_val, a->bv_val, *matchp );
+#endif
+
+#endif
 
        return LDAP_SUCCESS;
 }
@@ -77,6 +147,10 @@ struct slap_schema_ad_map {
        { "objectClass",
                objectClassMatch, objectClassIndexer, objectClassFilter,
                offsetof(struct slap_internal_schema, si_ad_objectClass) },
+       { "structuralObjectClass",
+               structuralObjectClassMatch,
+               structuralObjectClassIndexer, structuralObjectClassFilter,
+               offsetof(struct slap_internal_schema, si_ad_structuralObjectClass) },
 
        /* user entry operational attributes */
        { "creatorsName", NULL, NULL, NULL,
@@ -101,6 +175,8 @@ struct slap_schema_ad_map {
                offsetof(struct slap_internal_schema, si_ad_supportedLDAPVersion) },
        { "supportedSASLMechanisms", NULL, NULL, NULL,
                offsetof(struct slap_internal_schema, si_ad_supportedSASLMechanisms) },
+       { "supportedFeatures", NULL, NULL, NULL,
+               offsetof(struct slap_internal_schema, si_ad_supportedFeatures) },
 
        /* subschema subentry attributes */
        { "attributeTypes", NULL, NULL, NULL,
@@ -140,6 +216,39 @@ struct slap_schema_ad_map {
        { NULL, NULL, NULL, NULL, 0 }
 };
 
+static AttributeType slap_at_undefined = {
+       "UNDEFINED", /* cname */
+       { "1.1.1", NULL, NULL, 1, NULL,
+               NULL, NULL, NULL, NULL,
+               0, 0, 0, 1, 3 },
+       NULL, /* sup */
+       NULL, /* subtypes */
+       NULL, NULL, NULL, NULL, /* matching rules */
+       NULL, /* syntax (this may need to be defined) */
+       NULL  /* next */
+};
+
+struct slap_schema_mr_map {
+       char *ssmm_name;
+       size_t ssmm_offset;
+} mr_map[] = {
+       { "distinguishedNameMatch",
+               offsetof(struct slap_internal_schema, si_mr_distinguishedNameMatch) },
+       { "integerMatch",
+               offsetof(struct slap_internal_schema, si_mr_integerMatch) },
+       { NULL, 0 }
+};
+
+struct slap_schema_syn_map {
+       char *sssm_name;
+       size_t sssm_offset;
+} syn_map[] = {
+       { "1.3.6.1.4.1.1466.115.121.1.12",
+               offsetof(struct slap_internal_schema, si_syn_distinguishedName) },
+       { "1.3.6.1.4.1.1466.115.121.1.27",
+               offsetof(struct slap_internal_schema, si_syn_integer) },
+       { NULL, 0 }
+};
 
 int
 schema_prep( void )
@@ -186,6 +295,42 @@ schema_prep( void )
                }
        }
 
+       slap_at_undefined.sat_syntax = syn_find( SLAPD_OCTETSTRING_SYNTAX );
+       if( slap_at_undefined.sat_syntax == NULL ) {
+               fprintf( stderr,
+                       "No octetString syntax \"" SLAPD_OCTETSTRING_SYNTAX "\"\n" );
+               return LDAP_INVALID_SYNTAX;
+       }
+       slap_schema.si_at_undefined = &slap_at_undefined;
+
+       for( i=0; mr_map[i].ssmm_name; i++ ) {
+               MatchingRule ** mrp = (MatchingRule **)
+                       &(((char *) &slap_schema)[mr_map[i].ssmm_offset]);
+
+               *mrp = mr_find( mr_map[i].ssmm_name );
+
+               if( *mrp == NULL ) {
+                       fprintf( stderr,
+                               "No matching rule \"%s\" defined in schema\n",
+                               mr_map[i].ssmm_name );
+                       return LDAP_INAPPROPRIATE_MATCHING;
+               }
+       }
+
+       for( i=0; syn_map[i].sssm_name; i++ ) {
+               Syntax ** synp = (Syntax **)
+                       &(((char *) &slap_schema)[syn_map[i].sssm_offset]);
+
+               *synp = syn_find( syn_map[i].sssm_name );
+
+               if( *synp == NULL ) {
+                       fprintf( stderr,
+                               "No syntax \"%s\" defined in schema\n",
+                               syn_map[i].sssm_name );
+                       return LDAP_INVALID_SYNTAX;
+               }
+       }
+
        ++schema_init_done;
        return LDAP_SUCCESS;
 }