X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fdn.c;h=173426dfb16a94d1f6625d959c4ac5a915a1470f;hb=4ede3a32f5222280cbfec8df290a6cc92694ab27;hp=5da22ac6a44a6f834e4c42eb5bbc03e8d93a3415;hpb=a736b1041e40798a5da912e866fc0aa6fbd021fd;p=openldap

diff --git a/servers/slapd/dn.c b/servers/slapd/dn.c
index 5da22ac6a4..173426dfb1 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-2005 The OpenLDAP Foundation.
+ * Copyright 1998-2014 The OpenLDAP Foundation.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -53,32 +53,46 @@
 
 #define	AVA_PRIVATE( ava ) ( ( AttributeDescription * )(ava)->la_private )
 
+int slap_DN_strict = SLAP_AD_NOINSERT;
+
 static int
 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_DN_strict );
+				if ( rc != LDAP_SUCCESS ) {
+					return LDAP_INVALID_SYNTAX;
+				}
 			}
 
 			ava->la_private = ( void * )ad;
 		}
 
+		/*
+		 * Do not allow X-ORDERED 'VALUES' naming attributes
+		 */
+		if ( ad->ad_type->sat_flags & SLAP_AT_ORDERED_VAL ) {
+			return LDAP_INVALID_SYNTAX;
+		}
+
 		/* 
 		 * Replace attr oid/name with the canonical name
 		 */
@@ -112,50 +126,12 @@ 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 );
-
-		for ( iAVA = 0; rdn[ iAVA ]; iAVA++ ) {
-			LDAPAVA			*ava = rdn[ iAVA ];
-			AttributeDescription	*ad;
-			slap_syntax_validate_func *validate = NULL;
-
-			assert( ava );
-			
-			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;
-				}
-
-				ava->la_private = ( void * )ad;
-			}
-
-			/* 
-			 * Replace attr oid/name with the canonical name
-			 */
-			ava->la_attr = ad->ad_cname;
-
-			validate = ad->ad_type->sat_syntax->ssyn_validate;
-
-			if ( validate ) {
-				/*
-			 	 * validate value by validate function
-				 */
-				rc = ( *validate )( ad->ad_type->sat_syntax,
-					&ava->la_value );
-			
-				if ( rc != LDAP_SUCCESS ) {
-					return LDAP_INVALID_SYNTAX;
-				}
-			}
+		rc = LDAPRDN_validate( dn[ iRDN ] );
+		if ( rc != LDAP_SUCCESS ) {
+			return rc;
 		}
 	}
 
