1 /* at.c - routines for dealing with attribute types */
3 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
5 * Copyright 1998-2007 The OpenLDAP Foundation.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted only as authorized by the OpenLDAP
12 * A copy of this license is available in the file LICENSE in the
13 * top-level directory of the distribution or, alternatively, at
14 * <http://www.OpenLDAP.org/license.html>.
23 #include <ac/socket.h>
24 #include <ac/string.h>
34 for ( ; at != NULL; at = at->sat_sup ) {
35 if ( at->sat_syntax_oid ) {
36 return at->sat_syntax_oid;
50 const char *syn_oid = at_syntax( at );
53 return strcmp( syn_oid, oid ) == 0;
63 for( ; sub != NULL; sub = sub->sat_sup ) {
64 if( sub == sup ) return 1;
71 struct berval air_name;
72 AttributeType *air_at;
75 static Avlnode *attr_index = NULL;
76 static Avlnode *attr_cache = NULL;
77 static LDAP_STAILQ_HEAD(ATList, slap_attribute_type) attr_list
78 = LDAP_STAILQ_HEAD_INITIALIZER(attr_list);
80 /* Last hardcoded attribute registered */
81 AttributeType *at_sys_tail;
90 const struct aindexrec *air1 = v_air1;
91 const struct aindexrec *air2 = v_air2;
92 int i = air1->air_name.bv_len - air2->air_name.bv_len;
94 return (strcasecmp( air1->air_name.bv_val, air2->air_name.bv_val ));
102 const struct berval *type = v_type;
103 const struct aindexrec *air = v_air;
104 int i = type->bv_len - air->air_name.bv_len;
106 return (strncasecmp( type->bv_val, air->air_name.bv_val, type->bv_len ));
110 at_find( const char *name )
114 bv.bv_val = (char *)name;
115 bv.bv_len = strlen( name );
117 return at_bvfind( &bv );
121 at_bvfind( struct berval *name )
123 struct aindexrec *air;
126 air = avl_find( attr_cache, name, attr_index_name_cmp );
127 if ( air ) return air->air_at;
130 air = avl_find( attr_index, name, attr_index_name_cmp );
133 if ( air->air_at->sat_flags & SLAP_AT_DELETED ) {
135 } else if (( slapMode & SLAP_TOOL_MODE ) && at_oc_cache ) {
136 avl_insert( &attr_cache, (caddr_t) air,
137 attr_index_cmp, avl_dup_error );
141 return air != NULL ? air->air_at : NULL;
147 AttributeType ***listp )
149 AttributeType **list;
150 AttributeType **list1;
156 list = ch_calloc(size, sizeof(AttributeType *));
168 list1 = ch_realloc(list, size*sizeof(AttributeType *));
183 AttributeType ***listp )
185 AttributeType **list;
186 AttributeType **list1;
194 for ( i=0; list[i]; i++ )
199 for ( i=pos, j=pos+1; list[j]; i++, j++ ) {
203 /* Tell the runtime this can be shrinked */
204 list1 = ch_realloc(list, (i+1)*sizeof(AttributeType **));
215 AttributeType **list )
222 for ( i=0; list[i]; i++ ) {
223 if ( sat == list[i] ) {
231 at_delete_names( AttributeType *at )
233 char **names = at->sat_names;
236 struct aindexrec tmpair, *air;
238 ber_str2bv( *names, 0, 0, &tmpair.air_name );
240 air = (struct aindexrec *)avl_delete( &attr_index,
241 (caddr_t)&tmpair, attr_index_cmp );
242 assert( air != NULL );
248 /* Mark the attribute as deleted, remove from list, and remove all its
249 * names from the AVL tree. Leave the OID in the tree.
252 at_delete( AttributeType *at )
254 at->sat_flags |= SLAP_AT_DELETED;
256 LDAP_STAILQ_REMOVE(&attr_list,at,slap_attribute_type,sat_next);
258 at_delete_names( at );
262 at_clean( AttributeType *a )
264 if ( a->sat_equality ) {
267 mr = mr_find( a->sat_equality->smr_oid );
268 assert( mr != NULL );
269 if ( mr != a->sat_equality ) {
270 ch_free( a->sat_equality );
271 a->sat_equality = NULL;
275 assert( a->sat_syntax != NULL );
276 if ( a->sat_syntax != NULL ) {
279 syn = syn_find( a->sat_syntax->ssyn_oid );
280 assert( syn != NULL );
281 if ( syn != a->sat_syntax ) {
282 ch_free( a->sat_syntax );
283 a->sat_syntax = NULL;
287 if ( a->sat_oidmacro ) ldap_memfree( a->sat_oidmacro );
288 if ( a->sat_subtypes ) ldap_memfree( a->sat_subtypes );
292 at_destroy_one( void *v )
294 struct aindexrec *air = v;
295 AttributeType *a = air->air_at;
298 ad_destroy(a->sat_ad);
299 ldap_pvt_thread_mutex_destroy(&a->sat_ad_mutex);
300 ldap_attributetype_free((LDAPAttributeType *)a);
309 while( !LDAP_STAILQ_EMPTY(&attr_list) ) {
310 a = LDAP_STAILQ_FIRST(&attr_list);
311 LDAP_STAILQ_REMOVE_HEAD(&attr_list, sat_next);
313 at_delete_names( a );
316 avl_free(attr_index, at_destroy_one);
318 if ( slap_schema.si_at_undefined ) {
319 ad_destroy(slap_schema.si_at_undefined->sat_ad);
322 if ( slap_schema.si_at_proxied ) {
323 ad_destroy(slap_schema.si_at_proxied->sat_ad);
328 at_start( AttributeType **at )
330 assert( at != NULL );
332 *at = LDAP_STAILQ_FIRST(&attr_list);
334 return (*at != NULL);
338 at_next( AttributeType **at )
340 assert( at != NULL );
342 #if 1 /* pedantic check */
344 AttributeType *tmp = NULL;
346 LDAP_STAILQ_FOREACH(tmp,&attr_list,sat_next) {
352 assert( tmp != NULL );
356 *at = LDAP_STAILQ_NEXT(*at,sat_next);
358 return (*at != NULL);
362 * check whether the two attributeTypes actually __are__ identical,
363 * or rather inconsistent
368 AttributeType *new_sat )
370 if ( new_sat->sat_oid != NULL ) {
371 if ( sat->sat_oid == NULL ) {
372 return SLAP_SCHERR_ATTR_INCONSISTENT;
375 if ( strcmp( sat->sat_oid, new_sat->sat_oid ) != 0 ) {
376 return SLAP_SCHERR_ATTR_INCONSISTENT;
380 if ( sat->sat_oid != NULL ) {
381 return SLAP_SCHERR_ATTR_INCONSISTENT;
385 if ( new_sat->sat_names ) {
388 if ( sat->sat_names == NULL ) {
389 return SLAP_SCHERR_ATTR_INCONSISTENT;
392 for ( i = 0; new_sat->sat_names[ i ]; i++ ) {
393 if ( sat->sat_names[ i ] == NULL ) {
394 return SLAP_SCHERR_ATTR_INCONSISTENT;
397 if ( strcasecmp( sat->sat_names[ i ],
398 new_sat->sat_names[ i ] ) != 0 )
400 return SLAP_SCHERR_ATTR_INCONSISTENT;
404 if ( sat->sat_names != NULL ) {
405 return SLAP_SCHERR_ATTR_INCONSISTENT;
409 return SLAP_SCHERR_ATTR_DUP;
412 static struct aindexrec *air_old;
415 at_dup_error( void *left, void *right )
427 struct aindexrec *air;
429 AttributeType *sat = *rat;
431 if ( sat->sat_oid ) {
432 air = (struct aindexrec *)
433 ch_calloc( 1, sizeof(struct aindexrec) );
434 ber_str2bv( sat->sat_oid, 0, 0, &air->air_name );
438 if ( avl_insert( &attr_index, (caddr_t) air,
439 attr_index_cmp, at_dup_error ) )
441 AttributeType *old_sat;
446 assert( air_old != NULL );
447 old_sat = air_old->air_at;
449 /* replacing a deleted definition? */
450 if ( old_sat->sat_flags & SLAP_AT_DELETED ) {
453 /* Keep old oid, free new oid;
454 * Keep old ads, free new ads;
455 * Keep new everything else, free old
459 old_sat->sat_oid = tmp.sat_oid;
460 tmp.sat_oid = sat->sat_oid;
461 old_sat->sat_ad = tmp.sat_ad;
462 tmp.sat_ad = sat->sat_ad;
466 at_destroy_one( air );
474 rc = at_check_dup( old_sat, sat );
479 /* FIX: temporal consistency check */
480 at_bvfind( &air->air_name );
483 names = sat->sat_names;
486 air = (struct aindexrec *)
487 ch_calloc( 1, sizeof(struct aindexrec) );
488 ber_str2bv( *names, 0, 0, &air->air_name );
490 if ( avl_insert( &attr_index, (caddr_t) air,
491 attr_index_cmp, avl_dup_error ) )
493 AttributeType *old_sat;
498 old_sat = at_bvfind( &air->air_name );
499 assert( old_sat != NULL );
500 rc = at_check_dup( old_sat, sat );
504 while ( names > sat->sat_names ) {
505 struct aindexrec tmpair;
508 ber_str2bv( *names, 0, 0, &tmpair.air_name );
510 air = (struct aindexrec *)avl_delete( &attr_index,
511 (caddr_t)&tmpair, attr_index_cmp );
512 assert( air != NULL );
516 if ( sat->sat_oid ) {
517 struct aindexrec tmpair;
519 ber_str2bv( sat->sat_oid, 0, 0, &tmpair.air_name );
521 air = (struct aindexrec *)avl_delete( &attr_index,
522 (caddr_t)&tmpair, attr_index_cmp );
523 assert( air != NULL );
529 /* FIX: temporal consistency check */
530 at_bvfind(&air->air_name);
535 if ( sat->sat_oid ) {
536 slap_ad_undef_promote( sat->sat_oid, sat );
539 names = sat->sat_names;
542 slap_ad_undef_promote( *names, sat );
547 if ( sat->sat_flags & SLAP_AT_HARDCODE ) {
552 LDAP_STAILQ_INSERT_AFTER( &attr_list, prev, sat, sat_next );
554 LDAP_STAILQ_INSERT_TAIL( &attr_list, sat, sat_next );
562 LDAPAttributeType *at,
564 AttributeType **rsat,
568 AttributeType *sat = NULL;
569 MatchingRule *mr = NULL;
572 int code = LDAP_SUCCESS;
578 return SLAP_SCHERR_ATTR_INCOMPLETE;
581 if ( !OID_LEADCHAR( at->at_oid[0] )) {
584 /* Expand OID macros */
585 oid = oidm_find( at->at_oid );
588 return SLAP_SCHERR_OIDM;
590 if ( oid != at->at_oid ) {
596 if ( at->at_syntax_oid && !OID_LEADCHAR( at->at_syntax_oid[0] )) {
599 /* Expand OID macros */
600 oid = oidm_find( at->at_syntax_oid );
602 *err = at->at_syntax_oid;
603 code = SLAP_SCHERR_OIDM;
606 if ( oid != at->at_syntax_oid ) {
607 ldap_memfree( at->at_syntax_oid );
608 at->at_syntax_oid = oid;
612 if ( at->at_names && at->at_names[0] ) {
615 for( i=0; at->at_names[i]; i++ ) {
616 if( !slap_valid_descr( at->at_names[i] ) ) {
617 *err = at->at_names[i];
618 code = SLAP_SCHERR_BAD_DESCR;
623 cname = at->at_names[0];
632 if ( !at->at_usage && at->at_no_user_mod ) {
633 /* user attribute must be modifable */
634 code = SLAP_SCHERR_ATTR_BAD_USAGE;
638 if ( at->at_collective ) {
640 /* collective attributes cannot be operational */
641 code = SLAP_SCHERR_ATTR_BAD_USAGE;
645 if( at->at_single_value ) {
646 /* collective attributes cannot be single-valued */
647 code = SLAP_SCHERR_ATTR_BAD_USAGE;
652 sat = (AttributeType *) ch_calloc( 1, sizeof(AttributeType) );
653 AC_MEMCPY( &sat->sat_atype, at, sizeof(LDAPAttributeType));
655 sat->sat_cname.bv_val = cname;
656 sat->sat_cname.bv_len = strlen( cname );
657 sat->sat_oidmacro = oidm;
658 ldap_pvt_thread_mutex_init(&sat->sat_ad_mutex);
660 if ( at->at_sup_oid ) {
661 AttributeType *supsat = at_find(at->at_sup_oid);
663 if ( supsat == NULL ) {
664 *err = at->at_sup_oid;
665 code = SLAP_SCHERR_ATTR_NOT_FOUND;
669 sat->sat_sup = supsat;
671 if ( at_append_to_list(sat, &supsat->sat_subtypes) ) {
672 code = SLAP_SCHERR_OUTOFMEM;
676 if ( sat->sat_usage != supsat->sat_usage ) {
677 /* subtypes must have same usage as their SUP */
678 code = SLAP_SCHERR_ATTR_BAD_USAGE;
682 if ( supsat->sat_obsolete && !sat->sat_obsolete ) {
683 /* subtypes must be obsolete if super is */
684 code = SLAP_SCHERR_ATTR_BAD_SUP;
688 if ( sat->sat_flags & SLAP_AT_FINAL ) {
689 /* cannot subtype a "final" attribute type */
690 code = SLAP_SCHERR_ATTR_BAD_SUP;
696 * Inherit definitions from superiors. We only check the
697 * direct superior since that one has already inherited from
700 if ( sat->sat_sup ) {
701 sat->sat_syntax = sat->sat_sup->sat_syntax;
702 sat->sat_equality = sat->sat_sup->sat_equality;
703 sat->sat_approx = sat->sat_sup->sat_approx;
704 sat->sat_ordering = sat->sat_sup->sat_ordering;
705 sat->sat_substr = sat->sat_sup->sat_substr;
709 * check for X-ORDERED attributes
711 if ( sat->sat_extensions ) {
712 for (i=0; sat->sat_extensions[i]; i++) {
713 if (!strcasecmp( sat->sat_extensions[i]->lsei_name,
714 "X-ORDERED" ) && sat->sat_extensions[i]->lsei_values ) {
715 if ( !strcasecmp( sat->sat_extensions[i]->lsei_values[0],
717 sat->sat_flags |= SLAP_AT_ORDERED_VAL;
719 } else if ( !strcasecmp( sat->sat_extensions[i]->lsei_values[0],
721 sat->sat_flags |= SLAP_AT_ORDERED_SIB;
729 sat->sat_flags |= SLAP_AT_HARDCODE;
731 if ( at->at_syntax_oid ) {
732 syn = syn_find(sat->sat_syntax_oid);
734 *err = sat->sat_syntax_oid;
735 code = SLAP_SCHERR_SYN_NOT_FOUND;
739 if( sat->sat_syntax != NULL && sat->sat_syntax != syn ) {
740 code = SLAP_SCHERR_ATTR_BAD_SUP;
744 sat->sat_syntax = syn;
746 } else if ( sat->sat_syntax == NULL ) {
747 code = SLAP_SCHERR_ATTR_INCOMPLETE;
751 if ( sat->sat_equality_oid ) {
752 mr = mr_find(sat->sat_equality_oid);
755 *err = sat->sat_equality_oid;
756 code = SLAP_SCHERR_MR_NOT_FOUND;
760 if(( mr->smr_usage & SLAP_MR_EQUALITY ) != SLAP_MR_EQUALITY ) {
761 *err = sat->sat_equality_oid;
762 code = SLAP_SCHERR_ATTR_BAD_MR;
766 if( sat->sat_syntax != mr->smr_syntax ) {
767 if( mr->smr_compat_syntaxes == NULL ) {
768 *err = sat->sat_equality_oid;
769 code = SLAP_SCHERR_ATTR_BAD_MR;
773 for(i=0; mr->smr_compat_syntaxes[i]; i++) {
774 if( sat->sat_syntax == mr->smr_compat_syntaxes[i] ) {
781 *err = sat->sat_equality_oid;
782 code = SLAP_SCHERR_ATTR_BAD_MR;
787 sat->sat_equality = mr;
788 sat->sat_approx = mr->smr_associated;
791 if ( sat->sat_ordering_oid ) {
792 if( !sat->sat_equality ) {
793 *err = sat->sat_ordering_oid;
794 code = SLAP_SCHERR_ATTR_BAD_MR;
798 mr = mr_find(sat->sat_ordering_oid);
801 *err = sat->sat_ordering_oid;
802 code = SLAP_SCHERR_MR_NOT_FOUND;
806 if(( mr->smr_usage & SLAP_MR_ORDERING ) != SLAP_MR_ORDERING ) {
807 *err = sat->sat_ordering_oid;
808 code = SLAP_SCHERR_ATTR_BAD_MR;
812 if( sat->sat_syntax != mr->smr_syntax ) {
813 if( mr->smr_compat_syntaxes == NULL ) {
814 *err = sat->sat_ordering_oid;
815 code = SLAP_SCHERR_ATTR_BAD_MR;
819 for(i=0; mr->smr_compat_syntaxes[i]; i++) {
820 if( sat->sat_syntax == mr->smr_compat_syntaxes[i] ) {
827 *err = sat->sat_ordering_oid;
828 code = SLAP_SCHERR_ATTR_BAD_MR;
833 sat->sat_ordering = mr;
836 if ( sat->sat_substr_oid ) {
837 if( !sat->sat_equality ) {
838 *err = sat->sat_substr_oid;
839 code = SLAP_SCHERR_ATTR_BAD_MR;
843 mr = mr_find(sat->sat_substr_oid);
846 *err = sat->sat_substr_oid;
847 code = SLAP_SCHERR_MR_NOT_FOUND;
851 if(( mr->smr_usage & SLAP_MR_SUBSTR ) != SLAP_MR_SUBSTR ) {
852 *err = sat->sat_substr_oid;
853 code = SLAP_SCHERR_ATTR_BAD_MR;
857 /* due to funky LDAP builtin substring rules,
858 * we check against the equality rule assertion
859 * syntax and compat syntaxes instead of those
860 * associated with the substrings rule.
862 if( sat->sat_syntax != sat->sat_equality->smr_syntax ) {
863 if( sat->sat_equality->smr_compat_syntaxes == NULL ) {
864 *err = sat->sat_substr_oid;
865 code = SLAP_SCHERR_ATTR_BAD_MR;
869 for(i=0; sat->sat_equality->smr_compat_syntaxes[i]; i++) {
870 if( sat->sat_syntax ==
871 sat->sat_equality->smr_compat_syntaxes[i] )
879 *err = sat->sat_substr_oid;
880 code = SLAP_SCHERR_ATTR_BAD_MR;
885 sat->sat_substr = mr;
888 code = at_insert( &sat, prev, err );
892 ldap_pvt_thread_mutex_destroy( &sat->sat_ad_mutex );
897 SLAP_FREE( at->at_oid );
911 at_index_printnode( void *v_air, void *ignore )
913 struct aindexrec *air = v_air;
915 air->air_name.bv_val,
916 ldap_attributetype2str(&air->air_at->sat_atype) );
921 at_index_print( void )
923 printf("Printing attribute type index:\n");
924 (void) avl_apply( attr_index, at_index_printnode, 0, -1, AVL_INORDER );
930 at_unparse( BerVarray *res, AttributeType *start, AttributeType *end, int sys )
934 struct berval bv, *bva = NULL, idx;
938 start = LDAP_STAILQ_FIRST( &attr_list );
940 /* count the result size */
942 for ( at=start; at; at=LDAP_STAILQ_NEXT(at, sat_next)) {
943 if ( sys && !(at->sat_flags & SLAP_AT_HARDCODE)) break;
945 if ( at == end ) break;
950 bva = ch_malloc( (num+1) * sizeof(struct berval) );
958 for ( at=start; at; at=LDAP_STAILQ_NEXT(at, sat_next)) {
959 LDAPAttributeType lat, *latp;
960 if ( sys && !(at->sat_flags & SLAP_AT_HARDCODE)) break;
961 if ( at->sat_oidmacro ) {
963 lat.at_oid = at->sat_oidmacro;
966 latp = &at->sat_atype;
968 if ( ldap_attributetype2bv( latp, &bv ) == NULL ) {
969 ber_bvarray_free( bva );
972 idx.bv_len = sprintf(idx.bv_val, "{%d}", i);
974 bva[i].bv_len = idx.bv_len + bv.bv_len;
975 bva[i].bv_val = ch_malloc( bva[i].bv_len + 1 );
976 strcpy( bva[i].bv_val, ibuf );
977 strcpy( bva[i].bv_val + idx.bv_len, bv.bv_val );
979 bva[i].bv_val = NULL;
980 ldap_memfree( bv.bv_val );
981 if ( at == end ) break;
987 at_schema_info( Entry *e )
989 AttributeDescription *ad_attributeTypes = slap_schema.si_ad_attributeTypes;
994 LDAP_STAILQ_FOREACH(at,&attr_list,sat_next) {
995 if( at->sat_flags & SLAP_AT_HIDE ) continue;
997 if ( ldap_attributetype2bv( &at->sat_atype, &val ) == NULL ) {
1001 ber_str2bv( at->sat_oid, 0, 0, &nval );
1003 if( attr_merge_one( e, ad_attributeTypes, &val, &nval ) )
1007 ldap_memfree( val.bv_val );
1013 register_at( char *def, AttributeDescription **rad, int dupok )
1015 LDAPAttributeType *at;
1016 int code, freeit = 0;
1018 AttributeDescription *ad = NULL;
1020 at = ldap_str2attributetype( def, &code, &err, LDAP_SCHEMA_ALLOW_ALL );
1022 Debug( LDAP_DEBUG_ANY,
1023 "register_at: AttributeType \"%s\": %s, %s\n",
1024 def, ldap_scherr2str(code), err );
1028 code = at_add( at, 0, NULL, NULL, &err );
1030 if ( code == SLAP_SCHERR_ATTR_DUP && dupok ) {
1034 ldap_attributetype_free( at );
1035 Debug( LDAP_DEBUG_ANY,
1036 "register_at: AttributeType \"%s\": %s, %s\n",
1037 def, scherr2str(code), err );
1041 code = slap_str2ad( at->at_names[0], &ad, &err );
1042 if ( freeit || code ) {
1043 ldap_attributetype_free( at );
1048 Debug( LDAP_DEBUG_ANY, "register_at: AttributeType \"%s\": %s\n",
1051 if ( rad ) *rad = ad;