X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fdn.c;h=7effba1534808bad1945ca07ea6d61a21de3f780;hb=0af1940f3fb59fe57b2281ef253fe1341c505c2c;hp=5ac362d1edecc6c2c9dccfd2b1bf058dc25df570;hpb=ad19032bf2a7e4e3f698dde758c66a3f828d31a3;p=openldap

diff --git a/servers/slapd/dn.c b/servers/slapd/dn.c
index 5ac362d1ed..7effba1534 100644
--- a/servers/slapd/dn.c
+++ b/servers/slapd/dn.c
@@ -2,7 +2,7 @@
 /* $OpenLDAP$ */
 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
  *
- * Copyright 1998-2004 The OpenLDAP Foundation.
+ * Copyright 1998-2006 The OpenLDAP Foundation.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -34,7 +34,6 @@
 #include <ac/time.h>
 
 #include "slap.h"
-#include "ldap_pvt.h" /* must be after slap.h, to get ldap_bv2dn_x() & co */
 #include "lutil.h"
 
 /*
@@ -60,21 +59,26 @@ LDAPRDN_validate( LDAPRDN rdn )
 	int		iAVA;
 	int 		rc;
 
-	assert( rdn );
+	assert( rdn != NULL );
 
 	for ( iAVA = 0; rdn[ iAVA ]; iAVA++ ) {
 		LDAPAVA			*ava = rdn[ iAVA ];
 		AttributeDescription	*ad;
 		slap_syntax_validate_func *validate = NULL;
 
-		assert( ava );
+		assert( ava != NULL );
 		
 		if ( ( ad = AVA_PRIVATE( ava ) ) == NULL ) {
 			const char	*text = NULL;
 
 			rc = slap_bv2ad( &ava->la_attr, &ad, &text );
 			if ( rc != LDAP_SUCCESS ) {
-				return LDAP_INVALID_SYNTAX;
+				rc = slap_bv2undef_ad( &ava->la_attr,
+					&ad, &text,
+					SLAP_AD_PROXIED|SLAP_AD_NOINSERT );
+				if ( rc != LDAP_SUCCESS ) {
+					return LDAP_INVALID_SYNTAX;
+				}
 			}
 
 			ava->la_private = ( void * )ad;
@@ -99,6 +103,8 @@ LDAPRDN_validate( LDAPRDN rdn )
 			}
 		}
 	}
+
+	return LDAP_SUCCESS;
 }
 
 /*
@@ -111,27 +117,32 @@ LDAPDN_validate( LDAPDN dn )
 	int 		iRDN;
 	int 		rc;
 
-	assert( dn );
+	assert( dn != NULL );
 
 	for ( iRDN = 0; dn[ iRDN ]; iRDN++ ) {
 		LDAPRDN		rdn = dn[ iRDN ];
 		int		iAVA;
 
-		assert( rdn );
+		assert( rdn != NULL );
 
 		for ( iAVA = 0; rdn[ iAVA ]; iAVA++ ) {
 			LDAPAVA			*ava = rdn[ iAVA ];
 			AttributeDescription	*ad;
 			slap_syntax_validate_func *validate = NULL;
 
-			assert( ava );
+			assert( ava != NULL );
 			
 			if ( ( ad = AVA_PRIVATE( ava ) ) == NULL ) {
 				const char	*text = NULL;
 
 				rc = slap_bv2ad( &ava->la_attr, &ad, &text );
 				if ( rc != LDAP_SUCCESS ) {
-					return LDAP_INVALID_SYNTAX;
+					rc = slap_bv2undef_ad( &ava->la_attr,
+						&ad, &text,
+						SLAP_AD_PROXIED|SLAP_AD_NOINSERT );
+					if ( rc != LDAP_SUCCESS ) {
+						return LDAP_INVALID_SYNTAX;
+					}
 				}
 
 				ava->la_private = ( void * )ad;
@@ -172,7 +183,7 @@ dnValidate(
 	int		rc;
 	LDAPDN		dn = NULL;
 
-	assert( in );
+	assert( in != NULL );
 
 	if ( in->bv_len == 0 ) {
 		return LDAP_SUCCESS;
@@ -207,11 +218,10 @@ rdnValidate(
 	struct berval *in )
 {
 	int		rc;
-	LDAPDN		dn = NULL;
 	LDAPRDN		rdn;
 	char*		p;
 
-	assert( in );
+	assert( in != NULL );
 	if ( in->bv_len == 0 ) {
 		return LDAP_SUCCESS;
 
@@ -261,14 +271,14 @@ AVA_Sort( LDAPRDN rdn, int iAVA )
 	int		i;
 	LDAPAVA		*ava_in = rdn[ iAVA ];
 
-	assert( rdn );
-	assert( ava_in );
+	assert( rdn != NULL );
+	assert( ava_in != NULL );
 	
 	for ( i = 0; i < iAVA; i++ ) {
 		LDAPAVA		*ava = rdn[ i ];
 		int		a, j;
 
-		assert( ava );
+		assert( ava != NULL );
 
 		a = strcmp( ava_in->la_attr.bv_val, ava->la_attr.bv_val );
 
@@ -337,14 +347,19 @@ LDAPRDN_rewrite( LDAPRDN rdn, unsigned flags, void *ctx )
 		struct berval		bv = BER_BVNULL;
 		int			do_sort = 0;
 
-		assert( ava );
+		assert( ava != NULL );
 
 		if ( ( ad = AVA_PRIVATE( ava ) ) == NULL ) {
 			const char	*text = NULL;
 
 			rc = slap_bv2ad( &ava->la_attr, &ad, &text );
 			if ( rc != LDAP_SUCCESS ) {
-				return LDAP_INVALID_SYNTAX;
+				rc = slap_bv2undef_ad( &ava->la_attr,
+					&ad, &text,
+					SLAP_AD_PROXIED|SLAP_AD_NOINSERT );
+				if ( rc != LDAP_SUCCESS ) {
+					return LDAP_INVALID_SYNTAX;
+				}
 			}
 			
 			ava->la_private = ( void * )ad;
@@ -371,7 +386,9 @@ LDAPRDN_rewrite( LDAPRDN rdn, unsigned flags, void *ctx )
 		} else { /* normalization */
 			validf = ad->ad_type->sat_syntax->ssyn_validate;
 			mr = ad->ad_type->sat_equality;
