unifdef -DLDAP_NULL_IS_NULL

[openldap] / servers / slapd / dn.c

diff --git a/servers/slapd/dn.c b/servers/slapd/dn.c
index 2e6379a2ee25e6d86c419d932a54ce894c8e1bf5..c6be5e99cb61d94df591ff3c238579cf4913893d 100644 (file)
--- a/servers/slapd/dn.c
+++ b/servers/slapd/dn.c
@@ -2,7 +2,7 @@
 /* $OpenLDAP$ */
 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
  *
- * Copyright 1998-2005 The OpenLDAP Foundation.
+ * Copyright 1998-2006 The OpenLDAP Foundation.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -59,21 +59,26 @@ LDAPRDN_validate( LDAPRDN rdn )
        int             iAVA;
        int             rc;
 
-       assert( rdn );
+       assert( rdn != NULL );
 
        for ( iAVA = 0; rdn[ iAVA ]; iAVA++ ) {
                LDAPAVA                 *ava = rdn[ iAVA ];
                AttributeDescription    *ad;
                slap_syntax_validate_func *validate = NULL;
 
-               assert( ava );
+               assert( ava != NULL );
                
                if ( ( ad = AVA_PRIVATE( ava ) ) == NULL ) {
                        const char      *text = NULL;
 
                        rc = slap_bv2ad( &ava->la_attr, &ad, &text );
                        if ( rc != LDAP_SUCCESS ) {
-                               return LDAP_INVALID_SYNTAX;
+                               rc = slap_bv2undef_ad( &ava->la_attr,
+                                       &ad, &text,
+                                       SLAP_AD_PROXIED|SLAP_AD_NOINSERT );
+                               if ( rc != LDAP_SUCCESS ) {
+                                       return LDAP_INVALID_SYNTAX;
+                               }
                        }
 
                        ava->la_private = ( void * )ad;
@@ -112,27 +117,32 @@ LDAPDN_validate( LDAPDN dn )
        int             iRDN;
        int             rc;
 
-       assert( dn );
+       assert( dn != NULL );
 
        for ( iRDN = 0; dn[ iRDN ]; iRDN++ ) {
                LDAPRDN         rdn = dn[ iRDN ];
                int             iAVA;
 
-               assert( rdn );
+               assert( rdn != NULL );
 
                for ( iAVA = 0; rdn[ iAVA ]; iAVA++ ) {
                        LDAPAVA                 *ava = rdn[ iAVA ];
                        AttributeDescription    *ad;
                        slap_syntax_validate_func *validate = NULL;
 
-                       assert( ava );
+                       assert( ava != NULL );
                        
                        if ( ( ad = AVA_PRIVATE( ava ) ) == NULL ) {
                                const char      *text = NULL;
 
                                rc = slap_bv2ad( &ava->la_attr, &ad, &text );
                                if ( rc != LDAP_SUCCESS ) {
-                                       return LDAP_INVALID_SYNTAX;
+                                       rc = slap_bv2undef_ad( &ava->la_attr,
+                                               &ad, &text,
+                                               SLAP_AD_PROXIED|SLAP_AD_NOINSERT );
+                                       if ( rc != LDAP_SUCCESS ) {
+                                               return LDAP_INVALID_SYNTAX;
+                                       }
                                }
 
                                ava->la_private = ( void * )ad;
@@ -173,7 +183,7 @@ dnValidate(
        int             rc;
        LDAPDN          dn = NULL;
 
-       assert( in );
+       assert( in != NULL );
 
        if ( in->bv_len == 0 ) {
                return LDAP_SUCCESS;
@@ -211,7 +221,7 @@ rdnValidate(
        LDAPRDN         rdn;
        char*           p;
 
-       assert( in );
+       assert( in != NULL );
        if ( in->bv_len == 0 ) {
                return LDAP_SUCCESS;
 
@@ -261,14 +271,14 @@ AVA_Sort( LDAPRDN rdn, int iAVA )
        int             i;
        LDAPAVA         *ava_in = rdn[ iAVA ];
 
-       assert( rdn );
-       assert( ava_in );
+       assert( rdn != NULL );
+       assert( ava_in != NULL );
        
        for ( i = 0; i < iAVA; i++ ) {
                LDAPAVA         *ava = rdn[ i ];
                int             a, j;
 
-               assert( ava );
+               assert( ava != NULL );
 
                a = strcmp( ava_in->la_attr.bv_val, ava->la_attr.bv_val );
 
@@ -337,14 +347,19 @@ LDAPRDN_rewrite( LDAPRDN rdn, unsigned flags, void *ctx )
                struct berval           bv = BER_BVNULL;
                int                     do_sort = 0;
 
-               assert( ava );
+               assert( ava != NULL );
 
                if ( ( ad = AVA_PRIVATE( ava ) ) == NULL ) {
                        const char      *text = NULL;
 
                        rc = slap_bv2ad( &ava->la_attr, &ad, &text );
                        if ( rc != LDAP_SUCCESS ) {
-                               return LDAP_INVALID_SYNTAX;
+                               rc = slap_bv2undef_ad( &ava->la_attr,
+                                       &ad, &text,
+                                       SLAP_AD_PROXIED|SLAP_AD_NOINSERT );
+                               if ( rc != LDAP_SUCCESS ) {
+                                       return LDAP_INVALID_SYNTAX;
+                               }
                        }
                        
                        ava->la_private = ( void * )ad;
@@ -371,7 +386,9 @@ LDAPRDN_rewrite( LDAPRDN rdn, unsigned flags, void *ctx )
                } else { /* normalization */
                        validf = ad->ad_type->sat_syntax->ssyn_validate;
                        mr = ad->ad_type->sat_equality;
-                       if( mr ) normf = mr->smr_normalize;
+                       if( mr && (!( mr->smr_usage & SLAP_MR_MUTATION_NORMALIZER ))) {
+                               normf = mr->smr_normalize;
+                       }
                }
 
                if ( validf ) {
@@ -444,13 +461,13 @@ LDAPDN_rewrite( LDAPDN dn, unsigned flags, void *ctx )
        int             iRDN;
        int             rc;
 
-       assert( dn );
+       assert( dn != NULL );
 
        for ( iRDN = 0; dn[ iRDN ]; iRDN++ ) {
                LDAPRDN         rdn = dn[ iRDN ];
                int             iAVA;
 
-               assert( rdn );
+               assert( rdn != NULL );
 
                for ( iAVA = 0; rdn[ iAVA ]; iAVA++ ) {
                        LDAPAVA                 *ava = rdn[ iAVA ];
@@ -462,14 +479,19 @@ LDAPDN_rewrite( LDAPDN dn, unsigned flags, void *ctx )
                        struct berval           bv = BER_BVNULL;
                        int                     do_sort = 0;
 
-                       assert( ava );
+                       assert( ava != NULL );
 
                        if ( ( ad = AVA_PRIVATE( ava ) ) == NULL ) {
                                const char      *text = NULL;
 
                                rc = slap_bv2ad( &ava->la_attr, &ad, &text );
                                if ( rc != LDAP_SUCCESS ) {
-                                       return LDAP_INVALID_SYNTAX;
+                                       rc = slap_bv2undef_ad( &ava->la_attr,
+                                               &ad, &text,
+                                               SLAP_AD_PROXIED|SLAP_AD_NOINSERT );
+                                       if ( rc != LDAP_SUCCESS ) {
+                                               return LDAP_INVALID_SYNTAX;
+                                       }
                                }
                                
                                ava->la_private = ( void * )ad;
@@ -496,7 +518,9 @@ LDAPDN_rewrite( LDAPDN dn, unsigned flags, void *ctx )
                        } else { /* normalization */
                                validf = ad->ad_type->sat_syntax->ssyn_validate;
                                mr = ad->ad_type->sat_equality;
-                               if( mr ) normf = mr->smr_normalize;
+                               if( mr && (!( mr->smr_usage & SLAP_MR_MUTATION_NORMALIZER ))) {
+                                       normf = mr->smr_normalize;
+                               }
                        }
 
                        if ( validf ) {
@@ -570,8 +594,8 @@ dnNormalize(
     struct berval *out,
     void *ctx)
 {
-       assert( val );
-       assert( out );
+       assert( val != NULL );
+       assert( out != NULL );
 
        Debug( LDAP_DEBUG_TRACE, ">>> dnNormalize: <%s>\n", val->bv_val, 0, 0 );
 
@@ -626,8 +650,8 @@ rdnNormalize(
     struct berval *out,
     void *ctx)
 {
-       assert( val );
-       assert( out );
+       assert( val != NULL );
+       assert( out != NULL );
 
        Debug( LDAP_DEBUG_TRACE, ">>> dnNormalize: <%s>\n", val->bv_val, 0, 0 );
        if ( val->bv_len != 0 ) {
@@ -682,8 +706,8 @@ dnPretty(
        struct berval *out,
        void *ctx)
 {
-       assert( val );
-       assert( out );
+       assert( val != NULL );
+       assert( out != NULL );
 
        Debug( LDAP_DEBUG_TRACE, ">>> dnPretty: <%s>\n", val->bv_val, 0, 0 );
 
@@ -739,8 +763,8 @@ rdnPretty(
        struct berval *out,
        void *ctx)
 {
-       assert( val );
-       assert( out );
+       assert( val != NULL );
+       assert( out != NULL );
 
        Debug( LDAP_DEBUG_TRACE, ">>> dnPretty: <%s>\n", val->bv_val, 0, 0 );
 
@@ -800,8 +824,8 @@ dnPrettyNormalDN(
        int flags,
        void *ctx )
 {
-       assert( val );
-       assert( dn );
+       assert( val != NULL );
+       assert( dn != NULL );
 
        Debug( LDAP_DEBUG_TRACE, ">>> dn%sDN: <%s>\n", 
                        flags == SLAP_LDAPDN_PRETTY ? "Pretty" : "Normal", 
@@ -854,9 +878,9 @@ dnPrettyNormal(
 {
        Debug( LDAP_DEBUG_TRACE, ">>> dnPrettyNormal: <%s>\n", val->bv_val, 0, 0 );
 
-       assert( val );
-       assert( pretty );
-       assert( normal );
+       assert( val != NULL );
+       assert( pretty != NULL );
+       assert( normal != NULL );
 
        if ( val->bv_len == 0 ) {
                ber_dupbv_x( pretty, val, ctx );
@@ -940,9 +964,9 @@ dnMatch(
        int match;
        struct berval *asserted = (struct berval *) assertedValue;
 
-       assert( matchp );
-       assert( value );
-       assert( assertedValue );
+       assert( matchp != NULL );
+       assert( value != NULL );
+       assert( assertedValue != NULL );
        assert( !BER_BVISNULL( value ) );
        assert( !BER_BVISNULL( asserted ) );
        
@@ -975,9 +999,9 @@ dnRelativeMatch(
        int match;
        struct berval *asserted = (struct berval *) assertedValue;
 
-       assert( matchp );
-       assert( value );
-       assert( assertedValue );
+       assert( matchp != NULL );
+       assert( value != NULL );
+       assert( assertedValue != NULL );
        assert( !BER_BVISNULL( value ) );
        assert( !BER_BVISNULL( asserted ) );
 
@@ -996,7 +1020,7 @@ dnRelativeMatch(
                                        asserted->bv_val, 
                                        asserted->bv_len );
                        } else {
-                               return 1;
+                               match = 1;
                        }
                }
 
@@ -1022,7 +1046,7 @@ dnRelativeMatch(
                                        asserted->bv_val, 
                                        asserted->bv_len );
                        } else {
-                               return 1;
+                               match = 1;
                        }
                }
 
@@ -1049,7 +1073,7 @@ dnRelativeMatch(
                                        match = dnIsOneLevelRDN( &rdn ) ? 0 : 1;
                                }
                        } else {
-                               return 1;
+                               match = 1;
                        }
                }
 
@@ -1074,9 +1098,9 @@ rdnMatch(
        int match;
        struct berval *asserted = (struct berval *) assertedValue;
 
-       assert( matchp );
-       assert( value );
-       assert( assertedValue );
+       assert( matchp != NULL );
+       assert( value != NULL );
+       assert( assertedValue != NULL );
        
        match = value->bv_len - asserted->bv_len;
 
@@ -1097,6 +1121,10 @@ rdnMatch(
  * dnParent - dn's parent, in-place
  * note: the incoming dn is assumed to be normalized/prettyfied,
  * so that escaped rdn/ava separators are in '\'+hexpair form
+ *
+ * note: "dn" and "pdn" can point to the same berval;
+ * beware that, in this case, the pointer to the original buffer
+ * will get lost.
  */
 void
 dnParent( 
@@ -1105,7 +1133,7 @@ dnParent(
 {
        char    *p;
 
-       p = strchr( dn->bv_val, ',' );
+       p = ber_bvchr( dn, ',' );
 
        /* one-level dn */
        if ( p == NULL ) {
@@ -1137,7 +1165,7 @@ dnRdn(
        char    *p;
 
        *rdn = *dn;
-       p = strchr( dn->bv_val, ',' );
+       p = ber_bvchr( dn, ',' );
 
        /* one-level dn */
        if ( p == NULL ) {
@@ -1161,8 +1189,8 @@ dnExtractRdn(
        const char      *p;
        int             rc;
 
-       assert( dn );
-       assert( rdn );
+       assert( dn != NULL );
+       assert( rdn != NULL );
 
        if( dn->bv_len == 0 ) {
                return LDAP_OTHER;
@@ -1183,14 +1211,14 @@ dnExtractRdn(
 /*
  * We can assume the input is a prettied or normalized DN
  */
-int 
+ber_len_t
 dn_rdnlen(
        Backend         *be,
        struct berval   *dn_in )
 {
        const char      *p;
 
-       assert( dn_in );
+       assert( dn_in != NULL );
 
        if ( dn_in == NULL ) {
                return 0;
@@ -1204,7 +1232,7 @@ dn_rdnlen(
                return 0;
        }
 
-       p = strchr( dn_in->bv_val, ',' );
+       p = ber_bvchr( dn_in, ',' );
 
        return p ? p - dn_in->bv_val : dn_in->bv_len;
 }
@@ -1228,7 +1256,7 @@ rdn_validate( struct berval *rdn )
        {
                return LDAP_INVALID_SYNTAX;
        }
-       return strchr( rdn->bv_val, ',' ) == NULL
+       return ber_bvchr( rdn, ',' ) == NULL
                ? LDAP_SUCCESS : LDAP_INVALID_SYNTAX;
 
 #else
@@ -1315,8 +1343,8 @@ dnIsSuffix(
 {
        int     d = dn->bv_len - suffix->bv_len;
 
-       assert( dn );
-       assert( suffix );
+       assert( dn != NULL );
+       assert( suffix != NULL );
 
        /* empty suffix matches any dn */
        if ( suffix->bv_len == 0 ) {