Do not return pointers into BerElement we do not own

[openldap] / servers / slapd / dn.c

diff --git a/servers/slapd/dn.c b/servers/slapd/dn.c
index 82db98532b97bbbd17f9e7cfbc757b18dac3048e..b1168901c001dac8fadb72f57778ef1e983be181 100644 (file)
--- a/servers/slapd/dn.c
+++ b/servers/slapd/dn.c
@@ -1,7 +1,7 @@
 /* dn.c - routines for dealing with distinguished names */
 /* $OpenLDAP$ */
 /*
- * Copyright 1998-2002 The OpenLDAP Foundation, All Rights Reserved.
+ * Copyright 1998-2003 The OpenLDAP Foundation, All Rights Reserved.
  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
  */
 
@@ -20,12 +20,6 @@
 
 #include "lutil.h"
 
-const struct berval slap_empty_bv = { 0, "" };
-
-#define SLAP_LDAPDN_PRETTY 0x1
-
-#define SLAP_LDAPDN_MAXLEN 8192
-
 /*
  * The DN syntax-related functions take advantage of the dn representation
  * handling functions ldap_str2dn/ldap_dn2str.  The latter are not schema-
@@ -245,8 +239,11 @@ LDAPDN_rewrite( LDAPDN *dn, unsigned flags )
                        LDAPAVA                 *ava = rdn[ 0 ][ iAVA ];
                        AttributeDescription    *ad;
                        slap_syntax_validate_func *validf = NULL;
+#ifdef SLAP_NVALUES
+                       slap_mr_normalize_func *normf = NULL;
+#endif
                        slap_syntax_transform_func *transf = NULL;
-                       MatchingRule *mr;
+                       MatchingRule *mr = NULL;
                        struct berval           bv = { 0, NULL };
                        int                     do_sort = 0;
 
@@ -270,18 +267,25 @@ LDAPDN_rewrite( LDAPDN *dn, unsigned flags )
                        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 */
-                               validf = NULL;
-                               transf = NULL;
-                               mr = NULL;
                        } else if( flags & SLAP_LDAPDN_PRETTY ) {
-                               validf = NULL;
                                transf = ad->ad_type->sat_syntax->ssyn_pretty;
-                               mr = NULL;
-                       } else {
+                               if( !transf ) {
+                                       validf = ad->ad_type->sat_syntax->ssyn_validate;
+                               }
+                       } else { /* normalization */
                                validf = ad->ad_type->sat_syntax->ssyn_validate;
-                               transf = ad->ad_type->sat_syntax->ssyn_normalize;
                                mr = ad->ad_type->sat_equality;
+#ifdef SLAP_NVALUES
+                               if( mr ) normf = mr->smr_normalize;
+#else
+                               transf = ad->ad_type->sat_syntax->ssyn_normalize;
+#endif
                        }
 
                        if ( validf ) {
@@ -298,7 +302,11 @@ LDAPDN_rewrite( LDAPDN *dn, unsigned flags )
 
                        if ( transf ) {
                                /*
+#ifdef SLAP_NVALUES
+                                * transform value by pretty function
+#else
                                 * transform value by normalize/pretty function
+#endif
                                 *      if value is empty, use empty_bv
                                 */
                                rc = ( *transf )( ad->ad_type->sat_syntax,
@@ -312,6 +320,27 @@ LDAPDN_rewrite( LDAPDN *dn, unsigned flags )
                                }
                        }
 
+#ifdef SLAP_NVALUES
+                       if ( normf ) {
+                               /*
+                                * normalize value
+                                *      if value is empty, use empty_bv
+                                */
+                               rc = ( *normf )(
+                                       0,
+                                       ad->ad_type->sat_syntax,
+                                       mr,
+                                       ava->la_value.bv_len
+                                               ? &ava->la_value
+                                               : (struct berval *) &slap_empty_bv,
+                                       &bv );
+                       
+                               if ( rc != LDAP_SUCCESS ) {
+                                       return LDAP_INVALID_SYNTAX;
+                               }
+                       }
+
+#else
                        if( mr && ( mr->smr_usage & SLAP_MR_DN_FOLD ) ) {
                                char *s = bv.bv_val;
 
@@ -321,6 +350,7 @@ LDAPDN_rewrite( LDAPDN *dn, unsigned flags )
                                }
                                free( s );
                        }
