minor cleanup

diff --git a/servers/slapd/schema_init.c b/servers/slapd/schema_init.c
index b578a35be70b9314f21fb0c099ab118039540d47..1d3ea4241506dfc00e8e50423f73ce266fe06b8f 100644 (file)
--- a/servers/slapd/schema_init.c
+++ b/servers/slapd/schema_init.c
@@ -223,6 +223,21 @@ int octetStringFilter(
 
 #ifdef USE_LDAP_DN_PARSING
 
+/*
+ * The DN syntax-related functions take advantage of the dn representation
+ * handling functions ldap_str2dn/ldap_dn2str.  The latter are not schema-
+ * aware, so the attributes and their values need be validated (and possibly
+ * normalized).  In the current implementation the required validation/nor-
+ * malization/"pretty"ing are done on newly created DN structural represen-
+ * tations; however the idea is to move towards DN handling in structural
+ * representation instead of the current string representation.  To this
+ * purpose, we need to do only the required operations and keep track of
+ * what has been done to minimize their impact on performances.
+ *
+ * Developers are strongly encouraged to use this feature, to speed-up
+ * its stabilization.
+ */
+
 #define        AVA_PRIVATE( ava ) ( ( AttributeDescription * )(ava)->la_private )
 
 /*
@@ -241,10 +256,14 @@ LDAPDN_validate( LDAPDN *dn )
                LDAPRDN         *rdn = dn[ iRDN ][ 0 ];
                int             iAVA;
 
+               assert( rdn );
+
                for ( iAVA = 0; rdn[ iAVA ]; iAVA++ ) {
                        LDAPAVA                 *ava = rdn[ iAVA ][ 0 ];
                        AttributeDescription    *ad;
                        slap_syntax_validate_func *validate = NULL;
+
+                       assert( ava );
                        
                        if ( ( ad = AVA_PRIVATE( ava ) ) == NULL ) {
                                const char      *text = NULL;
@@ -282,6 +301,9 @@ LDAPDN_validate( LDAPDN *dn )
        return LDAP_SUCCESS;
 }
 
+/*
+ * dn validate routine
+ */
 static int
 dnValidate(
        Syntax *syntax,
@@ -290,6 +312,8 @@ dnValidate(
        int             rc;
        LDAPDN          *dn = NULL;
 
+       assert( in );
+
        if ( in->bv_len == 0 ) {
                return( LDAP_SUCCESS );
        }
@@ -312,16 +336,32 @@ dnValidate(
        return( LDAP_SUCCESS );
 }
 
+/*
+ * AVA sorting inside a RDN
+ *
+ * rule: sort attributeTypes in alphabetical order; in case of multiple
+ * occurrences of the same attributeType, sort values in byte order
+ * (use memcmp, which implies alphabetical order in case of IA5 value;
+ * this should guarantee the repeatability of the operation).
+ *
+ * uses a linear search; should be fine since the number of AVAs in
+ * a RDN should be limited.
+ */
 static void
 AVA_Sort( LDAPRDN *rdn, int iAVA )
 {
        int             i;
        LDAPAVA         *ava_in = rdn[ iAVA ][ 0 ];
+
+       assert( rdn );
+       assert( ava_in );
        
        for ( i = 0; i < iAVA; i++ ) {
                LDAPAVA         *ava = rdn[ i ][ 0 ];
                int             a, j;
 
+               assert( ava );
+
                a = strcmp( ava_in->la_attr->bv_val, ava->la_attr->bv_val );
 
                if ( a > 0 ) {
@@ -389,6 +429,8 @@ LDAPDN_rewrite( LDAPDN *dn, unsigned flags )
                LDAPRDN         *rdn = dn[ iRDN ][ 0 ];
                int             iAVA;
 
+               assert( rdn );
+
                for ( iAVA = 0; rdn[ iAVA ]; iAVA++ ) {
                        LDAPAVA                 *ava = rdn[ iAVA ][ 0 ];
                        AttributeDescription    *ad;
@@ -396,6 +438,8 @@ LDAPDN_rewrite( LDAPDN *dn, unsigned flags )
                        MatchingRule *mr;
                        struct berval           *bv = NULL;
 
+                       assert( ava );
+
                        if ( ( ad = AVA_PRIVATE( ava ) ) == NULL ) {
                                const char      *text = NULL;
 
@@ -454,6 +498,9 @@ LDAPDN_rewrite( LDAPDN *dn, unsigned flags )
        return LDAP_SUCCESS;
 }
 
+/*
+ * dn normalize routine
+ */
 int
 dnNormalize(
        Syntax *syntax,
@@ -464,6 +511,9 @@ dnNormalize(
 
        Debug( LDAP_DEBUG_TRACE, ">>> dnNormalize: <%s>\n", val->bv_val, 0, 0 );
 
+       assert( val );
+       assert( normalized );
+
        if ( val->bv_len != 0 ) {
                LDAPDN          *dn = NULL;
                char            *dn_out = NULL;
@@ -509,6 +559,9 @@ dnNormalize(
        return LDAP_SUCCESS;
 }
 
+/*
+ * dn "pretty"ing routine
+ */
 int
 dnPretty(
        Syntax *syntax,
@@ -519,6 +572,9 @@ dnPretty(
 
        Debug( LDAP_DEBUG_TRACE, ">>> dnPretty: <%s>\n", val->bv_val, 0, 0 );
 
+       assert( val );
+       assert( pretty );
+
        if ( val->bv_len != 0 ) {
                LDAPDN          *dn = NULL;
                char            *dn_out = NULL;
@@ -539,6 +595,9 @@ dnPretty(
                }
 
                /* FIXME: not sure why the default isn't pretty */
+               /* RE: the default is the form that is used as
+                * an internal representation; the pretty form
+                * is a variant */
                rc = ldap_dn2str( dn, &dn_out,
                        LDAP_DN_FORMAT_LDAPV3 | LDAP_DN_PRETTY );
 
@@ -561,6 +620,12 @@ dnPretty(
        return LDAP_SUCCESS;
 }
 
+/*
+ * dn match routine
+ *
+ * note: uses exact string match (strcmp) because it is supposed to work
+ * on normalized DNs.
+ */
 int
 dnMatch(
        int *matchp,
@@ -572,6 +637,10 @@ dnMatch(
 {
        int match;
        struct berval *asserted = (struct berval *) assertedValue;
+
+       assert( matchp );
+       assert( value );
+       assert( assertedValue );
        
        match = value->bv_len - asserted->bv_len;