-			if( mr ) normf = mr->smr_normalize;
+			if( mr && (!( mr->smr_usage & SLAP_MR_MUTATION_NORMALIZER ))) {
+				normf = mr->smr_normalize;
+			}
 		}
 
 		if ( validf ) {
@@ -444,13 +461,13 @@ LDAPDN_rewrite( LDAPDN dn, unsigned flags, void *ctx )
 	int 		iRDN;
 	int 		rc;
 
-	assert( dn );
+	assert( dn != NULL );
 
 	for ( iRDN = 0; dn[ iRDN ]; iRDN++ ) {
 		LDAPRDN		rdn = dn[ iRDN ];
 		int		iAVA;
 
-		assert( rdn );
+		assert( rdn != NULL );
 
 		for ( iAVA = 0; rdn[ iAVA ]; iAVA++ ) {
 			LDAPAVA			*ava = rdn[ iAVA ];
@@ -462,14 +479,19 @@ LDAPDN_rewrite( LDAPDN dn, unsigned flags, void *ctx )
 			struct berval		bv = BER_BVNULL;
 			int			do_sort = 0;
 
-			assert( ava );
+			assert( ava != NULL );
 
 			if ( ( ad = AVA_PRIVATE( ava ) ) == NULL ) {
 				const char	*text = NULL;
 
 				rc = slap_bv2ad( &ava->la_attr, &ad, &text );
 				if ( rc != LDAP_SUCCESS ) {
-					return LDAP_INVALID_SYNTAX;
+					rc = slap_bv2undef_ad( &ava->la_attr,
+						&ad, &text,
+						SLAP_AD_PROXIED|SLAP_AD_NOINSERT );
+					if ( rc != LDAP_SUCCESS ) {
+						return LDAP_INVALID_SYNTAX;
+					}
 				}
 				
 				ava->la_private = ( void * )ad;
@@ -496,7 +518,9 @@ LDAPDN_rewrite( LDAPDN dn, unsigned flags, void *ctx )
 			} else { /* normalization */
 				validf = ad->ad_type->sat_syntax->ssyn_validate;
 				mr = ad->ad_type->sat_equality;
-				if( mr ) normf = mr->smr_normalize;
+				if( mr && (!( mr->smr_usage & SLAP_MR_MUTATION_NORMALIZER ))) {
+					normf = mr->smr_normalize;
+				}
 			}
 
 			if ( validf ) {
@@ -570,8 +594,8 @@ dnNormalize(
     struct berval *out,
     void *ctx)
 {
-	assert( val );
-	assert( out );
+	assert( val != NULL );
+	assert( out != NULL );
 
 	Debug( LDAP_DEBUG_TRACE, ">>> dnNormalize: <%s>\n", val->bv_val, 0, 0 );
 
@@ -626,8 +650,8 @@ rdnNormalize(
     struct berval *out,
     void *ctx)
 {
-	assert( val );
-	assert( out );
+	assert( val != NULL );
+	assert( out != NULL );
 
 	Debug( LDAP_DEBUG_TRACE, ">>> dnNormalize: <%s>\n", val->bv_val, 0, 0 );
 	if ( val->bv_len != 0 ) {
@@ -682,14 +706,10 @@ dnPretty(
 	struct berval *out,
 	void *ctx)
 {
-	assert( val );
-	assert( out );
+	assert( val != NULL );
+	assert( out != NULL );
 
-#ifdef NEW_LOGGING
-	LDAP_LOG( OPERATION, ARGS, ">>> dnPretty: <%s>\n", val->bv_val, 0, 0 );
-#else
 	Debug( LDAP_DEBUG_TRACE, ">>> dnPretty: <%s>\n", val->bv_val, 0, 0 );
-#endif
 
 	if ( val->bv_len == 0 ) {
 		ber_dupbv_x( out, val, ctx );
@@ -731,11 +751,7 @@ dnPretty(
 		}
 	}
 
-#ifdef NEW_LOGGING
-	LDAP_LOG( OPERATION, ARGS, "<<< dnPretty: <%s>\n", out->bv_val, 0, 0 );
-#else
 	Debug( LDAP_DEBUG_TRACE, "<<< dnPretty: <%s>\n", out->bv_val, 0, 0 );
-#endif
 
 	return LDAP_SUCCESS;
 }
@@ -747,14 +763,10 @@ rdnPretty(
 	struct berval *out,
 	void *ctx)
 {
-	assert( val );
-	assert( out );
+	assert( val != NULL );
+	assert( out != NULL );
 
-#ifdef NEW_LOGGING
-	LDAP_LOG( OPERATION, ARGS, ">>> dnPretty: <%s>\n", val->bv_val, 0, 0 );
-#else
 	Debug( LDAP_DEBUG_TRACE, ">>> dnPretty: <%s>\n", val->bv_val, 0, 0 );
-#endif
 
 	if ( val->bv_len == 0 ) {
 		ber_dupbv_x( out, val, ctx );
@@ -798,11 +810,7 @@ rdnPretty(
 		}
 	}
 
-#ifdef NEW_LOGGING
-	LDAP_LOG( OPERATION, ARGS, "<<< dnPretty: <%s>\n", out->bv_val, 0, 0 );
-#else
 	Debug( LDAP_DEBUG_TRACE, "<<< dnPretty: <%s>\n", out->bv_val, 0, 0 );
-#endif
 
 	return LDAP_SUCCESS;
 }
@@ -816,18 +824,12 @@ dnPrettyNormalDN(
 	int flags,
 	void *ctx )
 {
-	assert( val );
-	assert( dn );
+	assert( val != NULL );
+	assert( dn != NULL );
 
-#ifdef NEW_LOGGING
-	LDAP_LOG( OPERATION, ARGS, ">>> dn%sDN: <%s>\n", 
-			flags == SLAP_LDAPDN_PRETTY ? "Pretty" : "Normal", 
-			val->bv_val, 0 );
-#else
 	Debug( LDAP_DEBUG_TRACE, ">>> dn%sDN: <%s>\n", 
 			flags == SLAP_LDAPDN_PRETTY ? "Pretty" : "Normal", 
 			val->bv_val, 0 );
-#endif
 
 	if ( val->bv_len == 0 ) {
 		return LDAP_SUCCESS;
@@ -874,15 +876,11 @@ dnPrettyNormal(
 	struct berval *normal,
 	void *ctx)
 {
-#ifdef NEW_LOGGING
-	LDAP_LOG ( OPERATION, ENTRY, ">>> dnPrettyNormal: <%s>\n", val->bv_val, 0, 0 );
-#else
 	Debug( LDAP_DEBUG_TRACE, ">>> dnPrettyNormal: <%s>\n", val->bv_val, 0, 0 );
-#endif
 
-	assert( val );
-	assert( pretty );
-	assert( normal );
+	assert( val != NULL );
+	assert( pretty != NULL );
+	assert( normal != NULL );
 
 	if ( val->bv_len == 0 ) {
 		ber_dupbv_x( pretty, val, ctx );
@@ -945,13 +943,8 @@ dnPrettyNormal(
 		}
 	}
 
-#ifdef NEW_LOGGING
-	LDAP_LOG (OPERATION, RESULTS, "<<< dnPrettyNormal: <%s>, <%s>\n",
-		pretty->bv_val, normal->bv_val, 0  );
-#else
 	Debug( LDAP_DEBUG_TRACE, "<<< dnPrettyNormal: <%s>, <%s>\n",
 		pretty->bv_val, normal->bv_val, 0 );
-#endif
 
 	return LDAP_SUCCESS;
 }
@@ -971,9 +964,11 @@ dnMatch(
 	int match;
 	struct berval *asserted = (struct berval *) assertedValue;
 
-	assert( matchp );
-	assert( value );
-	assert( assertedValue );
+	assert( matchp != NULL );
+	assert( value != NULL );
+	assert( assertedValue != NULL );
+	assert( !BER_BVISNULL( value ) );
+	assert( !BER_BVISNULL( asserted ) );
 	
 	match = value->bv_len - asserted->bv_len;
 
@@ -982,16 +977,113 @@ dnMatch(
 				value->bv_len );
 	}
 
-#ifdef NEW_LOGGING
-	LDAP_LOG( CONFIG, ENTRY, "dnMatch: %d\n    %s\n    %s\n", 
-		match, value->bv_val, asserted->bv_val  );
-#else
 	Debug( LDAP_DEBUG_ARGS, "dnMatch %d\n\t\"%s\"\n\t\"%s\"\n",
 		match, value->bv_val, asserted->bv_val );
-#endif
 
 	*matchp = match;
-	return( LDAP_SUCCESS );
+	return LDAP_SUCCESS;
+}
+
+/*
+ * dnRelativeMatch routine
+ */
+int
+dnRelativeMatch(
+	int *matchp,
+	slap_mask_t flags,
+	Syntax *syntax,
+	MatchingRule *mr,
+	struct berval *value,
+	void *assertedValue )
+{
+	int match;
+	struct berval *asserted = (struct berval *) assertedValue;
+
+	assert( matchp != NULL );
+	assert( value != NULL );
+	assert( assertedValue != NULL );
+	assert( !BER_BVISNULL( value ) );
+	assert( !BER_BVISNULL( asserted ) );
+
+	if( mr == slap_schema.si_mr_dnSubtreeMatch ) {
+		if( asserted->bv_len > value->bv_len ) {
+			match = -1;
+		} else if ( asserted->bv_len == value->bv_len ) {
+			match = memcmp( value->bv_val, asserted->bv_val, 
+				value->bv_len );
+		} else {
+			if( DN_SEPARATOR(
+				value->bv_val[value->bv_len - asserted->bv_len - 1] ))
+			{
+				match = memcmp(
+					&value->bv_val[value->bv_len - asserted->bv_len],
+					asserted->bv_val, 
+					asserted->bv_len );
+			} else {
+				match = 1;
+			}
+		}
+
+		*matchp = match;
+		return LDAP_SUCCESS;
+	}
+
+	if( mr == slap_schema.si_mr_dnSuperiorMatch ) {
+		asserted = value;
+		value = (struct berval *) assertedValue;
+		mr = slap_schema.si_mr_dnSubordinateMatch;
+	}
+
+	if( mr == slap_schema.si_mr_dnSubordinateMatch ) {
+		if( asserted->bv_len >= value->bv_len ) {
+			match = -1;
+		} else {
+			if( DN_SEPARATOR(
+				value->bv_val[value->bv_len - asserted->bv_len - 1] ))
+			{
+				match = memcmp(
+					&value->bv_val[value->bv_len - asserted->bv_len],
+					asserted->bv_val, 
+					asserted->bv_len );
+			} else {
+				match = 1;
+			}
+		}
+
+		*matchp = match;
+		return LDAP_SUCCESS;
+	}
+
+	if( mr == slap_schema.si_mr_dnOneLevelMatch ) {
+		if( asserted->bv_len >= value->bv_len ) {
+			match = -1;
+		} else {
+			if( DN_SEPARATOR(
+				value->bv_val[value->bv_len - asserted->bv_len - 1] ))
+			{
+				match = memcmp(
+					&value->bv_val[value->bv_len - asserted->bv_len],
+					asserted->bv_val, 
+					asserted->bv_len );
+
+				if( !match ) {
+					struct berval rdn;
+					rdn.bv_val = value->bv_val;
+					rdn.bv_len = value->bv_len - asserted->bv_len - 1;
+					match = dnIsOneLevelRDN( &rdn ) ? 0 : 1;
+				}
+			} else {
+				match = 1;
+			}
+		}
+
+		*matchp = match;
+		return LDAP_SUCCESS;
+	}
+
+	/* should not be reachable */
+	assert( 0 );
+	return LDAP_OTHER;
 }
 
 int
@@ -1006,9 +1098,9 @@ rdnMatch(
 	int match;
 	struct berval *asserted = (struct berval *) assertedValue;
 
-	assert( matchp );
-	assert( value );
-	assert( assertedValue );
+	assert( matchp != NULL );
+	assert( value != NULL );
+	assert( assertedValue != NULL );
 	
 	match = value->bv_len - asserted->bv_len;
 
@@ -1017,16 +1109,11 @@ rdnMatch(
 				value->bv_len );
 	}
 
-#ifdef NEW_LOGGING
-	LDAP_LOG( CONFIG, ENTRY, "dnMatch: %d\n    %s\n    %s\n", 
-		match, value->bv_val, asserted->bv_val  );
-#else
-	Debug( LDAP_DEBUG_ARGS, "dnMatch %d\n\t\"%s\"\n\t\"%s\"\n",
+	Debug( LDAP_DEBUG_ARGS, "rdnMatch %d\n\t\"%s\"\n\t\"%s\"\n",
 		match, value->bv_val, asserted->bv_val );
-#endif
 
 	*matchp = match;
-	return( LDAP_SUCCESS );
+	return LDAP_SUCCESS;
 }
 
 
@@ -1034,6 +1121,10 @@ rdnMatch(
  * dnParent - dn's parent, in-place
  * note: the incoming dn is assumed to be normalized/prettyfied,
  * so that escaped rdn/ava separators are in '\'+hexpair form
+ *
+ * note: "dn" and "pdn" can point to the same berval;
+ * beware that, in this case, the pointer to the original buffer
+ * will get lost.
  */
 void
 dnParent( 
@@ -1042,7 +1133,7 @@ dnParent(
 {
 	char	*p;
 
-	p = strchr( dn->bv_val, ',' );
+	p = ber_bvchr( dn, ',' );
 
 	/* one-level dn */
 	if ( p == NULL ) {
@@ -1055,8 +1146,35 @@ dnParent(
 	p++;
 
 	assert( ATTR_LEADCHAR( p[ 0 ] ) );
-	pdn->bv_val = p;
 	pdn->bv_len = dn->bv_len - (p - dn->bv_val);
+	pdn->bv_val = p;
+
+	return;
+}
+
+/*
+ * dnRdn - dn's rdn, in-place
+ * note: the incoming dn is assumed to be normalized/prettyfied,
+ * so that escaped rdn/ava separators are in '\'+hexpair form
+ */
+void
+dnRdn( 
+	struct berval	*dn, 
+	struct berval	*rdn )
+{
+	char	*p;
+
+	*rdn = *dn;
+	p = ber_bvchr( dn, ',' );
+
+	/* one-level dn */
+	if ( p == NULL ) {
+		return;
+	}
+
+	assert( DN_SEPARATOR( p[ 0 ] ) );
+	assert( ATTR_LEADCHAR( p[ 1 ] ) );
+	rdn->bv_len = p - dn->bv_val;
 
 	return;
 }
@@ -1071,8 +1189,8 @@ dnExtractRdn(
 	const char	*p;
 	int		rc;
 
-	assert( dn );
-	assert( rdn );
+	assert( dn != NULL );
+	assert( rdn != NULL );
 
 	if( dn->bv_len == 0 ) {
 		return LDAP_OTHER;
@@ -1083,27 +1201,24 @@ dnExtractRdn(
 		return rc;
 	}
 
-	rc = ldap_rdn2bv_x( tmpRDN, rdn, LDAP_DN_FORMAT_LDAPV3 | LDAP_DN_PRETTY, ctx );
+	rc = ldap_rdn2bv_x( tmpRDN, rdn, LDAP_DN_FORMAT_LDAPV3 | LDAP_DN_PRETTY,
+		ctx );
 
 	ldap_rdnfree_x( tmpRDN, ctx );
-	if ( rc != LDAP_SUCCESS ) {
-		return rc;
-	}
-
-	return LDAP_SUCCESS;
+	return rc;
 }
 
 /*
  * We can assume the input is a prettied or normalized DN
  */
-int 
+ber_len_t
 dn_rdnlen(
 	Backend		*be,
 	struct berval	*dn_in )
 {
 	const char	*p;
 
-	assert( dn_in );
+	assert( dn_in != NULL );
 
 	if ( dn_in == NULL ) {
 		return 0;
@@ -1117,7 +1232,7 @@ dn_rdnlen(
 		return 0;
 	}
 
-	p = strchr( dn_in->bv_val, ',' );
+	p = ber_bvchr( dn_in, ',' );
 
 	return p ? p - dn_in->bv_val : dn_in->bv_len;
 }
@@ -1141,7 +1256,7 @@ rdn_validate( struct berval *rdn )
 	{
 		return LDAP_INVALID_SYNTAX;
 	}
-	return strchr( rdn->bv_val, ',' ) == NULL
+	return ber_bvchr( rdn, ',' ) == NULL
 		? LDAP_SUCCESS : LDAP_INVALID_SYNTAX;
 
 #else
@@ -1204,14 +1319,14 @@ build_new_dn( struct berval * new_dn,
 	char *ptr;
 
 	if ( parent_dn == NULL || parent_dn->bv_len == 0 ) {
-		ber_dupbv( new_dn, newrdn );
+		ber_dupbv_x( new_dn, newrdn, memctx );
 		return;
 	}
 
 	new_dn->bv_len = parent_dn->bv_len + newrdn->bv_len + 1;
 	new_dn->bv_val = (char *) slap_sl_malloc( new_dn->bv_len + 1, memctx );
 
-	ptr = lutil_strcopy( new_dn->bv_val, newrdn->bv_val );
+	ptr = lutil_strncopy( new_dn->bv_val, newrdn->bv_val, newrdn->bv_len );
 	*ptr++ = ',';
 	strcpy( ptr, parent_dn->bv_val );
 }
@@ -1228,8 +1343,8 @@ dnIsSuffix(
 {
 	int	d = dn->bv_len - suffix->bv_len;
 
-	assert( dn );
-	assert( suffix );
+	assert( dn != NULL );
+	assert( suffix != NULL );
 
 	/* empty suffix matches any dn */
 	if ( suffix->bv_len == 0 ) {
@@ -1255,6 +1370,35 @@ dnIsSuffix(
 	return( strcmp( dn->bv_val + d, suffix->bv_val ) == 0 );
 }
 
+int
+dnIsOneLevelRDN( struct berval *rdn )
+{
+	ber_len_t	len = rdn->bv_len;
+	for ( ; len--; ) {
+		if ( DN_SEPARATOR( rdn->bv_val[ len ] ) ) {
+			return 0;
+		}
+	}
+
+	return 1;
+}
+
+#ifdef HAVE_TLS
+static SLAP_CERT_MAP_FN *DNX509PeerNormalizeCertMap = NULL;
+#endif
+
+int register_certificate_map_function(SLAP_CERT_MAP_FN *fn)
+{
+#ifdef HAVE_TLS
+	if ( DNX509PeerNormalizeCertMap == NULL ) {
+		DNX509PeerNormalizeCertMap = fn;
+		return 0;
+	}
+#endif
+
+	return -1;
+}
+
 #ifdef HAVE_TLS
 /*
  * Convert an X.509 DN into a normalized LDAP DN
@@ -1277,8 +1421,16 @@ dnX509normalize( void *x509_name, struct berval *out )
 int
 dnX509peerNormalize( void *ssl, struct berval *dn )
 {
+	int rc = LDAP_INVALID_CREDENTIALS;
 
-	return ldap_pvt_tls_get_peer_dn( ssl, dn,
-		(LDAPDN_rewrite_dummy *)LDAPDN_rewrite, 0 );
+	if ( DNX509PeerNormalizeCertMap != NULL )
+		rc = (*DNX509PeerNormalizeCertMap)( ssl, dn );
+
+	if ( rc != LDAP_SUCCESS ) {
+		rc = ldap_pvt_tls_get_peer_dn( ssl, dn,
+			(LDAPDN_rewrite_dummy *)LDAPDN_rewrite, 0 );
+	}
+
+	return rc;
 }
 #endif