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

   1 /* mr.c - routines to manage matching rule definitions */
   2 /* $OpenLDAP$ */
   3 /*
   4  * Copyright 1998-2003 The OpenLDAP Foundation, All Rights Reserved.
   5  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   6  */
   7
   8 #include "portable.h"
   9
  10 #include <stdio.h>
  11
  12 #include <ac/ctype.h>
  13 #include <ac/string.h>
  14 #include <ac/socket.h>
  15
  16 #include "slap.h"
  17 #include "ldap_pvt.h"
  18
  19 struct mindexrec {
  20         struct berval   mir_name;
  21         MatchingRule    *mir_mr;
  22 };
  23
  24 static Avlnode  *mr_index = NULL;
  25 static LDAP_SLIST_HEAD(MRList, slap_matching_rule) mr_list
  26         = LDAP_SLIST_HEAD_INITIALIZER(&mr_list);
  27 static LDAP_SLIST_HEAD(MRUList, slap_matching_rule_use) mru_list
  28         = LDAP_SLIST_HEAD_INITIALIZER(&mru_list);
  29
  30 static int
  31 mr_index_cmp(
  32     const void  *v_mir1,
  33     const void  *v_mir2
  34 )
  35 {
  36         const struct mindexrec  *mir1 = v_mir1;
  37         const struct mindexrec  *mir2 = v_mir2;
  38         int i = mir1->mir_name.bv_len - mir2->mir_name.bv_len;
  39         if (i) return i;
  40         return (strcmp( mir1->mir_name.bv_val, mir2->mir_name.bv_val ));
  41 }
  42
  43 static int
  44 mr_index_name_cmp(
  45     const void  *v_name,
  46     const void  *v_mir
  47 )
  48 {
  49         const struct berval    *name = v_name;
  50         const struct mindexrec *mir  = v_mir;
  51         int i = name->bv_len - mir->mir_name.bv_len;
  52         if (i) return i;
  53         return (strncmp( name->bv_val, mir->mir_name.bv_val, name->bv_len ));
  54 }
  55
  56 MatchingRule *
  57 mr_find( const char *mrname )
  58 {
  59         struct berval bv;
  60
  61         bv.bv_val = (char *)mrname;
  62         bv.bv_len = strlen( mrname );
  63         return mr_bvfind( &bv );
  64 }
  65
  66 MatchingRule *
  67 mr_bvfind( struct berval *mrname )
  68 {
  69         struct mindexrec        *mir = NULL;
  70
  71         if ( (mir = avl_find( mr_index, mrname, mr_index_name_cmp )) != NULL ) {
  72                 return( mir->mir_mr );
  73         }
  74         return( NULL );
  75 }
  76
  77 void
  78 mr_destroy( void )
  79 {
  80         MatchingRule *m;
  81
  82         avl_free(mr_index, ldap_memfree);
  83         while( !LDAP_SLIST_EMPTY(&mr_list) ) {
  84                 m = LDAP_SLIST_FIRST(&mr_list);
  85                 LDAP_SLIST_REMOVE_HEAD(&mr_list, smr_next);
  86                 ch_free( m->smr_str.bv_val );
  87                 ldap_matchingrule_free((LDAPMatchingRule *)m);
  88         }
  89 }
  90
  91 static int
  92 mr_insert(
  93     MatchingRule        *smr,
  94     const char          **err
  95 )
  96 {
  97         struct mindexrec        *mir;
  98         char                    **names;
  99
 100         LDAP_SLIST_NEXT( smr, smr_next ) = NULL;
 101         LDAP_SLIST_INSERT_HEAD(&mr_list, smr, smr_next);
 102
 103         if ( smr->smr_oid ) {
 104                 mir = (struct mindexrec *)
 105                         ch_calloc( 1, sizeof(struct mindexrec) );
 106                 mir->mir_name.bv_val = smr->smr_oid;
 107                 mir->mir_name.bv_len = strlen( smr->smr_oid );
 108                 mir->mir_mr = smr;
 109                 if ( avl_insert( &mr_index, (caddr_t) mir,
 110                                  mr_index_cmp, avl_dup_error ) ) {
 111                         *err = smr->smr_oid;
 112                         ldap_memfree(mir);
 113                         return SLAP_SCHERR_MR_DUP;
 114                 }
 115                 /* FIX: temporal consistency check */
 116                 mr_bvfind(&mir->mir_name);
 117         }
 118         if ( (names = smr->smr_names) ) {
 119                 while ( *names ) {
 120                         mir = (struct mindexrec *)
 121                                 ch_calloc( 1, sizeof(struct mindexrec) );
 122                         mir->mir_name.bv_val = *names;
 123                         mir->mir_name.bv_len = strlen( *names );
 124                         mir->mir_mr = smr;
 125                         if ( avl_insert( &mr_index, (caddr_t) mir,
 126                                          mr_index_cmp, avl_dup_error ) ) {
 127                                 *err = *names;
 128                                 ldap_memfree(mir);
 129                                 return SLAP_SCHERR_MR_DUP;
 130                         }
 131                         /* FIX: temporal consistency check */
 132                         mr_bvfind(&mir->mir_name);
 133                         names++;
 134                 }
 135         }
 136         return 0;
 137 }
 138
 139 int
 140 mr_add(
 141     LDAPMatchingRule            *mr,
 142     slap_mrule_defs_rec *def,
 143         MatchingRule    *amr,
 144     const char          **err
 145 )
 146 {
 147         MatchingRule    *smr;
 148         Syntax          *syn;
 149         Syntax          **compat_syn = NULL;
 150         int             code;
 151
 152         if( def->mrd_compat_syntaxes ) {
 153                 int i;
 154                 for( i=0; def->mrd_compat_syntaxes[i]; i++ ) {
 155                         /* just count em */
 156                 }
 157
 158                 compat_syn = ch_malloc( sizeof(Syntax *) * (i+1) );
 159
 160                 for( i=0; def->mrd_compat_syntaxes[i]; i++ ) {
 161                         compat_syn[i] = syn_find( def->mrd_compat_syntaxes[i] );
 162                         if( compat_syn[i] == NULL ) {
 163                                 return SLAP_SCHERR_SYN_NOT_FOUND;
 164                         }
 165                 }
 166
 167                 compat_syn[i] = NULL;
 168         }
 169
 170         smr = (MatchingRule *) ch_calloc( 1, sizeof(MatchingRule) );
 171         AC_MEMCPY( &smr->smr_mrule, mr, sizeof(LDAPMatchingRule));
 172
 173         /*
 174          * note: smr_bvoid uses the same memory of smr_mrule.mr_oid;
 175          * smr_oidlen is #defined as smr_bvoid.bv_len
 176          */
 177         smr->smr_bvoid.bv_val = smr->smr_mrule.mr_oid;
 178         smr->smr_oidlen = strlen( mr->mr_oid );
 179         smr->smr_usage = def->mrd_usage;
 180         smr->smr_compat_syntaxes = compat_syn;
 181         smr->smr_normalize = def->mrd_normalize;
 182         smr->smr_match = def->mrd_match;
 183 #ifdef SLAP_NVALUES
 184         /* disable indexing for now */
 185 #else
 186         smr->smr_convert = def->mrd_convert;
 187         smr->smr_indexer = def->mrd_indexer;
 188         smr->smr_filter = def->mrd_filter;
 189 #endif
 190         smr->smr_associated = amr;
 191
 192         if ( smr->smr_syntax_oid ) {
 193                 if ( (syn = syn_find(smr->smr_syntax_oid)) ) {
 194                         smr->smr_syntax = syn;
 195                 } else {
 196                         *err = smr->smr_syntax_oid;
 197                         return SLAP_SCHERR_SYN_NOT_FOUND;
 198                 }
 199         } else {
 200                 *err = "";
 201                 return SLAP_SCHERR_MR_INCOMPLETE;
 202         }
 203         code = mr_insert(smr,err);
 204         return code;
 205 }
 206
 207 int
 208 register_matching_rule(
 209         slap_mrule_defs_rec *def )
 210 {
 211         LDAPMatchingRule *mr;
 212         MatchingRule *amr = NULL;
 213         int             code;
 214         const char      *err;
 215
 216         if( def->mrd_usage == SLAP_MR_NONE &&
 217                 def->mrd_compat_syntaxes == NULL )
 218         {
 219 #ifdef NEW_LOGGING
 220                 LDAP_LOG( OPERATION, ERR,
 221                         "register_matching_rule: %s not usable\n", def->mrd_desc, 0, 0 );
 222 #else
 223                 Debug( LDAP_DEBUG_ANY, "register_matching_rule: not usable %s\n",
 224                     def->mrd_desc, 0, 0 );
 225 #endif
 226
 227                 return -1;
 228         }
 229
 230         if( def->mrd_associated != NULL ) {
 231                 amr = mr_find( def->mrd_associated );
 232
 233 #if 0
 234                 /* ignore for now */
 235
 236                 if( amr == NULL ) {
 237 #ifdef NEW_LOGGING
 238                         LDAP_LOG( OPERATION, ERR,
 239                            "register_matching_rule: could not locate associated "
 240                            "matching rule %s for %s\n",
 241                                 def->mrd_associated, def->mrd_desc, 0 );
 242 #else
 243                         Debug( LDAP_DEBUG_ANY, "register_matching_rule: could not locate "
 244                                 "associated matching rule %s for %s\n",
 245                                 def->mrd_associated, def->mrd_desc, 0 );
 246 #endif
 247
 248                         return -1;
 249                 }
 250 #endif
 251         }
 252
 253         mr = ldap_str2matchingrule( def->mrd_desc, &code, &err,
 254                 LDAP_SCHEMA_ALLOW_ALL );
 255         if ( !mr ) {
 256 #ifdef NEW_LOGGING
 257                 LDAP_LOG( OPERATION, ERR,
 258                         "register_matching_rule: %s before %s in %s.\n",
 259                         ldap_scherr2str(code), err, def->mrd_desc );
 260 #else
 261                 Debug( LDAP_DEBUG_ANY,
 262                         "Error in register_matching_rule: %s before %s in %s\n",
 263                     ldap_scherr2str(code), err, def->mrd_desc );
 264 #endif
 265
 266                 return( -1 );
 267         }
 268
 269         code = mr_add( mr, def, amr, &err );
 270
 271         ldap_memfree( mr );
 272
 273         if ( code ) {
 274 #ifdef NEW_LOGGING
 275                 LDAP_LOG( OPERATION, ERR,
 276                         "register_matching_rule: %s for %s in %s.\n",
 277                         scherr2str(code), err, def->mrd_desc );
 278 #else
 279                 Debug( LDAP_DEBUG_ANY,
 280                         "Error in register_matching_rule: %s for %s in %s\n",
 281                     scherr2str(code), err, def->mrd_desc );
 282 #endif
 283
 284                 return( -1 );
 285         }
 286
 287         return( 0 );
 288 }
 289
 290 void
 291 mru_destroy( void )
 292 {
 293         MatchingRuleUse *m;
 294
 295         while( !LDAP_SLIST_EMPTY(&mru_list) ) {
 296                 m = LDAP_SLIST_FIRST(&mru_list);
 297                 LDAP_SLIST_REMOVE_HEAD(&mru_list, smru_next);
 298
 299                 if ( m->smru_str.bv_val ) {
 300                         ch_free( m->smru_str.bv_val );
 301                 }
 302                 /* memory borrowed from m->smru_mr */
 303                 m->smru_oid = NULL;
 304                 m->smru_names = NULL;
 305                 m->smru_desc = NULL;
 306
 307                 /* free what's left (basically
 308                  * smru_mruleuse.mru_applies_oids) */
 309                 ldap_matchingruleuse_free((LDAPMatchingRuleUse *)m);
 310         }
 311 }
 312
 313 int
 314 matching_rule_use_init( void )
 315 {
 316         MatchingRule    *mr;
 317         MatchingRuleUse **mru_ptr = &LDAP_SLIST_FIRST(&mru_list);
 318
 319 #ifdef NEW_LOGGING
 320         LDAP_LOG( OPERATION, INFO, "matching_rule_use_init\n", 0, 0, 0 );
 321 #else
 322         Debug( LDAP_DEBUG_TRACE, "matching_rule_use_init\n", 0, 0, 0 );
 323 #endif
 324
 325         LDAP_SLIST_FOREACH( mr, &mr_list, smr_next ) {
 326                 AttributeType   *at;
 327                 MatchingRuleUse mru_storage, *mru = &mru_storage;
 328
 329                 char            **applies_oids = NULL;
 330
 331                 mr->smr_mru = NULL;
 332
 333                 /* hide rules marked as HIDE */
 334                 if ( mr->smr_usage & SLAP_MR_HIDE ) {
 335                         continue;
 336                 }
 337
 338                 /* hide rules not marked as designed for extensibility */
 339                 /* MR_EXT means can be used any attribute type whose
 340                  * syntax is same as the assertion syntax.
 341                  * Another mechanism is needed where rule can be used
 342                  * with attribute of other syntaxes.
 343                  * Framework doesn't support this (yet).
 344                  */
 345
 346                 if (!( ( mr->smr_usage & SLAP_MR_EXT )
 347                         || mr->smr_compat_syntaxes ) )
 348                 {
 349                         continue;
 350                 }
 351
 352                 memset( mru, 0, sizeof( MatchingRuleUse ) );
 353
 354                 /*
 355                  * Note: we're using the same values of the corresponding
 356                  * MatchingRule structure; maybe we'd copy them ...
 357                  */
 358                 mru->smru_mr = mr;
 359                 mru->smru_obsolete = mr->smr_obsolete;
 360                 mru->smru_applies_oids = NULL;
 361                 LDAP_SLIST_NEXT(mru, smru_next) = NULL;
 362                 mru->smru_oid = mr->smr_oid;
 363                 mru->smru_names = mr->smr_names;
 364                 mru->smru_desc = mr->smr_desc;
 365
 366 #ifdef NEW_LOGGING
 367                 LDAP_LOG( OPERATION, INFO, "    %s (%s): ",
 368                                 mru->smru_oid,
 369                                 mru->smru_names ? mru->smru_names[ 0 ] : "", 0 );
 370 #else
 371                 Debug( LDAP_DEBUG_TRACE, "    %s (%s): ",
 372                                 mru->smru_oid,
 373                                 mru->smru_names ? mru->smru_names[ 0 ] : "", 0 );
 374 #endif
 375
 376                 at = NULL;
 377                 for ( at_start( &at ); at; at_next( &at ) ) {
 378                         if( at->sat_flags & SLAP_AT_HIDE ) continue;
 379
 380                         if( mr_usable_with_at( mr, at )) {
 381                                 ldap_charray_add( &applies_oids, at->sat_cname.bv_val );
 382                         }
 383                 }
 384
 385                 /*
 386                  * Note: the matchingRules that are not used
 387                  * by any attributeType are not listed as
 388                  * matchingRuleUse
 389                  */
 390                 if ( applies_oids != NULL ) {
 391                         mru->smru_applies_oids = applies_oids;
 392 #ifdef NEW_LOGGING
 393                         {
 394                                 char *str = ldap_matchingruleuse2str( &mru->smru_mruleuse );
 395                                 LDAP_LOG( OPERATION, INFO, "matchingRuleUse: %s\n", str, 0, 0 );
 396                                 ldap_memfree( str );
 397                         }
 398 #else
 399                         {
 400                                 char *str = ldap_matchingruleuse2str( &mru->smru_mruleuse );
 401                                 Debug( LDAP_DEBUG_TRACE, "matchingRuleUse: %s\n", str, 0, 0 );
 402                                 ldap_memfree( str );
 403                         }
 404 #endif
 405
 406                         mru = (MatchingRuleUse *)ber_memalloc( sizeof( MatchingRuleUse ) );
 407                         /* call-forward from MatchingRule to MatchingRuleUse */
 408                         mr->smr_mru = mru;
 409                         /* copy static data to newly allocated struct */
 410                         *mru = mru_storage;
 411                         /* append the struct pointer to the end of the list */
 412                         *mru_ptr = mru;
 413                         /* update the list head pointer */
 414                         mru_ptr = &LDAP_SLIST_NEXT(mru,smru_next);
 415                 }
 416         }
 417
 418         return( 0 );
 419 }
 420
 421 int mr_usable_with_at(
 422         MatchingRule *mr,
 423         AttributeType *at )
 424 {
 425         if( mr->smr_usage & SLAP_MR_EXT && (
 426                 mr->smr_syntax == at->sat_syntax ||
 427                 mr == at->sat_equality || mr == at->sat_approx ) )
 428         {
 429                 return 1;
 430         }
 431
 432         if ( mr->smr_compat_syntaxes ) {
 433                 int i;
 434                 for( i=0; mr->smr_compat_syntaxes[i]; i++ ) {
 435                         if( at->sat_syntax == mr->smr_compat_syntaxes[i] ) {
 436                                 return 1;
 437                         }
 438                 }
 439         }
 440         return 0;
 441 }
 442
 443 int mr_schema_info( Entry *e )
 444 {
 445         MatchingRule *mr;
 446
 447         AttributeDescription *ad_matchingRules = slap_schema.si_ad_matchingRules;
 448
 449         LDAP_SLIST_FOREACH(mr, &mr_list, smr_next ) {
 450                 if ( mr->smr_usage & SLAP_MR_HIDE ) {
 451                         /* skip hidden rules */
 452                         continue;
 453                 }
 454
 455                 if ( ! mr->smr_match ) {
 456                         /* skip rules without matching functions */
 457                         continue;
 458                 }
 459
 460                 if ( mr->smr_str.bv_val == NULL ) {
 461                         if ( ldap_matchingrule2bv( &mr->smr_mrule, &mr->smr_str ) == NULL ) {
 462                                 return -1;
 463                         }
 464                 }
 465 #if 0
 466                 Debug( LDAP_DEBUG_TRACE, "Merging mr [%lu] %s\n",
 467                         mr->smr_str.bv_len, mr->smr_str.bv_val, 0 );
 468 #endif
 469 #ifdef SLAP_NVALUES
 470                 if( attr_merge_one( e, ad_matchingRules, &mr->smr_str, NULL /* FIXME */ ) )
 471 #else
 472                 if( attr_merge_one( e, ad_matchingRules, &mr->smr_str ) )
 473 #endif
 474                 {
 475                         return -1;
 476                 }
 477         }
 478         return 0;
 479 }
 480
 481 int mru_schema_info( Entry *e )
 482 {
 483         MatchingRuleUse *mru;
 484
 485         AttributeDescription *ad_matchingRuleUse
 486                 = slap_schema.si_ad_matchingRuleUse;
 487
 488         LDAP_SLIST_FOREACH( mru, &mru_list, smru_next ) {
 489
 490                 assert( !( mru->smru_usage & SLAP_MR_HIDE ) );
 491
 492                 if ( mru->smru_str.bv_val == NULL ) {
 493                         if ( ldap_matchingruleuse2bv( &mru->smru_mruleuse, &mru->smru_str )
 494                                         == NULL ) {
 495                                 return -1;
 496                         }
 497                 }
 498
 499 #if 0
 500                 Debug( LDAP_DEBUG_TRACE, "Merging mru [%lu] %s\n",
 501                         mru->smru_str.bv_len, mru->smru_str.bv_val, 0 );
 502 #endif
 503 #ifdef SLAP_NVALUES
 504                 if( attr_merge_one( e, ad_matchingRuleUse, &mru->smru_str, NULL /* FIXME */ ) )
 505 #else
 506                 if( attr_merge_one( e, ad_matchingRuleUse, &mru->smru_str ) )
 507 #endif
 508                 {
 509                         return -1;
 510                 }
 511         }
 512         return 0;
 513 }