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-2005 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 int is_at_syntax(
  31         AttributeType *at,
  32         const char *oid )
  33 {
  34         for( ; at != NULL; at = at->sat_sup ) {
  35                 if( at->sat_syntax_oid ) {
  36                         return ( strcmp( at->sat_syntax_oid, oid ) == 0 );
  37                 }
  38         }
  39
  40         return 0;
  41 }
  42
  43 int is_at_subtype(
  44         AttributeType *sub,
  45         AttributeType *sup )
  46 {
  47         for( ; sub != NULL; sub = sub->sat_sup ) {
  48                 if( sub == sup ) return 1;
  49         }
  50
  51         return 0;
  52 }
  53
  54 struct aindexrec {
  55         struct berval   air_name;
  56         AttributeType   *air_at;
  57 };
  58
  59 static Avlnode  *attr_index = NULL;
  60 static Avlnode  *attr_cache = NULL;
  61 static LDAP_SLIST_HEAD(ATList, slap_attribute_type) attr_list
  62         = LDAP_SLIST_HEAD_INITIALIZER(&attr_list);
  63
  64 int at_oc_cache;
  65
  66 static int
  67 attr_index_cmp(
  68     const void  *v_air1,
  69     const void  *v_air2 )
  70 {
  71         const struct aindexrec  *air1 = v_air1;
  72         const struct aindexrec  *air2 = v_air2;
  73         int i = air1->air_name.bv_len - air2->air_name.bv_len;
  74         if (i) return i;
  75         return (strcasecmp( air1->air_name.bv_val, air2->air_name.bv_val ));
  76 }
  77
  78 static int
  79 attr_index_name_cmp(
  80     const void  *v_type,
  81     const void  *v_air )
  82 {
  83     const struct berval    *type = v_type;
  84     const struct aindexrec *air  = v_air;
  85         int i = type->bv_len - air->air_name.bv_len;
  86         if (i) return i;
  87         return (strncasecmp( type->bv_val, air->air_name.bv_val, type->bv_len ));
  88 }
  89
  90 AttributeType *
  91 at_find( const char *name )
  92 {
  93         struct berval bv;
  94
  95         bv.bv_val = (char *)name;
  96         bv.bv_len = strlen( name );
  97
  98         return at_bvfind( &bv );
  99 }
 100
 101 AttributeType *
 102 at_bvfind( struct berval *name )
 103 {
 104         struct aindexrec *air;
 105
 106         if ( attr_cache ) {
 107                 air = avl_find( attr_cache, name, attr_index_name_cmp );
 108                 if ( air ) return air->air_at;
 109         }
 110
 111         air = avl_find( attr_index, name, attr_index_name_cmp );
 112
 113         if ( air && ( slapMode & SLAP_TOOL_MODE ) && at_oc_cache ) {
 114                 avl_insert( &attr_cache, (caddr_t) air,
 115                         attr_index_cmp, avl_dup_error );
 116         }
 117
 118         return air != NULL ? air->air_at : NULL;
 119 }
 120
 121 int
 122 at_append_to_list(
 123     AttributeType       *sat,
 124     AttributeType       ***listp )
 125 {
 126         AttributeType   **list;
 127         AttributeType   **list1;
 128         int             size;
 129
 130         list = *listp;
 131         if ( !list ) {
 132                 size = 2;
 133                 list = ch_calloc(size, sizeof(AttributeType *));
 134                 if ( !list ) {
 135                         return -1;
 136                 }
 137         } else {
 138                 size = 0;
 139                 list1 = *listp;
 140                 while ( *list1 ) {
 141                         size++;
 142                         list1++;
 143                 }
 144                 size += 2;
 145                 list1 = ch_realloc(list, size*sizeof(AttributeType *));
 146                 if ( !list1 ) {
 147                         return -1;
 148                 }
 149                 list = list1;
 150         }
 151         list[size-2] = sat;
 152         list[size-1] = NULL;
 153         *listp = list;
 154         return 0;
 155 }
 156
 157 int
 158 at_delete_from_list(
 159     int                 pos,
 160     AttributeType       ***listp )
 161 {
 162         AttributeType   **list;
 163         AttributeType   **list1;
 164         int             i;
 165         int             j;
 166
 167         if ( pos < 0 ) {
 168                 return -2;
 169         }
 170         list = *listp;
 171         for ( i=0; list[i]; i++ )
 172                 ;
 173         if ( pos >= i ) {
 174                 return -2;
 175         }
 176         for ( i=pos, j=pos+1; list[j]; i++, j++ ) {
 177                 list[i] = list[j];
 178         }
 179         list[i] = NULL;
 180         /* Tell the runtime this can be shrinked */
 181         list1 = ch_realloc(list, (i+1)*sizeof(AttributeType **));
 182         if ( !list1 ) {
 183                 return -1;
 184         }
 185         *listp = list1;
 186         return 0;
 187 }
 188
 189 int
 190 at_find_in_list(
 191     AttributeType       *sat,
 192     AttributeType       **list )
 193 {
 194         int     i;
 195
 196         if ( !list ) {
 197                 return -1;
 198         }
 199         for ( i=0; list[i]; i++ ) {
 200                 if ( sat == list[i] ) {
 201                         return i;
 202                 }
 203         }
 204         return -1;
 205 }
 206
 207 void
 208 at_destroy( void )
 209 {
 210         AttributeType *a;
 211         avl_free(attr_index, ldap_memfree);
 212
 213         while( !LDAP_SLIST_EMPTY(&attr_list) ) {
 214                 a = LDAP_SLIST_FIRST(&attr_list);
 215                 LDAP_SLIST_REMOVE_HEAD(&attr_list, sat_next);
 216
 217                 if (a->sat_subtypes) ldap_memfree(a->sat_subtypes);
 218                 ad_destroy(a->sat_ad);
 219                 ldap_pvt_thread_mutex_destroy(&a->sat_ad_mutex);
 220                 ldap_attributetype_free((LDAPAttributeType *)a);
 221         }
 222
 223         if ( slap_schema.si_at_undefined ) {
 224                 ad_destroy(slap_schema.si_at_undefined->sat_ad);
 225         }
 226 }
 227
 228 int
 229 at_start( AttributeType **at )
 230 {
 231         assert( at );
 232
 233         *at = LDAP_SLIST_FIRST(&attr_list);
 234
 235         return (*at != NULL);
 236 }
 237
 238 int
 239 at_next( AttributeType **at )
 240 {
 241         assert( at );
 242
 243 #if 1   /* pedantic check */
 244         {
 245                 AttributeType *tmp = NULL;
 246
 247                 LDAP_SLIST_FOREACH(tmp,&attr_list,sat_next) {
 248                         if ( tmp == *at ) {
 249                                 break;
 250                         }
 251                 }
 252
 253                 assert( tmp );
 254         }
 255 #endif
 256
 257         *at = LDAP_SLIST_NEXT(*at,sat_next);
 258
 259         return (*at != NULL);
 260 }
 261
 262
 263
 264 static int
 265 at_insert(
 266     AttributeType       *sat,
 267     const char          **err )
 268 {
 269         struct aindexrec        *air;
 270         char                    **names;
 271
 272         LDAP_SLIST_NEXT( sat, sat_next ) = NULL;
 273         LDAP_SLIST_INSERT_HEAD( &attr_list, sat, sat_next );
 274
 275         if ( sat->sat_oid ) {
 276                 air = (struct aindexrec *)
 277                         ch_calloc( 1, sizeof(struct aindexrec) );
 278                 air->air_name.bv_val = sat->sat_oid;
 279                 air->air_name.bv_len = strlen(sat->sat_oid);
 280                 air->air_at = sat;
 281                 if ( avl_insert( &attr_index, (caddr_t) air,
 282                                  attr_index_cmp, avl_dup_error ) ) {
 283                         *err = sat->sat_oid;
 284                         ldap_memfree(air);
 285                         return SLAP_SCHERR_ATTR_DUP;
 286                 }
 287                 /* FIX: temporal consistency check */
 288                 at_bvfind(&air->air_name);
 289         }
 290
 291         if ( (names = sat->sat_names) ) {
 292                 while ( *names ) {
 293                         air = (struct aindexrec *)
 294                                 ch_calloc( 1, sizeof(struct aindexrec) );
 295                         air->air_name.bv_val = *names;
 296                         air->air_name.bv_len = strlen(*names);
 297                         air->air_at = sat;
 298                         if ( avl_insert( &attr_index, (caddr_t) air,
 299                                          attr_index_cmp, avl_dup_error ) ) {
 300                                 *err = *names;
 301                                 ldap_memfree(air);
 302                                 return SLAP_SCHERR_ATTR_DUP;
 303                         }
 304                         /* FIX: temporal consistency check */
 305                         at_bvfind(&air->air_name);
 306                         names++;
 307                 }
 308         }
 309
 310         return 0;
 311 }
 312
 313 int
 314 at_add(
 315     LDAPAttributeType   *at,
 316     const char          **err )
 317 {
 318         AttributeType   *sat;
 319         MatchingRule    *mr;
 320         Syntax          *syn;
 321         int             i;
 322         int             code;
 323         char    *cname;
 324         char    *oid;
 325
 326         if ( !OID_LEADCHAR( at->at_oid[0] )) {
 327                 /* Expand OID macros */
 328                 oid = oidm_find( at->at_oid );
 329                 if ( !oid ) {
 330                         *err = at->at_oid;
 331                         return SLAP_SCHERR_OIDM;
 332                 }
 333                 if ( oid != at->at_oid ) {
 334                         ldap_memfree( at->at_oid );
 335                         at->at_oid = oid;
 336                 }
 337         }
 338
 339         if ( at->at_syntax_oid && !OID_LEADCHAR( at->at_syntax_oid[0] )) {
 340                 /* Expand OID macros */
 341                 oid = oidm_find( at->at_syntax_oid );
 342                 if ( !oid ) {
 343                         *err = at->at_syntax_oid;
 344                         return SLAP_SCHERR_OIDM;
 345                 }
 346                 if ( oid != at->at_syntax_oid ) {
 347                         ldap_memfree( at->at_syntax_oid );
 348                         at->at_syntax_oid = oid;
 349                 }
 350         }
 351
 352         if ( at->at_names && at->at_names[0] ) {
 353                 int i;
 354
 355                 for( i=0; at->at_names[i]; i++ ) {
 356                         if( !slap_valid_descr( at->at_names[i] ) ) {
 357                                 *err = at->at_names[i];
 358                                 return SLAP_SCHERR_BAD_DESCR;
 359                         }
 360                 }
 361
 362                 cname = at->at_names[0];
 363
 364         } else if ( at->at_oid ) {
 365                 cname = at->at_oid;
 366
 367         } else {
 368                 *err = "";
 369                 return SLAP_SCHERR_ATTR_INCOMPLETE;
 370         }
 371
 372         *err = cname;
 373
 374         if ( !at->at_usage && at->at_no_user_mod ) {
 375                 /* user attribute must be modifable */
 376                 return SLAP_SCHERR_ATTR_BAD_USAGE;
 377         }
 378
 379         if ( at->at_collective ) {
 380                 if( at->at_usage ) {
 381                         /* collective attributes cannot be operational */
 382                         return SLAP_SCHERR_ATTR_BAD_USAGE;
 383                 }
 384
 385                 if( at->at_single_value ) {
 386                         /* collective attributes cannot be single-valued */
 387                         return SLAP_SCHERR_ATTR_BAD_USAGE;
 388                 }
 389         }
 390
 391         sat = (AttributeType *) ch_calloc( 1, sizeof(AttributeType) );
 392         AC_MEMCPY( &sat->sat_atype, at, sizeof(LDAPAttributeType));
 393
 394         sat->sat_cname.bv_val = cname;
 395         sat->sat_cname.bv_len = strlen( cname );
 396         ldap_pvt_thread_mutex_init(&sat->sat_ad_mutex);
 397
 398         if ( at->at_sup_oid ) {
 399                 AttributeType *supsat = at_find(at->at_sup_oid);
 400
 401                 if ( supsat == NULL ) {
 402                         *err = at->at_sup_oid;
 403                         return SLAP_SCHERR_ATTR_NOT_FOUND;
 404                 }
 405
 406                 sat->sat_sup = supsat;
 407
 408                 if ( at_append_to_list(sat, &supsat->sat_subtypes) ) {
 409                         return SLAP_SCHERR_OUTOFMEM;
 410                 }
 411
 412                 if ( sat->sat_usage != supsat->sat_usage ) {
 413                         /* subtypes must have same usage as their SUP */
 414                         return SLAP_SCHERR_ATTR_BAD_USAGE;
 415                 }
 416
 417                 if ( supsat->sat_obsolete && !sat->sat_obsolete ) {
 418                         /* subtypes must be obsolete if super is */
 419                         return SLAP_SCHERR_ATTR_BAD_SUP;
 420                 }
 421
 422                 if ( sat->sat_flags & SLAP_AT_FINAL ) {
 423                         /* cannot subtype a "final" attribute type */
 424                         return SLAP_SCHERR_ATTR_BAD_SUP;
 425                 }
 426         }
 427
 428         /*
 429          * Inherit definitions from superiors.  We only check the
 430          * direct superior since that one has already inherited from
 431          * its own superiorss
 432          */
 433         if ( sat->sat_sup ) {
 434                 sat->sat_syntax = sat->sat_sup->sat_syntax;
 435                 sat->sat_equality = sat->sat_sup->sat_equality;
 436                 sat->sat_approx = sat->sat_sup->sat_approx;
 437                 sat->sat_ordering = sat->sat_sup->sat_ordering;
 438                 sat->sat_substr = sat->sat_sup->sat_substr;
 439         }
 440
 441         if ( at->at_syntax_oid ) {
 442                 syn = syn_find(sat->sat_syntax_oid);
 443                 if ( syn == NULL ) {
 444                         *err = sat->sat_syntax_oid;
 445                         return SLAP_SCHERR_SYN_NOT_FOUND;
 446                 }
 447
 448                 if( sat->sat_syntax != NULL && sat->sat_syntax != syn ) {
 449                         return SLAP_SCHERR_ATTR_BAD_SUP;
 450                 }
 451
 452                 sat->sat_syntax = syn;
 453
 454         } else if ( sat->sat_syntax == NULL ) {
 455                 return SLAP_SCHERR_ATTR_INCOMPLETE;
 456         }
 457
 458         if ( sat->sat_equality_oid ) {
 459                 mr = mr_find(sat->sat_equality_oid);
 460
 461                 if( mr == NULL ) {
 462                         *err = sat->sat_equality_oid;
 463                         return SLAP_SCHERR_MR_NOT_FOUND;
 464                 }
 465
 466                 if(( mr->smr_usage & SLAP_MR_EQUALITY ) != SLAP_MR_EQUALITY ) {
 467                         *err = sat->sat_equality_oid;
 468                         return SLAP_SCHERR_ATTR_BAD_MR;
 469                 }
 470
 471                 if( sat->sat_syntax != mr->smr_syntax ) {
 472                         if( mr->smr_compat_syntaxes == NULL ) {
 473                                 *err = sat->sat_equality_oid;
 474                                 return SLAP_SCHERR_ATTR_BAD_MR;
 475                         }
 476
 477                         for(i=0; mr->smr_compat_syntaxes[i]; i++) {
 478                                 if( sat->sat_syntax == mr->smr_compat_syntaxes[i] ) {
 479                                         i = -1;
 480                                         break;
 481                                 }
 482                         }
 483
 484                         if( i >= 0 ) {
 485                                 *err = sat->sat_equality_oid;
 486                                 return SLAP_SCHERR_ATTR_BAD_MR;
 487                         }
 488                 }
 489
 490                 sat->sat_equality = mr;
 491                 sat->sat_approx = mr->smr_associated;
 492         }
 493
 494         if ( sat->sat_ordering_oid ) {
 495                 if( !sat->sat_equality ) {
 496                         *err = sat->sat_ordering_oid;
 497                         return SLAP_SCHERR_ATTR_BAD_MR;
 498                 }
 499
 500                 mr = mr_find(sat->sat_ordering_oid);
 501
 502                 if( mr == NULL ) {
 503                         *err = sat->sat_ordering_oid;
 504                         return SLAP_SCHERR_MR_NOT_FOUND;
 505                 }
 506
 507                 if(( mr->smr_usage & SLAP_MR_ORDERING ) != SLAP_MR_ORDERING ) {
 508                         *err = sat->sat_ordering_oid;
 509                         return SLAP_SCHERR_ATTR_BAD_MR;
 510                 }
 511
 512                 if( sat->sat_syntax != mr->smr_syntax ) {
 513                         if( mr->smr_compat_syntaxes == NULL ) {
 514                                 *err = sat->sat_ordering_oid;
 515                                 return SLAP_SCHERR_ATTR_BAD_MR;
 516                         }
 517
 518                         for(i=0; mr->smr_compat_syntaxes[i]; i++) {
 519                                 if( sat->sat_syntax == mr->smr_compat_syntaxes[i] ) {
 520                                         i = -1;
 521                                         break;
 522                                 }
 523                         }
 524
 525                         if( i >= 0 ) {
 526                                 *err = sat->sat_ordering_oid;
 527                                 return SLAP_SCHERR_ATTR_BAD_MR;
 528                         }
 529                 }
 530
 531                 sat->sat_ordering = mr;
 532         }
 533
 534         if ( sat->sat_substr_oid ) {
 535                 if( !sat->sat_equality ) {
 536                         *err = sat->sat_substr_oid;
 537                         return SLAP_SCHERR_ATTR_BAD_MR;
 538                 }
 539
 540                 mr = mr_find(sat->sat_substr_oid);
 541
 542                 if( mr == NULL ) {
 543                         *err = sat->sat_substr_oid;
 544                         return SLAP_SCHERR_MR_NOT_FOUND;
 545                 }
 546
 547                 if(( mr->smr_usage & SLAP_MR_SUBSTR ) != SLAP_MR_SUBSTR ) {
 548                         *err = sat->sat_substr_oid;
 549                         return SLAP_SCHERR_ATTR_BAD_MR;
 550                 }
 551
 552                 /* due to funky LDAP builtin substring rules,
 553                  * we check against the equality rule assertion
 554                  * syntax and compat syntaxes instead of those
 555                  * associated with the substrings rule.
 556                  */
 557                 if( sat->sat_syntax != sat->sat_equality->smr_syntax ) {
 558                         if( sat->sat_equality->smr_compat_syntaxes == NULL ) {
 559                                 *err = sat->sat_substr_oid;
 560                                 return SLAP_SCHERR_ATTR_BAD_MR;
 561                         }
 562
 563                         for(i=0; sat->sat_equality->smr_compat_syntaxes[i]; i++) {
 564                                 if( sat->sat_syntax ==
 565                                         sat->sat_equality->smr_compat_syntaxes[i] )
 566                                 {
 567                                         i = -1;
 568                                         break;
 569                                 }
 570                         }
 571
 572                         if( i >= 0 ) {
 573                                 *err = sat->sat_substr_oid;
 574                                 return SLAP_SCHERR_ATTR_BAD_MR;
 575                         }
 576                 }
 577
 578                 sat->sat_substr = mr;
 579         }
 580
 581         code = at_insert(sat,err);
 582         return code;
 583 }
 584
 585 #ifdef LDAP_DEBUG
 586 static int
 587 at_index_printnode( void *v_air, void *ignore )
 588 {
 589         struct aindexrec *air = v_air;
 590         printf("%s = %s\n",
 591                 air->air_name.bv_val,
 592                 ldap_attributetype2str(&air->air_at->sat_atype) );
 593         return( 0 );
 594 }
 595
 596 static void
 597 at_index_print( void )
 598 {
 599         printf("Printing attribute type index:\n");
 600         (void) avl_apply( attr_index, at_index_printnode, 0, -1, AVL_INORDER );
 601 }
 602 #endif
 603
 604 int
 605 at_schema_info( Entry *e )
 606 {
 607         AttributeDescription *ad_attributeTypes = slap_schema.si_ad_attributeTypes;
 608         AttributeType   *at;
 609         struct berval   val;
 610         struct berval   nval;
 611
 612         LDAP_SLIST_FOREACH(at,&attr_list,sat_next) {
 613                 if( at->sat_flags & SLAP_AT_HIDE ) continue;
 614
 615                 if ( ldap_attributetype2bv( &at->sat_atype, &val ) == NULL ) {
 616                         return -1;
 617                 }
 618
 619                 nval.bv_val = at->sat_oid;
 620                 nval.bv_len = strlen(at->sat_oid);
 621
 622                 if( attr_merge_one( e, ad_attributeTypes, &val, &nval ) )
 623                 {
 624                         return -1;
 625                 }
 626                 ldap_memfree( val.bv_val );
 627         }
 628         return 0;
 629 }