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-2002 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 MatchingRule *mr_list = NULL;
  26
  27 static int
  28 mr_index_cmp(
  29     struct mindexrec    *mir1,
  30     struct mindexrec    *mir2
  31 )
  32 {
  33         int i = mir1->mir_name.bv_len - mir2->mir_name.bv_len;
  34         if (i) return i;
  35         return (strcmp( mir1->mir_name.bv_val, mir2->mir_name.bv_val ));
  36 }
  37
  38 static int
  39 mr_index_name_cmp(
  40     struct berval       *name,
  41     struct mindexrec    *mir
  42 )
  43 {
  44         int i = name->bv_len - mir->mir_name.bv_len;
  45         if (i) return i;
  46         return (strncmp( name->bv_val, mir->mir_name.bv_val, name->bv_len ));
  47 }
  48
  49 MatchingRule *
  50 mr_find( const char *mrname )
  51 {
  52         struct berval bv;
  53
  54         bv.bv_val = (char *)mrname;
  55         bv.bv_len = strlen( mrname );
  56         return mr_bvfind( &bv );
  57 }
  58
  59 MatchingRule *
  60 mr_bvfind( struct berval *mrname )
  61 {
  62         struct mindexrec        *mir = NULL;
  63
  64         if ( (mir = (struct mindexrec *) avl_find( mr_index, mrname,
  65             (AVL_CMP) mr_index_name_cmp )) != NULL ) {
  66                 return( mir->mir_mr );
  67         }
  68         return( NULL );
  69 }
  70
  71 void
  72 mr_destroy( void )
  73 {
  74         MatchingRule *m, *n;
  75
  76         avl_free(mr_index, ldap_memfree);
  77         for (m=mr_list; m; m=n) {
  78                 n = m->smr_next;
  79                 ldap_matchingrule_free((LDAPMatchingRule *)m);
  80         }
  81 }
  82
  83 static int
  84 mr_insert(
  85     MatchingRule        *smr,
  86     const char          **err
  87 )
  88 {
  89         MatchingRule            **mrp;
  90         struct mindexrec        *mir;
  91         char                    **names;
  92
  93         mrp = &mr_list;
  94         while ( *mrp != NULL ) {
  95                 mrp = &(*mrp)->smr_next;
  96         }
  97         *mrp = smr;
  98
  99         if ( smr->smr_oid ) {
 100                 mir = (struct mindexrec *)
 101                         ch_calloc( 1, sizeof(struct mindexrec) );
 102                 mir->mir_name.bv_val = smr->smr_oid;
 103                 mir->mir_name.bv_len = strlen( smr->smr_oid );
 104                 mir->mir_mr = smr;
 105                 if ( avl_insert( &mr_index, (caddr_t) mir,
 106                                  (AVL_CMP) mr_index_cmp,
 107                                  (AVL_DUP) avl_dup_error ) ) {
 108                         *err = smr->smr_oid;
 109                         ldap_memfree(mir);
 110                         return SLAP_SCHERR_MR_DUP;
 111                 }
 112                 /* FIX: temporal consistency check */
 113                 mr_bvfind(&mir->mir_name);
 114         }
 115         if ( (names = smr->smr_names) ) {
 116                 while ( *names ) {
 117                         mir = (struct mindexrec *)
 118                                 ch_calloc( 1, sizeof(struct mindexrec) );
 119                         mir->mir_name.bv_val = *names;
 120                         mir->mir_name.bv_len = strlen( *names );
 121                         mir->mir_mr = smr;
 122                         if ( avl_insert( &mr_index, (caddr_t) mir,
 123                                          (AVL_CMP) mr_index_cmp,
 124                                          (AVL_DUP) avl_dup_error ) ) {
 125                                 *err = *names;
 126                                 ldap_memfree(mir);
 127                                 return SLAP_SCHERR_MR_DUP;
 128                         }
 129                         /* FIX: temporal consistency check */
 130                         mr_bvfind(&mir->mir_name);
 131                         names++;
 132                 }
 133         }
 134         return 0;
 135 }
 136
 137 int
 138 mr_add(
 139     LDAPMatchingRule            *mr,
 140     slap_mrule_defs_rec *def,
 141         MatchingRule    *amr,
 142     const char          **err
 143 )
 144 {
 145         MatchingRule    *smr;
 146         Syntax          *syn;
 147         int             code;
 148
 149         smr = (MatchingRule *) ch_calloc( 1, sizeof(MatchingRule) );
 150         AC_MEMCPY( &smr->smr_mrule, mr, sizeof(LDAPMatchingRule));
 151
 152         smr->smr_oidlen = strlen( mr->mr_oid );
 153         smr->smr_usage = def->mrd_usage;
 154         smr->smr_convert = def->mrd_convert;
 155         smr->smr_normalize = def->mrd_normalize;
 156         smr->smr_match = def->mrd_match;
 157         smr->smr_indexer = def->mrd_indexer;
 158         smr->smr_filter = def->mrd_filter;
 159         smr->smr_associated = amr;
 160
 161         if ( smr->smr_syntax_oid ) {
 162                 if ( (syn = syn_find(smr->smr_syntax_oid)) ) {
 163                         smr->smr_syntax = syn;
 164                 } else {
 165                         *err = smr->smr_syntax_oid;
 166                         return SLAP_SCHERR_SYN_NOT_FOUND;
 167                 }
 168         } else {
 169                 *err = "";
 170                 return SLAP_SCHERR_MR_INCOMPLETE;
 171         }
 172         code = mr_insert(smr,err);
 173         return code;
 174 }
 175
 176
 177 int
 178 register_matching_rule(
 179         slap_mrule_defs_rec *def )
 180 {
 181         LDAPMatchingRule *mr;
 182         MatchingRule *amr = NULL;
 183         int             code;
 184         const char      *err;
 185
 186         if( def->mrd_usage == SLAP_MR_NONE ) {
 187 #ifdef NEW_LOGGING
 188                 LDAP_LOG( OPERATION, ERR,
 189                         "register_matching_rule: %s not usable\n", def->mrd_desc, 0, 0 );
 190 #else
 191                 Debug( LDAP_DEBUG_ANY, "register_matching_rule: not usable %s\n",
 192                     def->mrd_desc, 0, 0 );
 193 #endif
 194
 195                 return -1;
 196         }
 197
 198         if( def->mrd_associated != NULL ) {
 199                 amr = mr_find( def->mrd_associated );
 200
 201 #if 0
 202                 /* ignore for now */
 203
 204                 if( amr == NULL ) {
 205 #ifdef NEW_LOGGING
 206                         LDAP_LOG( OPERATION, ERR,
 207                            "register_matching_rule: could not locate associated "
 208                            "matching rule %s for %s\n",  def->mrd_associated, def->mrd_desc, 0 );
 209 #else
 210                         Debug( LDAP_DEBUG_ANY, "register_matching_rule: could not locate "
 211                                 "associated matching rule %s for %s\n",
 212                                 def->mrd_associated, def->mrd_desc, 0 );
 213 #endif
 214
 215                         return -1;
 216                 }
 217 #endif
 218
 219         }
 220
 221         mr = ldap_str2matchingrule( def->mrd_desc, &code, &err, LDAP_SCHEMA_ALLOW_ALL);
 222         if ( !mr ) {
 223 #ifdef NEW_LOGGING
 224                 LDAP_LOG( OPERATION, ERR,
 225                         "register_matching_rule: %s before %s in %s.\n",
 226                         ldap_scherr2str(code), err, def->mrd_desc );
 227 #else
 228                 Debug( LDAP_DEBUG_ANY, "Error in register_matching_rule: %s before %s in %s\n",
 229                     ldap_scherr2str(code), err, def->mrd_desc );
 230 #endif
 231
 232                 return( -1 );
 233         }
 234
 235         code = mr_add( mr, def, amr, &err );
 236
 237         ldap_memfree( mr );
 238
 239         if ( code ) {
 240 #ifdef NEW_LOGGING
 241                 LDAP_LOG( OPERATION, ERR,
 242                         "register_matching_rule: %s for %s in %s.\n",
 243                         scherr2str(code), err, def->mrd_desc );
 244 #else
 245                 Debug( LDAP_DEBUG_ANY, "Error in register_matching_rule: %s for %s in %s\n",
 246                     scherr2str(code), err, def->mrd_desc );
 247 #endif
 248
 249                 return( -1 );
 250         }
 251
 252         return( 0 );
 253 }
 254
 255
 256 #if defined( SLAPD_SCHEMA_DN )
 257
 258 int mr_schema_info( Entry *e )
 259 {
 260         struct berval   vals[2];
 261         MatchingRule    *mr;
 262
 263         AttributeDescription *ad_matchingRules = slap_schema.si_ad_matchingRules;
 264
 265         vals[1].bv_val = NULL;
 266
 267         for ( mr = mr_list; mr; mr = mr->smr_next ) {
 268                 if ( mr->smr_usage & SLAP_MR_HIDE ) {
 269                         /* skip hidden rules */
 270                         continue;
 271                 }
 272
 273                 if ( ! mr->smr_match ) {
 274                         /* skip rules without matching functions */
 275                         continue;
 276                 }
 277
 278                 if ( ldap_matchingrule2bv( &mr->smr_mrule, vals ) == NULL ) {
 279                         return -1;
 280                 }
 281 #if 0
 282                 Debug( LDAP_DEBUG_TRACE, "Merging mr [%ld] %s\n",
 283                (long) vals[0].bv_len, vals[0].bv_val, 0 );
 284 #endif
 285                 attr_merge( e, ad_matchingRules, vals );
 286                 ldap_memfree( vals[0].bv_val );
 287         }
 288         return 0;
 289 }
 290
 291 int mru_schema_info( Entry *e )
 292 {
 293         return 0;
 294 }
 295
 296 #endif