?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Patrick Welche <prlw1@cam.ac.uk>
[netbsd-mini2440.git] / external / bsd / openldap / dist / servers / slapd / at.c
blobc8f97e7bed7c332d6020982e1eea2d58c93c506d
1 /* at.c - routines for dealing with attribute types */
2 /* $OpenLDAP: pkg/ldap/servers/slapd/at.c,v 1.84.2.6 2008/07/08 19:01:38 quanah Exp $ */
3 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
4 *
5 * Copyright 1998-2008 The OpenLDAP Foundation.
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted only as authorized by the OpenLDAP
10 * Public License.
11 *
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>.
15 */
16
17 #include "portable.h"
18
19 #include <stdio.h>
20
21 #include <ac/ctype.h>
22 #include <ac/errno.h>
23 #include <ac/socket.h>
24 #include <ac/string.h>
25 #include <ac/time.h>
26
27 #include "slap.h"
28
29
30 const char *
31 at_syntax(
32 AttributeType *at )
33 {
34 for ( ; at != NULL; at = at->sat_sup ) {
35 if ( at->sat_syntax_oid ) {
36 return at->sat_syntax_oid;
37 }
38 }
39
40 assert( 0 );
41
42 return NULL;
43 }
44
45 int
46 is_at_syntax(
47 AttributeType *at,
48 const char *oid )
49 {
50 const char *syn_oid = at_syntax( at );
51
52 if ( syn_oid ) {
53 return strcmp( syn_oid, oid ) == 0;
54 }
55
56 return 0;
57 }
58
59 int is_at_subtype(
60 AttributeType *sub,
61 AttributeType *sup )
62 {
63 for( ; sub != NULL; sub = sub->sat_sup ) {
64 if( sub == sup ) return 1;
65 }
66
67 return 0;
68 }
69
70 struct aindexrec {
71 struct berval air_name;
72 AttributeType *air_at;
73 };
74
75 static Avlnode *attr_index = NULL;
76 static Avlnode *attr_cache = NULL;
77 static LDAP_STAILQ_HEAD(ATList, AttributeType) attr_list
78 = LDAP_STAILQ_HEAD_INITIALIZER(attr_list);
79
80 /* Last hardcoded attribute registered */
81 AttributeType *at_sys_tail;
82
83 int at_oc_cache;
84
85 static int
86 attr_index_cmp(
87 const void *v_air1,
88 const void *v_air2 )
89 {
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;
93 if (i) return i;
94 return (strcasecmp( air1->air_name.bv_val, air2->air_name.bv_val ));
95 }
96
97 static int
98 attr_index_name_cmp(
99 const void *v_type,
100 const void *v_air )
101 {
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;
105 if (i) return i;
106 return (strncasecmp( type->bv_val, air->air_name.bv_val, type->bv_len ));
107 }
108
109 AttributeType *
110 at_find( const char *name )
111 {
112 struct berval bv;
113
114 bv.bv_val = (char *)name;
115 bv.bv_len = strlen( name );
116
117 return at_bvfind( &bv );
118 }
119
120 AttributeType *
121 at_bvfind( struct berval *name )
122 {
123 struct aindexrec *air;
124
125 if ( attr_cache ) {
126 air = avl_find( attr_cache, name, attr_index_name_cmp );
127 if ( air ) return air->air_at;
128 }
129
130 air = avl_find( attr_index, name, attr_index_name_cmp );
131
132 if ( air ) {
133 if ( air->air_at->sat_flags & SLAP_AT_DELETED ) {
134 air = NULL;
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 );
138 }
139 }
140
141 return air != NULL ? air->air_at : NULL;
142 }
143
144 int
145 at_append_to_list(
146 AttributeType *sat,
147 AttributeType ***listp )
148 {
149 AttributeType **list;
150 AttributeType **list1;
151 int size;
152
153 list = *listp;
154 if ( !list ) {
155 size = 2;
156 list = ch_calloc(size, sizeof(AttributeType *));
157 if ( !list ) {
158 return -1;
159 }
160 } else {
161 size = 0;
162 list1 = *listp;
163 while ( *list1 ) {
164 size++;
165 list1++;
166 }
167 size += 2;
168 list1 = ch_realloc(list, size*sizeof(AttributeType *));
169 if ( !list1 ) {
170 return -1;
171 }
172 list = list1;
173 }
174 list[size-2] = sat;
175 list[size-1] = NULL;
176 *listp = list;
177 return 0;
178 }
179
180 int
181 at_delete_from_list(
182 int pos,
183 AttributeType ***listp )
184 {
185 AttributeType **list;
186 AttributeType **list1;
187 int i;
188 int j;
189
190 if ( pos < 0 ) {
191 return -2;
192 }
193 list = *listp;
194 for ( i=0; list[i]; i++ )
195 ;
196 if ( pos >= i ) {
197 return -2;
198 }
199 for ( i=pos, j=pos+1; list[j]; i++, j++ ) {
200 list[i] = list[j];
201 }
202 list[i] = NULL;
203 /* Tell the runtime this can be shrinked */
204 list1 = ch_realloc(list, (i+1)*sizeof(AttributeType **));
205 if ( !list1 ) {
206 return -1;
207 }
208 *listp = list1;
209 return 0;
210 }
211
212 int
213 at_find_in_list(
214 AttributeType *sat,
215 AttributeType **list )
216 {
217 int i;
218
219 if ( !list ) {
220 return -1;
221 }
222 for ( i=0; list[i]; i++ ) {
223 if ( sat == list[i] ) {
224 return i;
225 }
226 }
227 return -1;
228 }
229
230 static void
231 at_delete_names( AttributeType *at )
232 {
233 char **names = at->sat_names;
234
235 while (*names) {
236 struct aindexrec tmpair, *air;
237
238 ber_str2bv( *names, 0, 0, &tmpair.air_name );
239 tmpair.air_at = at;
240 air = (struct aindexrec *)avl_delete( &attr_index,
241 (caddr_t)&tmpair, attr_index_cmp );
242 assert( air != NULL );
243 ldap_memfree( air );
244 names++;
245 }
246 }
247
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.
250 */
251 void
252 at_delete( AttributeType *at )
253 {
254 at->sat_flags |= SLAP_AT_DELETED;
255
256 LDAP_STAILQ_REMOVE(&attr_list, at, AttributeType, sat_next);
257
258 at_delete_names( at );
259 }
260
261 static void
262 at_clean( AttributeType *a )
263 {
264 if ( a->sat_equality ) {
265 MatchingRule *mr;
266
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;
272 }
273 }
274
275 assert( a->sat_syntax != NULL );
276 if ( a->sat_syntax != NULL ) {
277 Syntax *syn;
278
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;
284 }
285 }
286
287 if ( a->sat_oidmacro ) {
288 ldap_memfree( a->sat_oidmacro );
289 a->sat_oidmacro = NULL;
290 }
291 if ( a->sat_soidmacro ) {
292 ldap_memfree( a->sat_soidmacro );
293 a->sat_soidmacro = NULL;
294 }
295 if ( a->sat_subtypes ) {
296 ldap_memfree( a->sat_subtypes );
297 a->sat_subtypes = NULL;
298 }
299 }
300
301 static void
302 at_destroy_one( void *v )
303 {
304 struct aindexrec *air = v;
305 AttributeType *a = air->air_at;
306
307 at_clean( a );
308 ad_destroy(a->sat_ad);
309 ldap_pvt_thread_mutex_destroy(&a->sat_ad_mutex);
310 ldap_attributetype_free((LDAPAttributeType *)a);
311 ldap_memfree(air);
312 }
313
314 void
315 at_destroy( void )
316 {
317 AttributeType *a;
318
319 while( !LDAP_STAILQ_EMPTY(&attr_list) ) {
320 a = LDAP_STAILQ_FIRST(&attr_list);
321 LDAP_STAILQ_REMOVE_HEAD(&attr_list, sat_next);
322
323 at_delete_names( a );
324 }
325
326 avl_free(attr_index, at_destroy_one);
327
328 if ( slap_schema.si_at_undefined ) {
329 ad_destroy(slap_schema.si_at_undefined->sat_ad);
330 }
331
332 if ( slap_schema.si_at_proxied ) {
333 ad_destroy(slap_schema.si_at_proxied->sat_ad);
334 }
335 }
336
337 int
338 at_start( AttributeType **at )
339 {
340 assert( at != NULL );
341
342 *at = LDAP_STAILQ_FIRST(&attr_list);
343
344 return (*at != NULL);
345 }
346
347 int
348 at_next( AttributeType **at )
349 {
350 assert( at != NULL );
351
352 #if 0 /* pedantic check: don't use this */
353 {
354 AttributeType *tmp = NULL;
355
356 LDAP_STAILQ_FOREACH(tmp,&attr_list,sat_next) {
357 if ( tmp == *at ) {
358 break;
359 }
360 }
361
362 assert( tmp != NULL );
363 }
364 #endif
365
366 *at = LDAP_STAILQ_NEXT(*at,sat_next);
367
368 return (*at != NULL);
369 }
370
371 /*
372 * check whether the two attributeTypes actually __are__ identical,
373 * or rather inconsistent
374 */
375 static int
376 at_check_dup(
377 AttributeType *sat,
378 AttributeType *new_sat )
379 {
380 if ( new_sat->sat_oid != NULL ) {
381 if ( sat->sat_oid == NULL ) {
382 return SLAP_SCHERR_ATTR_INCONSISTENT;
383 }
384
385 if ( strcmp( sat->sat_oid, new_sat->sat_oid ) != 0 ) {
386 return SLAP_SCHERR_ATTR_INCONSISTENT;
387 }
388
389 } else {
390 if ( sat->sat_oid != NULL ) {
391 return SLAP_SCHERR_ATTR_INCONSISTENT;
392 }
393 }
394
395 if ( new_sat->sat_names ) {
396 int i;
397
398 if ( sat->sat_names == NULL ) {
399 return SLAP_SCHERR_ATTR_INCONSISTENT;
400 }
401
402 for ( i = 0; new_sat->sat_names[ i ]; i++ ) {
403 if ( sat->sat_names[ i ] == NULL ) {
404 return SLAP_SCHERR_ATTR_INCONSISTENT;
405 }
406
407 if ( strcasecmp( sat->sat_names[ i ],
408 new_sat->sat_names[ i ] ) != 0 )
409 {
410 return SLAP_SCHERR_ATTR_INCONSISTENT;
411 }
412 }
413 } else {
414 if ( sat->sat_names != NULL ) {
415 return SLAP_SCHERR_ATTR_INCONSISTENT;
416 }
417 }
418
419 return SLAP_SCHERR_ATTR_DUP;
420 }
421
422 static struct aindexrec *air_old;
423
424 static int
425 at_dup_error( void *left, void *right )
426 {
427 air_old = left;
428 return -1;
429 }
430
431 static int
432 at_insert(
433 AttributeType **rat,
434 AttributeType *prev,
435 const char **err )
436 {
437 struct aindexrec *air;
438 char **names = NULL;
439 AttributeType *sat = *rat;
440
441 if ( sat->sat_oid ) {
442 air = (struct aindexrec *)
443 ch_calloc( 1, sizeof(struct aindexrec) );
444 ber_str2bv( sat->sat_oid, 0, 0, &air->air_name );
445 air->air_at = sat;
446 air_old = NULL;
447
448 if ( avl_insert( &attr_index, (caddr_t) air,
449 attr_index_cmp, at_dup_error ) )
450 {
451 AttributeType *old_sat;
452 int rc;
453
454 *err = sat->sat_oid;
455
456 assert( air_old != NULL );
457 old_sat = air_old->air_at;
458
459 /* replacing a deleted definition? */
460 if ( old_sat->sat_flags & SLAP_AT_DELETED ) {
461 AttributeType tmp;
462 AttributeDescription *ad;
463
464 /* Keep old oid, free new oid;
465 * Keep old ads, free new ads;
466 * Keep old ad_mutex, free new ad_mutex;
467 * Keep new everything else, free old
468 */
469 tmp = *old_sat;
470 *old_sat = *sat;
471 old_sat->sat_oid = tmp.sat_oid;
472 tmp.sat_oid = sat->sat_oid;
473 old_sat->sat_ad = tmp.sat_ad;
474 tmp.sat_ad = sat->sat_ad;
475 old_sat->sat_ad_mutex = tmp.sat_ad_mutex;
476 tmp.sat_ad_mutex = sat->sat_ad_mutex;
477 *sat = tmp;
478
479 /* Check for basic ad pointing at old cname */
480 for ( ad = old_sat->sat_ad; ad; ad=ad->ad_next ) {
481 if ( ad->ad_cname.bv_val == sat->sat_cname.bv_val ) {
482 ad->ad_cname = old_sat->sat_cname;
483 break;
484 }
485 }
486
487 at_clean( sat );
488 at_destroy_one( air );
489
490 air = air_old;
491 sat = old_sat;
492 *rat = sat;
493 } else {
494 ldap_memfree( air );
495
496 rc = at_check_dup( old_sat, sat );
497
498 return rc;
499 }
500 }
501 /* FIX: temporal consistency check */
502 at_bvfind( &air->air_name );
503 }
504
505 names = sat->sat_names;
506 if ( names ) {
507 while ( *names ) {
508 air = (struct aindexrec *)
509 ch_calloc( 1, sizeof(struct aindexrec) );
510 ber_str2bv( *names, 0, 0, &air->air_name );
511 air->air_at = sat;
512 if ( avl_insert( &attr_index, (caddr_t) air,
513 attr_index_cmp, avl_dup_error ) )
514 {
515 AttributeType *old_sat;
516 int rc;
517
518 *err = *names;
519
520 old_sat = at_bvfind( &air->air_name );
521 assert( old_sat != NULL );
522 rc = at_check_dup( old_sat, sat );
523
524 ldap_memfree(air);
525
526 while ( names > sat->sat_names ) {
527 struct aindexrec tmpair;
528
529 names--;
530 ber_str2bv( *names, 0, 0, &tmpair.air_name );
531 tmpair.air_at = sat;
532 air = (struct aindexrec *)avl_delete( &attr_index,
533 (caddr_t)&tmpair, attr_index_cmp );
534 assert( air != NULL );
535 ldap_memfree( air );
536 }
537
538 if ( sat->sat_oid ) {
539 struct aindexrec tmpair;
540
541 ber_str2bv( sat->sat_oid, 0, 0, &tmpair.air_name );
542 tmpair.air_at = sat;
543 air = (struct aindexrec *)avl_delete( &attr_index,
544 (caddr_t)&tmpair, attr_index_cmp );
545 assert( air != NULL );
546 ldap_memfree( air );
547 }
548
549 return rc;
550 }
551 /* FIX: temporal consistency check */
552 at_bvfind(&air->air_name);
553 names++;
554 }
555 }
556
557 if ( sat->sat_oid ) {
558 slap_ad_undef_promote( sat->sat_oid, sat );
559 }
560
561 names = sat->sat_names;
562 if ( names ) {
563 while ( *names ) {
564 slap_ad_undef_promote( *names, sat );
565 names++;
566 }
567 }
568
569 if ( sat->sat_flags & SLAP_AT_HARDCODE ) {
570 prev = at_sys_tail;
571 at_sys_tail = sat;
572 }
573 if ( prev ) {
574 LDAP_STAILQ_INSERT_AFTER( &attr_list, prev, sat, sat_next );
575 } else {
576 LDAP_STAILQ_INSERT_TAIL( &attr_list, sat, sat_next );
577 }
578
579 return 0;
580 }
581
582 int
583 at_add(
584 LDAPAttributeType *at,
585 int user,
586 AttributeType **rsat,
587 AttributeType *prev,
588 const char **err )
589 {
590 AttributeType *sat = NULL;
591 MatchingRule *mr = NULL;
592 Syntax *syn = NULL;
593 int i;
594 int code = LDAP_SUCCESS;
595 char *cname = NULL;
596 char *oidm = NULL;
597 char *soidm = NULL;
598
599 if ( !at->at_oid ) {
600 *err = "";
601 return SLAP_SCHERR_ATTR_INCOMPLETE;
602 }
603
604 if ( !OID_LEADCHAR( at->at_oid[0] )) {
605 char *oid;
606
607 /* Expand OID macros */
608 oid = oidm_find( at->at_oid );
609 if ( !oid ) {
610 *err = at->at_oid;
611 return SLAP_SCHERR_OIDM;
612 }
613 if ( oid != at->at_oid ) {
614 oidm = at->at_oid;
615 at->at_oid = oid;
616 }
617 }
618
619 if ( at->at_syntax_oid && !OID_LEADCHAR( at->at_syntax_oid[0] )) {
620 char *oid;
621
622 /* Expand OID macros */
623 oid = oidm_find( at->at_syntax_oid );
624 if ( !oid ) {
625 *err = at->at_syntax_oid;
626 code = SLAP_SCHERR_OIDM;
627 goto error_return;
628 }
629 if ( oid != at->at_syntax_oid ) {
630 soidm = at->at_syntax_oid;
631 at->at_syntax_oid = oid;
632 }
633 }
634
635 if ( at->at_names && at->at_names[0] ) {
636 int i;
637
638 for( i=0; at->at_names[i]; i++ ) {
639 if( !slap_valid_descr( at->at_names[i] ) ) {
640 *err = at->at_names[i];
641 code = SLAP_SCHERR_BAD_DESCR;
642 goto error_return;
643 }
644 }
645
646 cname = at->at_names[0];
647
648 } else {
649 cname = at->at_oid;
650
651 }
652
653 *err = cname;
654
655 if ( !at->at_usage && at->at_no_user_mod ) {
656 /* user attribute must be modifable */
657 code = SLAP_SCHERR_ATTR_BAD_USAGE;
658 goto error_return;
659 }
660
661 if ( at->at_collective ) {
662 if( at->at_usage ) {
663 /* collective attributes cannot be operational */
664 code = SLAP_SCHERR_ATTR_BAD_USAGE;
665 goto error_return;
666 }
667
668 if( at->at_single_value ) {
669 /* collective attributes cannot be single-valued */
670 code = SLAP_SCHERR_ATTR_BAD_USAGE;
671 goto error_return;
672 }
673 }
674
675 sat = (AttributeType *) ch_calloc( 1, sizeof(AttributeType) );
676 AC_MEMCPY( &sat->sat_atype, at, sizeof(LDAPAttributeType));
677
678 sat->sat_cname.bv_val = cname;
679 sat->sat_cname.bv_len = strlen( cname );
680 sat->sat_oidmacro = oidm;
681 sat->sat_soidmacro = soidm;
682 ldap_pvt_thread_mutex_init(&sat->sat_ad_mutex);
683
684 if ( at->at_sup_oid ) {
685 AttributeType *supsat = at_find(at->at_sup_oid);
686
687 if ( supsat == NULL ) {
688 *err = at->at_sup_oid;
689 code = SLAP_SCHERR_ATTR_NOT_FOUND;
690 goto error_return;
691 }
692
693 sat->sat_sup = supsat;
694
695 if ( at_append_to_list(sat, &supsat->sat_subtypes) ) {
696 code = SLAP_SCHERR_OUTOFMEM;
697 goto error_return;
698 }
699
700 if ( sat->sat_usage != supsat->sat_usage ) {
701 /* subtypes must have same usage as their SUP */
702 code = SLAP_SCHERR_ATTR_BAD_USAGE;
703 goto error_return;
704 }
705
706 if ( supsat->sat_obsolete && !sat->sat_obsolete ) {
707 /* subtypes must be obsolete if super is */
708 code = SLAP_SCHERR_ATTR_BAD_SUP;
709 goto error_return;
710 }
711
712 if ( sat->sat_flags & SLAP_AT_FINAL ) {
713 /* cannot subtype a "final" attribute type */
714 code = SLAP_SCHERR_ATTR_BAD_SUP;
715 goto error_return;
716 }
717 }
718
719 /*
720 * Inherit definitions from superiors. We only check the
721 * direct superior since that one has already inherited from
722 * its own superiorss
723 */
724 if ( sat->sat_sup ) {
725 sat->sat_syntax = sat->sat_sup->sat_syntax;
726 sat->sat_equality = sat->sat_sup->sat_equality;
727 sat->sat_approx = sat->sat_sup->sat_approx;
728 sat->sat_ordering = sat->sat_sup->sat_ordering;
729 sat->sat_substr = sat->sat_sup->sat_substr;
730 }
731
732 /*
733 * check for X-ORDERED attributes
734 */
735 if ( sat->sat_extensions ) {
736 for (i=0; sat->sat_extensions[i]; i++) {
737 if (!strcasecmp( sat->sat_extensions[i]->lsei_name,
738 "X-ORDERED" ) && sat->sat_extensions[i]->lsei_values ) {
739 if ( !strcasecmp( sat->sat_extensions[i]->lsei_values[0],
740 "VALUES" )) {
741 sat->sat_flags |= SLAP_AT_ORDERED_VAL;
742 break;
743 } else if ( !strcasecmp( sat->sat_extensions[i]->lsei_values[0],
744 "SIBLINGS" )) {
745 sat->sat_flags |= SLAP_AT_ORDERED_SIB;
746 break;
747 }
748 }
749 }
750 }
751
752 if ( !user )
753 sat->sat_flags |= SLAP_AT_HARDCODE;
754
755 if ( at->at_syntax_oid ) {
756 syn = syn_find(sat->sat_syntax_oid);
757 if ( syn == NULL ) {
758 *err = sat->sat_syntax_oid;
759 code = SLAP_SCHERR_SYN_NOT_FOUND;
760 goto error_return;
761 }
762
763 if ( sat->sat_syntax != NULL && sat->sat_syntax != syn ) {
764 /* BEWARE: no loop detection! */
765 if ( syn_is_sup( sat->sat_syntax, syn ) ) {
766 code = SLAP_SCHERR_ATTR_BAD_SUP;
767 goto error_return;
768 }
769 }
770
771 sat->sat_syntax = syn;
772
773 } else if ( sat->sat_syntax == NULL ) {
774 code = SLAP_SCHERR_ATTR_INCOMPLETE;
775 goto error_return;
776 }
777
778 if ( sat->sat_equality_oid ) {
779 mr = mr_find(sat->sat_equality_oid);
780
781 if( mr == NULL ) {
782 *err = sat->sat_equality_oid;
783 code = SLAP_SCHERR_MR_NOT_FOUND;
784 goto error_return;
785 }
786
787 if(( mr->smr_usage & SLAP_MR_EQUALITY ) != SLAP_MR_EQUALITY ) {
788 *err = sat->sat_equality_oid;
789 code = SLAP_SCHERR_ATTR_BAD_MR;
790 goto error_return;
791 }
792
793 if( sat->sat_syntax != mr->smr_syntax ) {
794 if( mr->smr_compat_syntaxes == NULL ) {
795 *err = sat->sat_equality_oid;
796 code = SLAP_SCHERR_ATTR_BAD_MR;
797 goto error_return;
798 }
799
800 for(i=0; mr->smr_compat_syntaxes[i]; i++) {
801 if( sat->sat_syntax == mr->smr_compat_syntaxes[i] ) {
802 i = -1;
803 break;
804 }
805 }
806
807 if( i >= 0 ) {
808 *err = sat->sat_equality_oid;
809 code = SLAP_SCHERR_ATTR_BAD_MR;
810 goto error_return;
811 }
812 }
813
814 sat->sat_equality = mr;
815 sat->sat_approx = mr->smr_associated;
816 }
817
818 if ( sat->sat_ordering_oid ) {
819 if( !sat->sat_equality ) {
820 *err = sat->sat_ordering_oid;
821 code = SLAP_SCHERR_ATTR_BAD_MR;
822 goto error_return;
823 }
824
825 mr = mr_find(sat->sat_ordering_oid);
826
827 if( mr == NULL ) {
828 *err = sat->sat_ordering_oid;
829 code = SLAP_SCHERR_MR_NOT_FOUND;
830 goto error_return;
831 }
832
833 if(( mr->smr_usage & SLAP_MR_ORDERING ) != SLAP_MR_ORDERING ) {
834 *err = sat->sat_ordering_oid;
835 code = SLAP_SCHERR_ATTR_BAD_MR;
836 goto error_return;
837 }
838
839 if( sat->sat_syntax != mr->smr_syntax ) {
840 if( mr->smr_compat_syntaxes == NULL ) {
841 *err = sat->sat_ordering_oid;
842 code = SLAP_SCHERR_ATTR_BAD_MR;
843 goto error_return;
844 }
845
846 for(i=0; mr->smr_compat_syntaxes[i]; i++) {
847 if( sat->sat_syntax == mr->smr_compat_syntaxes[i] ) {
848 i = -1;
849 break;
850 }
851 }
852
853 if( i >= 0 ) {
854 *err = sat->sat_ordering_oid;
855 code = SLAP_SCHERR_ATTR_BAD_MR;
856 goto error_return;
857 }
858 }
859
860 sat->sat_ordering = mr;
861 }
862
863 if ( sat->sat_substr_oid ) {
864 if( !sat->sat_equality ) {
865 *err = sat->sat_substr_oid;
866 code = SLAP_SCHERR_ATTR_BAD_MR;
867 goto error_return;
868 }
869
870 mr = mr_find(sat->sat_substr_oid);
871
872 if( mr == NULL ) {
873 *err = sat->sat_substr_oid;
874 code = SLAP_SCHERR_MR_NOT_FOUND;
875 goto error_return;
876 }
877
878 if(( mr->smr_usage & SLAP_MR_SUBSTR ) != SLAP_MR_SUBSTR ) {
879 *err = sat->sat_substr_oid;
880 code = SLAP_SCHERR_ATTR_BAD_MR;
881 goto error_return;
882 }
883
884 /* due to funky LDAP builtin substring rules,
885 * we check against the equality rule assertion
886 * syntax and compat syntaxes instead of those
887 * associated with the substrings rule.
888 */
889 if( sat->sat_syntax != sat->sat_equality->smr_syntax ) {
890 if( sat->sat_equality->smr_compat_syntaxes == NULL ) {
891 *err = sat->sat_substr_oid;
892 code = SLAP_SCHERR_ATTR_BAD_MR;
893 goto error_return;
894 }
895
896 for(i=0; sat->sat_equality->smr_compat_syntaxes[i]; i++) {
897 if( sat->sat_syntax ==
898 sat->sat_equality->smr_compat_syntaxes[i] )
899 {
900 i = -1;
901 break;
902 }
903 }
904
905 if( i >= 0 ) {
906 *err = sat->sat_substr_oid;
907 code = SLAP_SCHERR_ATTR_BAD_MR;
908 goto error_return;
909 }
910 }
911
912 sat->sat_substr = mr;
913 }
914
915 code = at_insert( &sat, prev, err );
916 if ( code != 0 ) {
917 error_return:;
918 if ( sat ) {
919 ldap_pvt_thread_mutex_destroy( &sat->sat_ad_mutex );
920 ch_free( sat );
921 }
922
923 if ( oidm ) {
924 SLAP_FREE( at->at_oid );
925 at->at_oid = oidm;
926 }
927
928 } else if ( rsat ) {
929 *rsat = sat;
930 }
931
932 return code;
933 }
934
935 #ifdef LDAP_DEBUG
936 #ifdef SLAPD_UNUSED
937 static int
938 at_index_printnode( void *v_air, void *ignore )
939 {
940 struct aindexrec *air = v_air;
941 printf("%s = %s\n",
942 air->air_name.bv_val,
943 ldap_attributetype2str(&air->air_at->sat_atype) );
944 return( 0 );
945 }
946
947 static void
948 at_index_print( void )
949 {
950 printf("Printing attribute type index:\n");
951 (void) avl_apply( attr_index, at_index_printnode, 0, -1, AVL_INORDER );
952 }
953 #endif
954 #endif
955
956 void
957 at_unparse( BerVarray *res, AttributeType *start, AttributeType *end, int sys )
958 {
959 AttributeType *at;
960 int i, num;
961 struct berval bv, *bva = NULL, idx;
962 char ibuf[32];
963
964 if ( !start )
965 start = LDAP_STAILQ_FIRST( &attr_list );
966
967 /* count the result size */
968 i = 0;
969 for ( at=start; at; at=LDAP_STAILQ_NEXT(at, sat_next)) {
970 if ( sys && !(at->sat_flags & SLAP_AT_HARDCODE)) break;
971 i++;
972 if ( at == end ) break;
973 }
974 if (!i) return;
975
976 num = i;
977 bva = ch_malloc( (num+1) * sizeof(struct berval) );
978 BER_BVZERO( bva );
979 idx.bv_val = ibuf;
980 if ( sys ) {
981 idx.bv_len = 0;
982 ibuf[0] = '\0';
983 }
984 i = 0;
985 for ( at=start; at; at=LDAP_STAILQ_NEXT(at, sat_next)) {
986 LDAPAttributeType lat, *latp;
987 if ( sys && !(at->sat_flags & SLAP_AT_HARDCODE)) break;
988 if ( at->sat_oidmacro || at->sat_soidmacro ) {
989 lat = at->sat_atype;
990 if ( at->sat_oidmacro )
991 lat.at_oid = at->sat_oidmacro;
992 if ( at->sat_soidmacro )
993 lat.at_syntax_oid = at->sat_soidmacro;
994 latp = &lat;
995 } else {
996 latp = &at->sat_atype;
997 }
998 if ( ldap_attributetype2bv( latp, &bv ) == NULL ) {
999 ber_bvarray_free( bva );
1000 }
1001 if ( !sys ) {
1002 idx.bv_len = sprintf(idx.bv_val, "{%d}", i);
1003 }
1004 bva[i].bv_len = idx.bv_len + bv.bv_len;
1005 bva[i].bv_val = ch_malloc( bva[i].bv_len + 1 );
1006 strcpy( bva[i].bv_val, ibuf );
1007 strcpy( bva[i].bv_val + idx.bv_len, bv.bv_val );
1008 i++;
1009 bva[i].bv_val = NULL;
1010 ldap_memfree( bv.bv_val );
1011 if ( at == end ) break;
1012 }
1013 *res = bva;
1014 }
1015
1016 int
1017 at_schema_info( Entry *e )
1018 {
1019 AttributeDescription *ad_attributeTypes = slap_schema.si_ad_attributeTypes;
1020 AttributeType *at;
1021 struct berval val;
1022 struct berval nval;
1023
1024 LDAP_STAILQ_FOREACH(at,&attr_list,sat_next) {
1025 if( at->sat_flags & SLAP_AT_HIDE ) continue;
1026
1027 if ( ldap_attributetype2bv( &at->sat_atype, &val ) == NULL ) {
1028 return -1;
1029 }
1030
1031 ber_str2bv( at->sat_oid, 0, 0, &nval );
1032
1033 if( attr_merge_one( e, ad_attributeTypes, &val, &nval ) )
1034 {
1035 return -1;
1036 }
1037 ldap_memfree( val.bv_val );
1038 }
1039 return 0;
1040 }
1041
1042 int
1043 register_at( const char *def, AttributeDescription **rad, int dupok )
1044 {
1045 LDAPAttributeType *at;
1046 int code, freeit = 0;
1047 const char *err;
1048 AttributeDescription *ad = NULL;
1049
1050 at = ldap_str2attributetype( def, &code, &err, LDAP_SCHEMA_ALLOW_ALL );
1051 if ( !at ) {
1052 Debug( LDAP_DEBUG_ANY,
1053 "register_at: AttributeType \"%s\": %s, %s\n",
1054 def, ldap_scherr2str(code), err );
1055 return code;
1056 }
1057
1058 code = at_add( at, 0, NULL, NULL, &err );
1059 if ( code ) {
1060 if ( code == SLAP_SCHERR_ATTR_DUP && dupok ) {
1061 freeit = 1;
1062
1063 } else {
1064 ldap_attributetype_free( at );
1065 Debug( LDAP_DEBUG_ANY,
1066 "register_at: AttributeType \"%s\": %s, %s\n",
1067 def, scherr2str(code), err );
1068 return code;
1069 }
1070 }
1071 code = slap_str2ad( at->at_names[0], &ad, &err );
1072 if ( freeit || code ) {
1073 ldap_attributetype_free( at );
1074 } else {
1075 ldap_memfree( at );
1076 }
1077 if ( code ) {
1078 Debug( LDAP_DEBUG_ANY, "register_at: AttributeType \"%s\": %s\n",
1079 def, err, 0 );
1080 }
1081 if ( rad ) *rad = ad;
1082 return code;
1083 }
NetBSD on the FriendlyARM MINI2440