X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;ds=sidebyside;f=servers%2Fslapd%2Fdn.c;h=3930ea666b18abed239692fbf81ea66b8e231a22;hb=9184d038ead9aeabff5b7c0bb2ed0d1e6bc95c8c;hp=2b76efc5865bf68111fd588939b5a85941e21abe;hpb=152829be87dbff64388e3771807dad467e2d1401;p=openldap diff --git a/servers/slapd/dn.c b/servers/slapd/dn.c index 2b76efc586..3930ea666b 100644 --- a/servers/slapd/dn.c +++ b/servers/slapd/dn.c @@ -20,8 +20,6 @@ #include "lutil.h" -const struct berval slap_empty_bv = { 0, "" }; - /* * The DN syntax-related functions take advantage of the dn representation * handling functions ldap_str2dn/ldap_dn2str. The latter are not schema- @@ -44,21 +42,21 @@ const struct berval slap_empty_bv = { 0, "" }; * 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; @@ -108,7 +106,7 @@ dnValidate( struct berval *in ) { int rc; - LDAPDN *dn = NULL; + LDAPDN dn = NULL; assert( in ); @@ -154,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 ); @@ -202,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 ); } @@ -211,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; } @@ -224,26 +222,24 @@ 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; -#ifdef SLAP_NVALUES slap_mr_normalize_func *normf = NULL; -#endif slap_syntax_transform_func *transf = NULL; MatchingRule *mr = NULL; struct berval bv = { 0, NULL }; @@ -269,6 +265,11 @@ 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 */ } else if( flags & SLAP_LDAPDN_PRETTY ) { transf = ad->ad_type->sat_syntax->ssyn_pretty; @@ -278,11 +279,7 @@ LDAPDN_rewrite( LDAPDN *dn, unsigned flags ) } else { /* normalization */ validf = ad->ad_type->sat_syntax->ssyn_validate; 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 ) { @@ -299,25 +296,20 @@ 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, ava->la_value.bv_len ? &ava->la_value : (struct berval *) &slap_empty_bv, - &bv ); + &bv, ctx ); if ( rc != LDAP_SUCCESS ) { return LDAP_INVALID_SYNTAX; } } -#ifdef SLAP_NVALUES if ( normf ) { /* * normalize value @@ -330,27 +322,16 @@ 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; } } -#else - if( mr && ( mr->smr_usage & SLAP_MR_DN_FOLD ) ) { - char *s = bv.bv_val; - - if ( UTF8bvnormalize( &bv, &bv, - LDAP_UTF8_CASEFOLD ) == NULL ) { - return LDAP_INVALID_SYNTAX; - } - free( s ); - } -#endif if( bv.bv_val ) { - free( ava->la_value.bv_val ); + ber_memfree_x( ava->la_value.bv_val, ctx ); ava->la_value = bv; } @@ -361,34 +342,14 @@ LDAPDN_rewrite( LDAPDN *dn, unsigned flags ) return LDAP_SUCCESS; } -/* - * dn normalize routine - */ int 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, + void *ctx) { assert( val ); assert( out ); @@ -396,13 +357,13 @@ dnNormalize2( 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; } @@ -412,7 +373,7 @@ dnNormalize2( /* * 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; } @@ -420,16 +381,16 @@ dnNormalize2( /* * 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 ); @@ -437,34 +398,12 @@ dnNormalize2( return LDAP_SUCCESS; } -/* - * 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; -} - -int -dnPretty2( - Syntax *syntax, - struct berval *val, - struct berval *out) + struct berval *out, + void *ctx) { assert( val ); assert( out ); @@ -476,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; } @@ -496,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; } @@ -505,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; @@ -524,8 +463,9 @@ int dnPrettyNormalDN( Syntax *syntax, struct berval *val, - LDAPDN **dn, - int flags ) + LDAPDN *dn, + int flags, + void *ctx ) { assert( val ); assert( dn ); @@ -550,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; } @@ -560,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; } @@ -582,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 ); @@ -595,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; @@ -612,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; } @@ -622,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; @@ -739,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; @@ -752,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; }