@@ -173,7 +149,7 @@ dnValidate(
 	int		rc;
 	LDAPDN		dn = NULL;
 
-	assert( in );
+	assert( in != NULL );
 
 	if ( in->bv_len == 0 ) {
 		return LDAP_SUCCESS;
@@ -211,7 +187,7 @@ rdnValidate(
 	LDAPRDN		rdn;
 	char*		p;
 
-	assert( in );
+	assert( in != NULL );
 	if ( in->bv_len == 0 ) {
 		return LDAP_SUCCESS;
 
@@ -244,89 +220,54 @@ rdnValidate(
 /*
  * 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).
+ * Rule: sort attributeTypes in alphabetical order.
  *
  * Note: the sorting can be slightly improved by sorting first
  * by attribute type length, then by alphabetical order.
  *
- * uses a linear search; should be fine since the number of AVAs in
+ * uses an insertion sort; should be fine since the number of AVAs in
  * a RDN should be limited.
  */
-static void
-AVA_Sort( LDAPRDN rdn, int iAVA )
+static int
+AVA_Sort( LDAPRDN rdn, int nAVAs )
 {
+	LDAPAVA	*ava_i;
 	int		i;
-	LDAPAVA		*ava_in = rdn[ iAVA ];
-
-	assert( rdn );
-	assert( ava_in );
-	
-	for ( i = 0; i < iAVA; i++ ) {
-		LDAPAVA		*ava = rdn[ i ];
-		int		a, j;
-
-		assert( ava );
-
-		a = strcmp( ava_in->la_attr.bv_val, ava->la_attr.bv_val );
 
-		if ( a > 0 ) {
-			break;
-		}
+	assert( rdn != NULL );
 
-		while ( a == 0 ) {
-			int		v, d;
+	for ( i = 1; i < nAVAs; i++ ) {
+		LDAPAVA *ava_j;
+		int j;
 
-			d = ava_in->la_value.bv_len - ava->la_value.bv_len;
+		ava_i = rdn[ i ];
+		for ( j = i-1; j >=0; j-- ) {
+			int a;
 
-			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 );
+			ava_j = rdn[ j ];
+			a = strcmp( ava_i->la_attr.bv_val, ava_j->la_attr.bv_val );
 
-			if ( v == 0 && d != 0 ) {
-				v = d;
-			}
+			/* RFC4512 does not allow multiple AVAs
+			 * with the same attribute type in RDN (ITS#5968) */
+			if ( a == 0 )
+				return LDAP_INVALID_DN_SYNTAX;
 
-			if ( v <= 0 ) {
-				/* 
-				 * got it!
-				 */
+			if ( a > 0 )
 				break;
-			}
-
-			if ( ++i == iAVA ) {
-				/*
-				 * already sorted
-				 */
-				return;
-			}
 
-			ava = rdn[ i ];
-			a = strcmp( ava_in->la_attr.bv_val, 
-					ava->la_attr.bv_val );
-		}
-
-		/*
-		 * move ahead
-		 */
-		for ( j = iAVA; j > i; j-- ) {
-			rdn[ j ] = rdn[ j - 1 ];
+			rdn[ j+1 ] = rdn[ j ];
 		}
-		rdn[ i ] = ava_in;
-
-		return;
+		rdn[ j+1 ] = ava_i;
 	}
+	return LDAP_SUCCESS;
 }
 
 static int
 LDAPRDN_rewrite( LDAPRDN rdn, unsigned flags, void *ctx )
 {
 
-	int rc;
-	int		iAVA;
+	int rc, iAVA, do_sort = 0;
+
 	for ( iAVA = 0; rdn[ iAVA ]; iAVA++ ) {
 		LDAPAVA			*ava = rdn[ iAVA ];
 		AttributeDescription	*ad;
@@ -335,16 +276,20 @@ LDAPRDN_rewrite( LDAPRDN rdn, unsigned flags, void *ctx )
 		slap_syntax_transform_func *transf = NULL;
 		MatchingRule *mr = NULL;
 		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_DN_strict );
+				if ( rc != LDAP_SUCCESS ) {
+					return LDAP_INVALID_SYNTAX;
+				}
 			}
 			
 			ava->la_private = ( void * )ad;
@@ -357,12 +302,13 @@ LDAPRDN_rewrite( LDAPRDN rdn, unsigned flags, void *ctx )
 		ava->la_attr = ad->ad_cname;
 
 		if( ava->la_flags & LDAP_AVA_BINARY ) {
-			if( ava->la_value.bv_len == 0 ) {
-				/* BER encoding is empty */
-				return LDAP_INVALID_SYNTAX;
-			}
+			/* AVA is binary encoded, not supported */
+			return LDAP_INVALID_SYNTAX;
+
+			/* Do not allow X-ORDERED 'VALUES' naming attributes */
+		} else if( ad->ad_type->sat_flags & SLAP_AT_ORDERED_VAL ) {
+			return LDAP_INVALID_SYNTAX;
 
-			/* AVA is binary encoded, don't muck with it */
 		} else if( flags & SLAP_LDAPDN_PRETTY ) {
 			transf = ad->ad_type->sat_syntax->ssyn_pretty;
 			if( !transf ) {
@@ -371,7 +317,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 ) {
@@ -428,10 +376,18 @@ LDAPRDN_rewrite( LDAPRDN rdn, unsigned flags, void *ctx )
 			ava->la_value = bv;
 			ava->la_flags |= LDAP_AVA_FREE_VALUE;
 		}
+		/* reject empty values */
+		if (!ava->la_value.bv_len) {
+			return LDAP_INVALID_SYNTAX;
+		}
+	}
+	rc = LDAP_SUCCESS;
 
-		if( do_sort ) AVA_Sort( rdn, iAVA );
+	if ( do_sort ) {
+		rc = AVA_Sort( rdn, iAVA );
 	}
-	return LDAP_SUCCESS;
+
+	return rc;
 }
 
 /*
@@ -444,117 +400,12 @@ 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 );
-
-		for ( iAVA = 0; rdn[ iAVA ]; iAVA++ ) {
-			LDAPAVA			*ava = rdn[ iAVA ];
-			AttributeDescription	*ad;
-			slap_syntax_validate_func *validf = NULL;
-			slap_mr_normalize_func *normf = NULL;
-			slap_syntax_transform_func *transf = NULL;
-			MatchingRule *mr = NULL;
-			struct berval		bv = BER_BVNULL;
-			int			do_sort = 0;
-
-			assert( ava );
-
-			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;
-				}
-				
-				ava->la_private = ( void * )ad;
-				do_sort = 1;
-			}
-
-			/* 
-			 * Replace attr oid/name with the canonical name
-			 */
-			ava->la_attr = ad->ad_cname;
-
-			if( ava->la_flags & LDAP_AVA_BINARY ) {
-				if( ava->la_value.bv_len == 0 ) {
-					/* BER encoding is empty */
-					return LDAP_INVALID_SYNTAX;
-				}
-
-				/* AVA is binary encoded, don't muck with it */
-			} else if( flags & SLAP_LDAPDN_PRETTY ) {
-				transf = ad->ad_type->sat_syntax->ssyn_pretty;
-				if( !transf ) {
-					validf = ad->ad_type->sat_syntax->ssyn_validate;
-				}
-			} else { /* normalization */
-				validf = ad->ad_type->sat_syntax->ssyn_validate;
-				mr = ad->ad_type->sat_equality;
-				if( mr ) normf = mr->smr_normalize;
-			}
-
-			if ( validf ) {
-				/* validate value before normalization */
-				rc = ( *validf )( ad->ad_type->sat_syntax,
-					ava->la_value.bv_len
-						? &ava->la_value
-						: (struct berval *) &slap_empty_bv );
-
-				if ( rc != LDAP_SUCCESS ) {
-					return LDAP_INVALID_SYNTAX;
-				}
-			}
-
-			if ( transf ) {
-				/*
-			 	 * transform value by pretty function
-				 *	if value is empty, use empty_bv
-				 */
-				rc = ( *transf )( ad->ad_type->sat_syntax,
-					ava->la_value.bv_len
-						? &ava->la_value
-						: (struct berval *) &slap_empty_bv,
-					&bv, ctx );
-			
-				if ( rc != LDAP_SUCCESS ) {
-					return LDAP_INVALID_SYNTAX;
-				}
-			}
-
-			if ( normf ) {
-				/*
-			 	 * normalize value
-				 *	if value is empty, use empty_bv
-				 */
-				rc = ( *normf )(
-					SLAP_MR_VALUE_OF_ASSERTION_SYNTAX,
-					ad->ad_type->sat_syntax,
-					mr,
-					ava->la_value.bv_len
-						? &ava->la_value
-						: (struct berval *) &slap_empty_bv,
-					&bv, ctx );
-			
-				if ( rc != LDAP_SUCCESS ) {
-					return LDAP_INVALID_SYNTAX;
-				}
-			}
-
-
-			if( bv.bv_val ) {
-				if ( ava->la_flags & LDAP_AVA_FREE_VALUE )
-					ber_memfree_x( ava->la_value.bv_val, ctx );
-				ava->la_value = bv;
-				ava->la_flags |= LDAP_AVA_FREE_VALUE;
-			}
-
-			if( do_sort ) AVA_Sort( rdn, iAVA );
+		rc = LDAPRDN_rewrite( dn[ iRDN ], flags, ctx );
+		if ( rc != LDAP_SUCCESS ) {
+			return rc;
 		}
 	}
 
@@ -570,10 +421,10 @@ 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 );
+	Debug( LDAP_DEBUG_TRACE, ">>> dnNormalize: <%s>\n", val->bv_val ? val->bv_val : "", 0, 0 );
 
 	if ( val->bv_len != 0 ) {
 		LDAPDN		dn = NULL;
@@ -612,7 +463,7 @@ dnNormalize(
 		ber_dupbv_x( out, val, ctx );
 	}
 
-	Debug( LDAP_DEBUG_TRACE, "<<< dnNormalize: <%s>\n", out->bv_val, 0, 0 );
+	Debug( LDAP_DEBUG_TRACE, "<<< dnNormalize: <%s>\n", out->bv_val ? out->bv_val : "", 0, 0 );
 
 	return LDAP_SUCCESS;
 }
@@ -626,10 +477,10 @@ 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 );
+	Debug( LDAP_DEBUG_TRACE, ">>> dnNormalize: <%s>\n", val->bv_val ? val->bv_val : "", 0, 0 );
 	if ( val->bv_len != 0 ) {
 		LDAPRDN		rdn = NULL;
 		int		rc;
@@ -670,7 +521,7 @@ rdnNormalize(
 		ber_dupbv_x( out, val, ctx );
 	}
 
-	Debug( LDAP_DEBUG_TRACE, "<<< dnNormalize: <%s>\n", out->bv_val, 0, 0 );
+	Debug( LDAP_DEBUG_TRACE, "<<< dnNormalize: <%s>\n", out->bv_val ? out->bv_val : "", 0, 0 );
 
 	return LDAP_SUCCESS;
 }
@@ -682,10 +533,10 @@ dnPretty(
 	struct berval *out,
 	void *ctx)
 {
-	assert( val );
-	assert( out );
+	assert( val != NULL );
+	assert( out != NULL );
 
-	Debug( LDAP_DEBUG_TRACE, ">>> dnPretty: <%s>\n", val->bv_val, 0, 0 );
+	Debug( LDAP_DEBUG_TRACE, ">>> dnPretty: <%s>\n", val->bv_val ? val->bv_val : "", 0, 0 );
 
 	if ( val->bv_len == 0 ) {
 		ber_dupbv_x( out, val, ctx );
@@ -727,7 +578,7 @@ dnPretty(
 		}
 	}
 
-	Debug( LDAP_DEBUG_TRACE, "<<< dnPretty: <%s>\n", out->bv_val, 0, 0 );
+	Debug( LDAP_DEBUG_TRACE, "<<< dnPretty: <%s>\n", out->bv_val ? out->bv_val : "", 0, 0 );
 
 	return LDAP_SUCCESS;
 }
@@ -739,10 +590,10 @@ rdnPretty(
 	struct berval *out,
 	void *ctx)
 {
-	assert( val );
-	assert( out );
+	assert( val != NULL );
+	assert( out != NULL );
 
-	Debug( LDAP_DEBUG_TRACE, ">>> dnPretty: <%s>\n", val->bv_val, 0, 0 );
+	Debug( LDAP_DEBUG_TRACE, ">>> rdnPretty: <%s>\n", val->bv_val ? val->bv_val : "", 0, 0 );
 
 	if ( val->bv_len == 0 ) {
 		ber_dupbv_x( out, val, ctx );
@@ -786,7 +637,7 @@ rdnPretty(
 		}
 	}
 
-	Debug( LDAP_DEBUG_TRACE, "<<< dnPretty: <%s>\n", out->bv_val, 0, 0 );
+	Debug( LDAP_DEBUG_TRACE, "<<< dnPretty: <%s>\n", out->bv_val ? out->bv_val : "", 0, 0 );
 
 	return LDAP_SUCCESS;
 }
@@ -800,12 +651,12 @@ dnPrettyNormalDN(
 	int flags,
 	void *ctx )
 {
-	assert( val );
-	assert( dn );
+	assert( val != NULL );
+	assert( dn != NULL );
 
 	Debug( LDAP_DEBUG_TRACE, ">>> dn%sDN: <%s>\n", 
 			flags == SLAP_LDAPDN_PRETTY ? "Pretty" : "Normal", 
-			val->bv_val, 0 );
+			val->bv_val ? val->bv_val : "", 0 );
 
 	if ( val->bv_len == 0 ) {
 		return LDAP_SUCCESS;
@@ -852,11 +703,10 @@ dnPrettyNormal(
 	struct berval *normal,
 	void *ctx)
 {
-	Debug( LDAP_DEBUG_TRACE, ">>> dnPrettyNormal: <%s>\n", val->bv_val, 0, 0 );
-
-	assert( val );
-	assert( pretty );
-	assert( normal );
+	assert( val != NULL );
+	assert( pretty != NULL );
+	assert( normal != NULL );
+	Debug( LDAP_DEBUG_TRACE, ">>> dnPrettyNormal: <%s>\n", val->bv_val ? val->bv_val : "", 0, 0 );
 
 	if ( val->bv_len == 0 ) {
 		ber_dupbv_x( pretty, val, ctx );
@@ -920,7 +770,8 @@ dnPrettyNormal(
 	}
 
 	Debug( LDAP_DEBUG_TRACE, "<<< dnPrettyNormal: <%s>, <%s>\n",
-		pretty->bv_val, normal->bv_val, 0 );
+		pretty->bv_val ? pretty->bv_val : "",
+		normal->bv_val ? normal->bv_val : "", 0 );
 
 	return LDAP_SUCCESS;
 }
@@ -940,9 +791,9 @@ 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 ) );
 	
@@ -975,9 +826,9 @@ dnRelativeMatch(
 	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 ) );
 
