X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fattr.c;h=4c21b9bfc0332f9d171deac124d2ca337d2cff40;hb=161574b00d68456a0f24d5e364853d923ef5ba8b;hp=d81a0626be4c38ce62d22336bcd925a7c204d74c;hpb=4cfb0be242b4ae2d8a125d19551acab28d451721;p=openldap diff --git a/servers/slapd/attr.c b/servers/slapd/attr.c index d81a0626be..4c21b9bfc0 100644 --- a/servers/slapd/attr.c +++ b/servers/slapd/attr.c @@ -1,4 +1,28 @@ /* attr.c - routines for dealing with attributes */ +/* $OpenLDAP$ */ +/* This work is part of OpenLDAP Software . + * + * Copyright 1998-2006 The OpenLDAP Foundation. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted only as authorized by the OpenLDAP + * Public License. + * + * A copy of this license is available in the file LICENSE in the + * top-level directory of the distribution or, alternatively, at + * . + */ +/* Portions Copyright (c) 1995 Regents of the University of Michigan. + * All rights reserved. + * + * Redistribution and use in source and binary forms are permitted + * provided that this notice is preserved and that due credit is given + * to the University of Michigan at Ann Arbor. The name of the University + * may not be used to endorse or promote products derived from this + * software without specific prior written permission. This software + * is provided ``as is'' without express or implied warranty. + */ #include "portable.h" @@ -14,648 +38,514 @@ #include #include -#ifdef HAVE_SYS_PARAM_H -#include -#endif - -#include "ldapconfig.h" #include "slap.h" -#ifdef LDAP_DEBUG -static void at_index_print( void ); -#endif - -void -attr_free( Attribute *a ) -{ - free( a->a_type ); - ber_bvecfree( a->a_vals ); - free( a ); -} - /* - * attr_normalize - normalize an attribute name (make it all lowercase) + * Allocate in chunks, minimum of 1000 at a time. */ +#define CHUNK_SIZE 1000 +typedef struct slap_list { + struct slap_list *next; +} slap_list; +static slap_list *attr_chunks; +static Attribute *attr_list; +static ldap_pvt_thread_mutex_t attr_mutex; -char * -attr_normalize( char *s ) +int +attr_prealloc( int num ) { - char *save; + Attribute *a; + slap_list *s; - assert( s != NULL ); + if (!num) return 0; - for ( save = s; *s; s++ ) { - *s = TOLOWER( (unsigned char) *s ); + s = ch_calloc( 1, sizeof(slap_list) + num * sizeof(Attribute)); + s->next = attr_chunks; + attr_chunks = s; + + a = (Attribute *)(s+1); + for ( ;num>1; num--) { + a->a_next = a+1; + a++; } + a->a_next = attr_list; + attr_list = (Attribute *)(s+1); - return( save ); + return 0; } -/* - * attr_merge_fast - merge the given type and value with the list of - * attributes in attrs. called from str2entry(), where we can make some - * assumptions to make things faster. - * returns 0 everything went ok - * -1 trouble - */ +Attribute * +attr_alloc( AttributeDescription *ad ) +{ + Attribute *a; + + ldap_pvt_thread_mutex_lock( &attr_mutex ); + if ( !attr_list ) + attr_prealloc( CHUNK_SIZE ); + a = attr_list; + attr_list = a->a_next; + a->a_next = NULL; + ldap_pvt_thread_mutex_unlock( &attr_mutex ); + + a->a_desc = ad; + + return a; +} -int -attr_merge_fast( - Entry *e, - char *type, - struct berval **vals, - int nvals, - int naddvals, - int *maxvals, - Attribute ***a -) +/* Return a list of num attrs */ +Attribute * +attrs_alloc( int num ) { - if ( *a == NULL ) { - for ( *a = &e->e_attrs; **a != NULL; *a = &(**a)->a_next ) { - if ( strcasecmp( (**a)->a_type, type ) == 0 ) { - break; - } + Attribute *head = NULL; + Attribute **a; + + ldap_pvt_thread_mutex_lock( &attr_mutex ); + for ( a = &attr_list; *a && num > 0; a = &(*a)->a_next ) { + if ( !head ) + head = *a; + num--; + } + attr_list = *a; + if ( num > 0 ) { + attr_prealloc( num > CHUNK_SIZE ? num : CHUNK_SIZE ); + *a = attr_list; + for ( ; *a && num > 0; a = &(*a)->a_next ) { + if ( !head ) + head = *a; + num--; } + attr_list = *a; } + *a = NULL; + ldap_pvt_thread_mutex_unlock( &attr_mutex ); - if ( **a == NULL ) { - **a = (Attribute *) ch_malloc( sizeof(Attribute) ); - (**a)->a_type = attr_normalize( ch_strdup( type ) ); - (**a)->a_vals = NULL; - (**a)->a_syntax = attr_syntax( type ); - (**a)->a_next = NULL; - } - - return( value_add_fast( &(**a)->a_vals, vals, nvals, naddvals, - maxvals ) ); + return head; } -/* - * attr_merge - merge the given type and value with the list of - * attributes in attrs. - * returns 0 everything went ok - * -1 trouble - */ -int -attr_merge( - Entry *e, - char *type, - struct berval **vals -) +void +attr_free( Attribute *a ) { - Attribute **a; - - for ( a = &e->e_attrs; *a != NULL; a = &(*a)->a_next ) { - if ( strcasecmp( (*a)->a_type, type ) == 0 ) { - break; + if ( a->a_nvals && a->a_nvals != a->a_vals && + !( a->a_flags & SLAP_ATTR_DONT_FREE_VALS )) { + if ( a->a_flags & SLAP_ATTR_DONT_FREE_DATA ) { + free( a->a_nvals ); + } else { + ber_bvarray_free( a->a_nvals ); } } - - if ( *a == NULL ) { - *a = (Attribute *) ch_malloc( sizeof(Attribute) ); - (*a)->a_type = attr_normalize( ch_strdup( type ) ); - (*a)->a_vals = NULL; - (*a)->a_syntax = attr_syntax( type ); - (*a)->a_next = NULL; + /* a_vals may be equal to slap_dummy_bv, a static empty berval; + * this is used as a placeholder for attributes that do not carry + * values, e.g. when proxying search entries with the "attrsonly" + * bit set. */ + if ( a->a_vals != &slap_dummy_bv && + !( a->a_flags & SLAP_ATTR_DONT_FREE_VALS )) { + if ( a->a_flags & SLAP_ATTR_DONT_FREE_DATA ) { + free( a->a_vals ); + } else { + ber_bvarray_free( a->a_vals ); + } } - - return( value_add( &(*a)->a_vals, vals ) ); + memset( a, 0, sizeof( Attribute )); + ldap_pvt_thread_mutex_lock( &attr_mutex ); + a->a_next = attr_list; + attr_list = a; + ldap_pvt_thread_mutex_unlock( &attr_mutex ); } -/* - * attr_find - find and return attribute type in list a - */ - -Attribute * -attr_find( - Attribute *a, - char *type -) +#ifdef LDAP_COMP_MATCH +void +comp_tree_free( Attribute *a ) { - for ( ; a != NULL; a = a->a_next ) { - if ( strcasecmp( a->a_type, type ) == 0 ) { - return( a ); + Attribute *next; + + for( ; a != NULL ; a = next ) { + next = a->a_next; + if ( component_destructor && a->a_comp_data ) { + if ( a->a_comp_data->cd_mem_op ) + component_destructor( a->a_comp_data->cd_mem_op ); + free ( a->a_comp_data ); } } - - return( NULL ); } +#endif -/* - * attr_delete - delete the attribute type in list pointed to by attrs - * return 0 deleted ok - * 1 not found in list a - * -1 something bad happened - */ - -int -attr_delete( - Attribute **attrs, - char *type -) +void +attrs_free( Attribute *a ) { - Attribute **a; - Attribute *save; + Attribute *next; - for ( a = attrs; *a != NULL; a = &(*a)->a_next ) { - if ( strcasecmp( (*a)->a_type, type ) == 0 ) { - break; - } + for( ; a != NULL ; a = next ) { + next = a->a_next; + attr_free( a ); } +} - if ( *a == NULL ) { - return( 1 ); - } +Attribute * +attr_dup( Attribute *a ) +{ + Attribute *tmp; - save = *a; - *a = (*a)->a_next; - attr_free( save ); + if ( a == NULL) return NULL; - return( 0 ); -} + tmp = attr_alloc( a->a_desc ); -#define DEFAULT_SYNTAX SYNTAX_CIS + if ( a->a_vals != NULL ) { + int i; -/* - * attr_syntax - return the syntax of attribute type - */ + for ( i = 0; !BER_BVISNULL( &a->a_vals[i] ); i++ ) { + /* EMPTY */ ; + } -int -attr_syntax( char *type ) -{ - AttributeType *sat; + tmp->a_vals = ch_malloc( (i + 1) * sizeof(struct berval) ); + for ( i = 0; !BER_BVISNULL( &a->a_vals[i] ); i++ ) { + ber_dupbv( &tmp->a_vals[i], &a->a_vals[i] ); + if ( BER_BVISNULL( &tmp->a_vals[i] ) ) break; + /* FIXME: error? */ + } + BER_BVZERO( &tmp->a_vals[i] ); - sat = at_find(type); - if ( sat ) { - return( sat->sat_syntax_compat ); - } + /* a_nvals must be non null; it may be equal to a_vals */ + assert( a->a_nvals != NULL ); - return( DEFAULT_SYNTAX ); -} + if ( a->a_nvals != a->a_vals ) { + int j; -/* - * attr_syntax_config - process an attribute syntax config line - */ + tmp->a_nvals = ch_malloc( (i + 1) * sizeof(struct berval) ); + for ( j = 0; !BER_BVISNULL( &a->a_nvals[j] ); j++ ) { + assert( j < i ); + ber_dupbv( &tmp->a_nvals[j], &a->a_nvals[j] ); + if ( BER_BVISNULL( &tmp->a_nvals[j] ) ) break; + /* FIXME: error? */ + } + assert( j == i ); + BER_BVZERO( &tmp->a_nvals[j] ); -void -attr_syntax_config( - char *fname, - int lineno, - int argc, - char **argv -) -{ - char *save; - LDAP_ATTRIBUTE_TYPE *at; - int lasti; - int code; - const char *err; - - if ( argc < 2 ) { - Debug( LDAP_DEBUG_ANY, -"%s: line %d: missing name in \"attribute + \" (ignored)\n", - fname, lineno, 0 ); - return; - } + } else { + tmp->a_nvals = tmp->a_vals; + } - at = (LDAP_ATTRIBUTE_TYPE *) - ch_calloc( 1, sizeof(LDAP_ATTRIBUTE_TYPE) ); - - lasti = argc - 1; - if ( strcasecmp( argv[lasti], "caseignorestring" ) == 0 || - strcasecmp( argv[lasti], "cis" ) == 0 ) { - at->at_syntax_oid = "1.3.6.1.4.1.1466.115.121.1.15"; - at->at_equality_oid = "2.5.13.2"; - } else if ( strcasecmp( argv[lasti], "telephone" ) == 0 || - strcasecmp( argv[lasti], "tel" ) == 0 ) { - at->at_syntax_oid = "1.3.6.1.4.1.1466.115.121.1.50"; - at->at_equality_oid = "2.5.13.20"; - } else if ( strcasecmp( argv[lasti], "dn" ) == 0 ) { - at->at_syntax_oid = "1.3.6.1.4.1.1466.115.121.1.12"; - at->at_equality_oid = "2.5.13.1"; - } else if ( strcasecmp( argv[lasti], "caseexactstring" ) == 0 || - strcasecmp( argv[lasti], "ces" ) == 0 ) { - at->at_syntax_oid = "1.3.6.1.4.1.1466.115.121.1.15"; - /* notice: this is caseExactIA5Match */ - at->at_equality_oid = "1.3.6.1.4.1.1466.109.114.1"; - } else if ( strcasecmp( argv[lasti], "binary" ) == 0 || - strcasecmp( argv[lasti], "bin" ) == 0 ) { - at->at_syntax_oid = "1.3.6.1.4.1.1466.115.121.1.5"; - /* There is no match for binary syntax. Really */ } else { - Debug( LDAP_DEBUG_ANY, - "%s: line %d: unknown syntax \"%s\" in attribute line (ignored)\n", - fname, lineno, argv[lasti] ); - Debug( LDAP_DEBUG_ANY, - "possible syntaxes are \"cis\", \"ces\", \"tel\", \"dn\", or \"bin\"\n", - 0, 0, 0 ); - free( (AttributeType *) at ); - return; + tmp->a_vals = NULL; + tmp->a_nvals = NULL; } - - save = argv[lasti]; - argv[lasti] = NULL; - at->at_names = charray_dup( argv ); - argv[lasti] = save; - - code = at_add( at, &err ); - if ( code ) { - fprintf( stderr, "%s: line %d: %s %s\n", - fname, lineno, scherr2str(code), err); - exit( 1 ); - } - ldap_memfree(at); + return tmp; } -int -at_fake_if_needed( - char *name -) +Attribute * +attrs_dup( Attribute *a ) { - char *argv[3]; + Attribute *tmp, **next; - if ( at_find( name ) ) { - return 0; - } else { - argv[0] = name; - argv[1] = "cis"; - argv[2] = NULL; - attr_syntax_config( "implicit", 0, 2, argv ); - return 0; - } -} + if( a == NULL ) return NULL; -struct aindexrec { - char *air_name; - AttributeType *air_at; -}; + tmp = NULL; + next = &tmp; -static Avlnode *attr_index = NULL; -static AttributeType *attr_list = NULL; - -static int -attr_index_cmp( - struct aindexrec *air1, - struct aindexrec *air2 -) -{ - return (strcasecmp( air1->air_name, air2->air_name )); -} + for( ; a != NULL ; a = a->a_next ) { + *next = attr_dup( a ); + next = &((*next)->a_next); + } + *next = NULL; -static int -attr_index_name_cmp( - char *type, - struct aindexrec *air -) -{ - return (strcasecmp( type, air->air_name )); + return tmp; } -AttributeType * -at_find( - const char *name -) -{ - struct aindexrec *air = NULL; - if ( (air = (struct aindexrec *) avl_find( attr_index, name, - (AVL_CMP) attr_index_name_cmp )) != NULL ) { - return( air->air_at ); - } - return( NULL ); -} +/* + * attr_merge - merge the given type and value with the list of + * attributes in attrs. + * + * 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 + */ int -at_append_to_list( - AttributeType *sat, - AttributeType ***listp -) +attr_merge( + Entry *e, + AttributeDescription *desc, + BerVarray vals, + BerVarray nvals ) { - AttributeType **list; - AttributeType **list1; - int size; - - list = *listp; - if ( !list ) { - size = 2; - list = calloc(size, sizeof(AttributeType *)); - if ( !list ) { - return -1; + int rc; + + Attribute **a; + + for ( a = &e->e_attrs; *a != NULL; a = &(*a)->a_next ) { + if ( (*a)->a_desc == desc ) { + break; } + } + + if ( *a == NULL ) { + *a = attr_alloc( desc ); } else { - size = 0; - list1 = *listp; - while ( *list1 ) { - size++; - list1++; - } - size += 2; - list1 = realloc(list, size*sizeof(AttributeType *)); - if ( !list1 ) { - return -1; + /* + * FIXME: if the attribute already exists, the presence + * of nvals and the value of (*a)->a_nvals must be consistent + */ + assert( ( nvals == NULL && (*a)->a_nvals == (*a)->a_vals ) + || ( nvals != NULL && ( + ( (*a)->a_vals == NULL && (*a)->a_nvals == NULL ) + || ( (*a)->a_nvals != (*a)->a_vals ) ) ) ); + } + + rc = value_add( &(*a)->a_vals, vals ); + + if ( rc == LDAP_SUCCESS ) { + if ( nvals ) { + rc = value_add( &(*a)->a_nvals, nvals ); + /* FIXME: what if rc != LDAP_SUCCESS ? */ + } else { + (*a)->a_nvals = (*a)->a_vals; } - list = list1; } - list[size-2] = sat; - list[size-1] = NULL; - *listp = list; - return 0; + + return rc; } +/* + * if a normalization function is defined for the equality matchingRule + * of desc, the value is normalized and stored in nval; otherwise nval + * is NULL + */ int -at_delete_from_list( - int pos, - AttributeType ***listp -) +attr_normalize( + AttributeDescription *desc, + BerVarray vals, + BerVarray *nvalsp, + void *memctx ) { - AttributeType **list; - AttributeType **list1; - int i; - int j; + int rc = LDAP_SUCCESS; + BerVarray nvals = NULL; - if ( pos < 0 ) { - return -2; - } - list = *listp; - for ( i=0; list[i]; i++ ) - ; - if ( pos >= i ) { - return -2; - } - for ( i=pos, j=pos+1; list[j]; i++, j++ ) { - list[i] = list[j]; + *nvalsp = NULL; + + if ( desc->ad_type->sat_equality && + desc->ad_type->sat_equality->smr_normalize ) + { + int i; + + for ( i = 0; !BER_BVISNULL( &vals[i] ); i++ ); + + nvals = slap_sl_calloc( sizeof(struct berval), i + 1, memctx ); + for ( i = 0; !BER_BVISNULL( &vals[i] ); i++ ) { + rc = desc->ad_type->sat_equality->smr_normalize( + SLAP_MR_VALUE_OF_ATTRIBUTE_SYNTAX, + desc->ad_type->sat_syntax, + desc->ad_type->sat_equality, + &vals[i], &nvals[i], memctx ); + + if ( rc != LDAP_SUCCESS ) { + BER_BVZERO( &nvals[i + 1] ); + break; + } + } + BER_BVZERO( &nvals[i] ); + *nvalsp = nvals; } - list[i] = NULL; - /* Tell the runtime this can be shrinked */ - list1 = realloc(list, (i+1)*sizeof(AttributeType **)); - if ( !list1 ) { - return -1; + +error_return:; + if ( rc != LDAP_SUCCESS && nvals != NULL ) { + ber_bvarray_free_x( nvals, memctx ); } - *listp = list1; - return 0; + + return rc; } int -at_find_in_list( - AttributeType *sat, - AttributeType **list -) +attr_merge_normalize( + Entry *e, + AttributeDescription *desc, + BerVarray vals, + void *memctx ) { - int i; - - if ( !list ) { - return -1; - } - for ( i=0; list[i]; i++ ) { - if ( sat == list[i] ) { - return i; + BerVarray nvals = NULL; + int rc; + + rc = attr_normalize( desc, vals, &nvals, memctx ); + if ( rc == LDAP_SUCCESS ) { + rc = attr_merge( e, desc, vals, nvals ); + if ( nvals != NULL ) { + ber_bvarray_free_x( nvals, memctx ); } } - return -1; + + return rc; } -static int -at_insert( - AttributeType *sat, - const char **err -) +int +attr_merge_one( + Entry *e, + AttributeDescription *desc, + struct berval *val, + struct berval *nval ) { - AttributeType **atp; - struct aindexrec *air; - char **names; + int rc; + Attribute **a; - atp = &attr_list; - while ( *atp != NULL ) { - atp = &(*atp)->sat_next; - } - *atp = sat; - - if ( sat->sat_oid ) { - air = (struct aindexrec *) - ch_calloc( 1, sizeof(struct aindexrec) ); - air->air_name = sat->sat_oid; - air->air_at = sat; - if ( avl_insert( &attr_index, (caddr_t) air, - (AVL_CMP) attr_index_cmp, - (AVL_DUP) avl_dup_error ) ) { - *err = sat->sat_oid; - ldap_memfree(air); - return SLAP_SCHERR_DUP_ATTR; + for ( a = &e->e_attrs; *a != NULL; a = &(*a)->a_next ) { + if ( (*a)->a_desc == desc ) { + break; } - /* FIX: temporal consistency check */ - at_find(air->air_name); } - if ( (names = sat->sat_names) ) { - while ( *names ) { - air = (struct aindexrec *) - ch_calloc( 1, sizeof(struct aindexrec) ); - air->air_name = ch_strdup(*names); - air->air_at = sat; - if ( avl_insert( &attr_index, (caddr_t) air, - (AVL_CMP) attr_index_cmp, - (AVL_DUP) avl_dup_error ) ) { - *err = *names; - ldap_memfree(air); - return SLAP_SCHERR_DUP_ATTR; - } - /* FIX: temporal consistency check */ - at_find(air->air_name); - names++; - } + + if ( *a == NULL ) { + *a = attr_alloc( desc ); } - return 0; -} + rc = value_add_one( &(*a)->a_vals, val ); -int -at_add( - LDAP_ATTRIBUTE_TYPE *at, - const char **err -) -{ - AttributeType *sat; - AttributeType *sat1; - MatchingRule *mr; - Syntax *syn; - int code; - char *errattr; - - if ( at->at_names && at->at_names[0] ) { - errattr = at->at_names[0]; - } else if ( at->at_oid ) { - errattr = at->at_oid; - } else { - errattr = ""; - return SLAP_SCHERR_ATTR_INCOMPLETE; - } - sat = (AttributeType *) ch_calloc( 1, sizeof(AttributeType) ); - memcpy( &sat->sat_atype, at, sizeof(LDAP_ATTRIBUTE_TYPE)); - if ( at->at_sup_oid ) { - if ( (sat1 = at_find(at->at_sup_oid)) ) { - sat->sat_sup = sat1; - if ( at_append_to_list(sat, &sat1->sat_subtypes) ) { - *err = errattr; - return SLAP_SCHERR_OUTOFMEM; - } + if ( rc == LDAP_SUCCESS ) { + if ( nval ) { + rc = value_add_one( &(*a)->a_nvals, nval ); + /* FIXME: what if rc != LDAP_SUCCESS ? */ } else { - *err = at->at_sup_oid; - return SLAP_SCHERR_ATTR_NOT_FOUND; + (*a)->a_nvals = (*a)->a_vals; } } + return rc; +} - if ( at->at_syntax_oid ) { - if ( (syn = syn_find(sat->sat_syntax_oid)) ) { - sat->sat_syntax = syn; - } else { - *err = sat->sat_syntax_oid; - return SLAP_SCHERR_SYN_NOT_FOUND; - } - if ( !strcmp(at->at_syntax_oid, - "1.3.6.1.4.1.1466.115.121.1.15") ) { - if ( at->at_equality_oid && - !strcmp(at->at_equality_oid, - "1.3.6.1.4.1.1466.109.114.1") ) { - sat->sat_syntax_compat = SYNTAX_CES; - } else { - sat->sat_syntax_compat = SYNTAX_CIS; - } - } else if ( !strcmp(at->at_syntax_oid, - "1.3.6.1.4.1.1466.115.121.1.50") ) { - sat->sat_syntax_compat = SYNTAX_CIS | SYNTAX_TEL; - } else if ( !strcmp(at->at_syntax_oid, - "1.3.6.1.4.1.1466.115.121.1.12") ) { - sat->sat_syntax_compat = SYNTAX_CIS | SYNTAX_DN; - } else if ( !strcmp(at->at_syntax_oid, "1.3.6.1.4.1.1466.115.121.1.5") ) { - sat->sat_syntax_compat = SYNTAX_BIN; - } else { - sat->sat_syntax_compat = DEFAULT_SYNTAX; - } - } else { - sat->sat_syntax_compat = DEFAULT_SYNTAX; - } +/* + * if a normalization function is defined for the equality matchingRule + * of desc, the value is normalized and stored in nval; otherwise nval + * is NULL + */ +int +attr_normalize_one( + AttributeDescription *desc, + struct berval *val, + struct berval *nval, + void *memctx ) +{ + int rc = LDAP_SUCCESS; - if ( sat->sat_equality_oid ) { - if ( (mr = mr_find(sat->sat_equality_oid)) ) { - sat->sat_equality = mr; - } else { - *err = sat->sat_equality_oid; - return SLAP_SCHERR_MR_NOT_FOUND; - } - } - if ( sat->sat_ordering_oid ) { - if ( (mr = mr_find(sat->sat_ordering_oid)) ) { - sat->sat_ordering = mr; - } else { - *err = sat->sat_ordering_oid; - return SLAP_SCHERR_MR_NOT_FOUND; - } - } - if ( sat->sat_substr_oid ) { - if ( (mr = mr_find(sat->sat_substr_oid)) ) { - sat->sat_substr = mr; - } else { - *err = sat->sat_substr_oid; - return SLAP_SCHERR_MR_NOT_FOUND; - } - } + BER_BVZERO( nval ); - /* - * Now inherit definitions from superiors. We only check the - * direct superior since that one has already inherited from - * its own superiorss - */ - if ( sat->sat_sup ) { - if ( !sat->sat_syntax ) { - sat->sat_syntax = sat->sat_sup->sat_syntax; - } - if ( !sat->sat_equality ) { - sat->sat_equality = sat->sat_sup->sat_equality; - } - if ( !sat->sat_ordering ) { - sat->sat_ordering = sat->sat_sup->sat_ordering; - } - if ( !sat->sat_substr ) { - sat->sat_substr = sat->sat_sup->sat_substr; + if ( desc->ad_type->sat_equality && + desc->ad_type->sat_equality->smr_normalize ) + { + rc = desc->ad_type->sat_equality->smr_normalize( + SLAP_MR_VALUE_OF_ATTRIBUTE_SYNTAX, + desc->ad_type->sat_syntax, + desc->ad_type->sat_equality, + val, nval, memctx ); + + if ( rc != LDAP_SUCCESS ) { + return rc; } } - code = at_insert(sat,err); - return code; -} + return rc; +} -char * -at_canonical_name( char * a_type ) +int +attr_merge_normalize_one( + Entry *e, + AttributeDescription *desc, + struct berval *val, + void *memctx ) { - AttributeType *atp; + struct berval nval = BER_BVNULL; + struct berval *nvalp = NULL; + int rc; - if ( (atp=at_find(a_type)) == NULL ) { + rc = attr_normalize_one( desc, val, &nval, memctx ); + if ( rc == LDAP_SUCCESS && !BER_BVISNULL( &nval ) ) { + nvalp = &nval; + } - return a_type; + rc = attr_merge_one( e, desc, val, nvalp ); + if ( nvalp != NULL ) { + slap_sl_free( nval.bv_val, memctx ); + } + return rc; +} - } else if ( atp->sat_names - && atp->sat_names[0] - && (*(atp->sat_names[0]) != '\0') ) { - - return atp->sat_names[0]; +/* + * attrs_find - find attribute(s) by AttributeDescription + * returns next attribute which is subtype of provided description. + */ - } else if (atp->sat_oid && (*atp->sat_oid != '\0')) { +Attribute * +attrs_find( + Attribute *a, + AttributeDescription *desc ) +{ + for ( ; a != NULL; a = a->a_next ) { + if ( is_ad_subtype( a->a_desc, desc ) ) { + return( a ); + } + } - return atp->sat_oid; - - } else { + return( NULL ); +} - return a_type; +/* + * attr_find - find attribute by type + */ +Attribute * +attr_find( + Attribute *a, + AttributeDescription *desc ) +{ + for ( ; a != NULL; a = a->a_next ) { + if ( a->a_desc == desc ) { + return( a ); + } } -}/* char * at_canonica_name() */ - + return( NULL ); +} -#if defined( SLAPD_SCHEMA_DN ) +/* + * attr_delete - delete the attribute type in list pointed to by attrs + * return 0 deleted ok + * 1 not found in list a + * -1 something bad happened + */ int -at_schema_info( Entry *e ) +attr_delete( + Attribute **attrs, + AttributeDescription *desc ) { - struct berval val; - struct berval *vals[2]; - AttributeType *at; - - vals[0] = &val; - vals[1] = NULL; - - for ( at = attr_list; at; at = at->sat_next ) { - val.bv_val = ldap_attributetype2str( &at->sat_atype ); - if ( val.bv_val ) { - val.bv_len = strlen( val.bv_val ); - Debug( LDAP_DEBUG_TRACE, "Merging at [%d] %s\n", - val.bv_len, val.bv_val, 0 ); - attr_merge( e, "attributeTypes", vals ); - ldap_memfree( val.bv_val ); - } else { - return -1; + Attribute **a; + + for ( a = attrs; *a != NULL; a = &(*a)->a_next ) { + if ( (*a)->a_desc == desc ) { + Attribute *save = *a; + *a = (*a)->a_next; + attr_free( save ); + + return LDAP_SUCCESS; } } - return 0; -} -#endif -#ifdef LDAP_DEBUG + return LDAP_NO_SUCH_ATTRIBUTE; +} -static int -at_index_printnode( struct aindexrec *air ) +int +attr_init( void ) { - - printf( "%s = %s\n", air->air_name, ldap_attributetype2str(&air->air_at->sat_atype) ); - return( 0 ); + ldap_pvt_thread_mutex_init( &attr_mutex ); + return 0; } -static void -at_index_print( void ) +int +attr_destroy( void ) { - printf("Printing attribute type index:\n"); - (void) avl_apply( attr_index, (AVL_APPLY) at_index_printnode, - 0, -1, AVL_INORDER ); -} + slap_list *a; -#endif + for ( a=attr_chunks; a; a=attr_chunks ) { + attr_chunks = a->next; + free( a ); + } + ldap_pvt_thread_mutex_destroy( &attr_mutex ); + return 0; +}