+#endif
 
                        if( bv.bv_val ) {
                                free( ava->la_value.bv_val );
@@ -334,34 +364,20 @@ LDAPDN_rewrite( LDAPDN *dn, unsigned flags )
        return LDAP_SUCCESS;
 }
 
-/*
- * dn normalize routine
- */
 int
+#ifdef SLAP_NVALUES
 dnNormalize(
-       Syntax *syntax,
-       struct berval *val,
-       struct berval **normalized )
-{
-       struct berval *out;
-       int rc;
-
-       assert( normalized && *normalized == NULL );
-
-       out = ch_malloc( sizeof( struct berval ) );
-       rc = dnNormalize2( syntax, val, out );
-       if ( rc != LDAP_SUCCESS )
-               free( out );
-       else
-               *normalized = out;
-       return rc;
-}
-
-int
-dnNormalize2(
-       Syntax *syntax,
-       struct berval *val,
-       struct berval *out )
+    slap_mask_t use,
+    Syntax *syntax,
+    MatchingRule *mr,
+    struct berval *val,
+    struct berval *out )
+#else
+dnNormalize(
+    Syntax *syntax,
+    struct berval *val,
+    struct berval *out )
+#endif
 {
        assert( val );
        assert( out );
@@ -393,7 +409,8 @@ dnNormalize2(
                /*
                 * Back to string representation
                 */
-               rc = ldap_dn2bv( dn, out, LDAP_DN_FORMAT_LDAPV3 );
+               rc = ldap_dn2bv( dn, out,
+                       LDAP_DN_FORMAT_LDAPV3 | LDAP_DN_PRETTY );
 
                ldap_dnfree( dn );
 
@@ -409,6 +426,7 @@ dnNormalize2(
        return LDAP_SUCCESS;
 }
 
+#if 0
 /*
  * dn "pretty"ing routine
  */
@@ -431,6 +449,7 @@ dnPretty(
                *pretty = out;
        return rc;
 }
+#endif
 
 int
 dnPretty2(
@@ -492,6 +511,60 @@ dnPretty2(
        return LDAP_SUCCESS;
 }
 
+int
+dnPrettyNormalDN(
+       Syntax *syntax,
+       struct berval *val,
+       LDAPDN **dn,
+       int flags )
+{
+       assert( val );
+       assert( dn );
+
+#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;
+
+       } else if ( val->bv_len > SLAP_LDAPDN_MAXLEN ) {
+               return LDAP_INVALID_SYNTAX;
+
+       } else {
+               int             rc;
+
+               /* FIXME: should be liberal in what we accept */
+               rc = ldap_bv2dn( val, dn, LDAP_DN_FORMAT_LDAP );
+               if ( rc != LDAP_SUCCESS ) {
+                       return LDAP_INVALID_SYNTAX;
+               }
+
+               assert( strlen( val->bv_val ) == val->bv_len );
+
+               /*
+                * Schema-aware rewrite
+                */
+               if ( LDAPDN_rewrite( *dn, flags ) != LDAP_SUCCESS ) {
+                       ldap_dnfree( *dn );
+                       *dn = NULL;
+                       return LDAP_INVALID_SYNTAX;
+               }
+       }
+
+       Debug( LDAP_DEBUG_TRACE, "<<< dn%sDN\n", 
+                       flags == SLAP_LDAPDN_PRETTY ? "Pretty" : "Normal",
+                       0, 0 );
+
+       return LDAP_SUCCESS;
+}
+
 /*
  * Combination of both dnPretty and dnNormalize
  */
@@ -561,7 +634,8 @@ dnPrettyNormal(
                        return LDAP_INVALID_SYNTAX;
                }
 
-               rc = ldap_dn2bv( dn, normal, LDAP_DN_FORMAT_LDAPV3 );
+               rc = ldap_dn2bv( dn, normal,
+                       LDAP_DN_FORMAT_LDAPV3 | LDAP_DN_PRETTY );
 
                ldap_dnfree( dn );
                if ( rc != LDAP_SUCCESS ) {
@@ -674,7 +748,8 @@ dnExtractRdn(
                return rc;
        }
 
-       rc = ldap_rdn2bv( tmpRDN, rdn, LDAP_DN_FORMAT_LDAPV3 );
+       rc = ldap_rdn2bv( tmpRDN, rdn, LDAP_DN_FORMAT_LDAPV3 | LDAP_DN_PRETTY );
+
        ldap_rdnfree( tmpRDN );
        if ( rc != LDAP_SUCCESS ) {
                return rc;