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

   1 /* $OpenLDAP$ */
   2 /*
   3  * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.
   4  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   5  */
   6 /* at.c - routines for dealing with attribute types */
   7
   8 #include "portable.h"
   9
  10 #include <stdio.h>
  11
  12 #include <ac/ctype.h>
  13 #include <ac/errno.h>
  14 #include <ac/socket.h>
  15 #include <ac/string.h>
  16 #include <ac/time.h>
  17
  18 #include "ldap_pvt.h"
  19 #include "slap.h"
  20
  21
  22 int is_at_syntax(
  23         AttributeType *at,
  24         const char *oid )
  25 {
  26         for( ; at != NULL; at = at->sat_sup ) {
  27                 if( at->sat_syntax_oid ) {
  28                         return ( strcmp( at->sat_syntax_oid, oid ) == 0 );
  29                 }
  30         }
  31
  32         return 0;
  33 }
  34
  35 int is_at_subtype(
  36         AttributeType *sub,
  37         AttributeType *sup )
  38 {
  39         for( ; sub != NULL; sub = sub->sat_sup ) {
  40                 if( sub == sup ) return 1;
  41         }
  42
  43         return 0;
  44 }
  45
  46 struct aindexrec {
  47         char            *air_name;
  48         AttributeType   *air_at;
  49 };
  50
  51 static Avlnode  *attr_index = NULL;
  52 static AttributeType *attr_list = NULL;
  53
  54 static int
  55 attr_index_cmp(
  56     struct aindexrec    *air1,
  57     struct aindexrec    *air2
  58 )
  59 {
  60         return (strcasecmp( air1->air_name, air2->air_name ));
  61 }
  62
  63 static int
  64 attr_index_name_cmp(
  65     const char          *type,
  66     struct aindexrec    *air
  67 )
  68 {
  69         return (strcasecmp( type, air->air_name ));
  70 }
  71
  72 AttributeType *
  73 at_find(
  74     const char          *name
  75 )
  76 {
  77         struct aindexrec *air;
  78
  79         air = (struct aindexrec *) avl_find( attr_index, name,
  80             (AVL_CMP) attr_index_name_cmp );
  81
  82         return air != NULL ? air->air_at : NULL;
  83 }
  84
  85 int
  86 at_append_to_list(
  87     AttributeType       *sat,
  88     AttributeType       ***listp
  89 )
  90 {
  91         AttributeType   **list;
  92         AttributeType   **list1;
  93         int             size;
  94
  95         list = *listp;
  96         if ( !list ) {
  97                 size = 2;
  98                 list = ch_calloc(size, sizeof(AttributeType *));
  99                 if ( !list ) {
 100                         return -1;
 101                 }
 102         } else {
 103                 size = 0;
 104                 list1 = *listp;
 105                 while ( *list1 ) {
 106                         size++;
 107                         list1++;
 108                 }
 109                 size += 2;
 110                 list1 = ch_realloc(list, size*sizeof(AttributeType *));
 111                 if ( !list1 ) {
 112                         return -1;
 113                 }
 114                 list = list1;
 115         }
 116         list[size-2] = sat;
 117         list[size-1] = NULL;
 118         *listp = list;
 119         return 0;
 120 }
 121
 122 int
 123 at_delete_from_list(
 124     int                 pos,
 125     AttributeType       ***listp
 126 )
 127 {
 128         AttributeType   **list;
 129         AttributeType   **list1;
 130         int             i;
 131         int             j;
 132
 133         if ( pos < 0 ) {
 134                 return -2;
 135         }
 136         list = *listp;
 137         for ( i=0; list[i]; i++ )
 138                 ;
 139         if ( pos >= i ) {
 140                 return -2;
 141         }
 142         for ( i=pos, j=pos+1; list[j]; i++, j++ ) {
 143                 list[i] = list[j];
 144         }
 145         list[i] = NULL;
 146         /* Tell the runtime this can be shrinked */
 147         list1 = ch_realloc(list, (i+1)*sizeof(AttributeType **));
 148         if ( !list1 ) {
 149                 return -1;
 150         }
 151         *listp = list1;
 152         return 0;
 153 }
 154
 155 int
 156 at_find_in_list(
 157     AttributeType       *sat,
 158     AttributeType       **list
 159 )
 160 {
 161         int     i;
 162
 163         if ( !list ) {
 164                 return -1;
 165         }
 166         for ( i=0; list[i]; i++ ) {
 167                 if ( sat == list[i] ) {
 168                         return i;
 169                 }
 170         }
 171         return -1;
 172 }
 173
 174 void
 175 at_destroy( void )
 176 {
 177         AttributeType *a, *n;
 178         avl_free(attr_index, ldap_memfree);
 179
 180         for (a=attr_list; a; a=n) {
 181                 n = a->sat_next;
 182                 ldap_memfree(a->sat_subtypes);
 183                 ad_destroy(a->sat_ad);
 184                 ldap_pvt_thread_mutex_destroy(&a->sat_ad_mutex);
 185                 ldap_attributetype_free((LDAPAttributeType *)a);
 186         }
 187 }
 188
 189 static int
 190 at_insert(
 191     AttributeType       *sat,
 192     const char          **err
 193 )
 194 {
 195         AttributeType           **atp;
 196         struct aindexrec        *air;
 197         char                    **names;
 198
 199         atp = &attr_list;
 200         while ( *atp != NULL ) {
 201                 atp = &(*atp)->sat_next;
 202         }
 203         *atp = sat;
 204
 205         if ( sat->sat_oid ) {
 206                 air = (struct aindexrec *)
 207                         ch_calloc( 1, sizeof(struct aindexrec) );
 208                 air->air_name = sat->sat_oid;
 209                 air->air_at = sat;
 210                 if ( avl_insert( &attr_index, (caddr_t) air,
 211                                  (AVL_CMP) attr_index_cmp,
 212                                  (AVL_DUP) avl_dup_error ) ) {
 213                         *err = sat->sat_oid;
 214                         ldap_memfree(air);
 215                         return SLAP_SCHERR_DUP_ATTR;
 216                 }
 217                 /* FIX: temporal consistency check */
 218                 at_find(air->air_name);
 219         }
 220
 221         if ( (names = sat->sat_names) ) {
 222                 while ( *names ) {
 223                         air = (struct aindexrec *)
 224                                 ch_calloc( 1, sizeof(struct aindexrec) );
 225                         air->air_name = *names;
 226                         air->air_at = sat;
 227                         if ( avl_insert( &attr_index, (caddr_t) air,
 228                                          (AVL_CMP) attr_index_cmp,
 229                                          (AVL_DUP) avl_dup_error ) ) {
 230                                 *err = *names;
 231                                 ldap_memfree(air);
 232                                 return SLAP_SCHERR_DUP_ATTR;
 233                         }
 234                         /* FIX: temporal consistency check */
 235                         at_find(air->air_name);
 236                         names++;
 237                 }
 238         }
 239
 240         return 0;
 241 }
 242
 243 int
 244 at_add(
 245     LDAPAttributeType   *at,
 246     const char          **err
 247 )
 248 {
 249         AttributeType   *sat;
 250         MatchingRule    *mr;
 251         Syntax          *syn;
 252         int             code;
 253         char                    *cname;
 254
 255         if ( at->at_names && at->at_names[0] ) {
 256                 int i;
 257
 258                 for( i=0; at->at_names[i]; i++ ) {
 259                         if( !slap_valid_descr( at->at_names[i] ) ) {
 260                                 return SLAP_SCHERR_BAD_DESCR;
 261                         }
 262                 }
 263
 264                 cname = at->at_names[0];
 265
 266         } else if ( at->at_oid ) {
 267                 cname = at->at_oid;
 268         } else {
 269                 return SLAP_SCHERR_ATTR_INCOMPLETE;
 270         }
 271
 272         if ( at->at_collective ) {
 273                 return SLAP_SCHERR_NOT_SUPPORTED;
 274         }
 275
 276         sat = (AttributeType *) ch_calloc( 1, sizeof(AttributeType) );
 277         AC_MEMCPY( &sat->sat_atype, at, sizeof(LDAPAttributeType));
 278
 279         sat->sat_cname.bv_val = cname;
 280         sat->sat_cname.bv_len = strlen( cname );
 281         ldap_pvt_thread_mutex_init(&sat->sat_ad_mutex);
 282
 283         if ( at->at_sup_oid ) {
 284                 AttributeType *supsat = at_find(at->at_sup_oid);
 285
 286                 if ( (supsat == NULL ) ) {
 287                         *err = at->at_sup_oid;
 288                         return SLAP_SCHERR_ATTR_NOT_FOUND;
 289                 }
 290
 291                 sat->sat_sup = supsat;
 292
 293                 if ( at_append_to_list(sat, &supsat->sat_subtypes) ) {
 294                         *err = cname;
 295                         return SLAP_SCHERR_OUTOFMEM;
 296                 }
 297         }
 298
 299         /*
 300          * Inherit definitions from superiors.  We only check the
 301          * direct superior since that one has already inherited from
 302          * its own superiorss
 303          */
 304         if ( sat->sat_sup ) {
 305                 sat->sat_syntax = sat->sat_sup->sat_syntax;
 306                 sat->sat_equality = sat->sat_sup->sat_equality;
 307                 sat->sat_approx = sat->sat_sup->sat_approx;
 308                 sat->sat_ordering = sat->sat_sup->sat_ordering;
 309                 sat->sat_substr = sat->sat_sup->sat_substr;
 310         }
 311
 312         if ( at->at_syntax_oid ) {
 313                 if ( (syn = syn_find(sat->sat_syntax_oid)) ) {
 314                         sat->sat_syntax = syn;
 315                 } else {
 316                         *err = sat->sat_syntax_oid;
 317                         return SLAP_SCHERR_SYN_NOT_FOUND;
 318                 }
 319
 320
 321         } else if ( sat->sat_syntax == NULL ) {
 322                 return SLAP_SCHERR_ATTR_INCOMPLETE;
 323         }
 324
 325         if ( sat->sat_equality_oid ) {
 326                 if ( (mr = mr_find(sat->sat_equality_oid)) ) {
 327                         sat->sat_equality = mr;
 328                         sat->sat_approx = mr->smr_associated;
 329                 } else {
 330                         *err = sat->sat_equality_oid;
 331                         return SLAP_SCHERR_MR_NOT_FOUND;
 332                 }
 333
 334         }
 335
 336         if ( sat->sat_ordering_oid ) {
 337                 if ( (mr = mr_find(sat->sat_ordering_oid)) ) {
 338                         sat->sat_ordering = mr;
 339                 } else {
 340                         *err = sat->sat_ordering_oid;
 341                         return SLAP_SCHERR_MR_NOT_FOUND;
 342                 }
 343         }
 344
 345         if ( sat->sat_substr_oid ) {
 346                 if ( (mr = mr_find(sat->sat_substr_oid)) ) {
 347                         sat->sat_substr = mr;
 348                 } else {
 349                         *err = sat->sat_substr_oid;
 350                         return SLAP_SCHERR_MR_NOT_FOUND;
 351                 }
 352         }
 353
 354         code = at_insert(sat,err);
 355         return code;
 356 }
 357
 358 #ifdef LDAP_DEBUG
 359 static int
 360 at_index_printnode( struct aindexrec *air )
 361 {
 362
 363         printf("%s = %s\n",
 364                 air->air_name,
 365                 ldap_attributetype2str(&air->air_at->sat_atype) );
 366         return( 0 );
 367 }
 368
 369 static void
 370 at_index_print( void )
 371 {
 372         printf("Printing attribute type index:\n");
 373         (void) avl_apply( attr_index, (AVL_APPLY) at_index_printnode,
 374                 0, -1, AVL_INORDER );
 375 }
 376 #endif
 377
 378 #if defined( SLAPD_SCHEMA_DN )
 379 int
 380 at_schema_info( Entry *e )
 381 {
 382         struct berval   val;
 383         struct berval   *vals[2];
 384         AttributeType   *at;
 385
 386         AttributeDescription *ad_attributeTypes = slap_schema.si_ad_attributeTypes;
 387
 388         vals[0] = &val;
 389         vals[1] = NULL;
 390
 391         for ( at = attr_list; at; at = at->sat_next ) {
 392                 val.bv_val = ldap_attributetype2str( &at->sat_atype );
 393                 if ( val.bv_val == NULL ) {
 394                         return -1;
 395                 }
 396                 val.bv_len = strlen( val.bv_val );
 397 #if 0
 398                 Debug( LDAP_DEBUG_TRACE, "Merging at [%ld] %s\n",
 399                        (long) val.bv_len, val.bv_val, 0 );
 400 #endif
 401                 attr_merge( e, ad_attributeTypes, vals );
 402                 ldap_memfree( val.bv_val );
 403         }
 404         return 0;
 405 }
 406 #endif