@@ -996,7 +847,7 @@ dnRelativeMatch(
 					asserted->bv_val, 
 					asserted->bv_len );
 			} else {
-				return 1;
+				match = 1;
 			}
 		}
 
@@ -1022,7 +873,7 @@ dnRelativeMatch(
 					asserted->bv_val, 
 					asserted->bv_len );
 			} else {
-				return 1;
+				match = 1;
 			}
 		}
 
@@ -1049,7 +900,7 @@ dnRelativeMatch(
 					match = dnIsOneLevelRDN( &rdn ) ? 0 : 1;
 				}
 			} else {
-				return 1;
+				match = 1;
 			}
 		}
 
@@ -1074,9 +925,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;
 
@@ -1109,12 +960,12 @@ dnParent(
 {
 	char	*p;
 
-	p = strchr( dn->bv_val, ',' );
+	p = ber_bvchr( dn, ',' );
 
 	/* one-level dn */
 	if ( p == NULL ) {
-		pdn->bv_len = 0;
 		pdn->bv_val = dn->bv_val + dn->bv_len;
+		pdn->bv_len = 0;
 		return;
 	}
 
@@ -1141,7 +992,7 @@ dnRdn(
 	char	*p;
 
 	*rdn = *dn;
-	p = strchr( dn->bv_val, ',' );
+	p = ber_bvchr( dn, ',' );
 
 	/* one-level dn */
 	if ( p == NULL ) {
@@ -1165,8 +1016,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;
@@ -1187,14 +1038,14 @@ dnExtractRdn(
 /*
  * 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;
@@ -1208,9 +1059,9 @@ 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;
+	return p ? (ber_len_t) (p - dn_in->bv_val) : dn_in->bv_len;
 }
 
 
@@ -1232,7 +1083,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
@@ -1280,7 +1131,7 @@ rdn_validate( struct berval *rdn )
 
 /* build_new_dn:
  *
- * Used by ldbm/bdb2 back_modrdn to create the new dn of entries being
+ * Used by back-bdb back_modrdn to create the new dn of entries being
  * renamed.
  *
  * new_dn = parent (p_dn) + separator + rdn (newrdn) + null.
@@ -1295,7 +1146,7 @@ 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;
 	}
 
@@ -1317,10 +1168,12 @@ dnIsSuffix(
 	const struct berval *dn,
 	const struct berval *suffix )
 {
-	int	d = dn->bv_len - suffix->bv_len;
+	int	d;
+
+	assert( dn != NULL );
+	assert( suffix != NULL );
 
-	assert( dn );
-	assert( suffix );
+	d = dn->bv_len - suffix->bv_len;
 
 	/* empty suffix matches any dn */
 	if ( suffix->bv_len == 0 ) {
@@ -1343,7 +1196,71 @@ dnIsSuffix(
 	}
 
 	/* compare */
-	return( strcmp( dn->bv_val + d, suffix->bv_val ) == 0 );
+	return( strncmp( dn->bv_val + d, suffix->bv_val, suffix->bv_len ) == 0 );
+}
+
+/*
+ * In place; assumes:
+ * - ndn is normalized
+ * - nbase is normalized
+ * - dnIsSuffix( ndn, nbase ) == TRUE
+ * - LDAP_SCOPE_DEFAULT == LDAP_SCOPE_SUBTREE
+ */
+int
+dnIsWithinScope( struct berval *ndn, struct berval *nbase, int scope )
+{
+	assert( ndn != NULL );
+	assert( nbase != NULL );
+	assert( !BER_BVISNULL( ndn ) );
+	assert( !BER_BVISNULL( nbase ) );
+
+	switch ( scope ) {
+	case LDAP_SCOPE_DEFAULT:
+	case LDAP_SCOPE_SUBTREE:
+		break;
+
+	case LDAP_SCOPE_BASE:
+		if ( ndn->bv_len != nbase->bv_len ) {
+			return 0;
+		}
+		break;
+
+	case LDAP_SCOPE_ONELEVEL: {
+		struct berval pndn;
+		dnParent( ndn, &pndn );
+		if ( pndn.bv_len != nbase->bv_len ) {
+			return 0;
+		}
+		} break;
+
+	case LDAP_SCOPE_SUBORDINATE:
+		if ( ndn->bv_len == nbase->bv_len ) {
+			return 0;
+		}
+		break;
+
+	/* unknown scope */
+	default:
+		return -1;
+	}
+
+	return 1;
+}
+
+/*
+ * In place; assumes:
+ * - ndn is normalized
+ * - nbase is normalized
+ * - LDAP_SCOPE_DEFAULT == LDAP_SCOPE_SUBTREE
+ */
+int
+dnIsSuffixScope( struct berval *ndn, struct berval *nbase, int scope )
+{
+	if ( !dnIsSuffix( ndn, nbase ) ) {
+		return 0;
+	}
+
+	return dnIsWithinScope( ndn, nbase, scope );
 }
 
 int
@@ -1375,7 +1292,6 @@ int register_certificate_map_function(SLAP_CERT_MAP_FN *fn)
 	return -1;
 }
 
-#ifdef HAVE_TLS
 /*
  * Convert an X.509 DN into a normalized LDAP DN
  */
@@ -1386,11 +1302,13 @@ dnX509normalize( void *x509_name, struct berval *out )
 	int rc = ldap_X509dn2bv( x509_name, out, LDAPDN_rewrite, 0 );
 
 	Debug( LDAP_DEBUG_TRACE,
-		"dnX509Normalize: <%s>\n", out->bv_val, 0, 0 );
+		"dnX509Normalize: <%s> (%d)\n",
+		BER_BVISNULL( out ) ? "(null)" : out->bv_val, rc, 0 );
 
 	return rc;
 }
 
+#ifdef HAVE_TLS
 /*
  * Get the TLS session's peer's DN into a normalized LDAP DN
  */