X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fattr.c;h=70600c4eb942fd4a362c160728fba4948ed5578c;hb=20965abe9c5bb80d79e5ad791cd2b59ec60259b5;hp=0b19c8b3ea5232d54bcca2ea2f050c9f67039027;hpb=40ab90fa9cb443fea3e9b4346967e3f6daba324b;p=openldap diff --git a/servers/slapd/attr.c b/servers/slapd/attr.c index 0b19c8b3ea..70600c4eb9 100644 --- a/servers/slapd/attr.c +++ b/servers/slapd/attr.c @@ -1,9 +1,28 @@ +/* attr.c - routines for dealing with attributes */ /* $OpenLDAP$ */ -/* - * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved. - * COPYING RESTRICTIONS APPLY, see COPYRIGHT file +/* This work is part of OpenLDAP Software . + * + * Copyright 1998-2004 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. */ -/* attr.c - routines for dealing with attributes */ #include "portable.h" @@ -19,22 +38,14 @@ #include #include -#include "ldap_pvt.h" #include "slap.h" -#ifdef LDAP_DEBUG -static void at_index_print( void ); -#endif - void attr_free( Attribute *a ) { -#ifdef SLAPD_SCHEMA_NOT_COMPAT - ad_free( a->a_desc, 1 ); -#else - free( a->a_type ); -#endif - ber_bvecfree( a->a_vals ); + if ( a->a_nvals && a->a_nvals != a->a_vals ) + ber_bvarray_free( a->a_nvals ); + ber_bvarray_free( a->a_vals ); free( a ); } @@ -49,47 +60,60 @@ attrs_free( Attribute *a ) } } -Attribute *attr_dup( Attribute *a ) +Attribute * +attr_dup( Attribute *a ) { Attribute *tmp; - if( a == NULL) return NULL; + if ( a == NULL) return NULL; tmp = ch_malloc( sizeof(Attribute) ); - if( a->a_vals != NULL ) { + if ( a->a_vals != NULL ) { int i; - for( i=0; a->a_vals[i] != NULL; i++ ) { + for ( i = 0; !BER_BVISNULL( &a->a_vals[i] ); i++ ) { /* EMPTY */ ; } - tmp->a_vals = ch_malloc((i+1) * sizeof(struct berval*)); + 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] ); - for( i=0; a->a_vals[i] != NULL; i++ ) { - tmp->a_vals[i] = ber_bvdup( a->a_vals[i] ); + /* a_nvals must be non null; it may be equal to a_vals */ + assert( a->a_nvals ); - if( tmp->a_vals[i] == NULL ) break; - } + 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] ); - tmp->a_vals[i] = NULL; + } else { + tmp->a_nvals = tmp->a_vals; + } } else { tmp->a_vals = NULL; + tmp->a_nvals = NULL; } -#ifdef SLAPD_SCHEMA_NOT_COMPAT - tmp->a_desc = ad_dup( a->a_desc ); -#else - tmp->a_type = ch_strdup( a->a_type ); - tmp->a_syntax = a->a_syntax; -#endif + tmp->a_desc = a->a_desc; tmp->a_next = NULL; + tmp->a_flags = 0; return tmp; } -Attribute *attrs_dup( Attribute *a ) +Attribute * +attrs_dup( Attribute *a ) { Attribute *tmp, **next; @@ -107,112 +131,172 @@ Attribute *attrs_dup( Attribute *a ) return tmp; } -#ifndef SLAPD_SCHEMA_NOT_COMPAT -/* - * attr_normalize - normalize an attribute name (make it all lowercase) - */ -char * -attr_normalize( char *s ) -{ - assert( s != NULL ); - return( ldap_pvt_str2lower( s ) ); -} -#endif - -#ifndef SLAPD_SCHEMA_NOT_COMPAT /* - * 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. + * 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_merge_fast( - Entry *e, - const char *type, - struct berval **vals, - int nvals, - int naddvals, - int *maxvals, - Attribute ***a -) +attr_merge( + Entry *e, + AttributeDescription *desc, + BerVarray vals, + BerVarray nvals ) { - if ( *a == NULL ) { - for ( *a = &e->e_attrs; **a != NULL; *a = &(**a)->a_next ) { -#ifdef SLAPD_SCHEMA_NOT_COMPAT - /* not yet implemented */ -#else - if ( strcasecmp( (**a)->a_type, type ) == 0 ) { - break; - } -#endif + 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_vals = NULL; -#ifndef SLAPD_SCHEMA_NOT_COMPAT - (**a)->a_type = attr_normalize( ch_strdup( type ) ); - (**a)->a_syntax = attr_syntax( type ); -#endif - (**a)->a_next = NULL; + 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 == LDAP_SUCCESS ) { + if ( nvals ) { + rc = value_add( &(*a)->a_nvals, nvals ); + /* FIXME: what if rc != LDAP_SUCCESS ? */ + } else { + (*a)->a_nvals = (*a)->a_vals; + } } - return( value_add_fast( &(**a)->a_vals, vals, nvals, naddvals, - maxvals ) ); + return rc; } -#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_normalize( + Entry *e, + AttributeDescription *desc, + BerVarray vals, + void *memctx ) +{ + 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] ); + } + + rc = attr_merge( e, desc, vals, nvals ); + +error_return:; + if ( nvals != NULL ) { + ber_bvarray_free_x( nvals, memctx ); + } + return rc; +} int -attr_merge( - Entry *e, -#ifdef SLAPD_SCHEMA_NOT_COMPAT +attr_merge_one( + Entry *e, AttributeDescription *desc, -#else - const char *type, -#endif - struct berval **vals ) + struct berval *val, + struct berval *nval ) { + int rc; Attribute **a; for ( a = &e->e_attrs; *a != NULL; a = &(*a)->a_next ) { -#ifdef SLAPD_SCHEMA_NOT_COMPAT - /* not yet implemented */ -#else - if ( strcasecmp( (*a)->a_type, type ) == 0 ) { + if ( ad_cmp( (*a)->a_desc, desc ) == 0 ) { break; } -#endif } if ( *a == NULL ) { *a = (Attribute *) ch_malloc( sizeof(Attribute) ); -#ifdef SLAPD_SCHEMA_NOT_COMPAT - /* not yet implemented */ -#else - (*a)->a_type = attr_normalize( ch_strdup( type ) ); - (*a)->a_syntax = attr_syntax( type ); -#endif + (*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 == 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 rc; +} - return( value_add( &(*a)->a_vals, vals ) ); +int +attr_merge_normalize_one( + Entry *e, + AttributeDescription *desc, + struct berval *val, + void *memctx ) +{ + 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; + } + + rc = attr_merge_one( e, desc, val, nvalp ); + if ( nvalp != NULL ) { + slap_sl_free( nval.bv_val, memctx ); + } + return rc; } -#ifdef SLAPD_SCHEMA_NOT_COMPAT /* * attrs_find - find attribute(s) by AttributeDescription * returns next attribute which is subtype of provided description. @@ -221,18 +305,16 @@ attr_merge( Attribute * attrs_find( Attribute *a, - AttributeDescription *desc -) + AttributeDescription *desc ) { for ( ; a != NULL; a = a->a_next ) { - if ( is_ad_subtype( a->a_desc, desc ) == 0 ) { + if ( is_ad_subtype( a->a_desc, desc ) ) { return( a ); } } return( NULL ); } -#endif /* * attr_find - find attribute by type @@ -241,20 +323,10 @@ attrs_find( Attribute * attr_find( Attribute *a, -#ifdef SLAPD_SCHEMA_NOT_COMPAT - AttributeDescription *desc -#else - const char *type -#endif -) + AttributeDescription *desc ) { for ( ; a != NULL; a = a->a_next ) { -#ifdef SLAPD_SCHEMA_NOT_COMPAT - if ( ad_cmp( a->a_desc, desc ) == 0 ) -#else - if ( strcasecmp( a->a_type, type ) == 0 ) -#endif - { + if ( ad_cmp( a->a_desc, desc ) == 0 ) { return( a ); } } @@ -272,34 +344,20 @@ attr_find( int attr_delete( Attribute **attrs, -#ifdef SLAPD_SCHEMA_NOT_COMPAT - AttributeDescription *desc -#else - const char *type -#endif -) + AttributeDescription *desc ) { Attribute **a; - Attribute *save; for ( a = attrs; *a != NULL; a = &(*a)->a_next ) { -#ifdef SLAPD_SCHEMA_NOT_COMPAT - /* not yet implemented */ -#else - if ( strcasecmp( (*a)->a_type, type ) == 0 ) { - break; - } -#endif - } + if ( ad_cmp( (*a)->a_desc, desc ) == 0 ) { + Attribute *save = *a; + *a = (*a)->a_next; + attr_free( save ); - if ( *a == NULL ) { - return( 1 ); + return LDAP_SUCCESS; + } } - save = *a; - *a = (*a)->a_next; - attr_free( save ); - - return( 0 ); + return LDAP_NO_SUCH_ATTRIBUTE; }