another step towards schema aware normalization: ava sorting in rdns; now by defining USE_LDAP_DN_PARSING both the new dn parsing and the server side normalization is used. There might be, every now and then, a flaw mostly due to naive normalization of pseudo-dn (thinking about some acl/regex stuff and so)

servers/slapd/config.c

@@ -930,7 +930,23 @@ read_config( const char *fname )
 
 				}
 				charray_add( &be->be_suffix, dn );
+#ifndef USE_LDAP_DN_PARSING
 				(void) ldap_pvt_str2upper( dn );
+#else /* USE_LDAP_DN_PARSING */
+				if ( dn_normalize( dn ) == NULL ) {
+#ifdef NEW_LOGGING
+					LDAP_LOG(( "config", LDAP_LEVEL_CRIT,
+						"%s: line %d: "
+						"unable to normalize suffix "
+						"\"%s\"\n", dn ));
+#else
+					Debug( LDAP_DEBUG_ANY, "%s: line %d: "
+						"unable to normalize suffix "
+						"\"%s\"\n", dn, NULL, NULL );
+#endif
+					return 1;
+				}
+#endif /* USE_LDAP_DN_PARSING */
 				charray_add( &be->be_nsuffix, dn );
 				free( dn );
 			}

servers/slapd/dn.c

@@ -254,8 +254,6 @@ dn_normalize( char *dn )
 	AC_MEMCPY( dn, normalized->bv_val, normalized->bv_len + 1 );
 	ber_bvfree( normalized );
 
-	( void )ldap_pvt_str2upper( dn );
-
 	return( dn );
 	
 #else /* !USE_LDAP_DN_PARSING */

servers/slapd/schema_init.c

@@ -243,28 +243,79 @@ dnValidate(
 	return( LDAP_SUCCESS );
 }
 
-int
+static void
-dnNormalize(
+AVA_Sort( LDAPRDN *rdn, int iAVA )
-	Syntax *syntax,
-	struct berval *val,
-	struct berval **normalized )
 {
-	struct berval *out = NULL;
+	int		i;
+	LDAPAVA		*ava_in = rdn[ iAVA ][ 0 ];
 	
-	if ( val->bv_len != 0 ) {
+	for ( i = 0; i < iAVA; i++ ) {
-		LDAPDN		*dn = NULL;
+		LDAPAVA		*ava = rdn[ i ][ 0 ];
-		char		*dn_out = NULL;
+		int		a, j;
-		int		rc, iRDN;
 
-		rc = ldap_str2dn( val->bv_val, &dn, LDAP_DN_FORMAT_LDAPV3 );
+		a = strcmp( ava_in->la_attr->bv_val, ava->la_attr->bv_val );
-		if ( rc != LDAP_SUCCESS ) {
+
-			return( LDAP_INVALID_SYNTAX );
+		if ( a > 0 ) {
+			break;
 		}
 
-#if 0
+		while ( a == 0 ) {
+			int		v, d;
+
+			d = ava_in->la_value->bv_len - ava->la_value->bv_len;
+
+			v = memcmp( ava_in->la_value->bv_val, 
+					ava->la_value->bv_val,
+					d <= 0 ? ava_in->la_value->bv_len 
+						: ava->la_value->bv_len );
+
+			if ( v == 0 && d != 0 ) {
+				v = d;
+			}
+
+			if ( v <= 0 ) {
 				/* 
-		 * Add schema-aware normalization stuff
+				 * got it!
 				 */
+				break;
+			}
+
+			if ( ++i == iAVA ) {
+				/*
+				 * already sorted
+				 */
+				return;
+			}
+
+			ava = rdn[ i ][ 0 ];
+			a = strcmp( ava_in->la_value->bv_val, 
+					ava->la_value->bv_val );
+		}
+
+		/*
+		 * move ahead
+		 */
+		for ( j = iAVA; j > i; j-- ) {
+			rdn[ j ][ 0 ] = rdn[ j - 1 ][ 0 ];
+		}
+		rdn[ i ][ 0 ] = ava_in;
+
+		return;
+	}
+}
+
+/*
+ * In-place normalization of the structural representation 
+ * of a distinguished name
+ */
+static int
+DN_Normalize( LDAPDN *dn )
+{
+	int 		iRDN;
+	int 		rc;
+
+	assert( dn );
+
 	for ( iRDN = 0; dn[ iRDN ]; iRDN++ ) {
 		LDAPRDN		*rdn = dn[ iRDN ][ 0 ];
 		int		iAVA;
@@ -278,15 +329,14 @@ dnNormalize(
 
 			rc = slap_bv2ad( ava->la_attr, &ad, &text );
 			if ( rc != LDAP_SUCCESS ) {
-					goto error_return;
+				return( LDAP_INVALID_SYNTAX );
 			}
 
 			/* 
 			 * FIXME: is this required? 
 			 */
-				if ( isalpha( ava->la_attr->bv_val[0] ) ) {
+			ber_bvfree( ava->la_attr );
-					(void) ldap_pvt_str2upper( ava->la_attr->bv_val );
+			ava->la_attr = ber_bvdup( &ad->ad_cname );
-				}
 				
 			/*
 			 * FIXME: What is this intended for?
@@ -300,7 +350,7 @@ dnNormalize(
 				 ava->la_value, &bv );
 			
 			if ( rc != LDAP_SUCCESS ) {
-					goto error_return;
+				return( LDAP_INVALID_SYNTAX );
 			}
 
 			/*
@@ -318,10 +368,47 @@ dnNormalize(
 
 			ber_bvfree( ava->la_value );
 			ava->la_value = bv;
-			}
-		}
-#endif
 
+			AVA_Sort( rdn, iAVA );
+		}
+	}
+
+	return( LDAP_SUCCESS );
+}
+
+int
+dnNormalize(
+	Syntax *syntax,
+	struct berval *val,
+	struct berval **normalized )
+{
+	struct berval *out = NULL;
+
+	Debug( LDAP_DEBUG_TRACE, ">>> dnNormalize: %s\n", val->bv_val, 0, 0 );
+
+	if ( val->bv_len != 0 ) {
+		LDAPDN		*dn = NULL;
+		char		*dn_out = NULL;
+		int		rc;
+
+		/*
+		 * Go to structural representation
+		 */
+		rc = ldap_str2dn( val->bv_val, &dn, LDAP_DN_FORMAT_LDAPV3 );
+		if ( rc != LDAP_SUCCESS ) {
+			return( LDAP_INVALID_SYNTAX );
+		}
+
+		/*
+		 * Add schema-aware normalization stuff
+		 */
+		if ( DN_Normalize( dn ) != LDAP_SUCCESS ) {
+			goto error_return;
+		}
+
+		/*
+		 * Back to string representation
+		 */
 		rc = ldap_dn2str( dn, &dn_out, LDAP_DN_FORMAT_LDAPV3 );
 
 		if ( rc != LDAP_SUCCESS ) {
@@ -338,6 +425,8 @@ error_return:;
 		out = ber_bvdup( val );
 	}
 
+	Debug( LDAP_DEBUG_TRACE, "<<< dnNormalize: %s\n", out->bv_val, 0, 0 );
+
 	*normalized = out;
 
 	return( LDAP_SUCCESS );