git.sur5r.net Git - openldap/blob - servers/slapd/at.c

   1 /* at.c - routines for dealing with attribute types */
   2 /* $OpenLDAP$ */
   3 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   4  *
   5  * Copyright 1998-2007 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, slap_attribute_type) 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,slap_attribute_type,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_subtypes ) {
 292                 ldap_memfree( a->sat_subtypes );
 293                 a->sat_subtypes = NULL;
 294         }
 295 }
 296
 297 static void
 298 at_destroy_one( void *v )
 299 {
 300         struct aindexrec *air = v;
 301         AttributeType *a = air->air_at;
 302
 303         at_clean( a );
 304         ad_destroy(a->sat_ad);
 305         ldap_pvt_thread_mutex_destroy(&a->sat_ad_mutex);
 306         ldap_attributetype_free((LDAPAttributeType *)a);
 307         ldap_memfree(air);
 308 }
 309
 310 void
 311 at_destroy( void )
 312 {
 313         AttributeType *a;
 314
 315         while( !LDAP_STAILQ_EMPTY(&attr_list) ) {
 316                 a = LDAP_STAILQ_FIRST(&attr_list);
 317                 LDAP_STAILQ_REMOVE_HEAD(&attr_list, sat_next);
 318
 319                 at_delete_names( a );
 320         }
 321
 322         avl_free(attr_index, at_destroy_one);
 323
 324         if ( slap_schema.si_at_undefined ) {
 325                 ad_destroy(slap_schema.si_at_undefined->sat_ad);
 326         }
 327
 328         if ( slap_schema.si_at_proxied ) {
 329                 ad_destroy(slap_schema.si_at_proxied->sat_ad);
 330         }
 331 }
 332
 333 int
 334 at_start( AttributeType **at )
 335 {
 336         assert( at != NULL );
 337
 338         *at = LDAP_STAILQ_FIRST(&attr_list);
 339
 340         return (*at != NULL);
 341 }
 342
 343 int
 344 at_next( AttributeType **at )
 345 {
 346         assert( at != NULL );
 347
 348 #if 0   /* pedantic check: don't use this */
 349         {
 350                 AttributeType *tmp = NULL;
 351
 352                 LDAP_STAILQ_FOREACH(tmp,&attr_list,sat_next) {
 353                         if ( tmp == *at ) {
 354                                 break;
 355                         }
 356                 }
 357
 358                 assert( tmp != NULL );
 359         }
 360 #endif
 361
 362         *at = LDAP_STAILQ_NEXT(*at,sat_next);
 363
 364         return (*at != NULL);
 365 }
 366
 367 /*
 368  * check whether the two attributeTypes actually __are__ identical,
 369  * or rather inconsistent
 370  */
 371 static int
 372 at_check_dup(
 373         AttributeType           *sat,
 374         AttributeType           *new_sat )
 375 {
 376         if ( new_sat->sat_oid != NULL ) {
 377                 if ( sat->sat_oid == NULL ) {
 378                         return SLAP_SCHERR_ATTR_INCONSISTENT;
 379                 }
 380
 381                 if ( strcmp( sat->sat_oid, new_sat->sat_oid ) != 0 ) {
 382                         return SLAP_SCHERR_ATTR_INCONSISTENT;
 383                 }
 384
 385         } else {
 386                 if ( sat->sat_oid != NULL ) {
 387                         return SLAP_SCHERR_ATTR_INCONSISTENT;
 388                 }
 389         }
 390
 391         if ( new_sat->sat_names ) {
 392                 int     i;
 393
 394                 if ( sat->sat_names == NULL ) {
 395                         return SLAP_SCHERR_ATTR_INCONSISTENT;
 396                 }
 397
 398                 for ( i = 0; new_sat->sat_names[ i ]; i++ ) {
 399                         if ( sat->sat_names[ i ] == NULL ) {
 400                                 return SLAP_SCHERR_ATTR_INCONSISTENT;
 401                         }
 402
 403                         if ( strcasecmp( sat->sat_names[ i ],
 404                                         new_sat->sat_names[ i ] ) != 0 )
 405                         {
 406                                 return SLAP_SCHERR_ATTR_INCONSISTENT;
 407                         }
 408                 }
 409         } else {
 410                 if ( sat->sat_names != NULL ) {
 411                         return SLAP_SCHERR_ATTR_INCONSISTENT;
 412                 }
 413         }
 414
 415         return SLAP_SCHERR_ATTR_DUP;
 416 }
 417
 418 static struct aindexrec *air_old;
 419
 420 static int
 421 at_dup_error( void *left, void *right )
 422 {
 423         air_old = left;
 424         return -1;
 425 }
 426
 427 static int
 428 at_insert(
 429     AttributeType       **rat,
 430         AttributeType   *prev,
 431     const char          **err )
 432 {
 433         struct aindexrec        *air;
 434         char                    **names = NULL;
 435         AttributeType   *sat = *rat;
 436
 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 );
 441                 air->air_at = sat;
 442                 air_old = NULL;
 443
 444                 if ( avl_insert( &attr_index, (caddr_t) air,
 445                                  attr_index_cmp, at_dup_error ) )
 446                 {
 447                         AttributeType   *old_sat;
 448                         int             rc;
 449
 450                         *err = sat->sat_oid;
 451
 452                         assert( air_old != NULL );
 453                         old_sat = air_old->air_at;
 454
 455                         /* replacing a deleted definition? */
 456                         if ( old_sat->sat_flags & SLAP_AT_DELETED ) {
 457                                 AttributeType tmp;
 458
 459                                 /* Keep old oid, free new oid;
 460                                  * Keep old ads, free new ads;
 461                                  * Keep new everything else, free old
 462                                  */
 463                                 tmp = *old_sat;
 464                                 *old_sat = *sat;
 465                                 old_sat->sat_oid = tmp.sat_oid;
 466                                 tmp.sat_oid = sat->sat_oid;
 467                                 old_sat->sat_ad = tmp.sat_ad;
 468                                 tmp.sat_ad = sat->sat_ad;
 469                                 *sat = tmp;
 470
 471                                 at_clean( sat );
 472                                 at_destroy_one( air );
 473
 474                                 air = air_old;
 475                                 sat = old_sat;
 476                                 *rat = sat;
 477                         } else {
 478                                 ldap_memfree( air );
 479
 480                                 rc = at_check_dup( old_sat, sat );
 481
 482                                 return rc;
 483                         }
 484                 }
 485                 /* FIX: temporal consistency check */
 486                 at_bvfind( &air->air_name );
 487         }
 488
 489         names = sat->sat_names;
 490         if ( names ) {
 491                 while ( *names ) {
 492                         air = (struct aindexrec *)
 493                                 ch_calloc( 1, sizeof(struct aindexrec) );
 494                         ber_str2bv( *names, 0, 0, &air->air_name );
 495                         air->air_at = sat;
 496                         if ( avl_insert( &attr_index, (caddr_t) air,
 497                                          attr_index_cmp, avl_dup_error ) )
 498                         {
 499                                 AttributeType   *old_sat;
 500                                 int             rc;
 501
 502                                 *err = *names;
 503
 504                                 old_sat = at_bvfind( &air->air_name );
 505                                 assert( old_sat != NULL );
 506                                 rc = at_check_dup( old_sat, sat );
 507
 508                                 ldap_memfree(air);
 509
 510                                 while ( names > sat->sat_names ) {
 511                                         struct aindexrec        tmpair;
 512
 513                                         names--;
 514                                         ber_str2bv( *names, 0, 0, &tmpair.air_name );
 515                                         tmpair.air_at = sat;
 516                                         air = (struct aindexrec *)avl_delete( &attr_index,
 517                                                 (caddr_t)&tmpair, attr_index_cmp );
 518                                         assert( air != NULL );
 519                                         ldap_memfree( air );
 520                                 }
 521
 522                                 if ( sat->sat_oid ) {
 523                                         struct aindexrec        tmpair;
 524
 525                                         ber_str2bv( sat->sat_oid, 0, 0, &tmpair.air_name );
 526                                         tmpair.air_at = sat;
 527                                         air = (struct aindexrec *)avl_delete( &attr_index,
 528                                                 (caddr_t)&tmpair, attr_index_cmp );
 529                                         assert( air != NULL );
 530                                         ldap_memfree( air );
 531                                 }
 532
 533                                 return rc;
 534                         }
 535                         /* FIX: temporal consistency check */
 536                         at_bvfind(&air->air_name);
 537                         names++;
 538                 }
 539         }
 540
 541         if ( sat->sat_oid ) {
 542                 slap_ad_undef_promote( sat->sat_oid, sat );
 543         }
 544
 545         names = sat->sat_names;
 546         if ( names ) {
 547                 while ( *names ) {
 548                         slap_ad_undef_promote( *names, sat );
 549                         names++;
 550                 }
 551         }
 552
 553         if ( sat->sat_flags & SLAP_AT_HARDCODE ) {
 554                 prev = at_sys_tail;
 555                 at_sys_tail = sat;
 556         }
 557         if ( prev ) {
 558                 LDAP_STAILQ_INSERT_AFTER( &attr_list, prev, sat, sat_next );
 559         } else {
 560                 LDAP_STAILQ_INSERT_TAIL( &attr_list, sat, sat_next );
 561         }
 562
 563         return 0;
 564 }
 565
 566 int
 567 at_add(
 568         LDAPAttributeType       *at,
 569         int                     user,
 570         AttributeType           **rsat,
 571         AttributeType   *prev,
 572         const char              **err )
 573 {
 574         AttributeType   *sat = NULL;
 575         MatchingRule    *mr = NULL;
 576         Syntax          *syn = NULL;
 577         int             i;
 578         int             code = LDAP_SUCCESS;
 579         char            *cname = NULL;
 580         char            *oidm = NULL;
 581
 582         if ( !at->at_oid ) {
 583                 *err = "";
 584                 return SLAP_SCHERR_ATTR_INCOMPLETE;
 585         }
 586
 587         if ( !OID_LEADCHAR( at->at_oid[0] )) {
 588                 char    *oid;
 589
 590                 /* Expand OID macros */
 591                 oid = oidm_find( at->at_oid );
 592                 if ( !oid ) {
 593                         *err = at->at_oid;
 594                         return SLAP_SCHERR_OIDM;
 595                 }
 596                 if ( oid != at->at_oid ) {
 597                         oidm = at->at_oid;
 598                         at->at_oid = oid;
 599                 }
 600         }
 601
 602         if ( at->at_syntax_oid && !OID_LEADCHAR( at->at_syntax_oid[0] )) {
 603                 char    *oid;
 604
 605                 /* Expand OID macros */
 606                 oid = oidm_find( at->at_syntax_oid );
 607                 if ( !oid ) {
 608                         *err = at->at_syntax_oid;
 609                         code = SLAP_SCHERR_OIDM;
 610                         goto error_return;
 611                 }
 612                 if ( oid != at->at_syntax_oid ) {
 613                         ldap_memfree( at->at_syntax_oid );
 614                         at->at_syntax_oid = oid;
 615                 }
 616         }
 617
 618         if ( at->at_names && at->at_names[0] ) {
 619                 int i;
 620
 621                 for( i=0; at->at_names[i]; i++ ) {
 622                         if( !slap_valid_descr( at->at_names[i] ) ) {
 623                                 *err = at->at_names[i];
 624                                 code = SLAP_SCHERR_BAD_DESCR;
 625                                 goto error_return;
 626                         }
 627                 }
 628
 629                 cname = at->at_names[0];
 630
 631         } else {
 632                 cname = at->at_oid;
 633
 634         }
 635
 636         *err = cname;
 637
 638         if ( !at->at_usage && at->at_no_user_mod ) {
 639                 /* user attribute must be modifable */
 640                 code = SLAP_SCHERR_ATTR_BAD_USAGE;
 641                 goto error_return;
 642         }
 643
 644         if ( at->at_collective ) {
 645                 if( at->at_usage ) {
 646                         /* collective attributes cannot be operational */
 647                         code = SLAP_SCHERR_ATTR_BAD_USAGE;
 648                         goto error_return;
 649                 }
 650
 651                 if( at->at_single_value ) {
 652                         /* collective attributes cannot be single-valued */
 653                         code = SLAP_SCHERR_ATTR_BAD_USAGE;
 654                         goto error_return;
 655                 }
 656         }
 657
 658         sat = (AttributeType *) ch_calloc( 1, sizeof(AttributeType) );
 659         AC_MEMCPY( &sat->sat_atype, at, sizeof(LDAPAttributeType));
 660
 661         sat->sat_cname.bv_val = cname;
 662         sat->sat_cname.bv_len = strlen( cname );
 663         sat->sat_oidmacro = oidm;
 664         ldap_pvt_thread_mutex_init(&sat->sat_ad_mutex);
 665
 666         if ( at->at_sup_oid ) {
 667                 AttributeType *supsat = at_find(at->at_sup_oid);
 668
 669                 if ( supsat == NULL ) {
 670                         *err = at->at_sup_oid;
 671                         code = SLAP_SCHERR_ATTR_NOT_FOUND;
 672                         goto error_return;
 673                 }
 674
 675                 sat->sat_sup = supsat;
 676
 677                 if ( at_append_to_list(sat, &supsat->sat_subtypes) ) {
 678                         code = SLAP_SCHERR_OUTOFMEM;
 679                         goto error_return;
 680                 }
 681
 682                 if ( sat->sat_usage != supsat->sat_usage ) {
 683                         /* subtypes must have same usage as their SUP */
 684                         code = SLAP_SCHERR_ATTR_BAD_USAGE;
 685                         goto error_return;
 686                 }
 687
 688                 if ( supsat->sat_obsolete && !sat->sat_obsolete ) {
 689                         /* subtypes must be obsolete if super is */
 690                         code = SLAP_SCHERR_ATTR_BAD_SUP;
 691                         goto error_return;
 692                 }
 693
 694                 if ( sat->sat_flags & SLAP_AT_FINAL ) {
 695                         /* cannot subtype a "final" attribute type */
 696                         code = SLAP_SCHERR_ATTR_BAD_SUP;
 697                         goto error_return;
 698                 }
 699         }
 700
 701         /*
 702          * Inherit definitions from superiors.  We only check the
 703          * direct superior since that one has already inherited from
 704          * its own superiorss
 705          */
 706         if ( sat->sat_sup ) {
 707                 sat->sat_syntax = sat->sat_sup->sat_syntax;
 708                 sat->sat_equality = sat->sat_sup->sat_equality;
 709                 sat->sat_approx = sat->sat_sup->sat_approx;
 710                 sat->sat_ordering = sat->sat_sup->sat_ordering;
 711                 sat->sat_substr = sat->sat_sup->sat_substr;
 712         }
 713
 714         /*
 715          * check for X-ORDERED attributes
 716          */
 717         if ( sat->sat_extensions ) {
 718                 for (i=0; sat->sat_extensions[i]; i++) {
 719                         if (!strcasecmp( sat->sat_extensions[i]->lsei_name,
 720                                 "X-ORDERED" ) && sat->sat_extensions[i]->lsei_values ) {
 721                                 if ( !strcasecmp( sat->sat_extensions[i]->lsei_values[0],
 722                                         "VALUES" )) {
 723                                         sat->sat_flags |= SLAP_AT_ORDERED_VAL;
 724                                         break;
 725                                 } else if ( !strcasecmp( sat->sat_extensions[i]->lsei_values[0],
 726                                         "SIBLINGS" )) {
 727                                         sat->sat_flags |= SLAP_AT_ORDERED_SIB;
 728                                         break;
 729                                 }
 730                         }
 731                 }
 732         }
 733
 734         if ( !user )
 735                 sat->sat_flags |= SLAP_AT_HARDCODE;
 736
 737         if ( at->at_syntax_oid ) {
 738                 syn = syn_find(sat->sat_syntax_oid);
 739                 if ( syn == NULL ) {
 740                         *err = sat->sat_syntax_oid;
 741                         code = SLAP_SCHERR_SYN_NOT_FOUND;
 742                         goto error_return;
 743                 }
 744
 745                 if( sat->sat_syntax != NULL && sat->sat_syntax != syn ) {
 746                         code = SLAP_SCHERR_ATTR_BAD_SUP;
 747                         goto error_return;
 748                 }
 749
 750                 sat->sat_syntax = syn;
 751
 752         } else if ( sat->sat_syntax == NULL ) {
 753                 code = SLAP_SCHERR_ATTR_INCOMPLETE;
 754                 goto error_return;
 755         }
 756
 757         if ( sat->sat_equality_oid ) {
 758                 mr = mr_find(sat->sat_equality_oid);
 759
 760                 if( mr == NULL ) {
 761                         *err = sat->sat_equality_oid;
 762                         code = SLAP_SCHERR_MR_NOT_FOUND;
 763                         goto error_return;
 764                 }
 765
 766                 if(( mr->smr_usage & SLAP_MR_EQUALITY ) != SLAP_MR_EQUALITY ) {
 767                         *err = sat->sat_equality_oid;
 768                         code = SLAP_SCHERR_ATTR_BAD_MR;
 769                         goto error_return;
 770                 }
 771
 772                 if( sat->sat_syntax != mr->smr_syntax ) {
 773                         if( mr->smr_compat_syntaxes == NULL ) {
 774                                 *err = sat->sat_equality_oid;
 775                                 code = SLAP_SCHERR_ATTR_BAD_MR;
 776                                 goto error_return;
 777                         }
 778
 779                         for(i=0; mr->smr_compat_syntaxes[i]; i++) {
 780                                 if( sat->sat_syntax == mr->smr_compat_syntaxes[i] ) {
 781                                         i = -1;
 782                                         break;
 783                                 }
 784                         }
 785
 786                         if( i >= 0 ) {
 787                                 *err = sat->sat_equality_oid;
 788                                 code = SLAP_SCHERR_ATTR_BAD_MR;
 789                                 goto error_return;
 790                         }
 791                 }
 792
 793                 sat->sat_equality = mr;
 794                 sat->sat_approx = mr->smr_associated;
 795         }
 796
 797         if ( sat->sat_ordering_oid ) {
 798                 if( !sat->sat_equality ) {
 799                         *err = sat->sat_ordering_oid;
 800                         code = SLAP_SCHERR_ATTR_BAD_MR;
 801                         goto error_return;
 802                 }
 803
 804                 mr = mr_find(sat->sat_ordering_oid);
 805
 806                 if( mr == NULL ) {
 807                         *err = sat->sat_ordering_oid;
 808                         code = SLAP_SCHERR_MR_NOT_FOUND;
 809                         goto error_return;
 810                 }
 811
 812                 if(( mr->smr_usage & SLAP_MR_ORDERING ) != SLAP_MR_ORDERING ) {
 813                         *err = sat->sat_ordering_oid;
 814                         code = SLAP_SCHERR_ATTR_BAD_MR;
 815                         goto error_return;
 816                 }
 817
 818                 if( sat->sat_syntax != mr->smr_syntax ) {
 819                         if( mr->smr_compat_syntaxes == NULL ) {
 820                                 *err = sat->sat_ordering_oid;
 821                                 code = SLAP_SCHERR_ATTR_BAD_MR;
 822                                 goto error_return;
 823                         }
 824
 825                         for(i=0; mr->smr_compat_syntaxes[i]; i++) {
 826                                 if( sat->sat_syntax == mr->smr_compat_syntaxes[i] ) {
 827                                         i = -1;
 828                                         break;
 829                                 }
 830                         }
 831
 832                         if( i >= 0 ) {
 833                                 *err = sat->sat_ordering_oid;
 834                                 code = SLAP_SCHERR_ATTR_BAD_MR;
 835                                 goto error_return;
 836                         }
 837                 }
 838
 839                 sat->sat_ordering = mr;
 840         }
 841
 842         if ( sat->sat_substr_oid ) {
 843                 if( !sat->sat_equality ) {
 844                         *err = sat->sat_substr_oid;
 845                         code = SLAP_SCHERR_ATTR_BAD_MR;
 846                         goto error_return;
 847                 }
 848
 849                 mr = mr_find(sat->sat_substr_oid);
 850
 851                 if( mr == NULL ) {
 852                         *err = sat->sat_substr_oid;
 853                         code = SLAP_SCHERR_MR_NOT_FOUND;
 854                         goto error_return;
 855                 }
 856
 857                 if(( mr->smr_usage & SLAP_MR_SUBSTR ) != SLAP_MR_SUBSTR ) {
 858                         *err = sat->sat_substr_oid;
 859                         code = SLAP_SCHERR_ATTR_BAD_MR;
 860                         goto error_return;
 861                 }
 862
 863                 /* due to funky LDAP builtin substring rules,
 864                  * we check against the equality rule assertion
 865                  * syntax and compat syntaxes instead of those
 866                  * associated with the substrings rule.
 867                  */
 868                 if( sat->sat_syntax != sat->sat_equality->smr_syntax ) {
 869                         if( sat->sat_equality->smr_compat_syntaxes == NULL ) {
 870                                 *err = sat->sat_substr_oid;
 871                                 code = SLAP_SCHERR_ATTR_BAD_MR;
 872                                 goto error_return;
 873                         }
 874
 875                         for(i=0; sat->sat_equality->smr_compat_syntaxes[i]; i++) {
 876                                 if( sat->sat_syntax ==
 877                                         sat->sat_equality->smr_compat_syntaxes[i] )
 878                                 {
 879                                         i = -1;
 880                                         break;
 881                                 }
 882                         }
 883
 884                         if( i >= 0 ) {
 885                                 *err = sat->sat_substr_oid;
 886                                 code = SLAP_SCHERR_ATTR_BAD_MR;
 887                                 goto error_return;
 888                         }
 889                 }
 890
 891                 sat->sat_substr = mr;
 892         }
 893
 894         code = at_insert( &sat, prev, err );
 895         if ( code != 0 ) {
 896 error_return:;
 897                 if ( sat ) {
 898                         ldap_pvt_thread_mutex_destroy( &sat->sat_ad_mutex );
 899                         ch_free( sat );
 900                 }
 901
 902                 if ( oidm ) {
 903                         SLAP_FREE( at->at_oid );
 904                         at->at_oid = oidm;
 905                 }
 906
 907         } else if ( rsat ) {
 908                 *rsat = sat;
 909         }
 910
 911         return code;
 912 }
 913
 914 #ifdef LDAP_DEBUG
 915 #ifdef SLAPD_UNUSED
 916 static int
 917 at_index_printnode( void *v_air, void *ignore )
 918 {
 919         struct aindexrec *air = v_air;
 920         printf("%s = %s\n",
 921                 air->air_name.bv_val,
 922                 ldap_attributetype2str(&air->air_at->sat_atype) );
 923         return( 0 );
 924 }
 925
 926 static void
 927 at_index_print( void )
 928 {
 929         printf("Printing attribute type index:\n");
 930         (void) avl_apply( attr_index, at_index_printnode, 0, -1, AVL_INORDER );
 931 }
 932 #endif
 933 #endif
 934
 935 void
 936 at_unparse( BerVarray *res, AttributeType *start, AttributeType *end, int sys )
 937 {
 938         AttributeType *at;
 939         int i, num;
 940         struct berval bv, *bva = NULL, idx;
 941         char ibuf[32];
 942
 943         if ( !start )
 944                 start = LDAP_STAILQ_FIRST( &attr_list );
 945
 946         /* count the result size */
 947         i = 0;
 948         for ( at=start; at; at=LDAP_STAILQ_NEXT(at, sat_next)) {
 949                 if ( sys && !(at->sat_flags & SLAP_AT_HARDCODE)) break;
 950                 i++;
 951                 if ( at == end ) break;
 952         }
 953         if (!i) return;
 954
 955         num = i;
 956         bva = ch_malloc( (num+1) * sizeof(struct berval) );
 957         BER_BVZERO( bva );
 958         idx.bv_val = ibuf;
 959         if ( sys ) {
 960                 idx.bv_len = 0;
 961                 ibuf[0] = '\0';
 962         }
 963         i = 0;
 964         for ( at=start; at; at=LDAP_STAILQ_NEXT(at, sat_next)) {
 965                 LDAPAttributeType lat, *latp;
 966                 if ( sys && !(at->sat_flags & SLAP_AT_HARDCODE)) break;
 967                 if ( at->sat_oidmacro ) {
 968                         lat = at->sat_atype;
 969                         lat.at_oid = at->sat_oidmacro;
 970                         latp = &lat;
 971                 } else {
 972                         latp = &at->sat_atype;
 973                 }
 974                 if ( ldap_attributetype2bv( latp, &bv ) == NULL ) {
 975                         ber_bvarray_free( bva );
 976                 }
 977                 if ( !sys ) {
 978                         idx.bv_len = sprintf(idx.bv_val, "{%d}", i);
 979                 }
 980                 bva[i].bv_len = idx.bv_len + bv.bv_len;
 981                 bva[i].bv_val = ch_malloc( bva[i].bv_len + 1 );
 982                 strcpy( bva[i].bv_val, ibuf );
 983                 strcpy( bva[i].bv_val + idx.bv_len, bv.bv_val );
 984                 i++;
 985                 bva[i].bv_val = NULL;
 986                 ldap_memfree( bv.bv_val );
 987                 if ( at == end ) break;
 988         }
 989         *res = bva;
 990 }
 991
 992 int
 993 at_schema_info( Entry *e )
 994 {
 995         AttributeDescription *ad_attributeTypes = slap_schema.si_ad_attributeTypes;
 996         AttributeType   *at;
 997         struct berval   val;
 998         struct berval   nval;
 999
1000         LDAP_STAILQ_FOREACH(at,&attr_list,sat_next) {
1001                 if( at->sat_flags & SLAP_AT_HIDE ) continue;
1002
1003                 if ( ldap_attributetype2bv( &at->sat_atype, &val ) == NULL ) {
1004                         return -1;
1005                 }
1006
1007                 ber_str2bv( at->sat_oid, 0, 0, &nval );
1008
1009                 if( attr_merge_one( e, ad_attributeTypes, &val, &nval ) )
1010                 {
1011                         return -1;
1012                 }
1013                 ldap_memfree( val.bv_val );
1014         }
1015         return 0;
1016 }
1017
1018 int
1019 register_at( char *def, AttributeDescription **rad, int dupok )
1020 {
1021         LDAPAttributeType *at;
1022         int code, freeit = 0;
1023         const char *err;
1024         AttributeDescription *ad = NULL;
1025
1026         at = ldap_str2attributetype( def, &code, &err, LDAP_SCHEMA_ALLOW_ALL );
1027         if ( !at ) {
1028                 Debug( LDAP_DEBUG_ANY,
1029                         "register_at: AttributeType \"%s\": %s, %s\n",
1030                                 def, ldap_scherr2str(code), err );
1031                 return code;
1032         }
1033
1034         code = at_add( at, 0, NULL, NULL, &err );
1035         if ( code ) {
1036                 if ( code == SLAP_SCHERR_ATTR_DUP && dupok ) {
1037                         freeit = 1;
1038
1039                 } else {
1040                         ldap_attributetype_free( at );
1041                         Debug( LDAP_DEBUG_ANY,
1042                                 "register_at: AttributeType \"%s\": %s, %s\n",
1043                                 def, scherr2str(code), err );
1044                         return code;
1045                 }
1046         }
1047         code = slap_str2ad( at->at_names[0], &ad, &err );
1048         if ( freeit || code ) {
1049                 ldap_attributetype_free( at );
1050         } else {
1051                 ldap_memfree( at );
1052         }
1053         if ( code ) {
1054                 Debug( LDAP_DEBUG_ANY, "register_at: AttributeType \"%s\": %s\n",
1055                         def, err, 0 );
1056         }
1057         if ( rad ) *rad = ad;
1058         return code;
1059 }