X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fat.c;h=44ec64c2e0499b4ddfea3fa46d0c428e0bb8014e;hb=f38e72b26c4a245dc0aa43c0f6310f20ae3fd9cc;hp=14c20bd19f10370f30c6d901a2d3e1191faf5433;hpb=11ef270498d35430f1be45c29f2a3e9c48b6103d;p=openldap diff --git a/servers/slapd/at.c b/servers/slapd/at.c index 14c20bd19f..44ec64c2e0 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-2000 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" @@ -15,164 +24,22 @@ #include #include -#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 ) -{ - 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 -at_config( - const char *fname, - int lineno, - int argc, - char **argv -) +int is_at_syntax( + AttributeType *at, + const char *oid ) { - 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) ); - -#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 ); + for( ; at != NULL; at = at->sat_sup ) { + if( at->sat_syntax_oid ) { + return ( strcmp( at->sat_syntax_oid, oid ) == 0 ); + } } - 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 - int is_at_subtype( AttributeType *sub, AttributeType *sup ) @@ -185,73 +52,76 @@ int is_at_subtype( } struct aindexrec { - char *air_name; + struct berval air_name; AttributeType *air_at; }; static Avlnode *attr_index = NULL; -static AttributeType *attr_list = NULL; +static Avlnode *attr_cache = NULL; +static LDAP_STAILQ_HEAD(ATList, slap_attribute_type) attr_list + = LDAP_STAILQ_HEAD_INITIALIZER(attr_list); + +int at_oc_cache; 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( - const 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 * -at_find( - const char *name -) +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 ); + + return at_bvfind( &bv ); +} + +AttributeType * +at_bvfind( struct berval *name ) +{ + struct aindexrec *air; + + if ( attr_cache ) { + air = avl_find( attr_cache, name, attr_index_name_cmp ); + if ( air ) return air->air_at; } - 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 ); + air = avl_find( attr_index, name, attr_index_name_cmp ); + + if ( air && ( slapMode & SLAP_TOOL_MODE ) && at_oc_cache ) { + avl_insert( &attr_cache, (caddr_t) air, + attr_index_cmp, avl_dup_error ); } - if ( tmpname != name ) - ldap_memfree( tmpname ); - return( NULL ); + return air != NULL ? air->air_at : NULL; } int at_append_to_list( AttributeType *sat, - AttributeType ***listp -) + AttributeType ***listp ) { AttributeType **list; AttributeType **list1; @@ -260,7 +130,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; } @@ -272,7 +142,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; } @@ -287,8 +157,7 @@ at_append_to_list( int at_delete_from_list( int pos, - AttributeType ***listp -) + AttributeType ***listp ) { AttributeType **list; AttributeType **list1; @@ -309,7 +178,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; } @@ -320,8 +189,7 @@ at_delete_from_list( int at_find_in_list( AttributeType *sat, - AttributeType **list -) + AttributeType **list ) { int i; @@ -336,101 +204,328 @@ at_find_in_list( return -1; } +void +at_destroy( void ) +{ + AttributeType *a; + avl_free(attr_index, ldap_memfree); + + while( !LDAP_STAILQ_EMPTY(&attr_list) ) { + a = LDAP_STAILQ_FIRST(&attr_list); + LDAP_STAILQ_REMOVE_HEAD(&attr_list, sat_next); + + if ( a->sat_equality ) { + MatchingRule *mr; + + mr = mr_find( a->sat_equality->smr_oid ); + assert( mr != NULL ); + if ( mr != a->sat_equality ) { + ch_free( a->sat_equality ); + a->sat_equality = NULL; + } + } + + assert( a->sat_syntax != NULL ); + if ( a->sat_syntax != NULL ) { + Syntax *syn; + + syn = syn_find( a->sat_syntax->ssyn_oid ); + assert( syn != NULL ); + if ( syn != a->sat_syntax ) { + ch_free( a->sat_syntax ); + a->sat_syntax = NULL; + } + } + + if ( a->sat_oidmacro ) ldap_memfree( a->sat_oidmacro ); + 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 != NULL ); + + *at = LDAP_STAILQ_FIRST(&attr_list); + + return (*at != NULL); +} + +int +at_next( AttributeType **at ) +{ + assert( at != NULL ); + +#if 1 /* pedantic check */ + { + AttributeType *tmp = NULL; + + LDAP_STAILQ_FOREACH(tmp,&attr_list,sat_next) { + if ( tmp == *at ) { + break; + } + } + + assert( tmp != NULL ); + } +#endif + + *at = LDAP_STAILQ_NEXT(*at,sat_next); + + return (*at != NULL); +} + +/* + * check whether the two attributeTypes actually __are__ identical, + * or rather inconsistent + */ +static int +at_check_dup( + AttributeType *sat, + AttributeType *new_sat ) +{ + if ( new_sat->sat_oid != NULL ) { + if ( sat->sat_oid == NULL ) { + return SLAP_SCHERR_ATTR_INCONSISTENT; + } + + if ( strcmp( sat->sat_oid, new_sat->sat_oid ) != 0 ) { + return SLAP_SCHERR_ATTR_INCONSISTENT; + } + + } else { + if ( sat->sat_oid != NULL ) { + return SLAP_SCHERR_ATTR_INCONSISTENT; + } + } + + if ( new_sat->sat_names ) { + int i; + + if ( sat->sat_names == NULL ) { + return SLAP_SCHERR_ATTR_INCONSISTENT; + } + + for ( i = 0; new_sat->sat_names[ i ]; i++ ) { + if ( sat->sat_names[ i ] == NULL ) { + return SLAP_SCHERR_ATTR_INCONSISTENT; + } + + if ( strcasecmp( sat->sat_names[ i ], + new_sat->sat_names[ i ] ) != 0 ) + { + return SLAP_SCHERR_ATTR_INCONSISTENT; + } + } + } else { + if ( sat->sat_names != NULL ) { + return SLAP_SCHERR_ATTR_INCONSISTENT; + } + } + + return SLAP_SCHERR_ATTR_DUP; +} + + static int at_insert( AttributeType *sat, - const char **err -) + const char **err ) { - 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_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 ) ) + { + AttributeType *old_sat; + int rc; + *err = sat->sat_oid; - ldap_memfree(air); - return SLAP_SCHERR_DUP_ATTR; + + old_sat = at_bvfind( &air->air_name ); + assert( old_sat != NULL ); + rc = at_check_dup( old_sat, sat ); + + ldap_memfree( air ); + + return rc; } /* FIX: temporal consistency check */ - at_find(air->air_name); + at_bvfind( &air->air_name ); } - if ( (names = sat->sat_names) ) { + names = sat->sat_names; + if ( 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 ) ) + { + AttributeType *old_sat; + int rc; + *err = *names; - ldap_memfree(air->air_name); + + old_sat = at_bvfind( &air->air_name ); + assert( old_sat != NULL ); + rc = at_check_dup( old_sat, sat ); + ldap_memfree(air); - return SLAP_SCHERR_DUP_ATTR; + + return rc; } /* FIX: temporal consistency check */ - at_find(air->air_name); + at_bvfind(&air->air_name); names++; } } + LDAP_STAILQ_INSERT_TAIL( &attr_list, sat, sat_next ); + return 0; } int at_add( - LDAP_ATTRIBUTE_TYPE *at, - const char **err -) + LDAPAttributeType *at, + int user, + AttributeType **rsat, + const char **err ) { AttributeType *sat; MatchingRule *mr; Syntax *syn; + int i; int code; - char *cname; + char *cname; + char *oid; + char *oidm = NULL; + + 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 ) { + oidm = 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 ); + sat->sat_oidmacro = oidm; + 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; + code = SLAP_SCHERR_ATTR_NOT_FOUND; + goto error_return; } sat->sat_sup = supsat; if ( at_append_to_list(sat, &supsat->sat_subtypes) ) { - *err = cname; - return SLAP_SCHERR_OUTOFMEM; + code = SLAP_SCHERR_OUTOFMEM; + goto error_return; + } + + if ( sat->sat_usage != supsat->sat_usage ) { + /* subtypes must have same usage as their SUP */ + code = SLAP_SCHERR_ATTR_BAD_USAGE; + goto error_return; + } + + if ( supsat->sat_obsolete && !sat->sat_obsolete ) { + /* subtypes must be obsolete if super is */ + code = SLAP_SCHERR_ATTR_BAD_SUP; + goto error_return; + } + + if ( sat->sat_flags & SLAP_AT_FINAL ) { + /* cannot subtype a "final" attribute type */ + code = SLAP_SCHERR_ATTR_BAD_SUP; + goto error_return; } } @@ -441,98 +536,219 @@ at_add( */ if ( sat->sat_sup ) { sat->sat_syntax = sat->sat_sup->sat_syntax; -#ifndef SLAPD_SCHEMA_NOT_COMPAT - sat->sat_syntax_compat = sat->sat_sup->sat_syntax_compat; -#endif 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; } + /* + * check for X-ORDERED attributes + */ + if ( sat->sat_extensions ) { + for (i=0; sat->sat_extensions[i]; i++) { + if (!strcasecmp( sat->sat_extensions[i]->lsei_name, + "X-ORDERED" ) && sat->sat_extensions[i]->lsei_values ) { + if ( !strcasecmp( sat->sat_extensions[i]->lsei_values[0], + "VALUES" )) { + sat->sat_flags |= SLAP_AT_ORDERED_VAL; + break; + } else if ( !strcasecmp( sat->sat_extensions[i]->lsei_values[0], + "SIBLINGS" )) { + sat->sat_flags |= SLAP_AT_ORDERED_SIB; + break; + } + } + } + } + + if ( !user ) + sat->sat_flags |= SLAP_AT_HARDCODE; + 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; + code = SLAP_SCHERR_SYN_NOT_FOUND; + goto error_return; } -#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; - } + if( sat->sat_syntax != NULL && sat->sat_syntax != syn ) { + code = SLAP_SCHERR_ATTR_BAD_SUP; + goto error_return; + } - } 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; - } + sat->sat_syntax = syn; - } else if ( !strcmp(at->at_syntax_oid, SYNTAX_DN_OID ) ) { - sat->sat_syntax_compat = SYNTAX_CIS | SYNTAX_DN; + } else if ( sat->sat_syntax == NULL ) { + code = SLAP_SCHERR_ATTR_INCOMPLETE; + goto error_return; + } - } else if ( !strcmp(at->at_syntax_oid, SYNTAX_TEL_OID ) ) { - sat->sat_syntax_compat = SYNTAX_CIS | SYNTAX_TEL; + if ( sat->sat_equality_oid ) { + mr = mr_find(sat->sat_equality_oid); - } else if ( !strcmp(at->at_syntax_oid, SYNTAX_BIN_OID ) ) { - sat->sat_syntax_compat = SYNTAX_BIN; + if( mr == NULL ) { + *err = sat->sat_equality_oid; + code = SLAP_SCHERR_MR_NOT_FOUND; + goto error_return; + } - } else { - sat->sat_syntax_compat = DEFAULT_SYNTAX; + if(( mr->smr_usage & SLAP_MR_EQUALITY ) != SLAP_MR_EQUALITY ) { + *err = sat->sat_equality_oid; + code = SLAP_SCHERR_ATTR_BAD_MR; + goto error_return; } -#endif - } else if ( sat->sat_syntax == NULL ) { - return SLAP_SCHERR_ATTR_INCOMPLETE; - } + if( sat->sat_syntax != mr->smr_syntax ) { + if( mr->smr_compat_syntaxes == NULL ) { + *err = sat->sat_equality_oid; + code = SLAP_SCHERR_ATTR_BAD_MR; + goto error_return; + } - 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; + 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; + code = SLAP_SCHERR_ATTR_BAD_MR; + goto error_return; + } } + 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; + code = SLAP_SCHERR_ATTR_BAD_MR; + goto error_return; + } + + mr = mr_find(sat->sat_ordering_oid); + + if( mr == NULL ) { *err = sat->sat_ordering_oid; - return SLAP_SCHERR_MR_NOT_FOUND; + code = SLAP_SCHERR_MR_NOT_FOUND; + goto error_return; + } + + if(( mr->smr_usage & SLAP_MR_ORDERING ) != SLAP_MR_ORDERING ) { + *err = sat->sat_ordering_oid; + code = SLAP_SCHERR_ATTR_BAD_MR; + goto error_return; + } + + if( sat->sat_syntax != mr->smr_syntax ) { + if( mr->smr_compat_syntaxes == NULL ) { + *err = sat->sat_ordering_oid; + code = SLAP_SCHERR_ATTR_BAD_MR; + goto error_return; + } + + 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; + code = SLAP_SCHERR_ATTR_BAD_MR; + goto error_return; + } } + + 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; + code = SLAP_SCHERR_ATTR_BAD_MR; + goto error_return; + } + + mr = mr_find(sat->sat_substr_oid); + + if( mr == NULL ) { *err = sat->sat_substr_oid; - return SLAP_SCHERR_MR_NOT_FOUND; + code = SLAP_SCHERR_MR_NOT_FOUND; + goto error_return; } + + if(( mr->smr_usage & SLAP_MR_SUBSTR ) != SLAP_MR_SUBSTR ) { + *err = sat->sat_substr_oid; + code = SLAP_SCHERR_ATTR_BAD_MR; + goto error_return; + } + + /* due to funky LDAP builtin substring rules, + * 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; + code = SLAP_SCHERR_ATTR_BAD_MR; + goto error_return; + } + + 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; + code = SLAP_SCHERR_ATTR_BAD_MR; + goto error_return; + } + } + + sat->sat_substr = mr; + } + + code = at_insert( sat, err ); + if ( code != 0 ) { +error_return:; + if ( sat ) { + ldap_pvt_thread_mutex_destroy( &sat->sat_ad_mutex ); + ch_free( sat ); + } + + if ( oidm ) { + SLAP_FREE( at->at_oid ); + at->at_oid = oidm; + } + + } else if ( rsat ) { + *rsat = sat; } - code = at_insert(sat,err); return code; } #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 ); } @@ -541,41 +757,89 @@ 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 ) +void +at_unparse( BerVarray *res, AttributeType *start, AttributeType *end, int sys ) +{ + AttributeType *at; + int i, num; + struct berval bv, *bva = NULL, idx; + char ibuf[32]; + + if ( !start ) + start = LDAP_STAILQ_FIRST( &attr_list ); + + /* count the result size */ + i = 0; + for ( at=start; at; at=LDAP_STAILQ_NEXT(at, sat_next)) { + if ( sys && !(at->sat_flags & SLAP_AT_HARDCODE)) continue; + i++; + if ( at == end ) break; + } + if (!i) return; + + num = i; + bva = ch_malloc( (num+1) * sizeof(struct berval) ); + BER_BVZERO( bva ); + idx.bv_val = ibuf; + if ( sys ) { + idx.bv_len = 0; + ibuf[0] = '\0'; + } + i = 0; + for ( at=start; at; at=LDAP_STAILQ_NEXT(at, sat_next)) { + LDAPAttributeType lat, *latp; + if ( sys && !(at->sat_flags & SLAP_AT_HARDCODE)) continue; + if ( at->sat_oidmacro ) { + lat = at->sat_atype; + lat.at_oid = at->sat_oidmacro; + latp = ⪫ + } else { + latp = &at->sat_atype; + } + if ( ldap_attributetype2bv( latp, &bv ) == NULL ) { + ber_bvarray_free( bva ); + } + if ( !sys ) { + idx.bv_len = sprintf(idx.bv_val, "{%d}", i); + } + bva[i].bv_len = idx.bv_len + bv.bv_len; + bva[i].bv_val = ch_malloc( bva[i].bv_len + 1 ); + strcpy( bva[i].bv_val, ibuf ); + strcpy( bva[i].bv_val + idx.bv_len, bv.bv_val ); + i++; + bva[i].bv_val = NULL; + ldap_memfree( bv.bv_val ); + if ( at == end ) break; + } + *res = bva; +} + 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; -#ifdef SLAPD_SCHEMA_NOT_COMPAT - AttributeDescription *ad_attributeTypes = slap_schema.si_ad_attributeTypes; -#else - char *ad_attributeTypes = "attributeTypes"; -#endif + LDAP_STAILQ_FOREACH(at,&attr_list,sat_next) { + if( at->sat_flags & SLAP_AT_HIDE ) continue; - vals[0] = &val; - vals[1] = NULL; + if ( ldap_attributetype2bv( &at->sat_atype, &val ) == NULL ) { + return -1; + } - for ( at = attr_list; at; at = at->sat_next ) { - val.bv_val = ldap_attributetype2str( &at->sat_atype ); - if ( val.bv_val == NULL ) { + ber_str2bv( at->sat_oid, 0, 0, &nval ); + + if( attr_merge_one( e, ad_attributeTypes, &val, &nval ) ) + { return -1; } - val.bv_len = strlen( val.bv_val ); -#if 0 - Debug( LDAP_DEBUG_TRACE, "Merging at [%ld] %s\n", - (long) val.bv_len, val.bv_val, 0 ); -#endif - attr_merge( e, ad_attributeTypes, vals ); ldap_memfree( val.bv_val ); } return 0; } -#endif