X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fat.c;h=fe603c9aed9e554ff68edaed55fb35099637e161;hb=8a465da10c1a9c76cac9174c37bd854fd3e9d0ab;hp=deca47d695397434fa4a1d40425d5fd62516ad76;hpb=0dbaf87730ec9afe44dceaa452ae51e1dcaac3e7;p=openldap diff --git a/servers/slapd/at.c b/servers/slapd/at.c index deca47d695..fe603c9aed 100644 --- a/servers/slapd/at.c +++ b/servers/slapd/at.c @@ -1,9 +1,18 @@ +/* at.c - routines for dealing with attribute types */ /* $OpenLDAP$ */ -/* - * Copyright 1998-1999 The OpenLDAP Foundation, All Rights Reserved. - * COPYING RESTRICTIONS APPLY, see COPYRIGHT file +/* 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 + * . */ -/* at.c - routines for dealing with attribute types */ #include "portable.h" @@ -18,187 +27,67 @@ #include "ldap_pvt.h" #include "slap.h" -#ifndef SLAPD_SCHEMA_NOT_COMPAT -char * -at_canonical_name( const char * a_type ) -{ - AttributeType *atp; - - atp=at_find(a_type); - - if ( atp == NULL ) { - return (char *) 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; - } - - return (char *) a_type; -} - -#define DEFAULT_SYNTAX SYNTAX_CIS -/* - * attr_syntax - return the syntax of attribute type - */ - -int -attr_syntax( const char *type ) +int is_at_syntax( + AttributeType *at, + const char *oid ) { - AttributeType *sat; - - sat = at_find(type); - if ( sat ) { - return( sat->sat_syntax_compat ); + for( ; at != NULL; at = at->sat_sup ) { + if( at->sat_syntax_oid ) { + return ( strcmp( at->sat_syntax_oid, oid ) == 0 ); + } } - return( DEFAULT_SYNTAX ); + return 0; } -/* - * attr_syntax_config - process an attribute syntax config line - */ - -void -at_config( - const char *fname, - int lineno, - int argc, - char **argv -) +int is_at_subtype( + AttributeType *sub, + AttributeType *sup ) { - 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; + for( ; sub != NULL; sub = sub->sat_sup ) { + if( sub == sup ) return 1; } - at = (LDAP_ATTRIBUTE_TYPE *) - ch_calloc( 1, sizeof(LDAP_ATTRIBUTE_TYPE) ); - -#define SYNTAX_DS_OID "1.3.6.1.4.1.1466.115.121.1.15" -#define SYNTAX_DSCE_OID "2.5.13.5" -#define SYNTAX_IA5_OID "1.3.6.1.4.1.1466.115.121.1.26" -#define SYNTAX_IA5CE_OID "1.3.6.1.4.1.1466.109.114.1" -#define SYNTAX_DN_OID SLAPD_OID_DN_SYNTAX -#define SYNTAX_TEL_OID "1.3.6.1.4.1.1466.115.121.1.50" -#define SYNTAX_BIN_OID "1.3.6.1.4.1.1466.115.121.1.40" /* octetString */ - - lasti = argc - 1; - if ( strcasecmp( argv[lasti], "caseignorestring" ) == 0 || - strcasecmp( argv[lasti], "cis" ) == 0 ) { - at->at_syntax_oid = SYNTAX_DS_OID; - 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 = SYNTAX_TEL_OID; - 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 = SYNTAX_DN_OID; - at->at_equality_oid = "2.5.13.1"; - - } else if ( strcasecmp( argv[lasti], "caseexactstring" ) == 0 || - strcasecmp( argv[lasti], "ces" ) == 0 ) { - at->at_syntax_oid = SYNTAX_DS_OID; - at->at_equality_oid = SYNTAX_DSCE_OID; - 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 ) { - /* bin -> octetString, not binary! */ - at->at_syntax_oid = SYNTAX_BIN_OID; - at->at_equality_oid = "2.5.13.17"; - - } 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 ); - } - - ldap_memfree(at); -} - -int -at_fake_if_needed( - const char *name -) -{ - char *argv[3]; - - if ( at_find( name ) ) { - return 0; - } else { - argv[0] = (char*) name; - argv[1] = "cis"; - argv[2] = NULL; - at_config( "implicit", 0, 2, argv ); - return 0; - } + return 0; } -#endif - - - struct aindexrec { - char *air_name; + struct berval air_name; AttributeType *air_at; }; static Avlnode *attr_index = NULL; -static AttributeType *attr_list = NULL; +static LDAP_SLIST_HEAD(ATList, slap_attribute_type) attr_list + = LDAP_SLIST_HEAD_INITIALIZER(&attr_list); static int attr_index_cmp( - struct aindexrec *air1, - struct aindexrec *air2 + const void *v_air1, + const void *v_air2 ) { - return (strcasecmp( air1->air_name, air2->air_name )); + const struct aindexrec *air1 = v_air1; + const struct aindexrec *air2 = v_air2; + int i = air1->air_name.bv_len - air2->air_name.bv_len; + if (i) + return i; + return (strcasecmp( air1->air_name.bv_val, air2->air_name.bv_val )); } static int attr_index_name_cmp( - char *type, - struct aindexrec *air + const void *v_type, + const void *v_air ) { - return (strcasecmp( type, air->air_name )); + const struct berval *type = v_type; + const struct aindexrec *air = v_air; + int i = type->bv_len - air->air_name.bv_len; + if (i) + return i; + return (strncasecmp( type->bv_val, air->air_name.bv_val, + type->bv_len )); } AttributeType * @@ -206,36 +95,24 @@ at_find( const char *name ) { - struct aindexrec *air; - char *tmpname; + struct berval bv; -#ifndef SLAPD_SCHEMA_NOT_COMPAT - /* - * The name may actually be an AttributeDescription, i.e. it may - * contain options. - */ - /* Treat any attribute type with option as an unknown attribute type */ - char *p = strchr( name, ';' ); - if ( p ) { - tmpname = ch_malloc( p-name+1 ); - strncpy( tmpname, name, p-name ); - tmpname[p-name] = '\0'; - } else -#endif - { - tmpname = (char *)name; - } + bv.bv_val = (char *)name; + bv.bv_len = strlen( name ); - if ( (air = (struct aindexrec *) avl_find( attr_index, tmpname, - (AVL_CMP) attr_index_name_cmp )) != NULL ) { - if ( tmpname != name ) - ldap_memfree( tmpname ); - return( air->air_at ); - } + return at_bvfind( &bv ); +} + +AttributeType * +at_bvfind( + struct berval *name +) +{ + struct aindexrec *air; + + air = avl_find( attr_index, name, attr_index_name_cmp ); - if ( tmpname != name ) - ldap_memfree( tmpname ); - return( NULL ); + return air != NULL ? air->air_at : NULL; } int @@ -251,7 +128,7 @@ at_append_to_list( list = *listp; if ( !list ) { size = 2; - list = calloc(size, sizeof(AttributeType *)); + list = ch_calloc(size, sizeof(AttributeType *)); if ( !list ) { return -1; } @@ -263,7 +140,7 @@ at_append_to_list( list1++; } size += 2; - list1 = realloc(list, size*sizeof(AttributeType *)); + list1 = ch_realloc(list, size*sizeof(AttributeType *)); if ( !list1 ) { return -1; } @@ -300,7 +177,7 @@ at_delete_from_list( } list[i] = NULL; /* Tell the runtime this can be shrinked */ - list1 = realloc(list, (i+1)*sizeof(AttributeType **)); + list1 = ch_realloc(list, (i+1)*sizeof(AttributeType **)); if ( !list1 ) { return -1; } @@ -327,54 +204,106 @@ at_find_in_list( return -1; } +void +at_destroy( void ) +{ + AttributeType *a; + avl_free(attr_index, ldap_memfree); + + while( !LDAP_SLIST_EMPTY(&attr_list) ) { + a = LDAP_SLIST_FIRST(&attr_list); + LDAP_SLIST_REMOVE_HEAD(&attr_list, sat_next); + + if (a->sat_subtypes) ldap_memfree(a->sat_subtypes); + ad_destroy(a->sat_ad); + ldap_pvt_thread_mutex_destroy(&a->sat_ad_mutex); + ldap_attributetype_free((LDAPAttributeType *)a); + } + + if ( slap_schema.si_at_undefined ) { + ad_destroy(slap_schema.si_at_undefined->sat_ad); + } +} + +int +at_start( AttributeType **at ) +{ + assert( at ); + + *at = LDAP_SLIST_FIRST(&attr_list); + + return (*at != NULL); +} + +int +at_next( AttributeType **at ) +{ + assert( at ); + +#if 1 /* pedantic check */ + { + AttributeType *tmp = NULL; + + LDAP_SLIST_FOREACH(tmp,&attr_list,sat_next) { + if ( tmp == *at ) { + break; + } + } + + assert( tmp ); + } +#endif + + *at = LDAP_SLIST_NEXT(*at,sat_next); + + return (*at != NULL); +} + + + static int at_insert( AttributeType *sat, const char **err ) { - AttributeType **atp; struct aindexrec *air; char **names; - atp = &attr_list; - while ( *atp != NULL ) { - atp = &(*atp)->sat_next; - } - *atp = sat; + LDAP_SLIST_NEXT( sat, sat_next ) = NULL; + LDAP_SLIST_INSERT_HEAD( &attr_list, sat, sat_next ); if ( sat->sat_oid ) { air = (struct aindexrec *) ch_calloc( 1, sizeof(struct aindexrec) ); - air->air_name = sat->sat_oid; + air->air_name.bv_val = sat->sat_oid; + air->air_name.bv_len = strlen(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 ) ) { + attr_index_cmp, avl_dup_error ) ) { *err = sat->sat_oid; ldap_memfree(air); - return SLAP_SCHERR_DUP_ATTR; + return SLAP_SCHERR_ATTR_DUP; } /* FIX: temporal consistency check */ - at_find(air->air_name); + at_bvfind(&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_name.bv_val = *names; + air->air_name.bv_len = strlen(*names); air->air_at = sat; if ( avl_insert( &attr_index, (caddr_t) air, - (AVL_CMP) attr_index_cmp, - (AVL_DUP) avl_dup_error ) ) { + attr_index_cmp, avl_dup_error ) ) { *err = *names; - ldap_memfree(air->air_name); ldap_memfree(air); - return SLAP_SCHERR_DUP_ATTR; + return SLAP_SCHERR_ATTR_DUP; } /* FIX: temporal consistency check */ - at_find(air->air_name); + at_bvfind(&air->air_name); names++; } } @@ -384,35 +313,94 @@ at_insert( int at_add( - LDAP_ATTRIBUTE_TYPE *at, + LDAPAttributeType *at, const char **err ) { AttributeType *sat; MatchingRule *mr; Syntax *syn; + int i; int code; - char *cname; + char *cname; + char *oid; + + if ( !OID_LEADCHAR( at->at_oid[0] )) { + /* Expand OID macros */ + oid = oidm_find( at->at_oid ); + if ( !oid ) { + *err = at->at_oid; + return SLAP_SCHERR_OIDM; + } + if ( oid != at->at_oid ) { + ldap_memfree( at->at_oid ); + at->at_oid = oid; + } + } + + if ( at->at_syntax_oid && !OID_LEADCHAR( at->at_syntax_oid[0] )) { + /* Expand OID macros */ + oid = oidm_find( at->at_syntax_oid ); + if ( !oid ) { + *err = at->at_syntax_oid; + return SLAP_SCHERR_OIDM; + } + if ( oid != at->at_syntax_oid ) { + ldap_memfree( at->at_syntax_oid ); + at->at_syntax_oid = oid; + } + } if ( at->at_names && at->at_names[0] ) { + int i; + + for( i=0; at->at_names[i]; i++ ) { + if( !slap_valid_descr( at->at_names[i] ) ) { + *err = at->at_names[i]; + return SLAP_SCHERR_BAD_DESCR; + } + } + cname = at->at_names[0]; + } else if ( at->at_oid ) { cname = at->at_oid; + } else { - cname = ""; + *err = ""; return SLAP_SCHERR_ATTR_INCOMPLETE; } + + *err = cname; + + if ( !at->at_usage && at->at_no_user_mod ) { + /* user attribute must be modifable */ + return SLAP_SCHERR_ATTR_BAD_USAGE; + } + + if ( at->at_collective ) { + if( at->at_usage ) { + /* collective attributes cannot be operational */ + return SLAP_SCHERR_ATTR_BAD_USAGE; + } + + if( at->at_single_value ) { + /* collective attributes cannot be single-valued */ + return SLAP_SCHERR_ATTR_BAD_USAGE; + } + } + sat = (AttributeType *) ch_calloc( 1, sizeof(AttributeType) ); - memcpy( &sat->sat_atype, at, sizeof(LDAP_ATTRIBUTE_TYPE)); + AC_MEMCPY( &sat->sat_atype, at, sizeof(LDAPAttributeType)); -#ifdef SLAPD_SCHEMA_NOT_COMPAT - sat->sat_cname = cname; -#endif + sat->sat_cname.bv_val = cname; + sat->sat_cname.bv_len = strlen( cname ); + ldap_pvt_thread_mutex_init(&sat->sat_ad_mutex); if ( at->at_sup_oid ) { AttributeType *supsat = at_find(at->at_sup_oid); - if ( (supsat == NULL ) ) { + if ( supsat == NULL ) { *err = at->at_sup_oid; return SLAP_SCHERR_ATTR_NOT_FOUND; } @@ -420,9 +408,23 @@ at_add( sat->sat_sup = supsat; if ( at_append_to_list(sat, &supsat->sat_subtypes) ) { - *err = cname; return SLAP_SCHERR_OUTOFMEM; } + + if ( sat->sat_usage != supsat->sat_usage ) { + /* subtypes must have same usage as their SUP */ + return SLAP_SCHERR_ATTR_BAD_USAGE; + } + + if ( supsat->sat_obsolete && !sat->sat_obsolete ) { + /* subtypes must be obsolete if super is */ + return SLAP_SCHERR_ATTR_BAD_SUP; + } + + if ( sat->sat_flags & SLAP_AT_FINAL ) { + /* cannot subtype a "final" attribute type */ + return SLAP_SCHERR_ATTR_BAD_SUP; + } } /* @@ -432,83 +434,150 @@ at_add( */ if ( sat->sat_sup ) { sat->sat_syntax = sat->sat_sup->sat_syntax; - sat->sat_equality = sat->sat_sup->sat_equality; + sat->sat_approx = sat->sat_sup->sat_approx; sat->sat_ordering = sat->sat_sup->sat_ordering; sat->sat_substr = sat->sat_sup->sat_substr; } if ( at->at_syntax_oid ) { - if ( (syn = syn_find(sat->sat_syntax_oid)) ) { - sat->sat_syntax = syn; - } else { + syn = syn_find(sat->sat_syntax_oid); + if ( syn == NULL ) { *err = sat->sat_syntax_oid; return SLAP_SCHERR_SYN_NOT_FOUND; } -#ifndef SLAPD_SCHEMA_NOT_COMPAT - if ( !strcmp(at->at_syntax_oid, SYNTAX_DS_OID) ) { - if ( at->at_equality_oid && ( - !strcmp(at->at_equality_oid, SYNTAX_DSCE_OID) ) ) - { - sat->sat_syntax_compat = SYNTAX_CES; - } else { - sat->sat_syntax_compat = SYNTAX_CIS; - } - - } else if ( !strcmp(at->at_syntax_oid, SYNTAX_IA5_OID) ) { - if ( at->at_equality_oid && ( - !strcmp(at->at_equality_oid, SYNTAX_IA5CE_OID) ) ) - { - sat->sat_syntax_compat = SYNTAX_CES; - } else { - sat->sat_syntax_compat = SYNTAX_CIS; - } - - } else if ( !strcmp(at->at_syntax_oid, SYNTAX_DN_OID ) ) { - sat->sat_syntax_compat = SYNTAX_CIS | SYNTAX_DN; - - } else if ( !strcmp(at->at_syntax_oid, SYNTAX_TEL_OID ) ) { - sat->sat_syntax_compat = SYNTAX_CIS | SYNTAX_TEL; - - } else if ( !strcmp(at->at_syntax_oid, SYNTAX_BIN_OID ) ) { - sat->sat_syntax_compat = SYNTAX_BIN; - - } else { - sat->sat_syntax_compat = DEFAULT_SYNTAX; + if( sat->sat_syntax != NULL && sat->sat_syntax != syn ) { + return SLAP_SCHERR_ATTR_BAD_SUP; } -#endif + + sat->sat_syntax = syn; } else if ( sat->sat_syntax == NULL ) { return SLAP_SCHERR_ATTR_INCOMPLETE; } if ( sat->sat_equality_oid ) { - if ( (mr = mr_find(sat->sat_equality_oid)) ) { - sat->sat_equality = mr; - } else { + mr = mr_find(sat->sat_equality_oid); + + if( mr == NULL ) { *err = sat->sat_equality_oid; return SLAP_SCHERR_MR_NOT_FOUND; } + if(( mr->smr_usage & SLAP_MR_EQUALITY ) != SLAP_MR_EQUALITY ) { + *err = sat->sat_equality_oid; + return SLAP_SCHERR_ATTR_BAD_MR; + } + + if( sat->sat_syntax != mr->smr_syntax ) { + if( mr->smr_compat_syntaxes == NULL ) { + *err = sat->sat_equality_oid; + return SLAP_SCHERR_ATTR_BAD_MR; + } + + for(i=0; mr->smr_compat_syntaxes[i]; i++) { + if( sat->sat_syntax == mr->smr_compat_syntaxes[i] ) { + i = -1; + break; + } + } + + if( i >= 0 ) { + *err = sat->sat_equality_oid; + return SLAP_SCHERR_ATTR_BAD_MR; + } + } + + sat->sat_equality = mr; + sat->sat_approx = mr->smr_associated; } if ( sat->sat_ordering_oid ) { - if ( (mr = mr_find(sat->sat_ordering_oid)) ) { - sat->sat_ordering = mr; - } else { + if( !sat->sat_equality ) { + *err = sat->sat_ordering_oid; + return SLAP_SCHERR_ATTR_BAD_MR; + } + + mr = mr_find(sat->sat_ordering_oid); + + if( mr == NULL ) { *err = sat->sat_ordering_oid; return SLAP_SCHERR_MR_NOT_FOUND; } + + if(( mr->smr_usage & SLAP_MR_ORDERING ) != SLAP_MR_ORDERING ) { + *err = sat->sat_ordering_oid; + return SLAP_SCHERR_ATTR_BAD_MR; + } + + if( sat->sat_syntax != mr->smr_syntax ) { + if( mr->smr_compat_syntaxes == NULL ) { + *err = sat->sat_ordering_oid; + return SLAP_SCHERR_ATTR_BAD_MR; + } + + for(i=0; mr->smr_compat_syntaxes[i]; i++) { + if( sat->sat_syntax == mr->smr_compat_syntaxes[i] ) { + i = -1; + break; + } + } + + if( i >= 0 ) { + *err = sat->sat_ordering_oid; + return SLAP_SCHERR_ATTR_BAD_MR; + } + } + + sat->sat_ordering = mr; } if ( sat->sat_substr_oid ) { - if ( (mr = mr_find(sat->sat_substr_oid)) ) { - sat->sat_substr = mr; - } else { + if( !sat->sat_equality ) { + *err = sat->sat_substr_oid; + return SLAP_SCHERR_ATTR_BAD_MR; + } + + mr = mr_find(sat->sat_substr_oid); + + if( mr == NULL ) { *err = sat->sat_substr_oid; return SLAP_SCHERR_MR_NOT_FOUND; } + + if(( mr->smr_usage & SLAP_MR_SUBSTR ) != SLAP_MR_SUBSTR ) { + *err = sat->sat_substr_oid; + return SLAP_SCHERR_ATTR_BAD_MR; + } + + /* due to funky LDAP builtin substring rules, we + * we check against the equality rule assertion + * syntax and compat syntaxes instead of those + * associated with the substrings rule. + */ + if( sat->sat_syntax != sat->sat_equality->smr_syntax ) { + if( sat->sat_equality->smr_compat_syntaxes == NULL ) { + *err = sat->sat_substr_oid; + return SLAP_SCHERR_ATTR_BAD_MR; + } + + for(i=0; sat->sat_equality->smr_compat_syntaxes[i]; i++) { + if( sat->sat_syntax == + sat->sat_equality->smr_compat_syntaxes[i] ) + { + i = -1; + break; + } + } + + if( i >= 0 ) { + *err = sat->sat_substr_oid; + return SLAP_SCHERR_ATTR_BAD_MR; + } + } + + sat->sat_substr = mr; } code = at_insert(sat,err); @@ -517,11 +586,11 @@ at_add( #ifdef LDAP_DEBUG static int -at_index_printnode( struct aindexrec *air ) +at_index_printnode( void *v_air, void *ignore ) { - + struct aindexrec *air = v_air; printf("%s = %s\n", - air->air_name, + air->air_name.bv_val, ldap_attributetype2str(&air->air_at->sat_atype) ); return( 0 ); } @@ -530,34 +599,33 @@ 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 ); + (void) avl_apply( attr_index, at_index_printnode, 0, -1, AVL_INORDER ); } #endif -#if defined( SLAPD_SCHEMA_DN ) int at_schema_info( Entry *e ) { - struct berval val; - struct berval *vals[2]; + AttributeDescription *ad_attributeTypes = slap_schema.si_ad_attributeTypes; AttributeType *at; + struct berval val; + struct berval nval; + + LDAP_SLIST_FOREACH(at,&attr_list,sat_next) { + if( at->sat_flags & SLAP_AT_HIDE ) continue; - 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 [%ld] %s\n", - (long) val.bv_len, val.bv_val, 0 ); - attr_merge( e, "attributeTypes", vals ); - ldap_memfree( val.bv_val ); - } else { + if ( ldap_attributetype2bv( &at->sat_atype, &val ) == NULL ) { return -1; } + + nval.bv_val = at->sat_oid; + nval.bv_len = strlen(at->sat_oid); + + if( attr_merge_one( e, ad_attributeTypes, &val, &nval ) ) + { + return -1; + } + ldap_memfree( val.bv_val ); } return 0; } -#endif