X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fdn.c;h=3930ea666b18abed239692fbf81ea66b8e231a22;hb=9184d038ead9aeabff5b7c0bb2ed0d1e6bc95c8c;hp=0df75dfadb5d1c22a4b25e4f14e4cd342631e095;hpb=c75be97ae946dab41f002a31d8347cc38cda7658;p=openldap

diff --git a/servers/slapd/dn.c b/servers/slapd/dn.c
index 0df75dfadb..3930ea666b 100644
--- a/servers/slapd/dn.c
+++ b/servers/slapd/dn.c
@@ -42,21 +42,21 @@
  * structural representation of a distinguished name.
  */
 static int
-LDAPDN_validate( LDAPDN *dn )
+LDAPDN_validate( LDAPDN dn )
 {
 	int 		iRDN;
 	int 		rc;
 
 	assert( dn );
 
-	for ( iRDN = 0; dn[ 0 ][ iRDN ]; iRDN++ ) {
-		LDAPRDN		*rdn = dn[ 0 ][ iRDN ];
+	for ( iRDN = 0; dn[ iRDN ]; iRDN++ ) {
+		LDAPRDN		rdn = dn[ iRDN ];
 		int		iAVA;
 
 		assert( rdn );
 
-		for ( iAVA = 0; rdn[ 0 ][ iAVA ]; iAVA++ ) {
-			LDAPAVA			*ava = rdn[ 0 ][ iAVA ];
+		for ( iAVA = 0; rdn[ iAVA ]; iAVA++ ) {
+			LDAPAVA			*ava = rdn[ iAVA ];
 			AttributeDescription	*ad;
 			slap_syntax_validate_func *validate = NULL;
 
@@ -106,7 +106,7 @@ dnValidate(
 	struct berval *in )
 {
 	int		rc;
-	LDAPDN		*dn = NULL;
+	LDAPDN		dn = NULL;
 
 	assert( in );
 
@@ -152,16 +152,16 @@ dnValidate(
  * a RDN should be limited.
  */
 static void
-AVA_Sort( LDAPRDN *rdn, int iAVA )
+AVA_Sort( LDAPRDN rdn, int iAVA )
 {
 	int		i;
-	LDAPAVA		*ava_in = rdn[ 0 ][ iAVA ];
+	LDAPAVA		*ava_in = rdn[ iAVA ];
 
 	assert( rdn );
 	assert( ava_in );
 	
 	for ( i = 0; i < iAVA; i++ ) {
-		LDAPAVA		*ava = rdn[ 0 ][ i ];
+		LDAPAVA		*ava = rdn[ i ];
 		int		a, j;
 
 		assert( ava );
@@ -200,7 +200,7 @@ AVA_Sort( LDAPRDN *rdn, int iAVA )
 				return;
 			}
 
-			ava = rdn[ 0 ][ i ];
+			ava = rdn[ i ];
 			a = strcmp( ava_in->la_attr.bv_val, 
 					ava->la_attr.bv_val );
 		}
@@ -209,9 +209,9 @@ AVA_Sort( LDAPRDN *rdn, int iAVA )
 		 * move ahead
 		 */
 		for ( j = iAVA; j > i; j-- ) {
-			rdn[ 0 ][ j ] = rdn[ 0 ][ j - 1 ];
+			rdn[ j ] = rdn[ j - 1 ];
 		}
-		rdn[ 0 ][ i ] = ava_in;
+		rdn[ i ] = ava_in;
 
 		return;
 	}
@@ -222,21 +222,21 @@ AVA_Sort( LDAPRDN *rdn, int iAVA )
  * structural representation of a distinguished name.
  */
 static int
-LDAPDN_rewrite( LDAPDN *dn, unsigned flags )
+LDAPDN_rewrite( LDAPDN dn, unsigned flags, void *ctx )
 {
 	int 		iRDN;
 	int 		rc;
 
 	assert( dn );
 
-	for ( iRDN = 0; dn[ 0 ][ iRDN ]; iRDN++ ) {
-		LDAPRDN		*rdn = dn[ 0 ][ iRDN ];
+	for ( iRDN = 0; dn[ iRDN ]; iRDN++ ) {
+		LDAPRDN		rdn = dn[ iRDN ];
 		int		iAVA;
 
 		assert( rdn );
 
-		for ( iAVA = 0; rdn[ 0 ][ iAVA ]; iAVA++ ) {
-			LDAPAVA			*ava = rdn[ 0 ][ iAVA ];
+		for ( iAVA = 0; rdn[ iAVA ]; iAVA++ ) {
+			LDAPAVA			*ava = rdn[ iAVA ];
 			AttributeDescription	*ad;
 			slap_syntax_validate_func *validf = NULL;
 			slap_mr_normalize_func *normf = NULL;
@@ -303,7 +303,7 @@ LDAPDN_rewrite( LDAPDN *dn, unsigned flags )
 					ava->la_value.bv_len
 						? &ava->la_value
 						: (struct berval *) &slap_empty_bv,
-					&bv );
+					&bv, ctx );
 			
 				if ( rc != LDAP_SUCCESS ) {
 					return LDAP_INVALID_SYNTAX;
@@ -322,7 +322,7 @@ LDAPDN_rewrite( LDAPDN *dn, unsigned flags )
 					ava->la_value.bv_len
 						? &ava->la_value
 						: (struct berval *) &slap_empty_bv,
-					&bv );
+					&bv, ctx );
 			
 				if ( rc != LDAP_SUCCESS ) {
 					return LDAP_INVALID_SYNTAX;
@@ -331,7 +331,7 @@ LDAPDN_rewrite( LDAPDN *dn, unsigned flags )
 
 
 			if( bv.bv_val ) {
-				free( ava->la_value.bv_val );
+				ber_memfree_x( ava->la_value.bv_val, ctx );
 				ava->la_value = bv;
 			}
 
@@ -348,7 +348,8 @@ dnNormalize(
     Syntax *syntax,
     MatchingRule *mr,
     struct berval *val,
-    struct berval *out )
+    struct berval *out,
+    void *ctx)
 {
 	assert( val );
 	assert( out );
@@ -356,13 +357,13 @@ dnNormalize(
 	Debug( LDAP_DEBUG_TRACE, ">>> dnNormalize: <%s>\n", val->bv_val, 0, 0 );
 
 	if ( val->bv_len != 0 ) {
-		LDAPDN		*dn = NULL;
+		LDAPDN		dn = NULL;
 		int		rc;
 
 		/*
 		 * Go to structural representation
 		 */
-		rc = ldap_bv2dn( val, &dn, LDAP_DN_FORMAT_LDAP );
+		rc = ldap_bv2dn_x( val, &dn, LDAP_DN_FORMAT_LDAP, ctx );
 		if ( rc != LDAP_SUCCESS ) {
 			return LDAP_INVALID_SYNTAX;
 		}
@@ -372,7 +373,7 @@ dnNormalize(
 		/*
 		 * Schema-aware rewrite
 		 */
-		if ( LDAPDN_rewrite( dn, 0 ) != LDAP_SUCCESS ) {
+		if ( LDAPDN_rewrite( dn, 0, ctx ) != LDAP_SUCCESS ) {
 			ldap_dnfree( dn );
 			return LDAP_INVALID_SYNTAX;
 		}
@@ -380,16 +381,16 @@ dnNormalize(
 		/*
 		 * Back to string representation
 		 */
-		rc = ldap_dn2bv( dn, out,
-			LDAP_DN_FORMAT_LDAPV3 | LDAP_DN_PRETTY );
+		rc = ldap_dn2bv_x( dn, out,
+			LDAP_DN_FORMAT_LDAPV3 | LDAP_DN_PRETTY, ctx );
 
-		ldap_dnfree( dn );
+		ldap_dnfree_x( dn, ctx );
 
 		if ( rc != LDAP_SUCCESS ) {
 			return LDAP_INVALID_SYNTAX;
 		}
 	} else {
-		ber_dupbv( out, val );
+		ber_dupbv_x( out, val, ctx );
 	}
 
 	Debug( LDAP_DEBUG_TRACE, "<<< dnNormalize: <%s>\n", out->bv_val, 0, 0 );
@@ -397,36 +398,12 @@ dnNormalize(
 	return LDAP_SUCCESS;
 }
 
-#if 0
-/*
- * dn "pretty"ing routine
- */
 int
 dnPretty(
 	Syntax *syntax,
 	struct berval *val,
-	struct berval **pretty)
-{
-	struct berval *out;
-	int rc;
-
-	assert( pretty && *pretty == NULL );
-
-	out = ch_malloc( sizeof( struct berval ) );
-	rc = dnPretty2( syntax, val, out );
-	if ( rc != LDAP_SUCCESS )
-		free( out );
-	else
-		*pretty = out;
-	return rc;
-}
-#endif
-
-int
-dnPretty2(
-	Syntax *syntax,
-	struct berval *val,
-	struct berval *out)
+	struct berval *out,
+	void *ctx)
 {
 	assert( val );
 	assert( out );
@@ -438,17 +415,17 @@ dnPretty2(
 #endif
 
 	if ( val->bv_len == 0 ) {
-		ber_dupbv( out, val );
+		ber_dupbv_x( out, val, ctx );
 
 	} else if ( val->bv_len > SLAP_LDAPDN_MAXLEN ) {
 		return LDAP_INVALID_SYNTAX;
 
 	} else {
-		LDAPDN		*dn = NULL;
+		LDAPDN		dn = NULL;
 		int		rc;
 
 		/* FIXME: should be liberal in what we accept */
-		rc = ldap_bv2dn( val, &dn, LDAP_DN_FORMAT_LDAP );
+		rc = ldap_bv2dn_x( val, &dn, LDAP_DN_FORMAT_LDAP, ctx );
 		if ( rc != LDAP_SUCCESS ) {
 			return LDAP_INVALID_SYNTAX;
 		}
@@ -458,8 +435,8 @@ dnPretty2(
 		/*
 		 * Schema-aware rewrite
 		 */
-		if ( LDAPDN_rewrite( dn, SLAP_LDAPDN_PRETTY ) != LDAP_SUCCESS ) {
-			ldap_dnfree( dn );
+		if ( LDAPDN_rewrite( dn, SLAP_LDAPDN_PRETTY, ctx ) != LDAP_SUCCESS ) {
+			ldap_dnfree_x( dn, ctx );
 			return LDAP_INVALID_SYNTAX;
 		}
 
@@ -467,10 +444,10 @@ dnPretty2(
 		/* RE: the default is the form that is used as
 		 * an internal representation; the pretty form
 		 * is a variant */
-		rc = ldap_dn2bv( dn, out,
-			LDAP_DN_FORMAT_LDAPV3 | LDAP_DN_PRETTY );
+		rc = ldap_dn2bv_x( dn, out,
+			LDAP_DN_FORMAT_LDAPV3 | LDAP_DN_PRETTY, ctx );
 
-		ldap_dnfree( dn );
+		ldap_dnfree_x( dn, ctx );
 
 		if ( rc != LDAP_SUCCESS ) {
 			return LDAP_INVALID_SYNTAX;
@@ -486,8 +463,9 @@ int
 dnPrettyNormalDN(
 	Syntax *syntax,
 	struct berval *val,
-	LDAPDN **dn,
-	int flags )
+	LDAPDN *dn,
+	int flags,
+	void *ctx )
 {
 	assert( val );
 	assert( dn );
@@ -512,7 +490,7 @@ dnPrettyNormalDN(
 		int		rc;
 
 		/* FIXME: should be liberal in what we accept */
-		rc = ldap_bv2dn( val, dn, LDAP_DN_FORMAT_LDAP );
+		rc = ldap_bv2dn_x( val, dn, LDAP_DN_FORMAT_LDAP, ctx );
 		if ( rc != LDAP_SUCCESS ) {
 			return LDAP_INVALID_SYNTAX;
 		}
@@ -522,8 +500,8 @@ dnPrettyNormalDN(
 		/*
 		 * Schema-aware rewrite
 		 */
-		if ( LDAPDN_rewrite( *dn, flags ) != LDAP_SUCCESS ) {
-			ldap_dnfree( *dn );
+		if ( LDAPDN_rewrite( *dn, flags, ctx ) != LDAP_SUCCESS ) {
+			ldap_dnfree_x( *dn, ctx );
 			*dn = NULL;
 			return LDAP_INVALID_SYNTAX;
 		}
@@ -544,7 +522,8 @@ dnPrettyNormal(
 	Syntax *syntax,
 	struct berval *val,
 	struct berval *pretty,
-	struct berval *normal)
+	struct berval *normal,
+	void *ctx)
 {
 #ifdef NEW_LOGGING
 	LDAP_LOG ( OPERATION, ENTRY, ">>> dnPrettyNormal: <%s>\n", val->bv_val, 0, 0 );
@@ -557,15 +536,15 @@ dnPrettyNormal(
 	assert( normal );
 
 	if ( val->bv_len == 0 ) {
-		ber_dupbv( pretty, val );
-		ber_dupbv( normal, val );
+		ber_dupbv_x( pretty, val, ctx );
+		ber_dupbv_x( normal, val, ctx );
 
 	} else if ( val->bv_len > SLAP_LDAPDN_MAXLEN ) {
 		/* too big */
 		return LDAP_INVALID_SYNTAX;
 
 	} else {
-		LDAPDN		*dn = NULL;
+		LDAPDN		dn = NULL;
 		int		rc;
 
 		pretty->bv_val = NULL;
@@ -574,7 +553,7 @@ dnPrettyNormal(
 		normal->bv_len = 0;
 
 		/* FIXME: should be liberal in what we accept */
-		rc = ldap_bv2dn( val, &dn, LDAP_DN_FORMAT_LDAP );
+		rc = ldap_bv2dn_x( val, &dn, LDAP_DN_FORMAT_LDAP, ctx );
 		if ( rc != LDAP_SUCCESS ) {
 			return LDAP_INVALID_SYNTAX;
 		}
@@ -584,33 +563,33 @@ dnPrettyNormal(
 		/*
 		 * Schema-aware rewrite
 		 */
-		if ( LDAPDN_rewrite( dn, SLAP_LDAPDN_PRETTY ) != LDAP_SUCCESS ) {
-			ldap_dnfree( dn );
+		if ( LDAPDN_rewrite( dn, SLAP_LDAPDN_PRETTY, ctx ) != LDAP_SUCCESS ) {
+			ldap_dnfree_x( dn, ctx );
 			return LDAP_INVALID_SYNTAX;
 		}
 
-		rc = ldap_dn2bv( dn, pretty,
-			LDAP_DN_FORMAT_LDAPV3 | LDAP_DN_PRETTY );
+		rc = ldap_dn2bv_x( dn, pretty,
+			LDAP_DN_FORMAT_LDAPV3 | LDAP_DN_PRETTY, ctx );
 
 		if ( rc != LDAP_SUCCESS ) {
-			ldap_dnfree( dn );
+			ldap_dnfree_x( dn, ctx );
 			return LDAP_INVALID_SYNTAX;
 		}
 
-		if ( LDAPDN_rewrite( dn, 0 ) != LDAP_SUCCESS ) {
-			ldap_dnfree( dn );
-			free( pretty->bv_val );
+		if ( LDAPDN_rewrite( dn, 0, ctx ) != LDAP_SUCCESS ) {
+			ldap_dnfree_x( dn, ctx );
+			ber_memfree_x( pretty->bv_val, ctx );
 			pretty->bv_val = NULL;
 			pretty->bv_len = 0;
 			return LDAP_INVALID_SYNTAX;
 		}
 
-		rc = ldap_dn2bv( dn, normal,
-			LDAP_DN_FORMAT_LDAPV3 | LDAP_DN_PRETTY );
+		rc = ldap_dn2bv_x( dn, normal,
+			LDAP_DN_FORMAT_LDAPV3 | LDAP_DN_PRETTY, ctx );
 
-		ldap_dnfree( dn );
+		ldap_dnfree_x( dn, ctx );
 		if ( rc != LDAP_SUCCESS ) {
-			free( pretty->bv_val );
+			ber_memfree_x( pretty->bv_val, ctx );
 			pretty->bv_val = NULL;
 			pretty->bv_len = 0;
 			return LDAP_INVALID_SYNTAX;
@@ -701,9 +680,10 @@ dnParent(
 int
 dnExtractRdn( 
 	struct berval	*dn, 
-	struct berval 	*rdn )
+	struct berval 	*rdn,
+	void *ctx )
 {
-	LDAPRDN		*tmpRDN;
+	LDAPRDN		tmpRDN;
 	const char	*p;
 	int		rc;
 
@@ -714,14 +694,14 @@ dnExtractRdn(
 		return LDAP_OTHER;
 	}
 
-	rc = ldap_bv2rdn( dn, &tmpRDN, (char **)&p, LDAP_DN_FORMAT_LDAP );
+	rc = ldap_bv2rdn_x( dn, &tmpRDN, (char **)&p, LDAP_DN_FORMAT_LDAP, ctx );
 	if ( rc != LDAP_SUCCESS ) {
 		return rc;
 	}
 
-	rc = ldap_rdn2bv( tmpRDN, rdn, LDAP_DN_FORMAT_LDAPV3 | LDAP_DN_PRETTY );
+	rc = ldap_rdn2bv_x( tmpRDN, rdn, LDAP_DN_FORMAT_LDAPV3 | LDAP_DN_PRETTY, ctx );
 
-	ldap_rdnfree( tmpRDN );
+	ldap_rdnfree_x( tmpRDN, ctx );
 	if ( rc != LDAP_SUCCESS ) {
 		return rc;
 	}