X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fattr.c;h=7042d18c2b38f4e7a4cc0df377755101800e877c;hb=60339c7f774099c3e497ad18efcd8304324c30c6;hp=799a8a194dc77780ef31ea976223d84f11d2ab72;hpb=a97e3e94e665df092cc512cd5a3f9c5ceac820ef;p=openldap diff --git a/servers/slapd/attr.c b/servers/slapd/attr.c index 799a8a194d..7042d18c2b 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-2005 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,615 +38,358 @@ #include #include -#ifdef HAVE_SYS_PARAM_H -#include -#endif - -#include - -#include "ldapconfig.h" #include "slap.h" -#ifdef LDAP_DEBUG -static void at_index_print( void ); +Attribute * +attr_alloc( AttributeDescription *ad ) +{ + Attribute *a = ch_malloc( sizeof(Attribute) ); + + a->a_desc = ad; + a->a_next = NULL; + a->a_flags = 0; + a->a_vals = NULL; + a->a_nvals = NULL; +#ifdef LDAP_COMP_MATCH + a->a_comp_data = NULL; #endif -void -attr_free( Attribute *a ) -{ - free( a->a_type ); - ber_bvecfree( a->a_vals ); - free( a ); + return a; } -/* - * attr_normalize - normalize an attribute name (make it all lowercase) - */ - -char * -attr_normalize( char *s ) +void +attr_free( Attribute *a ) { - char *save; - - assert( s != NULL ); - - for ( save = s; *s; s++ ) { - *s = TOLOWER( (unsigned char) *s ); + if ( a->a_nvals && a->a_nvals != a->a_vals ) { + ber_bvarray_free( a->a_nvals ); } - - return( save ); + /* 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 ) { + ber_bvarray_free( a->a_vals ); + } + free( a ); } -/* - * 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 - */ - -int -attr_merge_fast( - Entry *e, - char *type, - struct berval **vals, - int nvals, - int naddvals, - int *maxvals, - Attribute ***a -) +#ifdef LDAP_COMP_MATCH +void +comp_tree_free( Attribute *a ) { - if ( *a == NULL ) { - for ( *a = &e->e_attrs; **a != NULL; *a = &(**a)->a_next ) { - if ( strcasecmp( (**a)->a_type, type ) == 0 ) { - break; - } + 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 ); } } - - 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 ) ); } +#endif -/* - * 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 +attrs_free( Attribute *a ) { - Attribute **a; + Attribute *next; - for ( a = &e->e_attrs; *a != NULL; a = &(*a)->a_next ) { - if ( strcasecmp( (*a)->a_type, type ) == 0 ) { - break; - } - } - - 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; + for( ; a != NULL ; a = next ) { + next = a->a_next; + attr_free( a ); } - - return( value_add( &(*a)->a_vals, vals ) ); } -/* - * attr_find - find and return attribute type in list a - */ - Attribute * -attr_find( - Attribute *a, - char *type -) +attr_dup( Attribute *a ) { - for ( ; a != NULL; a = a->a_next ) { - if ( strcasecmp( a->a_type, type ) == 0 ) { - return( a ); - } - } + Attribute *tmp; - return( NULL ); -} + if ( a == NULL) return NULL; -/* - * 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 - */ + tmp = attr_alloc( a->a_desc ); -int -attr_delete( - Attribute **attrs, - char *type -) -{ - Attribute **a; - Attribute *save; + if ( a->a_vals != NULL ) { + int i; - for ( a = attrs; *a != NULL; a = &(*a)->a_next ) { - if ( strcasecmp( (*a)->a_type, type ) == 0 ) { - break; + for ( i = 0; !BER_BVISNULL( &a->a_vals[i] ); i++ ) { + /* EMPTY */ ; } - } - if ( *a == NULL ) { - return( 1 ); - } - - save = *a; - *a = (*a)->a_next; - attr_free( save ); + 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] ); - return( 0 ); -} + /* a_nvals must be non null; it may be equal to a_vals */ + assert( a->a_nvals ); -#define DEFAULT_SYNTAX SYNTAX_CIS + if ( a->a_nvals != a->a_vals ) { + tmp->a_nvals = ch_malloc( (i + 1) * sizeof(struct berval) ); + for ( i = 0; !BER_BVISNULL( &a->a_nvals[i] ); i++ ) { + ber_dupbv( &tmp->a_nvals[i], &a->a_nvals[i] ); + if ( BER_BVISNULL( &tmp->a_nvals[i] ) ) break; + /* FIXME: error? */ + } + BER_BVZERO( &tmp->a_nvals[i] ); -/* Force compilation errors by commenting out this -struct asyntaxinfo { - char **asi_names; - int asi_syntax; -}; -static Avlnode *attr_syntaxes = NULL; + } else { + tmp->a_nvals = tmp->a_vals; + } -static int -attr_syntax_cmp( - struct asyntaxinfo *a1, - struct asyntaxinfo *a2 -) -{ - return( strcasecmp( a1->asi_names[0], a2->asi_names[0] ) ); + } else { + tmp->a_vals = NULL; + tmp->a_nvals = NULL; + } + return tmp; } -static int -attr_syntax_name_cmp( - char *type, - struct asyntaxinfo *a -) +Attribute * +attrs_dup( Attribute *a ) { - return( strcasecmp( type, a->asi_names[0] ) ); -} + Attribute *tmp, **next; -static int -attr_syntax_names_cmp( - char *type, - struct asyntaxinfo *a -) -{ - int i; + if( a == NULL ) return NULL; - for ( i = 0; a->asi_names[i] != NULL; i++ ) { - if ( strcasecmp( type, a->asi_names[i] ) == 0 ) { - return( 0 ); - } - } - return( 1 ); -} + tmp = NULL; + next = &tmp; -static int -attr_syntax_dup( - struct asyntaxinfo *a1, - struct asyntaxinfo *a2 -) -{ - if ( a1->asi_syntax != a2->asi_syntax ) { - return( -1 ); + for( ; a != NULL ; a = a->a_next ) { + *next = attr_dup( a ); + next = &((*next)->a_next); } + *next = NULL; - return( 1 ); + return tmp; } -*/ /* - * attr_syntax - return the syntax of attribute type + * 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 -attr_syntax( char *type ) +attr_merge( + Entry *e, + AttributeDescription *desc, + BerVarray vals, + BerVarray nvals ) { - AttributeType *sat; - - sat = at_find(type); - if ( sat ) { - return( sat->sat_syntax_compat ); - } - - return( DEFAULT_SYNTAX ); -} + int rc; -/* - * attr_syntax_config - process an attribute syntax config line - */ + Attribute **a; -void -attr_syntax_config( - char *fname, - int lineno, - int argc, - char **argv -) -{ - char *save; - LDAP_ATTRIBUTE_TYPE *at; - int lasti; - int code; - char *err; - - if ( argc < 2 ) { - Debug( LDAP_DEBUG_ANY, -"%s: line %d: missing name in \"attribute + \" (ignored)\n", - fname, lineno, 0 ); - return; + for ( a = &e->e_attrs; *a != NULL; a = &(*a)->a_next ) { + if ( (*a)->a_desc == desc ) { + break; + } } - 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 */ + if ( *a == NULL ) { + *a = attr_alloc( desc ); } 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; + /* + * 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_nvals != (*a)->a_vals ) ); } - save = argv[lasti]; - argv[lasti] = NULL; - at->at_names = charray_dup( argv ); - argv[lasti] = save; + rc = value_add( &(*a)->a_vals, vals ); - code = at_add( at, &err ); - if ( code ) { - fprintf( stderr, "%s: line %d: %s %s\n", - fname, lineno, scherr2str(code), err); - exit( 1 ); + 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; + } } - ldap_memfree(at); + + return rc; } int -at_fake_if_needed( - char *name -) +attr_merge_normalize( + Entry *e, + AttributeDescription *desc, + BerVarray vals, + void *memctx ) { - char *argv[3]; - - 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; + BerVarray nvals = NULL; + int rc; + + 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] ); + goto error_return; + } + } + BER_BVZERO( &nvals[i] ); } -} - -struct aindexrec { - char *air_name; - AttributeType *air_at; -}; - -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 )); -} - -static int -attr_index_name_cmp( - char *type, - struct aindexrec *air -) -{ - return (strcasecmp( type, air->air_name )); -} -AttributeType * -at_find( - char *name -) -{ - struct aindexrec *air = NULL; + rc = attr_merge( e, desc, vals, nvals ); - if ( (air = (struct aindexrec *) avl_find( attr_index, name, - (AVL_CMP) attr_index_name_cmp )) != NULL ) { - return( air->air_at ); +error_return:; + if ( nvals != NULL ) { + ber_bvarray_free_x( nvals, memctx ); } - return( NULL ); + return rc; } int -at_append_to_list( - AttributeType *sat, - AttributeType ***listp -) +attr_merge_one( + Entry *e, + AttributeDescription *desc, + struct berval *val, + struct berval *nval ) { - AttributeType **list; - AttributeType **list1; - int size; - - list = *listp; - if ( !list ) { - size = 2; - list = calloc(size, sizeof(AttributeType *)); - if ( !list ) { - return -1; - } - } else { - size = 0; - list1 = *listp; - while ( *list1 ) { - size++; - list1++; - } - size += 2; - list1 = realloc(list, size*sizeof(AttributeType *)); - if ( !list1 ) { - return -1; + int rc; + Attribute **a; + + for ( a = &e->e_attrs; *a != NULL; a = &(*a)->a_next ) { + if ( (*a)->a_desc == desc ) { + break; } - list = list1; } - list[size-2] = sat; - list[size-1] = NULL; - *listp = list; - return 0; -} - -int -at_delete_from_list( - int pos, - AttributeType ***listp -) -{ - AttributeType **list; - AttributeType **list1; - int i; - int j; - 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]; - } - list[i] = NULL; - /* Tell the runtime this can be shrinked */ - list1 = realloc(list, (i+1)*sizeof(AttributeType **)); - if ( !list1 ) { - return -1; + if ( *a == NULL ) { + *a = attr_alloc( desc ); } - *listp = list1; - return 0; -} -int -at_find_in_list( - AttributeType *sat, - AttributeType **list -) -{ - int i; + rc = value_add_one( &(*a)->a_vals, val ); - if ( !list ) { - return -1; - } - for ( i=0; list[i]; i++ ) { - if ( sat == list[i] ) { - return i; + if ( rc == LDAP_SUCCESS ) { + if ( nval ) { + rc = value_add_one( &(*a)->a_nvals, nval ); + /* FIXME: what if rc != LDAP_SUCCESS ? */ + } else { + (*a)->a_nvals = (*a)->a_vals; } } - return -1; + return rc; } -static int -at_insert( - AttributeType *sat, - char **err -) +int +attr_merge_normalize_one( + Entry *e, + AttributeDescription *desc, + struct berval *val, + void *memctx ) { - AttributeType **atp; - struct aindexrec *air; - char **names; - - 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; - } - /* 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++; + struct berval nval; + struct berval *nvalp = NULL; + int rc; + + 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; } + nvalp = &nval; } - return 0; + rc = attr_merge_one( e, desc, val, nvalp ); + if ( nvalp != NULL ) { + slap_sl_free( nval.bv_val, memctx ); + } + return rc; } -int -at_add( - LDAP_ATTRIBUTE_TYPE *at, - char **err -) -{ - AttributeType *sat; - AttributeType *sat1; - int code; - char *errattr; - - if ( at->at_names && at->at_names[0] ) { - errattr = at->at_names[0]; - } else { - errattr = at->at_oid; - } - 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; - } - } else { - *err = errattr; - return SLAP_SCHERR_ATTR_NOT_FOUND; - } - } +/* + * attrs_find - find attribute(s) by AttributeDescription + * returns next attribute which is subtype of provided description. + */ - if ( !strcmp(at->at_syntax_oid, "1.3.6.1.4.1.1466.115.121.1.15") ) { - if ( !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; +Attribute * +attrs_find( + Attribute *a, + AttributeDescription *desc ) +{ + for ( ; a != NULL; a = a->a_next ) { + if ( is_ad_subtype( a->a_desc, desc ) ) { + return( a ); } - } 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; } - code = at_insert(sat,err); - return code; + return( NULL ); } -#if defined( SLAPD_SCHEMA_DN ) +/* + * attr_find - find attribute by type + */ -int -at_schema_info( Entry *e ) +Attribute * +attr_find( + Attribute *a, + 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; + for ( ; a != NULL; a = a->a_next ) { + if ( a->a_desc == desc ) { + return( a ); } } - return 0; + + return( NULL ); } -#endif -#ifdef LDAP_DEBUG +/* + * 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 + */ -static int -at_index_printnode( struct aindexrec *air ) +int +attr_delete( + Attribute **attrs, + AttributeDescription *desc ) { + Attribute **a; - printf( "%s = %s\n", air->air_name, ldap_attributetype2str(&air->air_at->sat_atype) ); - return( 0 ); -} + for ( a = attrs; *a != NULL; a = &(*a)->a_next ) { + if ( (*a)->a_desc == desc ) { + Attribute *save = *a; + *a = (*a)->a_next; + attr_free( save ); -static void -at_index_print( void ) -{ - printf("Printing attribute type index:\n"); - (void) avl_apply( attr_index, (AVL_APPLY) at_index_printnode, - 0, -1, AVL_INORDER ); + return LDAP_SUCCESS; + } + } + + return LDAP_NO_SUCH_ATTRIBUTE; } -#endif