X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fattr.c;h=55a65b55eddb820d2638bfb4f917b9b54c078c55;hb=8a465da10c1a9c76cac9174c37bd854fd3e9d0ab;hp=fb9add64bc277aac01b5094eb36e12fc738bb169;hpb=0c0f011dc0302348484d0278e2e8f2cbe53d1961;p=openldap diff --git a/servers/slapd/attr.c b/servers/slapd/attr.c index fb9add64bc..55a65b55ed 100644 --- a/servers/slapd/attr.c +++ b/servers/slapd/attr.c @@ -1,339 +1,363 @@ /* 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" #include -#include -#include + +#ifdef HAVE_FCNTL_H #include -#include -#include -#include -#include -#include -#include "portable.h" -#include "slap.h" +#endif -extern char **charray_dup(); -extern char *ch_malloc(); -extern int errno; +#include +#include +#include +#include +#include + +#include "ldap_pvt.h" +#include "slap.h" void attr_free( Attribute *a ) { - free( a->a_type ); - 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 ); } -/* - * attr_normalize - normalize an attribute name (make it all lowercase) - */ - -char * -attr_normalize( char *s ) +void +attrs_free( Attribute *a ) { - char *save; + Attribute *next; - for ( save = s; *s; s++ ) { - *s = TOLOWER( *s ); + for( ; a != NULL ; a = next ) { + next = a->a_next; + attr_free( a ); } - - return( save ); } -/* - * 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 -) +Attribute * +attr_dup( Attribute *a ) { - int i; + Attribute *tmp; - if ( *a == NULL ) { - for ( *a = &e->e_attrs; **a != NULL; *a = &(**a)->a_next ) { - if ( strcasecmp( (**a)->a_type, type ) == 0 ) { - break; + if ( a == NULL) return NULL; + + tmp = ch_malloc( sizeof(Attribute) ); + + if ( a->a_vals != NULL ) { + int i; + + for ( i = 0; !BER_BVISNULL( &a->a_vals[i] ); i++ ) { + /* EMPTY */ ; + } + + 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? */ + } + tmp->a_vals[i].bv_val = NULL; + + /* a_nvals must be non null; it may be equal to a_vals */ + assert( a->a_nvals ); + + 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? */ } + tmp->a_nvals[i].bv_val = NULL; + + } else { + tmp->a_nvals = tmp->a_vals; } + + } else { + tmp->a_vals = NULL; + tmp->a_nvals = NULL; } - if ( **a == NULL ) { - **a = (Attribute *) ch_malloc( sizeof(Attribute) ); - (**a)->a_type = attr_normalize( strdup( type ) ); - (**a)->a_vals = NULL; - (**a)->a_syntax = attr_syntax( type ); - (**a)->a_next = NULL; + tmp->a_desc = a->a_desc; + tmp->a_next = NULL; + tmp->a_flags = 0; + + return tmp; +} + +Attribute * +attrs_dup( Attribute *a ) +{ + Attribute *tmp, **next; + + if( a == NULL ) return NULL; + + tmp = NULL; + next = &tmp; + + for( ; a != NULL ; a = a->a_next ) { + *next = attr_dup( a ); + next = &((*next)->a_next); } + *next = NULL; - return( value_add_fast( &(**a)->a_vals, vals, nvals, naddvals, - maxvals ) ); + return tmp; } + + /* * 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( - Entry *e, - char *type, - struct berval **vals -) + Entry *e, + AttributeDescription *desc, + BerVarray vals, + BerVarray nvals ) { - int i; + int rc; + Attribute **a; for ( a = &e->e_attrs; *a != NULL; a = &(*a)->a_next ) { - if ( strcasecmp( (*a)->a_type, type ) == 0 ) { + if ( ad_cmp( (*a)->a_desc, desc ) == 0 ) { break; } } if ( *a == NULL ) { *a = (Attribute *) ch_malloc( sizeof(Attribute) ); - (*a)->a_type = attr_normalize( strdup( type ) ); + (*a)->a_desc = desc; (*a)->a_vals = NULL; - (*a)->a_syntax = attr_syntax( type ); + (*a)->a_nvals = NULL; (*a)->a_next = NULL; + (*a)->a_flags = 0; } - return( value_add( &(*a)->a_vals, vals ) ); -} + rc = value_add( &(*a)->a_vals, vals ); -/* - * attr_find - find and return attribute type in list a - */ + 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; + } + } -Attribute * -attr_find( - Attribute *a, - char *type -) + return rc; +} + +int +attr_merge_normalize( + Entry *e, + AttributeDescription *desc, + BerVarray vals, + void *memctx ) { - for ( ; a != NULL; a = a->a_next ) { - if ( strcasecmp( a->a_type, type ) == 0 ) { - return( a ); + 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 = 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; + } } + nvals[i].bv_val = NULL; } - return( NULL ); -} + rc = attr_merge( e, desc, vals, nvals ); -/* - * 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 - */ +error_return:; + if ( nvals != NULL ) { + ber_bvarray_free_x( nvals, memctx ); + } + return rc; +} int -attr_delete( - Attribute **attrs, - char *type -) +attr_merge_one( + Entry *e, + AttributeDescription *desc, + struct berval *val, + struct berval *nval ) { + int rc; Attribute **a; - Attribute *save; - for ( a = attrs; *a != NULL; a = &(*a)->a_next ) { - if ( strcasecmp( (*a)->a_type, type ) == 0 ) { + for ( a = &e->e_attrs; *a != NULL; a = &(*a)->a_next ) { + if ( ad_cmp( (*a)->a_desc, desc ) == 0 ) { break; } } if ( *a == NULL ) { - return( 1 ); + *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; } - save = *a; - *a = (*a)->a_next; - attr_free( save ); - - return( 0 ); -} - -#define DEFAULT_SYNTAX SYNTAX_CIS - -struct asyntaxinfo { - char **asi_names; - int asi_syntax; -}; + rc = value_add_one( &(*a)->a_vals, val ); -static Avlnode *attr_syntaxes = NULL; - -static int -attr_syntax_cmp( - struct asyntaxinfo *a1, - struct asyntaxinfo *a2 -) -{ - return( strcasecmp( a1->asi_names[0], a2->asi_names[0] ) ); -} - -static int -attr_syntax_name_cmp( - char *type, - struct asyntaxinfo *a -) -{ - return( strcasecmp( type, a->asi_names[0] ) ); + 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; } -static int -attr_syntax_names_cmp( - char *type, - struct asyntaxinfo *a -) +int +attr_merge_normalize_one( + Entry *e, + AttributeDescription *desc, + struct berval *val, + void *memctx ) { - int i; + struct berval nval; + struct berval *nvalp = NULL; + int rc; - for ( i = 0; a->asi_names[i] != NULL; i++ ) { - if ( strcasecmp( type, a->asi_names[i] ) == 0 ) { - return( 0 ); + 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( 1 ); -} -static int -attr_syntax_dup( - struct asyntaxinfo *a1, - struct asyntaxinfo *a2 -) -{ - if ( a1->asi_syntax != a2->asi_syntax ) { - return( -1 ); + rc = attr_merge_one( e, desc, val, nvalp ); + if ( nvalp != NULL ) { + sl_free( nval.bv_val, memctx ); } - - return( 1 ); + return rc; } /* - * attr_syntax - return the syntax of attribute type + * attrs_find - find attribute(s) by AttributeDescription + * returns next attribute which is subtype of provided description. */ -int -attr_syntax( char *type ) +Attribute * +attrs_find( + Attribute *a, + AttributeDescription *desc ) { - struct asyntaxinfo *asi = NULL; - - if ( (asi = (struct asyntaxinfo *) avl_find( attr_syntaxes, type, - attr_syntax_name_cmp )) != NULL || (asi = (struct asyntaxinfo *) - avl_find_lin( attr_syntaxes, type, attr_syntax_names_cmp )) - != NULL ) - { - return( asi->asi_syntax ); + for ( ; a != NULL; a = a->a_next ) { + if ( is_ad_subtype( a->a_desc, desc ) ) { + return( a ); + } } - return( DEFAULT_SYNTAX ); + return( NULL ); } /* - * attr_syntax_config - process an attribute syntax config line + * attr_find - find attribute by type */ -void -attr_syntax_config( - char *fname, - int lineno, - int argc, - char **argv -) +Attribute * +attr_find( + Attribute *a, + AttributeDescription *desc ) { - char *save; - struct asyntaxinfo *a; - int i, lasti; - - if ( argc < 2 ) { - Debug( LDAP_DEBUG_ANY, -"%s: line %d: missing name in \"attribute + \" (ignored)\n", - fname, lineno, 0 ); - return; + for ( ; a != NULL; a = a->a_next ) { + if ( ad_cmp( a->a_desc, desc ) == 0 ) { + return( a ); + } } - a = (struct asyntaxinfo *) ch_calloc( 1, sizeof(struct asyntaxinfo) ); - - lasti = argc - 1; - if ( strcasecmp( argv[lasti], "caseignorestring" ) == 0 || - strcasecmp( argv[lasti], "cis" ) == 0 ) { - a->asi_syntax = SYNTAX_CIS; - } else if ( strcasecmp( argv[lasti], "telephone" ) == 0 || - strcasecmp( argv[lasti], "tel" ) == 0 ) { - a->asi_syntax = (SYNTAX_CIS | SYNTAX_TEL); - } else if ( strcasecmp( argv[lasti], "dn" ) == 0 ) { - a->asi_syntax = (SYNTAX_CIS | SYNTAX_DN); - } else if ( strcasecmp( argv[lasti], "caseexactstring" ) == 0 || - strcasecmp( argv[lasti], "ces" ) == 0 ) { - a->asi_syntax = SYNTAX_CES; - } else if ( strcasecmp( argv[lasti], "binary" ) == 0 || - strcasecmp( argv[lasti], "bin" ) == 0 ) { - a->asi_syntax = SYNTAX_BIN; - } else { - Debug( LDAP_DEBUG_ANY, - "%s: line %d: unknown syntax \"%s\" in attribute line (ignored)\n", - fname, lineno, 0 ); - Debug( LDAP_DEBUG_ANY, - "possible syntaxes are \"cis\", \"ces\", \"tel\", \"dn\", or \"bin\"\n", - 0, 0, 0 ); - free( (char *) a ); - return; - } - save = argv[lasti]; - argv[lasti] = NULL; - a->asi_names = charray_dup( argv ); - argv[lasti] = save; - - switch ( avl_insert( &attr_syntaxes, (caddr_t) a, attr_syntax_cmp, - attr_syntax_dup ) ) { - case -1: /* duplicate - different syntaxes */ - Debug( LDAP_DEBUG_ARGS, "%s: line %d: duplicate attribute\n", - fname, lineno, 0 ); - /* FALL */ - - case 1: /* duplicate - same syntaxes */ - charray_free( a->asi_names ); - free( (char *) a ); - break; - - default: /* inserted */ - break; - } + return( NULL ); } -#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 -attr_syntax_printnode( struct asyntaxinfo *a ) +int +attr_delete( + Attribute **attrs, + AttributeDescription *desc ) { - int i; + Attribute **a; + + for ( a = attrs; *a != NULL; a = &(*a)->a_next ) { + if ( ad_cmp( (*a)->a_desc, desc ) == 0 ) { + Attribute *save = *a; + *a = (*a)->a_next; + attr_free( save ); - printf( "syntax: 0x%x\n", a->asi_syntax ); - for ( i = 0; a->asi_names[i] != NULL; i++ ) { - printf( " name: %s\n", a->asi_names[i] ); + return LDAP_SUCCESS; + } } - return( 0 ); -} -static -attr_syntax_print() -{ - (void) avl_apply( attr_syntaxes, attr_syntax_printnode, 0, -1, - AVL_INORDER ); + return LDAP_NO_SUCH_ATTRIBUTE; } -#endif