/* dn.c - routines for dealing with distinguished names */
/* $OpenLDAP$ */
/*
- * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.
+ * Copyright 1998-2002 The OpenLDAP Foundation, All Rights Reserved.
* COPYING RESTRICTIONS APPLY, see COPYRIGHT file
*/
assert( dn );
- for ( iRDN = 0; dn[ iRDN ]; iRDN++ ) {
- LDAPRDN *rdn = dn[ iRDN ][ 0 ];
+ for ( iRDN = 0; dn[ 0 ][ iRDN ]; iRDN++ ) {
+ LDAPRDN *rdn = dn[ 0 ][ iRDN ];
int iAVA;
assert( rdn );
- for ( iAVA = 0; rdn[ iAVA ]; iAVA++ ) {
- LDAPAVA *ava = rdn[ iAVA ][ 0 ];
+ for ( iAVA = 0; rdn[ 0 ][ iAVA ]; iAVA++ ) {
+ LDAPAVA *ava = rdn[ 0 ][ iAVA ];
AttributeDescription *ad;
slap_syntax_validate_func *validate = NULL;
if ( ( ad = AVA_PRIVATE( ava ) ) == NULL ) {
const char *text = NULL;
- rc = slap_bv2ad( ava->la_attr, &ad, &text );
+ rc = slap_bv2ad( &ava->la_attr, &ad, &text );
if ( rc != LDAP_SUCCESS ) {
return LDAP_INVALID_SYNTAX;
}
/*
* Replace attr oid/name with the canonical name
*/
- ber_bvfree( ava->la_attr );
- ava->la_attr = ber_bvdup( &ad->ad_cname );
+ ava->la_attr = ad->ad_cname;
validate = ad->ad_type->sat_syntax->ssyn_validate;
* validate value by validate function
*/
rc = ( *validate )( ad->ad_type->sat_syntax,
- ava->la_value );
+ &ava->la_value );
if ( rc != LDAP_SUCCESS ) {
return LDAP_INVALID_SYNTAX;
*/
if ( rc == LDAP_SUCCESS ) {
rc = LDAPDN_validate( dn );
+ ldap_dnfree( dn );
}
- ldap_dnfree( dn );
-
if ( rc != LDAP_SUCCESS ) {
return( LDAP_INVALID_SYNTAX );
}
AVA_Sort( LDAPRDN *rdn, int iAVA )
{
int i;
- LDAPAVA *ava_in = rdn[ iAVA ][ 0 ];
+ LDAPAVA *ava_in = rdn[ 0 ][ iAVA ];
assert( rdn );
assert( ava_in );
for ( i = 0; i < iAVA; i++ ) {
- LDAPAVA *ava = rdn[ i ][ 0 ];
+ LDAPAVA *ava = rdn[ 0 ][ i ];
int a, j;
assert( ava );
- a = strcmp( ava_in->la_attr->bv_val, ava->la_attr->bv_val );
+ a = strcmp( ava_in->la_attr.bv_val, ava->la_attr.bv_val );
if ( a > 0 ) {
break;
while ( a == 0 ) {
int v, d;
- d = ava_in->la_value->bv_len - ava->la_value->bv_len;
+ d = ava_in->la_value.bv_len - ava->la_value.bv_len;
- 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 );
+ 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 );
if ( v == 0 && d != 0 ) {
v = d;
return;
}
- ava = rdn[ i ][ 0 ];
- a = strcmp( ava_in->la_value->bv_val,
- ava->la_value->bv_val );
+ ava = rdn[ 0 ][ i ];
+ a = strcmp( ava_in->la_value.bv_val,
+ ava->la_value.bv_val );
}
/*
* move ahead
*/
for ( j = iAVA; j > i; j-- ) {
- rdn[ j ][ 0 ] = rdn[ j - 1 ][ 0 ];
+ rdn[ 0 ][ j ] = rdn[ 0 ][ j - 1 ];
}
- rdn[ i ][ 0 ] = ava_in;
+ rdn[ 0 ][ i ] = ava_in;
return;
}
assert( dn );
- for ( iRDN = 0; dn[ iRDN ]; iRDN++ ) {
- LDAPRDN *rdn = dn[ iRDN ][ 0 ];
+ for ( iRDN = 0; dn[ 0 ][ iRDN ]; iRDN++ ) {
+ LDAPRDN *rdn = dn[ 0 ][ iRDN ];
int iAVA;
assert( rdn );
- for ( iAVA = 0; rdn[ iAVA ]; iAVA++ ) {
- LDAPAVA *ava = rdn[ iAVA ][ 0 ];
+ for ( iAVA = 0; rdn[ 0 ][ iAVA ]; iAVA++ ) {
+ LDAPAVA *ava = rdn[ 0 ][ iAVA ];
AttributeDescription *ad;
slap_syntax_transform_func *transf = NULL;
MatchingRule *mr;
- struct berval *bv = NULL;
+ struct berval bv = { 0, NULL };
+ int do_sort = 0;
assert( ava );
if ( ( ad = AVA_PRIVATE( ava ) ) == NULL ) {
const char *text = NULL;
- rc = slap_bv2ad( ava->la_attr, &ad, &text );
+ 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
*/
- ber_bvfree( ava->la_attr );
- ava->la_attr = ber_bvdup( &ad->ad_cname );
+ ava->la_attr = ad->ad_cname;
if( flags & SLAP_LDAPDN_PRETTY ) {
transf = ad->ad_type->sat_syntax->ssyn_pretty;
* transform value by normalize/pretty function
*/
rc = ( *transf )( ad->ad_type->sat_syntax,
- ava->la_value, &bv );
+ &ava->la_value, &bv );
if ( rc != LDAP_SUCCESS ) {
return LDAP_INVALID_SYNTAX;
}
if( mr && ( mr->smr_usage & SLAP_MR_DN_FOLD ) ) {
- struct berval *s = bv;
+ char *s = bv.bv_val;
- bv = ber_bvstr( UTF8normalize( bv ? bv : ava->la_value,
- UTF8_CASEFOLD ) );
-
- ber_bvfree( s );
+ ber_str2bv( UTF8normalize( bv.bv_val ? &bv
+ : &ava->la_value, LDAP_UTF8_CASEFOLD ),
+ 0, 0, &bv );
+ free( s );
}
- if( bv ) {
- ber_bvfree( ava->la_value );
+ if( bv.bv_val ) {
+ free( ava->la_value.bv_val );
ava->la_value = bv;
}
- AVA_Sort( rdn, iAVA );
+ if( do_sort ) AVA_Sort( rdn, iAVA );
}
}
struct berval *val,
struct berval **normalized )
{
- struct berval *out = NULL;
-
- Debug( LDAP_DEBUG_TRACE, ">>> dnNormalize: <%s>\n", val->bv_val, 0, 0 );
+ 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 )
+{
assert( val );
- assert( normalized );
+ assert( out );
- assert( *normalized == NULL );
+ Debug( LDAP_DEBUG_TRACE, ">>> dnNormalize: <%s>\n", val->bv_val, 0, 0 );
if ( val->bv_len != 0 ) {
LDAPDN *dn = NULL;
- char *dn_out = NULL;
int rc;
/*
/*
* Back to string representation
*/
- rc = ldap_dn2str( dn, &dn_out, LDAP_DN_FORMAT_LDAPV3 );
+ rc = ldap_dn2bv( dn, out, LDAP_DN_FORMAT_LDAPV3 );
ldap_dnfree( dn );
if ( rc != LDAP_SUCCESS ) {
return LDAP_INVALID_SYNTAX;
}
-
- out = ber_bvstr( dn_out );
-
} else {
- out = ber_bvdup( val );
+ ber_dupbv( out, val );
}
Debug( LDAP_DEBUG_TRACE, "<<< dnNormalize: <%s>\n", out->bv_val, 0, 0 );
- *normalized = out;
return LDAP_SUCCESS;
}
struct berval *val,
struct berval **pretty)
{
- struct berval *out = NULL;
-
- Debug( LDAP_DEBUG_TRACE, ">>> dnPretty: <%s>\n", val->bv_val, 0, 0 );
+ 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)
+{
assert( val );
- assert( pretty );
- assert( *pretty == NULL );
+ assert( out );
+
+ Debug( LDAP_DEBUG_TRACE, ">>> dnPretty: <%s>\n", val->bv_val, 0, 0 );
if ( val->bv_len != 0 ) {
LDAPDN *dn = NULL;
- char *dn_out = NULL;
int rc;
/* FIXME: should be liberal in what we accept */
/* RE: the default is the form that is used as
* an internal representation; the pretty form
* is a variant */
- rc = ldap_dn2str( dn, &dn_out,
+ rc = ldap_dn2bv( dn, out,
LDAP_DN_FORMAT_LDAPV3 | LDAP_DN_PRETTY );
ldap_dnfree( dn );
if ( rc != LDAP_SUCCESS ) {
return LDAP_INVALID_SYNTAX;
}
-
- out = ber_bvstr( dn_out );
-
} else {
- out = ber_bvdup( val );
+ ber_dupbv( out, val );
}
Debug( LDAP_DEBUG_TRACE, "<<< dnPretty: <%s>\n", out->bv_val, 0, 0 );
- *pretty = out;
+ return LDAP_SUCCESS;
+}
+
+/*
+ * Combination of both dnPretty and dnNormalize
+ */
+int
+dnPrettyNormal(
+ Syntax *syntax,
+ struct berval *val,
+ struct berval *pretty,
+ struct berval *normal)
+{
+ Debug( LDAP_DEBUG_TRACE, ">>> dnPrettyNormal: <%s>\n", val->bv_val, 0, 0 );
+
+ assert( val );
+ assert( pretty );
+ assert( normal );
+
+ if ( val->bv_len != 0 ) {
+ LDAPDN *dn = NULL;
+ int rc;
+
+ pretty->bv_val = NULL;
+ normal->bv_val = NULL;
+ pretty->bv_len = 0;
+ normal->bv_len = 0;
+
+ /* FIXME: should be liberal in what we accept */
+ rc = ldap_str2dn( val->bv_val, &dn, LDAP_DN_FORMAT_LDAP );
+ if ( rc != LDAP_SUCCESS ) {
+ return LDAP_INVALID_SYNTAX;
+ }
+
+ /*
+ * Schema-aware rewrite
+ */
+ if ( LDAPDN_rewrite( dn, SLAP_LDAPDN_PRETTY ) != LDAP_SUCCESS ) {
+ ldap_dnfree( dn );
+ return LDAP_INVALID_SYNTAX;
+ }
+
+ rc = ldap_dn2bv( dn, pretty,
+ LDAP_DN_FORMAT_LDAPV3 | LDAP_DN_PRETTY );
+
+ if ( rc != LDAP_SUCCESS ) {
+ ldap_dnfree( dn );
+ return LDAP_INVALID_SYNTAX;
+ }
+
+ if ( LDAPDN_rewrite( dn, 0 ) != LDAP_SUCCESS ) {
+ ldap_dnfree( dn );
+ free( pretty->bv_val );
+ pretty->bv_val = NULL;
+ pretty->bv_len = 0;
+ return LDAP_INVALID_SYNTAX;
+ }
+
+ rc = ldap_dn2bv( dn, normal, LDAP_DN_FORMAT_LDAPV3 );
+
+ ldap_dnfree( dn );
+ if ( rc != LDAP_SUCCESS ) {
+ free( pretty->bv_val );
+ pretty->bv_val = NULL;
+ pretty->bv_len = 0;
+ return LDAP_INVALID_SYNTAX;
+ }
+ } else {
+ ber_dupbv( pretty, val );
+ ber_dupbv( normal, val );
+ }
+
+ Debug( LDAP_DEBUG_TRACE, "<<< dnPrettyNormal: <%s>, <%s>\n",
+ pretty->bv_val, normal->bv_val, 0 );
return LDAP_SUCCESS;
}
const char *dn,
const char **pdn )
{
- LDAPRDN *tmpRDN;
const char *p;
int rc;
- rc = ldap_str2rdn( dn, &tmpRDN, &p, LDAP_DN_FORMAT_LDAP );
+ rc = ldap_str2rdn( dn, NULL, (char **)&p,
+ LDAP_DN_FORMAT_LDAP | LDAP_DN_SKIP );
if ( rc != LDAP_SUCCESS ) {
return rc;
}
- ldap_rdnfree( tmpRDN );
+
+ /* Parent is root */
+ if (*p == '\0') {
+ *pdn = "";
+ return LDAP_SUCCESS;
+ }
assert( DN_SEPARATOR( p[ 0 ] ) );
p++;
int
dnExtractRdn(
- const char *dn,
- struct berval **rdn )
+ struct berval *dn,
+ struct berval *rdn )
{
LDAPRDN *tmpRDN;
const char *p;
- char *rdnout;
int rc;
assert( dn );
assert( rdn );
- rc = ldap_str2rdn( dn, &tmpRDN, &p, LDAP_DN_FORMAT_LDAP );
+ if( dn->bv_len == 0 ) {
+ return LDAP_OTHER;
+ }
+
+ rc = ldap_str2rdn( dn->bv_val, &tmpRDN, (char **)&p, LDAP_DN_FORMAT_LDAP );
if ( rc != LDAP_SUCCESS ) {
return rc;
}
- rc = ldap_rdn2str( tmpRDN, &rdnout, LDAP_DN_FORMAT_LDAPV3 );
+ rc = ldap_rdn2bv( tmpRDN, rdn, LDAP_DN_FORMAT_LDAPV3 );
ldap_rdnfree( tmpRDN );
if ( rc != LDAP_SUCCESS ) {
return rc;
}
- *rdn = ber_bvstr( rdnout );
- if ( *rdn == NULL ) {
- free( rdnout );
- return LDAP_NO_MEMORY;
- }
-
return LDAP_SUCCESS;
}
int
dn_rdnlen(
Backend *be,
- const char *dn_in )
+ struct berval *dn_in )
{
- struct berval *rdn = NULL;
- int retval = 0;
+ int rc;
+ const char *p;
assert( dn_in );
return 0;
}
- while ( dn_in[ 0 ] && ASCII_SPACE( dn_in[ 0 ] ) ) {
- dn_in++;
- }
-
- if ( dn_in[ 0 ] == '\0' ) {
+ if ( !dn_in->bv_len ) {
return 0;
}
- if ( be != NULL && be_issuffix( be, dn_in ) ) {
+ if ( be != NULL && be_issuffix( be, dn_in->bv_val ) ) {
return 0;
}
- if ( dnExtractRdn( dn_in, &rdn ) != LDAP_SUCCESS ) {
- ber_bvfree( rdn );
+ rc = ldap_str2rdn( dn_in->bv_val, NULL, (char **)&p,
+ LDAP_DN_FORMAT_LDAP | LDAP_DN_SKIP );
+ if ( rc != LDAP_SUCCESS ) {
return 0;
}
- retval = rdn->bv_len;
- ber_bvfree( rdn );
-
- return retval;
+ return p - dn_in->bv_val;
}
/*
*/
char * dn_rdn(
Backend *be,
- const char *dn_in )
+ struct berval *dn_in )
{
- struct berval *rdn = NULL;
- char *retval;
+ struct berval rdn;
assert( dn_in );
return NULL;
}
- while ( dn_in[ 0 ] && ASCII_SPACE( dn_in[ 0 ] ) ) {
- dn_in++;
- }
-
- if ( dn_in[ 0 ] == '\0' ) {
+ if ( !dn_in->bv_len ) {
return NULL;
}
- if ( be != NULL && be_issuffix( be, dn_in ) ) {
+ if ( be != NULL && be_issuffix( be, dn_in->bv_val ) ) {
return NULL;
}
if ( dnExtractRdn( dn_in, &rdn ) != LDAP_SUCCESS ) {
- ber_bvfree( rdn );
return NULL;
}
- retval = rdn->bv_val;
- free( rdn );
-
- return retval;
+ return rdn.bv_val;
}
/*
char * rdn_attr_type( const char * s )
{
- char **attrs, **values, *retval;
+ char **attrs = NULL, **values = NULL, *retval;
if ( rdn_attrs( s, &attrs, &values ) != LDAP_SUCCESS ) {
return NULL;
char *
rdn_attr_value( const char * rdn )
{
- char **attrs, **values, *retval;
+ char **values = NULL, *retval;
- if ( rdn_attrs( rdn, &attrs, &values ) != LDAP_SUCCESS ) {
+ if ( rdn_attrs( rdn, NULL, &values ) != LDAP_SUCCESS ) {
return NULL;
}
retval = ch_strdup( values[ 0 ] );
- charray_free( attrs );
charray_free( values );
return retval;
int rc;
assert( rdn );
- assert( types );
assert( values );
+ assert( *values == NULL );
+ assert( types == NULL || *types == NULL );
- rc = ldap_str2rdn( rdn, &tmpRDN, &p, LDAP_DN_FORMAT_LDAP );
+ rc = ldap_str2rdn( rdn, &tmpRDN, (char **)&p, LDAP_DN_FORMAT_LDAP );
if ( rc != LDAP_SUCCESS ) {
return rc;
}
- for ( iAVA = 0; tmpRDN[ iAVA ]; iAVA++ ) {
- LDAPAVA *ava = tmpRDN[ iAVA ][ 0 ];
+#if 0
+ /*
+ * FIXME: should we complain if the rdn is actually a dn?
+ */
+ if ( p[ 0 ] != '\0' ) {
+ ldap_rdnfree( tmpRDN );
+ return LDAP_INVALID_DN_SYNTAX;
+ }
+#endif
+
+ for ( iAVA = 0; tmpRDN[ 0 ][ iAVA ]; iAVA++ ) {
+ LDAPAVA *ava = tmpRDN[ 0 ][ iAVA ];
assert( ava );
- assert( ava->la_attr );
- assert( ava->la_value );
+ assert( ava->la_attr.bv_val );
+ assert( ava->la_value.bv_val );
- charray_add_n( types, ava->la_attr->bv_val,
- ava->la_attr->bv_len );
- charray_add_n( values, ava->la_value->bv_val,
- ava->la_value->bv_len );
+ if ( types ) {
+ charray_add_n( types, ava->la_attr.bv_val,
+ ava->la_attr.bv_len );
+ }
+ charray_add_n( values, ava->la_value.bv_val,
+ ava->la_value.bv_len );
}
ldap_rdnfree( tmpRDN );
/*
* must be parsable
*/
- rc = ldap_str2rdn( rdn, &RDN, &p, LDAP_DN_FORMAT_LDAP );
+ rc = ldap_str2rdn( rdn, &RDN, (char **)&p, LDAP_DN_FORMAT_LDAP );
if ( rc != LDAP_SUCCESS ) {
return 0;
}
projects / openldap / blobdiff