X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fattr.c;h=7042d18c2b38f4e7a4cc0df377755101800e877c;hb=60339c7f774099c3e497ad18efcd8304324c30c6;hp=589291b943629a0b3637776316e87f750ca4f07a;hpb=df8f7cbb9b79be3be9205d116d1dd0b263d6861a;p=openldap diff --git a/servers/slapd/attr.c b/servers/slapd/attr.c index 589291b943..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,25 +38,58 @@ #include #include -#ifdef HAVE_SYS_PARAM_H -#include -#endif - -#include "ldap_defaults.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 + return a; +} + void attr_free( Attribute *a ) { - free( a->a_type ); - ber_bvecfree( a->a_vals ); + if ( a->a_nvals && a->a_nvals != a->a_vals ) { + ber_bvarray_free( a->a_nvals ); + } + /* 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 ); } +#ifdef LDAP_COMP_MATCH +void +comp_tree_free( Attribute *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 ); + } + } +} +#endif + void attrs_free( Attribute *a ) { @@ -44,41 +101,55 @@ 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) ); + tmp = attr_alloc( a->a_desc ); - 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*)); - - for( i=0; a->a_vals[i] != NULL; i++ ) { - tmp->a_vals[i] = ber_bvdup( a->a_vals[i] ); + 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] ); + + /* a_nvals must be non null; it may be equal to a_vals */ + assert( a->a_nvals ); - tmp->a_vals[i] = NULL; + 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] ); + + } else { + tmp->a_nvals = tmp->a_vals; + } } else { tmp->a_vals = NULL; + tmp->a_nvals = NULL; } - - tmp->a_type = ch_strdup( a->a_type ); - tmp->a_syntax = a->a_syntax; - tmp->a_next = NULL; - return tmp; } -Attribute *attrs_dup( Attribute *a ) +Attribute * +attrs_dup( Attribute *a ) { Attribute *tmp, **next; @@ -96,627 +167,229 @@ Attribute *attrs_dup( Attribute *a ) return tmp; } -/* - * attr_normalize - normalize an attribute name (make it all lowercase) - */ - -char * -attr_normalize( char *s ) -{ - assert( s != NULL ); - - return( str2lower( s ) ); -} - -/* - * 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 -) -{ - 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 ) { - **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 ) ); -} /* * 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 rc; + Attribute **a; for ( a = &e->e_attrs; *a != NULL; a = &(*a)->a_next ) { - if ( strcasecmp( (*a)->a_type, type ) == 0 ) { + if ( (*a)->a_desc == desc ) { 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; + *a = attr_alloc( desc ); + } else { + /* + * 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 ) ); } - return( value_add( &(*a)->a_vals, vals ) ); -} - -/* - * attr_find - find and return attribute type in list a - */ + rc = value_add( &(*a)->a_vals, vals ); -Attribute * -attr_find( - Attribute *a, - char *type -) -{ - for ( ; a != NULL; a = a->a_next ) { - if ( strcasecmp( a->a_type, type ) == 0 ) { - return( 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; } } - return( NULL ); + return rc; } -/* - * 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 -) +attr_merge_normalize( + Entry *e, + AttributeDescription *desc, + BerVarray vals, + void *memctx ) { - Attribute **a; - Attribute *save; + BerVarray nvals = NULL; + int rc; - for ( a = attrs; *a != NULL; a = &(*a)->a_next ) { - if ( strcasecmp( (*a)->a_type, type ) == 0 ) { - break; + 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] ); } - if ( *a == NULL ) { - return( 1 ); - } - - save = *a; - *a = (*a)->a_next; - attr_free( save ); - - return( 0 ); -} + rc = attr_merge( e, desc, vals, nvals ); -#define DEFAULT_SYNTAX SYNTAX_CIS - -/* - * attr_syntax - return the syntax of attribute type - */ - -int -attr_syntax( char *type ) -{ - AttributeType *sat; - - sat = at_find(type); - if ( sat ) { - return( sat->sat_syntax_compat ); - } - - return( DEFAULT_SYNTAX ); -} - -/* - * attr_syntax_config - process an attribute syntax config line - */ - -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; - } - - 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"; - at->at_ordering_oid = "2.5.13.3"; - at->at_substr_oid = "2.5.13.4"; - } 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"; - at->at_substr_oid = "2.5.13.21"; - } 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"; - at->at_equality_oid = "2.5.13.5"; - at->at_ordering_oid = "2.5.13.6"; - at->at_substr_oid = "2.5.13.7"; - } 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; - } - - 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( EXIT_FAILURE ); +error_return:; + if ( nvals != NULL ) { + ber_bvarray_free_x( nvals, memctx ); } - ldap_memfree(at); + return rc; } int -at_fake_if_needed( - char *name -) +attr_merge_one( + Entry *e, + AttributeDescription *desc, + struct berval *val, + struct berval *nval ) { - char *argv[3]; + int rc; + Attribute **a; - 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; + for ( a = &e->e_attrs; *a != NULL; a = &(*a)->a_next ) { + if ( (*a)->a_desc == desc ) { + break; + } } -} -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 )); -} + if ( *a == NULL ) { + *a = attr_alloc( desc ); + } -AttributeType * -at_find( - const char *name -) -{ - struct aindexrec *air = NULL; + rc = value_add_one( &(*a)->a_vals, val ); - if ( (air = (struct aindexrec *) avl_find( attr_index, name, - (AVL_CMP) attr_index_name_cmp )) != NULL ) { - return( air->air_at ); + 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( NULL ); + return rc; } int -at_append_to_list( - AttributeType *sat, - AttributeType ***listp -) +attr_merge_normalize_one( + Entry *e, + AttributeDescription *desc, + struct berval *val, + void *memctx ) { - 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++; + 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; } - size += 2; - list1 = realloc(list, size*sizeof(AttributeType *)); - if ( !list1 ) { - return -1; - } - list = list1; + nvalp = &nval; } - 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]; + rc = attr_merge_one( e, desc, val, nvalp ); + if ( nvalp != NULL ) { + slap_sl_free( nval.bv_val, memctx ); } - list[i] = NULL; - /* Tell the runtime this can be shrinked */ - list1 = realloc(list, (i+1)*sizeof(AttributeType **)); - if ( !list1 ) { - return -1; - } - *listp = list1; - return 0; + return rc; } -int -at_find_in_list( - AttributeType *sat, - AttributeType **list -) -{ - int i; - - if ( !list ) { - return -1; - } - for ( i=0; list[i]; i++ ) { - if ( sat == list[i] ) { - return i; - } - } - return -1; -} +/* + * attrs_find - find attribute(s) by AttributeDescription + * returns next attribute which is subtype of provided description. + */ -static int -at_insert( - AttributeType *sat, - const char **err -) +Attribute * +attrs_find( + Attribute *a, + AttributeDescription *desc ) { - 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++; + for ( ; a != NULL; a = a->a_next ) { + if ( is_ad_subtype( a->a_desc, desc ) ) { + return( a ); } } - return 0; + return( NULL ); } -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; - } - } else { - *err = at->at_sup_oid; - return SLAP_SCHERR_ATTR_NOT_FOUND; - } - } - - 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, "2.5.13.5") ) { - 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; - } +/* + * attr_find - find attribute by type + */ - 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; +Attribute * +attr_find( + Attribute *a, + AttributeDescription *desc ) +{ + for ( ; a != NULL; a = a->a_next ) { + if ( a->a_desc == desc ) { + return( a ); } } - /* - * 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; - sat->sat_syntax_len = sat->sat_sup->sat_syntax_len; - } - 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; - } - } - code = at_insert(sat,err); - return code; + 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 + */ -char * -at_canonical_name( char * a_type ) +int +attr_delete( + Attribute **attrs, + AttributeDescription *desc ) { - AttributeType *atp; - - if ( (atp=at_find(a_type)) == NULL ) { - - return a_type; - - } else if ( atp->sat_names - && atp->sat_names[0] - && (*(atp->sat_names[0]) != '\0') ) { - - return atp->sat_names[0]; - - } else if (atp->sat_oid && (*atp->sat_oid != '\0')) { - - return atp->sat_oid; - - } else { - - return a_type; - - } - -}/* char * at_canonica_name() */ - + Attribute **a; -#if defined( SLAPD_SCHEMA_DN ) + for ( a = attrs; *a != NULL; a = &(*a)->a_next ) { + if ( (*a)->a_desc == desc ) { + Attribute *save = *a; + *a = (*a)->a_next; + attr_free( save ); -int -at_schema_info( Entry *e ) -{ - 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; + return LDAP_SUCCESS; } } - return 0; -} -#endif -#ifdef LDAP_DEBUG - -static int -at_index_printnode( struct aindexrec *air ) -{ - - printf( "%s = %s\n", air->air_name, ldap_attributetype2str(&air->air_at->sat_atype) ); - return( 0 ); + return LDAP_NO_SUCH_ATTRIBUTE; } -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 ); -} - -#endif