Free IDL_CACHE locks

[openldap] / servers / slapd / attr.c

diff --git a/servers/slapd/attr.c b/servers/slapd/attr.c
index 9239e161f812e6c378608858e8c8f7ec2edcb634..d1023d96231ce053d6176a926cfe5cc7219bba0c 100644 (file)
--- a/servers/slapd/attr.c
+++ b/servers/slapd/attr.c
@@ -1,6 +1,6 @@
 /* $OpenLDAP$ */
 /*
- * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.
+ * Copyright 1998-2003 The OpenLDAP Foundation, All Rights Reserved.
  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
  */
 /* attr.c - routines for dealing with attributes */
@@ -22,15 +22,11 @@
 #include "ldap_pvt.h"
 #include "slap.h"
 
-#ifdef LDAP_DEBUG
-static void at_index_print( void );
-#endif
-
 void
 attr_free( Attribute *a )
 {
-       ad_free( a->a_desc, 1 );
-       ber_bvecfree( a->a_vals );
+       ber_bvarray_free( a->a_vals );
+       if (a->a_nvals != a->a_vals) ber_bvarray_free( a->a_nvals );
        free( a );
 }
 
@@ -56,26 +52,37 @@ Attribute *attr_dup( Attribute *a )
        if( a->a_vals != NULL ) {
                int i;
 
-               for( i=0; a->a_vals[i] != NULL; i++ ) {
+               for( i=0; a->a_vals[i].bv_val != NULL; i++ ) {
                        /* EMPTY */ ;
                }
 
-               tmp->a_vals = ch_malloc((i+1) * sizeof(struct berval*));
-
-               for( i=0; a->a_vals[i] != NULL; i++ ) {
-                       tmp->a_vals[i] = ber_bvdup( a->a_vals[i] );
-
-                       if( tmp->a_vals[i] == NULL ) break;
+               tmp->a_vals = ch_malloc((i+1) * sizeof(struct berval));
+               for( i=0; a->a_vals[i].bv_val != NULL; i++ ) {
+                       ber_dupbv( &tmp->a_vals[i], &a->a_vals[i] );
+                       if( tmp->a_vals[i].bv_val == NULL ) break;
+               }
+               tmp->a_vals[i].bv_val = NULL;
+
+               if( a->a_nvals != a->a_vals ) {
+                       tmp->a_nvals = ch_malloc((i+1) * sizeof(struct berval));
+                       for( i=0; a->a_nvals[i].bv_val != NULL; i++ ) {
+                               ber_dupbv( &tmp->a_nvals[i], &a->a_nvals[i] );
+                               if( tmp->a_nvals[i].bv_val == NULL ) break;
+                       }
+                       tmp->a_nvals[i].bv_val = NULL;
+
+               } else {
+                       tmp->a_nvals = tmp->a_vals;
                }
-
-               tmp->a_vals[i] = NULL;
 
        } else {
                tmp->a_vals = NULL;
+               tmp->a_nvals = NULL;
        }
 
-       tmp->a_desc = ad_dup( a->a_desc );
+       tmp->a_desc = a->a_desc;
        tmp->a_next = NULL;
+       tmp->a_flags = 0;
 
        return tmp;
 }
@@ -103,6 +110,10 @@ Attribute *attrs_dup( Attribute *a )
 /*
  * attr_merge - merge the given type and value with the list of
  * attributes in attrs.
+ *
+ * For SLAP_NVALUES: nvals must be NULL if the attribute has no
+ * normalizer. In this case, a->a_nvals will be set equal to a->a_vals.
+ *
  * returns     0       everything went ok
  *             -1      trouble
  */
@@ -111,25 +122,131 @@ int
 attr_merge(
        Entry           *e,
        AttributeDescription *desc,
-       struct berval   **vals )
-{
+       BerVarray       vals,
+       BerVarray       nvals
+) {
+       int rc;
+
+       Attribute       **a;
+
+       for ( a = &e->e_attrs; *a != NULL; a = &(*a)->a_next ) {
+               if ( ad_cmp( (*a)->a_desc, desc ) == 0 ) {
+                       break;
+               }
+       }
+
+       if ( *a == NULL ) {
+               *a = (Attribute *) ch_malloc( sizeof(Attribute) );
+               (*a)->a_desc = desc;
+               (*a)->a_vals = NULL;
+               (*a)->a_nvals = NULL;
+               (*a)->a_next = NULL;
+               (*a)->a_flags = 0;
+       }
+
+       rc = value_add( &(*a)->a_vals, vals );
+
+       if( !rc && nvals ) rc = value_add( &(*a)->a_nvals, nvals );
+       else (*a)->a_nvals = (*a)->a_vals;
+
+       return rc;
+}
+
+int
+attr_merge_normalize(
+       Entry           *e,
+       AttributeDescription *desc,
+       BerVarray       vals,
+       void     *memctx
+) {
+       BerVarray       nvals = NULL;
+       int             rc;
+
+       if ( desc->ad_type->sat_equality->smr_normalize ) {
+               int     i;
+               
+               for ( i = 0; vals[i].bv_val; i++);
+
+               nvals = ch_calloc( sizeof(struct berval), i + 1 );
+               for ( i = 0; vals[i].bv_val; i++ ) {
+                       rc = (*desc->ad_type->sat_equality->smr_normalize)(
+                                       0,
+                                       desc->ad_type->sat_syntax,
+                                       desc->ad_type->sat_equality,
+                                       &vals[i], &nvals[i], memctx );
+
+                       if ( rc != LDAP_SUCCESS ) {
+                               nvals[i+1].bv_val = NULL;
+                               goto error_return;
+                       }
+               }
+               nvals[i].bv_val = NULL;
+       }
+
+       rc = attr_merge( e, desc, vals, nvals );
+
+error_return:;
+       ber_bvarray_free( nvals );
+       return rc;
+}
+
+int
+attr_merge_one(
+       Entry           *e,
+       AttributeDescription *desc,
+       struct berval   *val,
+       struct berval   *nval
+) {
+       int rc;
        Attribute       **a;
 
        for ( a = &e->e_attrs; *a != NULL; a = &(*a)->a_next ) {
-               if ( ad_cmp( (*a)->a_desc, desc ) == 0 )
-               {
+               if ( ad_cmp( (*a)->a_desc, desc ) == 0 ) {
                        break;
                }
        }
 
        if ( *a == NULL ) {
                *a = (Attribute *) ch_malloc( sizeof(Attribute) );
-               (*a)->a_desc = ad_dup( desc );
+               (*a)->a_desc = desc;
                (*a)->a_vals = NULL;
+               (*a)->a_nvals = NULL;
                (*a)->a_next = NULL;
+               (*a)->a_flags = 0;
+       }
+
+       rc = value_add_one( &(*a)->a_vals, val );
+
+       if( !rc && nval ) rc = value_add_one( &(*a)->a_nvals, nval );
+       else (*a)->a_nvals = (*a)->a_vals;
+       return rc;
+}
+
+int
+attr_merge_normalize_one(
+       Entry           *e,
+       AttributeDescription *desc,
+       struct berval   *val,
+       void            *memctx
+) {
+       struct berval   nval;
+       int             rc;
+
+       if ( desc->ad_type->sat_equality->smr_normalize ) {
+               rc = (*desc->ad_type->sat_equality->smr_normalize)(
+                               0,
+                               desc->ad_type->sat_syntax,
+                               desc->ad_type->sat_equality,
+                               val, &nval, memctx );
+
+               if ( rc != LDAP_SUCCESS ) {
+                       return rc;
+               }
        }
 
-       return( value_add( &(*a)->a_vals, vals ) );
+       rc = attr_merge_one( e, desc, val, &nval );
+       ch_free( nval.bv_val );
+       return rc;
 }
 
 /*
@@ -163,8 +280,7 @@ attr_find(
 )
 {
        for ( ; a != NULL; a = a->a_next ) {
-               if ( ad_cmp( a->a_desc, desc ) == 0 )
-               {
+               if ( ad_cmp( a->a_desc, desc ) == 0 ) {
                        return( a );
                }
        }
@@ -188,8 +304,7 @@ attr_delete(
        Attribute       **a;
 
        for ( a = attrs; *a != NULL; a = &(*a)->a_next ) {
-               if ( ad_cmp( (*a)->a_desc, desc ) == 0 )
-               {
+               if ( ad_cmp( (*a)->a_desc, desc ) == 0 ) {
                        Attribute       *save = *a;
                        *a = (*a)->a_next;
                        attr_free( save );