X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fdn.c;h=b1168901c001dac8fadb72f57778ef1e983be181;hb=9b4bf8a973c8cfea809be9a4b658f785a6b16f2f;hp=82db98532b97bbbd17f9e7cfbc757b18dac3048e;hpb=e14f471a27a04a0ef61778f7ef8d48f34ad6bf22;p=openldap diff --git a/servers/slapd/dn.c b/servers/slapd/dn.c index 82db98532b..b1168901c0 100644 --- 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;