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 ) {
288 ldap_memfree( a->sat_oidmacro );
289 a->sat_oidmacro = NULL;
291 if ( a->sat_subtypes ) {
292 ldap_memfree( a->sat_subtypes );
293 a->sat_subtypes = NULL;
298 at_destroy_one( void *v )
300 struct aindexrec *air = v;
301 AttributeType *a = air->air_at;
304 ad_destroy(a->sat_ad);
305 ldap_pvt_thread_mutex_destroy(&a->sat_ad_mutex);
306 ldap_attributetype_free((LDAPAttributeType *)a);
315 while( !LDAP_STAILQ_EMPTY(&attr_list) ) {
316 a = LDAP_STAILQ_FIRST(&attr_list);
317 LDAP_STAILQ_REMOVE_HEAD(&attr_list, sat_next);
319 at_delete_names( a );
322 avl_free(attr_index, at_destroy_one);
324 if ( slap_schema.si_at_undefined ) {
325 ad_destroy(slap_schema.si_at_undefined->sat_ad);
328 if ( slap_schema.si_at_proxied ) {
329 ad_destroy(slap_schema.si_at_proxied->sat_ad);
334 at_start( AttributeType **at )
336 assert( at != NULL );
338 *at = LDAP_STAILQ_FIRST(&attr_list);
340 return (*at != NULL);
344 at_next( AttributeType **at )
346 assert( at != NULL );
348 #if 0 /* pedantic check: don't use this */
350 AttributeType *tmp = NULL;
352 LDAP_STAILQ_FOREACH(tmp,&attr_list,sat_next) {
358 assert( tmp != NULL );
362 *at = LDAP_STAILQ_NEXT(*at,sat_next);
364 return (*at != NULL);
368 * check whether the two attributeTypes actually __are__ identical,
369 * or rather inconsistent
374 AttributeType *new_sat )
376 if ( new_sat->sat_oid != NULL ) {
377 if ( sat->sat_oid == NULL ) {
378 return SLAP_SCHERR_ATTR_INCONSISTENT;
381 if ( strcmp( sat->sat_oid, new_sat->sat_oid ) != 0 ) {
382 return SLAP_SCHERR_ATTR_INCONSISTENT;
386 if ( sat->sat_oid != NULL ) {
387 return SLAP_SCHERR_ATTR_INCONSISTENT;
391 if ( new_sat->sat_names ) {
394 if ( sat->sat_names == NULL ) {
395 return SLAP_SCHERR_ATTR_INCONSISTENT;
398 for ( i = 0; new_sat->sat_names[ i ]; i++ ) {
399 if ( sat->sat_names[ i ] == NULL ) {
400 return SLAP_SCHERR_ATTR_INCONSISTENT;
403 if ( strcasecmp( sat->sat_names[ i ],
404 new_sat->sat_names[ i ] ) != 0 )
406 return SLAP_SCHERR_ATTR_INCONSISTENT;
410 if ( sat->sat_names != NULL ) {
411 return SLAP_SCHERR_ATTR_INCONSISTENT;
415 return SLAP_SCHERR_ATTR_DUP;
418 static struct aindexrec *air_old;
421 at_dup_error( void *left, void *right )
433 struct aindexrec *air;
435 AttributeType *sat = *rat;
437 if ( sat->sat_oid ) {
438 air = (struct aindexrec *)
439 ch_calloc( 1, sizeof(struct aindexrec) );
440 ber_str2bv( sat->sat_oid, 0, 0, &air->air_name );
444 if ( avl_insert( &attr_index, (caddr_t) air,
445 attr_index_cmp, at_dup_error ) )
447 AttributeType *old_sat;
452 assert( air_old != NULL );
453 old_sat = air_old->air_at;
455 /* replacing a deleted definition? */
456 if ( old_sat->sat_flags & SLAP_AT_DELETED ) {
458 AttributeDescription *ad;
460 /* Keep old oid, free new oid;
461 * Keep old ads, free new ads;
462 * Keep new everything else, free old
466 old_sat->sat_oid = tmp.sat_oid;
467 tmp.sat_oid = sat->sat_oid;
468 old_sat->sat_ad = tmp.sat_ad;
469 tmp.sat_ad = sat->sat_ad;
472 /* Check for basic ad pointing at old cname */
473 for ( ad = old_sat->sat_ad; ad; ad=ad->ad_next ) {
474 if ( ad->ad_cname.bv_val == sat->sat_cname.bv_val ) {
475 ad->ad_cname = old_sat->sat_cname;
481 at_destroy_one( air );
489 rc = at_check_dup( old_sat, sat );
494 /* FIX: temporal consistency check */
495 at_bvfind( &air->air_name );
498 names = sat->sat_names;
501 air = (struct aindexrec *)
502 ch_calloc( 1, sizeof(struct aindexrec) );
503 ber_str2bv( *names, 0, 0, &air->air_name );
505 if ( avl_insert( &attr_index, (caddr_t) air,
506 attr_index_cmp, avl_dup_error ) )
508 AttributeType *old_sat;
513 old_sat = at_bvfind( &air->air_name );
514 assert( old_sat != NULL );
515 rc = at_check_dup( old_sat, sat );
519 while ( names > sat->sat_names ) {
520 struct aindexrec tmpair;
523 ber_str2bv( *names, 0, 0, &tmpair.air_name );
525 air = (struct aindexrec *)avl_delete( &attr_index,
526 (caddr_t)&tmpair, attr_index_cmp );
527 assert( air != NULL );
531 if ( sat->sat_oid ) {
532 struct aindexrec tmpair;
534 ber_str2bv( sat->sat_oid, 0, 0, &tmpair.air_name );
536 air = (struct aindexrec *)avl_delete( &attr_index,
537 (caddr_t)&tmpair, attr_index_cmp );
538 assert( air != NULL );
544 /* FIX: temporal consistency check */
545 at_bvfind(&air->air_name);
550 if ( sat->sat_oid ) {
551 slap_ad_undef_promote( sat->sat_oid, sat );
554 names = sat->sat_names;
557 slap_ad_undef_promote( *names, sat );
562 if ( sat->sat_flags & SLAP_AT_HARDCODE ) {
567 LDAP_STAILQ_INSERT_AFTER( &attr_list, prev, sat, sat_next );
569 LDAP_STAILQ_INSERT_TAIL( &attr_list, sat, sat_next );
577 LDAPAttributeType *at,
579 AttributeType **rsat,
583 AttributeType *sat = NULL;
584 MatchingRule *mr = NULL;
587 int code = LDAP_SUCCESS;
593 return SLAP_SCHERR_ATTR_INCOMPLETE;
596 if ( !OID_LEADCHAR( at->at_oid[0] )) {
599 /* Expand OID macros */
600 oid = oidm_find( at->at_oid );
603 return SLAP_SCHERR_OIDM;
605 if ( oid != at->at_oid ) {
611 if ( at->at_syntax_oid && !OID_LEADCHAR( at->at_syntax_oid[0] )) {
614 /* Expand OID macros */
615 oid = oidm_find( at->at_syntax_oid );
617 *err = at->at_syntax_oid;
618 code = SLAP_SCHERR_OIDM;
621 if ( oid != at->at_syntax_oid ) {
622 ldap_memfree( at->at_syntax_oid );
623 at->at_syntax_oid = oid;
627 if ( at->at_names && at->at_names[0] ) {
630 for( i=0; at->at_names[i]; i++ ) {
631 if( !slap_valid_descr( at->at_names[i] ) ) {
632 *err = at->at_names[i];
633 code = SLAP_SCHERR_BAD_DESCR;
638 cname = at->at_names[0];
647 if ( !at->at_usage && at->at_no_user_mod ) {
648 /* user attribute must be modifable */
649 code = SLAP_SCHERR_ATTR_BAD_USAGE;
653 if ( at->at_collective ) {
655 /* collective attributes cannot be operational */
656 code = SLAP_SCHERR_ATTR_BAD_USAGE;
660 if( at->at_single_value ) {
661 /* collective attributes cannot be single-valued */
662 code = SLAP_SCHERR_ATTR_BAD_USAGE;
667 sat = (AttributeType *) ch_calloc( 1, sizeof(AttributeType) );
668 AC_MEMCPY( &sat->sat_atype, at, sizeof(LDAPAttributeType));
670 sat->sat_cname.bv_val = cname;
671 sat->sat_cname.bv_len = strlen( cname );
672 sat->sat_oidmacro = oidm;
673 ldap_pvt_thread_mutex_init(&sat->sat_ad_mutex);
675 if ( at->at_sup_oid ) {
676 AttributeType *supsat = at_find(at->at_sup_oid);
678 if ( supsat == NULL ) {
679 *err = at->at_sup_oid;
680 code = SLAP_SCHERR_ATTR_NOT_FOUND;
684 sat->sat_sup = supsat;
686 if ( at_append_to_list(sat, &supsat->sat_subtypes) ) {
687 code = SLAP_SCHERR_OUTOFMEM;
691 if ( sat->sat_usage != supsat->sat_usage ) {
692 /* subtypes must have same usage as their SUP */
693 code = SLAP_SCHERR_ATTR_BAD_USAGE;
697 if ( supsat->sat_obsolete && !sat->sat_obsolete ) {
698 /* subtypes must be obsolete if super is */
699 code = SLAP_SCHERR_ATTR_BAD_SUP;
703 if ( sat->sat_flags & SLAP_AT_FINAL ) {
704 /* cannot subtype a "final" attribute type */
705 code = SLAP_SCHERR_ATTR_BAD_SUP;
711 * Inherit definitions from superiors. We only check the
712 * direct superior since that one has already inherited from
715 if ( sat->sat_sup ) {
716 sat->sat_syntax = sat->sat_sup->sat_syntax;
717 sat->sat_equality = sat->sat_sup->sat_equality;
718 sat->sat_approx = sat->sat_sup->sat_approx;
719 sat->sat_ordering = sat->sat_sup->sat_ordering;
720 sat->sat_substr = sat->sat_sup->sat_substr;
724 * check for X-ORDERED attributes
726 if ( sat->sat_extensions ) {
727 for (i=0; sat->sat_extensions[i]; i++) {
728 if (!strcasecmp( sat->sat_extensions[i]->lsei_name,
729 "X-ORDERED" ) && sat->sat_extensions[i]->lsei_values ) {
730 if ( !strcasecmp( sat->sat_extensions[i]->lsei_values[0],
732 sat->sat_flags |= SLAP_AT_ORDERED_VAL;
734 } else if ( !strcasecmp( sat->sat_extensions[i]->lsei_values[0],
736 sat->sat_flags |= SLAP_AT_ORDERED_SIB;
744 sat->sat_flags |= SLAP_AT_HARDCODE;
746 if ( at->at_syntax_oid ) {
747 syn = syn_find(sat->sat_syntax_oid);
749 *err = sat->sat_syntax_oid;
750 code = SLAP_SCHERR_SYN_NOT_FOUND;
754 if( sat->sat_syntax != NULL && sat->sat_syntax != syn ) {
755 code = SLAP_SCHERR_ATTR_BAD_SUP;
759 sat->sat_syntax = syn;
761 } else if ( sat->sat_syntax == NULL ) {
762 code = SLAP_SCHERR_ATTR_INCOMPLETE;
766 if ( sat->sat_equality_oid ) {
767 mr = mr_find(sat->sat_equality_oid);
770 *err = sat->sat_equality_oid;
771 code = SLAP_SCHERR_MR_NOT_FOUND;
775 if(( mr->smr_usage & SLAP_MR_EQUALITY ) != SLAP_MR_EQUALITY ) {
776 *err = sat->sat_equality_oid;
777 code = SLAP_SCHERR_ATTR_BAD_MR;
781 if( sat->sat_syntax != mr->smr_syntax ) {
782 if( mr->smr_compat_syntaxes == NULL ) {
783 *err = sat->sat_equality_oid;
784 code = SLAP_SCHERR_ATTR_BAD_MR;
788 for(i=0; mr->smr_compat_syntaxes[i]; i++) {
789 if( sat->sat_syntax == mr->smr_compat_syntaxes[i] ) {
796 *err = sat->sat_equality_oid;
797 code = SLAP_SCHERR_ATTR_BAD_MR;
802 sat->sat_equality = mr;
803 sat->sat_approx = mr->smr_associated;
806 if ( sat->sat_ordering_oid ) {
807 if( !sat->sat_equality ) {
808 *err = sat->sat_ordering_oid;
809 code = SLAP_SCHERR_ATTR_BAD_MR;
813 mr = mr_find(sat->sat_ordering_oid);
816 *err = sat->sat_ordering_oid;
817 code = SLAP_SCHERR_MR_NOT_FOUND;
821 if(( mr->smr_usage & SLAP_MR_ORDERING ) != SLAP_MR_ORDERING ) {
822 *err = sat->sat_ordering_oid;
823 code = SLAP_SCHERR_ATTR_BAD_MR;
827 if( sat->sat_syntax != mr->smr_syntax ) {
828 if( mr->smr_compat_syntaxes == NULL ) {
829 *err = sat->sat_ordering_oid;
830 code = SLAP_SCHERR_ATTR_BAD_MR;
834 for(i=0; mr->smr_compat_syntaxes[i]; i++) {
835 if( sat->sat_syntax == mr->smr_compat_syntaxes[i] ) {
842 *err = sat->sat_ordering_oid;
843 code = SLAP_SCHERR_ATTR_BAD_MR;
848 sat->sat_ordering = mr;
851 if ( sat->sat_substr_oid ) {
852 if( !sat->sat_equality ) {
853 *err = sat->sat_substr_oid;
854 code = SLAP_SCHERR_ATTR_BAD_MR;
858 mr = mr_find(sat->sat_substr_oid);
861 *err = sat->sat_substr_oid;
862 code = SLAP_SCHERR_MR_NOT_FOUND;
866 if(( mr->smr_usage & SLAP_MR_SUBSTR ) != SLAP_MR_SUBSTR ) {
867 *err = sat->sat_substr_oid;
868 code = SLAP_SCHERR_ATTR_BAD_MR;
872 /* due to funky LDAP builtin substring rules,
873 * we check against the equality rule assertion
874 * syntax and compat syntaxes instead of those
875 * associated with the substrings rule.
877 if( sat->sat_syntax != sat->sat_equality->smr_syntax ) {
878 if( sat->sat_equality->smr_compat_syntaxes == NULL ) {
879 *err = sat->sat_substr_oid;
880 code = SLAP_SCHERR_ATTR_BAD_MR;
884 for(i=0; sat->sat_equality->smr_compat_syntaxes[i]; i++) {
885 if( sat->sat_syntax ==
886 sat->sat_equality->smr_compat_syntaxes[i] )
894 *err = sat->sat_substr_oid;
895 code = SLAP_SCHERR_ATTR_BAD_MR;
900 sat->sat_substr = mr;
903 code = at_insert( &sat, prev, err );
907 ldap_pvt_thread_mutex_destroy( &sat->sat_ad_mutex );
912 SLAP_FREE( at->at_oid );
926 at_index_printnode( void *v_air, void *ignore )
928 struct aindexrec *air = v_air;
930 air->air_name.bv_val,
931 ldap_attributetype2str(&air->air_at->sat_atype) );
936 at_index_print( void )
938 printf("Printing attribute type index:\n");
939 (void) avl_apply( attr_index, at_index_printnode, 0, -1, AVL_INORDER );
945 at_unparse( BerVarray *res, AttributeType *start, AttributeType *end, int sys )
949 struct berval bv, *bva = NULL, idx;
953 start = LDAP_STAILQ_FIRST( &attr_list );
955 /* count the result size */
957 for ( at=start; at; at=LDAP_STAILQ_NEXT(at, sat_next)) {
958 if ( sys && !(at->sat_flags & SLAP_AT_HARDCODE)) break;
960 if ( at == end ) break;
965 bva = ch_malloc( (num+1) * sizeof(struct berval) );
973 for ( at=start; at; at=LDAP_STAILQ_NEXT(at, sat_next)) {
974 LDAPAttributeType lat, *latp;
975 if ( sys && !(at->sat_flags & SLAP_AT_HARDCODE)) break;
976 if ( at->sat_oidmacro ) {
978 lat.at_oid = at->sat_oidmacro;
981 latp = &at->sat_atype;
983 if ( ldap_attributetype2bv( latp, &bv ) == NULL ) {
984 ber_bvarray_free( bva );
987 idx.bv_len = sprintf(idx.bv_val, "{%d}", i);
989 bva[i].bv_len = idx.bv_len + bv.bv_len;
990 bva[i].bv_val = ch_malloc( bva[i].bv_len + 1 );
991 strcpy( bva[i].bv_val, ibuf );
992 strcpy( bva[i].bv_val + idx.bv_len, bv.bv_val );
994 bva[i].bv_val = NULL;
995 ldap_memfree( bv.bv_val );
996 if ( at == end ) break;
1002 at_schema_info( Entry *e )
1004 AttributeDescription *ad_attributeTypes = slap_schema.si_ad_attributeTypes;
1009 LDAP_STAILQ_FOREACH(at,&attr_list,sat_next) {
1010 if( at->sat_flags & SLAP_AT_HIDE ) continue;
1012 if ( ldap_attributetype2bv( &at->sat_atype, &val ) == NULL ) {
1016 ber_str2bv( at->sat_oid, 0, 0, &nval );
1018 if( attr_merge_one( e, ad_attributeTypes, &val, &nval ) )
1022 ldap_memfree( val.bv_val );
1028 register_at( char *def, AttributeDescription **rad, int dupok )
1030 LDAPAttributeType *at;
1031 int code, freeit = 0;
1033 AttributeDescription *ad = NULL;
1035 at = ldap_str2attributetype( def, &code, &err, LDAP_SCHEMA_ALLOW_ALL );
1037 Debug( LDAP_DEBUG_ANY,
1038 "register_at: AttributeType \"%s\": %s, %s\n",
1039 def, ldap_scherr2str(code), err );
1043 code = at_add( at, 0, NULL, NULL, &err );
1045 if ( code == SLAP_SCHERR_ATTR_DUP && dupok ) {
1049 ldap_attributetype_free( at );
1050 Debug( LDAP_DEBUG_ANY,
1051 "register_at: AttributeType \"%s\": %s, %s\n",
1052 def, scherr2str(code), err );
1056 code = slap_str2ad( at->at_names[0], &ad, &err );
1057 if ( freeit || code ) {
1058 ldap_attributetype_free( at );
1063 Debug( LDAP_DEBUG_ANY, "register_at: AttributeType \"%s\": %s\n",
1066 if ( rad ) *rad = ad;