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