← Back to branch summary

~ttx/openldap/lucid-gssapi-495418

« back to all changes in this revision

Viewing changes to contrib/slapd-modules/comp_match/init.c

  • Committer: Bazaar Package Importer
  • Author(s): Mathias Gug
  • Date: 2008-07-10 14:45:49 UTC
  • Revision ID: james.westby@ubuntu.com-20080710144549-wck73med0e72gfyo
Tags: upstream-2.4.10
Import upstream version 2.4.10

Show diffs side-by-side

added added

removed removed

Lines of Context:
contrib/slapd-modules/comp_match/init.c
 
1
/* Copyright 2004 IBM Corporation
 
2
 * All rights reserved.
 
3
 * Redisribution and use in source and binary forms, with or without
 
4
 * modification, are permitted only as authorizd by the OpenLADP
 
5
 * Public License.
 
6
 */
 
7
/* ACKNOWLEDGEMENTS
 
8
 * This work originally developed by Sang Seok Lim
 
9
 * 2004/06/18   03:20:00        slim@OpenLDAP.org
 
10
 */
 
11
 
 
12
#include "portable.h"
 
13
#include <ac/string.h>
 
14
#include <ac/socket.h>
 
15
#include <ldap_pvt.h>
 
16
#include "lutil.h"
 
17
#include <ldap.h>
 
18
#include "slap.h"
 
19
#include "component.h"
 
20
 
 
21
#include "componentlib.h"
 
22
#include "asn.h"
 
23
#include <asn-gser.h>
 
24
 
 
25
#include <string.h>
 
26
 
 
27
#ifndef SLAPD_COMP_MATCH
 
28
#define SLAPD_COMP_MATCH SLAPD_MOD_DYNAMIC
 
29
#endif
 
30
 
 
31
/*
 
32
 * Attribute and MatchingRule aliasing table
 
33
 */
 
34
AttributeAliasing aa_table [ MAX_ALIASING_ENTRY ];
 
35
MatchingRuleAliasing mra_table [ MAX_ALIASING_ENTRY ];
 
36
 
 
37
OD_entry* gOD_table = NULL;
 
38
AsnTypetoMatchingRuleTable* gATMR_table = NULL;
 
39
 
 
40
int
 
41
load_derived_matching_rule ( char* cfg_path ){
 
42
}
 
43
 
 
44
AttributeAliasing*
 
45
comp_is_aliased_attribute( void *in  )
 
46
{
 
47
        AttributeAliasing* curr_aa;
 
48
        int i;
 
49
        AttributeDescription *ad = (AttributeDescription*)in;
 
50
 
 
51
        for ( i = 0; aa_table[i].aa_aliasing_ad && i < MAX_ALIASING_ENTRY; i++ ) {
 
52
                if ( strncmp(aa_table[i].aa_aliasing_ad->ad_cname.bv_val , ad->ad_cname.bv_val, ad->ad_cname.bv_len) == 0 )
 
53
                        return &aa_table[i];
 
54
        }
 
55
        return NULL;
 
56
}
 
57
 
 
58
static int
 
59
add_aa_entry( int index, char* aliasing_at_name, char* aliased_at_name, char* mr_name, char* component_filter )
 
60
{
 
61
        char text[1][128];
 
62
        int rc;
 
63
        struct berval type;
 
64
 
 
65
        /* get and store aliasing AttributeDescription */
 
66
        type.bv_val = aliasing_at_name;
 
67
        type.bv_len = strlen ( aliasing_at_name );
 
68
        rc = slap_bv2ad ( &type, &aa_table[index].aa_aliasing_ad,(const char**)text );
 
69
        if ( rc != LDAP_SUCCESS ) return rc;
 
70
 
 
71
        /* get and store aliased AttributeDescription */
 
72
        type.bv_val = aliased_at_name;
 
73
        type.bv_len = strlen ( aliased_at_name );
 
74
        rc = slap_bv2ad ( &type, &aa_table[index].aa_aliased_ad,(const char**)text );
 
75
        if ( rc != LDAP_SUCCESS ) return rc;
 
76
 
 
77
        /* get and store componentFilterMatch */
 
78
        type.bv_val = mr_name;
 
79
        type.bv_len = strlen ( mr_name);
 
80
        aa_table[index].aa_mr = mr_bvfind ( &type );
 
81
 
 
82
        /* get and store a component filter */
 
83
        type.bv_val = component_filter;
 
84
        type.bv_len = strlen ( component_filter );
 
85
        rc = get_comp_filter( NULL, &type, &aa_table[index].aa_cf,(const char**)text);
 
86
 
 
87
        aa_table[index].aa_cf_str = component_filter;
 
88
 
 
89
        return rc;
 
90
}
 
91
 
 
92
/*
 
93
 * Initialize attribute aliasing table when this module is loaded
 
94
 * add_aa_entry ( index for the global table,
 
95
 *                name of the aliasing attribute,
 
96
 *                component filter with filling value parts "xxx"
 
97
 *              )
 
98
 * "xxx" will be replaced with effective values later.
 
99
 * See RFC3687 to understand the content of a component filter.
 
100
 */
 
101
char* pre_processed_comp_filter[] = {
 
102
/*1*/"item:{ component \"toBeSigned.issuer.rdnSequence\", rule distinguishedNameMatch, value xxx }",
 
103
/*2*/"item:{ component \"toBeSigned.serialNumber\", rule integerMatch, value xxx }",
 
104
/*3*/"and:{ item:{ component \"toBeSigned.serialNumber\", rule integerMatch, value xxx }, item:{ component \"toBeSigned.issuer.rdnSequence\", rule distinguishedNameMatch, value xxx } }"
 
105
};
 
106
 
 
107
static int
 
108
init_attribute_aliasing_table ()
 
109
{
 
110
        int rc;
 
111
        int index = 0 ;
 
112
 
 
113
        rc = add_aa_entry ( index, "x509CertificateIssuer", "userCertificate","componentFilterMatch", pre_processed_comp_filter[index] );
 
114
        if ( rc != LDAP_SUCCESS ) return LDAP_PARAM_ERROR;
 
115
        index++;
 
116
 
 
117
        rc = add_aa_entry ( index, "x509CertificateSerial","userCertificate", "componentFilterMatch", pre_processed_comp_filter[index] );
 
118
        if ( rc != LDAP_SUCCESS ) return LDAP_PARAM_ERROR;
 
119
        index++;
 
120
 
 
121
        rc = add_aa_entry ( index, "x509CertificateSerialAndIssuer", "userCertificate", "componentFilterMatch", pre_processed_comp_filter[index] );
 
122
        if ( rc != LDAP_SUCCESS ) return LDAP_PARAM_ERROR;
 
123
        index++;
 
124
 
 
125
        return LDAP_SUCCESS;
 
126
}
 
127
 
 
128
void
 
129
init_component_description_table () {
 
130
        AsnTypeId id;
 
131
        struct berval mr;
 
132
        AsnTypetoSyntax* asn_to_syn;
 
133
        Syntax* syn;
 
134
 
 
135
        for ( id = BASICTYPE_BOOLEAN; id != ASNTYPE_END ; id++ ) {
 
136
                asntype_to_compType_mapping_tbl[id].ac_comp_type.ct_subtypes = NULL;
 
137
                asntype_to_compType_mapping_tbl[id].ac_comp_type.ct_syntax =  NULL;
 
138
 
 
139
                /* Equality Matching Rule */
 
140
                if ( asntype_to_compMR_mapping_tbl[id].atc_equality ) {
 
141
                        mr.bv_val = asntype_to_compMR_mapping_tbl[id].atc_equality;
 
142
                        mr.bv_len = strlen(asntype_to_compMR_mapping_tbl[id].atc_equality);
 
143
                        asntype_to_compType_mapping_tbl[id].ac_comp_type.ct_equality = mr_bvfind( &mr );
 
144
                }
 
145
                /* Approx Matching Rule */
 
146
                if ( asntype_to_compMR_mapping_tbl[id].atc_approx ) {
 
147
                        mr.bv_val = asntype_to_compMR_mapping_tbl[id].atc_approx;
 
148
                        mr.bv_len = strlen(asntype_to_compMR_mapping_tbl[id].atc_approx);
 
149
                        asntype_to_compType_mapping_tbl[id].ac_comp_type.ct_approx = mr_bvfind( &mr );
 
150
                }
 
151
 
 
152
                /* Ordering Matching Rule */
 
153
                if ( asntype_to_compMR_mapping_tbl[id].atc_ordering ) {
 
154
                        mr.bv_val = asntype_to_compMR_mapping_tbl[id].atc_ordering;
 
155
                        mr.bv_len = strlen(asntype_to_compMR_mapping_tbl[id].atc_ordering);
 
156
                        asntype_to_compType_mapping_tbl[id].ac_comp_type.ct_ordering= mr_bvfind( &mr );
 
157
                }
 
158
 
 
159
                /* Substr Matching Rule */
 
160
                if ( asntype_to_compMR_mapping_tbl[id].atc_substr ) {
 
161
                        mr.bv_val = asntype_to_compMR_mapping_tbl[id].atc_substr;
 
162
                        mr.bv_len = strlen(asntype_to_compMR_mapping_tbl[id].atc_substr);
 
163
                        asntype_to_compType_mapping_tbl[id].ac_comp_type.ct_substr = mr_bvfind( &mr );
 
164
                }
 
165
                /* Syntax */
 
166
 
 
167
                asn_to_syn = &asn_to_syntax_mapping_tbl[ id ];
 
168
                if ( asn_to_syn->ats_syn_oid )
 
169
                        syn = syn_find ( asn_to_syn->ats_syn_oid );
 
170
                else 
 
171
                        syn = NULL;
 
172
                asntype_to_compType_mapping_tbl[id].ac_comp_type.ct_syntax = syn;
 
173
 
 
174
                /* Initialize Component Descriptions of primitive ASN.1 types */
 
175
                asntype_to_compdesc_mapping_tbl[id].atcd_cd.cd_comp_type = (AttributeType*)&asntype_to_compType_mapping_tbl[id].ac_comp_type;
 
176
        }
 
177
}
 
178
 
 
179
MatchingRule*
 
180
retrieve_matching_rule( char* mr_oid, AsnTypeId type ) {
 
181
        char* tmp;
 
182
        struct berval mr_name = BER_BVNULL;
 
183
        AsnTypetoMatchingRuleTable* atmr;
 
184
 
 
185
        for ( atmr = gATMR_table ; atmr ; atmr = atmr->atmr_table_next ) {
 
186
                if ( strcmp( atmr->atmr_oid, mr_oid ) == 0 ) {
 
187
                        tmp = atmr->atmr_table[type].atmr_mr_name;
 
188
                        if ( tmp ) {
 
189
                                mr_name.bv_val = tmp;
 
190
                                mr_name.bv_len = strlen( tmp );
 
191
                                return mr_bvfind ( &mr_name );
 
192
                        }
 
193
                }
 
194
        }
 
195
        return (MatchingRule*)NULL;
 
196
}
 
197
 
 
198
void* 
 
199
comp_convert_attr_to_comp LDAP_P (( Attribute* a, Syntax *syn, struct berval* bv ))
 
200
{
 
201
        char* peek_head;
 
202
        int mode, bytesDecoded, size, rc;
 
203
        void* component;
 
204
        char* oid = a->a_desc->ad_type->sat_atype.at_oid ;
 
205
        GenBuf* b = NULL;
 
206
        ExpBuf* buf = NULL;
 
207
        OidDecoderMapping* odm;
 
208
        
 
209
        /* look for the decoder registered for the given attribute */
 
210
        odm = RetrieveOidDecoderMappingbyOid( oid, strlen(oid) );
 
211
 
 
212
        if ( !odm || (!odm->BER_Decode && !odm->GSER_Decode) )
 
213
                return (void*)NULL;
 
214
 
 
215
        buf = ExpBufAllocBuf();
 
216
        ExpBuftoGenBuf( buf, &b );
 
217
        ExpBufInstallDataInBuf ( buf, bv->bv_val, bv->bv_len );
 
218
        BufResetInReadMode( b );
 
219
 
 
220
        mode = DEC_ALLOC_MODE_2;
 
221
        /*
 
222
         * How can we decide which decoder will be called, GSER or BER?
 
223
         * Currently BER decoder is called for a certificate.
 
224
         * The flag of Attribute will say something about it in the future
 
225
         */
 
226
        if ( syn && slap_syntax_is_ber ( syn ) ) {
 
227
#if 0
 
228
                rc =BDecComponentTop(odm->BER_Decode, a->a_comp_data->cd_mem_op, b, 0,0, &component,&bytesDecoded,mode ) ;
 
229
#endif
 
230
                rc = odm->BER_Decode ( a->a_comp_data->cd_mem_op, b, (ComponentSyntaxInfo*)&component, &bytesDecoded, mode );
 
231
        }
 
232
        else {
 
233
                rc = odm->GSER_Decode( a->a_comp_data->cd_mem_op, b, (ComponentSyntaxInfo**)component, &bytesDecoded, mode);
 
234
        }
 
235
 
 
236
        ExpBufFreeBuf( buf );
 
237
        GenBufFreeBuf( b );
 
238
        if ( rc == -1 ) {
 
239
#if 0
 
240
                ShutdownNibbleMemLocal ( a->a_comp_data->cd_mem_op );
 
241
                free ( a->a_comp_data );
 
242
                a->a_comp_data = NULL;
 
243
#endif
 
244
                return (void*)NULL;
 
245
        }
 
246
        else {
 
247
                return component;
 
248
        }
 
249
}
 
250
 
 
251
#include <nibble-alloc.h>
 
252
void
 
253
comp_free_component ( void* mem_op ) {
 
254
        ShutdownNibbleMemLocal( (NibbleMem*)mem_op );
 
255
        return;
 
256
}
 
257
 
 
258
void
 
259
comp_convert_assert_to_comp (
 
260
        void* mem_op,
 
261
        ComponentSyntaxInfo *csi_attr,
 
262
        struct berval* bv,
 
263
        ComponentSyntaxInfo** csi, int* len, int mode )
 
264
{
 
265
        int rc;
 
266
        GenBuf* genBuf;
 
267
        ExpBuf* buf;
 
268
        gser_decoder_func *decoder = csi_attr->csi_comp_desc->cd_gser_decoder;
 
269
 
 
270
        buf = ExpBufAllocBuf();
 
271
        ExpBuftoGenBuf( buf, &genBuf );
 
272
        ExpBufInstallDataInBuf ( buf, bv->bv_val, bv->bv_len );
 
273
        BufResetInReadMode( genBuf );
 
274
 
 
275
        if ( csi_attr->csi_comp_desc->cd_type_id == BASICTYPE_ANY )
 
276
                decoder = ((ComponentAny*)csi_attr)->cai->GSER_Decode;
 
277
 
 
278
        rc = (*decoder)( mem_op, genBuf, csi, len, mode );
 
279
        ExpBufFreeBuf ( buf );
 
280
        GenBufFreeBuf( genBuf );
 
281
}
 
282
 
 
283
int intToAscii( int value, char* buf ) {
 
284
        int minus=0,i,temp;
 
285
        int total_num_digits;
 
286
 
 
287
        if ( value == 0 ){
 
288
                buf[0] = '0';
 
289
                return 1;
 
290
        }
 
291
 
 
292
        if ( value < 0 ){
 
293
                minus = 1;
 
294
                value = value*(-1);
 
295
                buf[0] = '-';
 
296
        }
 
297
        
 
298
        /* How many digits */
 
299
        for ( temp = value, total_num_digits=0 ; temp ; total_num_digits++ )
 
300
                temp = temp/10;
 
301
 
 
302
        total_num_digits += minus;
 
303
 
 
304
        for ( i = minus ; value ; i++ ) {
 
305
                buf[ total_num_digits - i - 1 ]= (char)(value%10 + '0');
 
306
                value = value/10;
 
307
        }
 
308
        return i;
 
309
}
 
310
 
 
311
int
 
312
comp_convert_asn_to_ldap ( MatchingRule* mr, ComponentSyntaxInfo* csi, struct berval* bv, int *allocated )
 
313
{
 
314
        int rc;
 
315
        struct berval prettied;
 
316
        Syntax* syn;
 
317
 
 
318
        AsnTypetoSyntax* asn_to_syn =
 
319
                &asn_to_syntax_mapping_tbl[csi->csi_comp_desc->cd_type_id];
 
320
        if ( asn_to_syn->ats_syn_oid )
 
321
                csi->csi_syntax = syn_find ( asn_to_syn->ats_syn_oid );
 
322
        else 
 
323
                csi->csi_syntax = NULL;
 
324
 
 
325
 
 
326
        switch ( csi->csi_comp_desc->cd_type_id ) {
 
327
          case BASICTYPE_BOOLEAN :
 
328
                bv->bv_val = (char*)malloc( 5 );
 
329
                *allocated = 1;
 
330
                bv->bv_len = 5;
 
331
                if ( ((ComponentBool*)csi)->value > 0 ) {
 
332
                        strcpy ( bv->bv_val , "TRUE" );
 
333
                        bv->bv_len = 4;
 
334
                }
 
335
                else {
 
336
                        strcpy ( bv->bv_val , "FALSE" );
 
337
                        bv->bv_len = 5;
 
338
                }
 
339
                break ;
 
340
          case BASICTYPE_NULL :
 
341
                bv->bv_len = 0;
 
342
                break;
 
343
          case BASICTYPE_INTEGER :
 
344
                bv->bv_val = (char*)malloc( INITIAL_ATTR_SIZE );
 
345
                *allocated = 1;
 
346
                bv->bv_len = INITIAL_ATTR_SIZE;
 
347
                bv->bv_len = intToAscii(((ComponentInt*)csi)->value, bv->bv_val );
 
348
                if ( bv->bv_len <= 0 )
 
349
                        return LDAP_INVALID_SYNTAX;
 
350
                break;
 
351
          case BASICTYPE_REAL :
 
352
                return LDAP_INVALID_SYNTAX;
 
353
          case BASICTYPE_ENUMERATED :
 
354
                bv->bv_val = (char*)malloc( INITIAL_ATTR_SIZE );
 
355
                *allocated = 1;
 
356
                bv->bv_len = INITIAL_ATTR_SIZE;
 
357
                bv->bv_len = intToAscii(((ComponentEnum*)csi)->value, bv->bv_val );
 
358
                if ( bv->bv_len <= 0 )
 
359
                        return LDAP_INVALID_SYNTAX;
 
360
                break;
 
361
          case BASICTYPE_OID :
 
362
          case BASICTYPE_OCTETSTRING :
 
363
          case BASICTYPE_BITSTRING :
 
364
          case BASICTYPE_NUMERIC_STR :
 
365
          case BASICTYPE_PRINTABLE_STR :
 
366
          case BASICTYPE_UNIVERSAL_STR :
 
367
          case BASICTYPE_IA5_STR :
 
368
          case BASICTYPE_BMP_STR :
 
369
          case BASICTYPE_UTF8_STR :
 
370
          case BASICTYPE_UTCTIME :
 
371
          case BASICTYPE_GENERALIZEDTIME :
 
372
          case BASICTYPE_GRAPHIC_STR :
 
373
          case BASICTYPE_VISIBLE_STR :
 
374
          case BASICTYPE_GENERAL_STR :
 
375
          case BASICTYPE_OBJECTDESCRIPTOR :
 
376
          case BASICTYPE_VIDEOTEX_STR :
 
377
          case BASICTYPE_T61_STR :
 
378
          case BASICTYPE_OCTETCONTAINING :
 
379
          case BASICTYPE_BITCONTAINING :
 
380
          case BASICTYPE_RELATIVE_OID :
 
381
                bv->bv_val = ((ComponentOcts*)csi)->value.octs;
 
382
                bv->bv_len = ((ComponentOcts*)csi)->value.octetLen;
 
383
                break;
 
384
          case BASICTYPE_ANY :
 
385
                csi = ((ComponentAny*)csi)->value;
 
386
                if ( csi->csi_comp_desc->cd_type != ASN_BASIC ||
 
387
                        csi->csi_comp_desc->cd_type_id == BASICTYPE_ANY )
 
388
                        return LDAP_INVALID_SYNTAX;
 
389
                return comp_convert_asn_to_ldap( mr, csi, bv, allocated );
 
390
          case COMPOSITE_ASN1_TYPE :
 
391
                break;
 
392
          case RDNSequence :
 
393
                /*dnMatch*/
 
394
                if( strncmp( mr->smr_mrule.mr_oid, DN_MATCH_OID, strlen(DN_MATCH_OID) ) != 0 )
 
395
                        return LDAP_INVALID_SYNTAX;
 
396
                *allocated = 1;
 
397
                rc = ConvertRDNSequence2RFC2253( (irRDNSequence*)csi, bv );
 
398
                if ( rc != LDAP_SUCCESS ) return rc;
 
399
                break;
 
400
          case RelativeDistinguishedName :
 
401
                /*rdnMatch*/
 
402
                if( strncmp( mr->smr_mrule.mr_oid, RDN_MATCH_OID, strlen(RDN_MATCH_OID) ) != 0 )
 
403
                        return LDAP_INVALID_SYNTAX;
 
404
                *allocated = 1;
 
405
                rc = ConvertRDN2RFC2253((irRelativeDistinguishedName*)csi,bv);
 
406
                if ( rc != LDAP_SUCCESS ) return rc;
 
407
                break;
 
408
          case TelephoneNumber :
 
409
          case FacsimileTelephoneNumber__telephoneNumber :
 
410
                break;
 
411
          case DirectoryString :
 
412
                return LDAP_INVALID_SYNTAX;
 
413
          case ASN_COMP_CERTIFICATE :
 
414
          case ASNTYPE_END :
 
415
                break;
 
416
          default :
 
417
                /*Only ASN Basic Type can be converted into LDAP string*/
 
418
                return LDAP_INVALID_SYNTAX;
 
419
        }
 
420
 
 
421
        if ( csi->csi_syntax ) {
 
422
                if ( csi->csi_syntax->ssyn_validate ) {
 
423
                        rc = csi->csi_syntax->ssyn_validate(csi->csi_syntax, bv);
 
424
                        if ( rc != LDAP_SUCCESS )
 
425
                                return LDAP_INVALID_SYNTAX;
 
426
                }
 
427
                if ( csi->csi_syntax->ssyn_pretty ) {
 
428
                        rc = csi->csi_syntax->ssyn_pretty(csi->csi_syntax, bv, &prettied , NULL );
 
429
                        if ( rc != LDAP_SUCCESS )
 
430
                                return LDAP_INVALID_SYNTAX;
 
431
#if 0
 
432
                        free ( bv->bv_val );/*potential memory leak?*/
 
433
#endif
 
434
                        bv->bv_val = prettied.bv_val;
 
435
                        bv->bv_len = prettied.bv_len;
 
436
                }
 
437
        }
 
438
 
 
439
        return LDAP_SUCCESS;
 
440
}
 
441
 
 
442
/*
 
443
 * If <all> type component referenced is used
 
444
 * more than one component will be tested
 
445
 */
 
446
#define IS_TERMINAL_COMPREF(cr) (cr->cr_curr->ci_next == NULL)
 
447
int
 
448
comp_test_all_components (
 
449
        void* attr_mem_op,
 
450
        void* assert_mem_op,
 
451
        ComponentSyntaxInfo *csi_attr,
 
452
        ComponentAssertion* ca )
 
453
{
 
454
        int rc;
 
455
        ComponentSyntaxInfo *csi_temp = NULL, *csi_assert = NULL, *comp_elmt = NULL;
 
456
        ComponentReference *cr = ca->ca_comp_ref;
 
457
        struct berval *ca_val = &ca->ca_ma_value;
 
458
 
 
459
        switch ( cr->cr_curr->ci_type ) {
 
460
            case LDAP_COMPREF_ALL:
 
461
                if ( IS_TERMINAL_COMPREF(cr) ) {
 
462
                        FOR_EACH_LIST_ELMT( comp_elmt, &((ComponentList*)csi_attr)->comp_list )
 
463
                        {
 
464
                                rc = comp_test_one_component( attr_mem_op, assert_mem_op, comp_elmt, ca );
 
465
                                if ( rc == LDAP_COMPARE_TRUE ) {
 
466
                                        break;
 
467
                                }
 
468
                        }
 
469
                } else {
 
470
                        ComponentId *start_compid = ca->ca_comp_ref->cr_curr->ci_next;
 
471
                        FOR_EACH_LIST_ELMT( comp_elmt, &((ComponentList*)csi_attr)->comp_list )
 
472
                        {
 
473
                                cr->cr_curr = start_compid;
 
474
                                rc = comp_test_components ( attr_mem_op, assert_mem_op, comp_elmt, ca );
 
475
                                if ( rc != LDAP_COMPARE_FALSE ) {
 
476
                                        break;
 
477
                                }
 
478
#if 0                           
 
479
                                if ( rc == LDAP_COMPARE_TRUE ) {
 
480
                                        break;
 
481
                                }
 
482
#endif
 
483
                        }
 
484
                }
 
485
                break;
 
486
            case LDAP_COMPREF_CONTENT:
 
487
            case LDAP_COMPREF_SELECT:
 
488
            case LDAP_COMPREF_DEFINED:
 
489
            case LDAP_COMPREF_UNDEFINED:
 
490
            case LDAP_COMPREF_IDENTIFIER:
 
491
            case LDAP_COMPREF_FROM_BEGINNING:
 
492
            case LDAP_COMPREF_FROM_END:
 
493
            case LDAP_COMPREF_COUNT:
 
494
                rc = LDAP_OPERATIONS_ERROR;
 
495
                break;
 
496
            default:
 
497
                rc = LDAP_OPERATIONS_ERROR;
 
498
        }
 
499
        return rc;
 
500
}
 
501
 
 
502
void
 
503
eat_bv_whsp ( struct berval* in )
 
504
{
 
505
        char* end = in->bv_val + in->bv_len;
 
506
        for ( ; ( *in->bv_val == ' ' ) && ( in->bv_val < end ) ; ) {
 
507
                in->bv_val++;
 
508
        }
 
509
}
 
510
 
 
511
/*
 
512
 * Perform matching one referenced component against assertion
 
513
 * If the matching rule in a component filter is allComponentsMatch
 
514
 * or its derivatives the extracted component's ASN.1 specification
 
515
 * is applied to the assertion value as its syntax
 
516
 * Otherwise, the matching rule's syntax is applied to the assertion value
 
517
 * By RFC 3687
 
518
 */
 
519
int
 
520
comp_test_one_component (
 
521
        void* attr_mem_op,
 
522
        void* assert_mem_op,
 
523
        ComponentSyntaxInfo *csi_attr,
 
524
        ComponentAssertion *ca )
 
525
{
 
526
        int len, rc;
 
527
        ComponentSyntaxInfo *csi_assert = NULL;
 
528
        char* oid = NULL;
 
529
        MatchingRule* mr = ca->ca_ma_rule;
 
530
 
 
531
        if ( mr->smr_usage & SLAP_MR_COMPONENT ) {
 
532
                /* If allComponentsMatch or its derivatives */
 
533
                if ( !ca->ca_comp_data.cd_tree ) {
 
534
                        comp_convert_assert_to_comp( assert_mem_op, csi_attr, &ca->ca_ma_value, &csi_assert, &len, DEC_ALLOC_MODE_0 );
 
535
                        ca->ca_comp_data.cd_tree = (void*)csi_assert;
 
536
                } else {
 
537
                        csi_assert = ca->ca_comp_data.cd_tree;
 
538
                }
 
539
 
 
540
                if ( !csi_assert )
 
541
                        return LDAP_PROTOCOL_ERROR;
 
542
 
 
543
                if ( strcmp( mr->smr_mrule.mr_oid, OID_ALL_COMP_MATCH ) != 0 )
 
544
                {
 
545
                        /* allComponentMatch's derivatives */
 
546
                        oid =  mr->smr_mrule.mr_oid;
 
547
                }
 
548
                        return csi_attr->csi_comp_desc->cd_all_match(
 
549
                                                 oid, csi_attr, csi_assert );
 
550
 
 
551
        } else {
 
552
                /* LDAP existing matching rules */
 
553
                struct berval attr_bv = BER_BVNULL;
 
554
                struct berval n_attr_bv = BER_BVNULL;
 
555
                struct berval* assert_bv = &ca->ca_ma_value;
 
556
                int allocated = 0;
 
557
                /*Attribute is converted to compatible LDAP encodings*/
 
558
                if ( comp_convert_asn_to_ldap( mr, csi_attr, &attr_bv, &allocated ) != LDAP_SUCCESS )
 
559
                        return LDAP_INAPPROPRIATE_MATCHING;
 
560
                /* extracted component value is not normalized */
 
561
                if ( ca->ca_ma_rule->smr_normalize ) {
 
562
                        rc = ca->ca_ma_rule->smr_normalize (
 
563
                                SLAP_MR_VALUE_OF_ASSERTION_SYNTAX,
 
564
                                NULL, ca->ca_ma_rule,
 
565
                                &attr_bv, &n_attr_bv, NULL );
 
566
                        if ( rc != LDAP_SUCCESS )
 
567
                                return rc;
 
568
                        if ( allocated && attr_bv.bv_val )
 
569
                                free (attr_bv.bv_val);
 
570
                } else {
 
571
                        n_attr_bv = attr_bv;
 
572
                }
 
573
#if 0
 
574
                /*Assertion value is validated by MR's syntax*/
 
575
                if ( !ca->ca_comp_data.cd_tree ) {
 
576
                        ca->ca_comp_data.cd_tree = assert_bv;
 
577
                }
 
578
                else {
 
579
                        assert_bv = ca->ca_comp_data.cd_tree;
 
580
                }
 
581
#endif
 
582
                if ( !n_attr_bv.bv_val )
 
583
                        return LDAP_COMPARE_FALSE;
 
584
                rc = csi_value_match( mr, &n_attr_bv, assert_bv );
 
585
                if ( n_attr_bv.bv_val )
 
586
                        free ( n_attr_bv.bv_val );
 
587
                return rc;
 
588
        }
 
589
}
 
590
 
 
591
int
 
592
comp_test_components( void* attr_nm, void* assert_nm, ComponentSyntaxInfo* csi_attr, ComponentAssertion* ca) {
 
593
        char* peek_head;
 
594
        int mode, bytesDecoded = 0, rc;
 
595
        GenBuf* b;
 
596
        ExpBuf* buf;
 
597
        OidDecoderMapping* odm;
 
598
        struct berval bv;
 
599
        char oid[MAX_OID_LEN];
 
600
        void* contained_comp, *anytype_comp;
 
601
        ComponentReference* cr = ca->ca_comp_ref;
 
602
 
 
603
        if ( !cr )
 
604
                return comp_test_one_component ( attr_nm, assert_nm, csi_attr, ca );
 
605
        /* Extracting the component refrenced by ca->ca_comp_ref */
 
606
        csi_attr = (ComponentSyntaxInfo*)csi_attr->csi_comp_desc->cd_extract_i( attr_nm, cr, csi_attr );
 
607
        if ( !csi_attr ) return LDAP_INVALID_SYNTAX;
 
608
        /* perform matching, considering the type of a Component Reference(CR)*/
 
609
        switch( cr->cr_curr->ci_type ) {
 
610
           case LDAP_COMPREF_IDENTIFIER:
 
611
           case LDAP_COMPREF_FROM_BEGINNING:
 
612
           case LDAP_COMPREF_FROM_END:
 
613
           case LDAP_COMPREF_COUNT:
 
614
                /*
 
615
                 * Exactly one component is referenced
 
616
                 * Fast Path for matching for this case
 
617
                 */
 
618
                rc = comp_test_one_component ( attr_nm, assert_nm, csi_attr, ca );
 
619
                break;
 
620
           case LDAP_COMPREF_ALL:
 
621
                /*
 
622
                 * If <all> type CR is used
 
623
                 * more than one component will be tested
 
624
                 */
 
625
                rc = comp_test_all_components ( attr_nm, assert_nm, csi_attr, ca );
 
626
                break;
 
627
 
 
628
           case LDAP_COMPREF_CONTENT:
 
629
                /*
 
630
                 * <content> type CR is used
 
631
                 * check if it is followed by <select> type CR.
 
632
                 * 1) If so, look up the corresponding decoder  in the mapping
 
633
                 * table(OID to decoder) by <select>
 
634
                 * and then decode the OCTET/BIT STRING with the decoder
 
635
                 * Finially, extreact the target component with the remaining CR.
 
636
                 * 2) If not, just return the current component, It SHOULD not be
 
637
                 * extracted further, because the component MUST be BIT/OCTET
 
638
                 * string.
 
639
                 */
 
640
 
 
641
                cr->cr_curr = cr->cr_curr->ci_next;
 
642
                if ( !cr->cr_curr ) {
 
643
                        /* case 2) in above description */
 
644
                        rc = comp_test_one_component ( attr_nm, assert_nm, csi_attr, ca );
 
645
                        break;
 
646
                }
 
647
 
 
648
                if ( cr->cr_curr->ci_type == LDAP_COMPREF_SELECT ) {
 
649
                        /* Look up OID mapping table */ 
 
650
                        odm = RetrieveOidDecoderMappingbyBV( &cr->cr_curr->ci_val.ci_select_value );
 
651
                        
 
652
                        if ( !odm || !odm->BER_Decode )
 
653
                                return  LDAP_PROTOCOL_ERROR;
 
654
 
 
655
                        /* current componet MUST be either BIT or OCTET STRING */
 
656
                        if ( csi_attr->csi_comp_desc->cd_type_id != BASICTYPE_BITSTRING ) {
 
657
                                bv.bv_val = ((ComponentBits*)csi_attr)->value.bits;
 
658
                                bv.bv_len = ((ComponentBits*)csi_attr)->value.bitLen;
 
659
                        }
 
660
                        else if ( csi_attr->csi_comp_desc->cd_type_id != BASICTYPE_BITSTRING ) {
 
661
                                bv.bv_val = ((ComponentOcts*)csi_attr)->value.octs;
 
662
                                bv.bv_len = ((ComponentOcts*)csi_attr)->value.octetLen;
 
663
                        }
 
664
                        else
 
665
                                return LDAP_PROTOCOL_ERROR;
 
666
 
 
667
                        buf = ExpBufAllocBuf();
 
668
                        ExpBuftoGenBuf( buf, &b );
 
669
                        ExpBufInstallDataInBuf ( buf, bv.bv_val, bv.bv_len );
 
670
                        BufResetInReadMode( b );
 
671
                        mode = DEC_ALLOC_MODE_2;
 
672
 
 
673
                        /* Try to decode with BER/DER decoder */
 
674
                        rc = odm->BER_Decode ( attr_nm, b, (ComponentSyntaxInfo*)&contained_comp, &bytesDecoded, mode );
 
675
 
 
676
                        ExpBufFreeBuf( buf );
 
677
                        GenBufFreeBuf( b );
 
678
 
 
679
                        if ( rc != LDAP_SUCCESS ) return LDAP_PROTOCOL_ERROR;
 
680
 
 
681
                        /* xxx.content.(x.xy.xyz).rfc822Name */
 
682
                        /* In the aboe Ex. move CR to the right to (x.xy.xyz)*/
 
683
                        cr->cr_curr = cr->cr_curr->ci_next;
 
684
                        if (!cr->cr_curr )
 
685
                                rc = comp_test_one_component ( attr_nm, assert_nm, csi_attr, ca );
 
686
                        else
 
687
                                rc = comp_test_components( attr_nm, assert_nm, contained_comp, ca );
 
688
                }
 
689
                else {
 
690
                        /* Ivalid Component reference */
 
691
                        rc = LDAP_PROTOCOL_ERROR;
 
692
                }
 
693
                break;
 
694
           case LDAP_COMPREF_SELECT:
 
695
                if (csi_attr->csi_comp_desc->cd_type_id != BASICTYPE_ANY )
 
696
                        return LDAP_INVALID_SYNTAX;
 
697
                rc = CheckSelectTypeCorrect( attr_nm, ((ComponentAny*)csi_attr)->cai, &cr->cr_curr->ci_val.ci_select_value );
 
698
                if ( rc < 0 ) return LDAP_INVALID_SYNTAX;
 
699
 
 
700
                /* point to the real component, not any type component */
 
701
                csi_attr = ((ComponentAny*)csi_attr)->value;
 
702
                cr->cr_curr = cr->cr_curr->ci_next;
 
703
                if ( cr->cr_curr )
 
704
                        rc =  comp_test_components( attr_nm, assert_nm, csi_attr, ca);
 
705
                else
 
706
                        rc =  comp_test_one_component( attr_nm, assert_nm, csi_attr, ca);
 
707
                break;
 
708
           default:
 
709
                rc = LDAP_INVALID_SYNTAX;
 
710
        }
 
711
        return rc;
 
712
}
 
713
 
 
714
 
 
715
void*
 
716
comp_nibble_memory_allocator ( int init_mem, int inc_mem ) {
 
717
        void* nm;
 
718
        nm = (void*)InitNibbleMemLocal( (unsigned long)init_mem, (unsigned long)inc_mem );
 
719
        if ( !nm ) return NULL;
 
720
        else return (void*)nm;
 
721
}
 
722
 
 
723
void
 
724
comp_nibble_memory_free ( void* nm ) {
 
725
        ShutdownNibbleMemLocal( nm );
 
726
}
 
727
 
 
728
void*
 
729
comp_get_component_description ( int id ) {
 
730
        if ( asntype_to_compdesc_mapping_tbl[id].atcd_typeId == id )
 
731
                return &asntype_to_compdesc_mapping_tbl[id].atcd_cd;
 
732
        else
 
733
                return NULL;
 
734
}
 
735
 
 
736
int
 
737
comp_component_encoder ( void* mem_op, ComponentSyntaxInfo* csi , struct berval* nval ) {
 
738
        int size, rc;
 
739
        GenBuf* b;
 
740
        ExpBuf* buf;
 
741
        struct berval bv;
 
742
        
 
743
        buf = ExpBufAllocBufAndData();
 
744
        ExpBufResetInWriteRvsMode(buf);
 
745
        ExpBuftoGenBuf( buf, &b );
 
746
 
 
747
        if ( !csi->csi_comp_desc->cd_gser_encoder && !csi->csi_comp_desc->cd_ldap_encoder )
 
748
                return (-1);
 
749
 
 
750
        /*
 
751
         * if an LDAP specific encoder is provided :
 
752
         * dn and rdn have their LDAP specific encoder
 
753
         */
 
754
        if ( csi->csi_comp_desc->cd_ldap_encoder ) {
 
755
                rc = csi->csi_comp_desc->cd_ldap_encoder( csi, &bv );
 
756
                if ( rc != LDAP_SUCCESS )
 
757
                        return rc;
 
758
                if ( mem_op )
 
759
                        nval->bv_val = CompAlloc( mem_op, bv.bv_len );
 
760
                else
 
761
                        nval->bv_val = malloc( size );
 
762
                memcpy( nval->bv_val, bv.bv_val, bv.bv_len );
 
763
                nval->bv_len = bv.bv_len;
 
764
                /*
 
765
                 * This free will be eliminated by making ldap_encoder
 
766
                 * use nibble memory in it 
 
767
                 */
 
768
                free ( bv.bv_val );
 
769
                GenBufFreeBuf( b );
 
770
                BufFreeBuf( buf );
 
771
                return LDAP_SUCCESS;
 
772
        }
 
773
 
 
774
        rc = csi->csi_comp_desc->cd_gser_encoder( b, csi );
 
775
        if ( rc < 0 ) {
 
776
                GenBufFreeBuf( b );
 
777
                BufFreeBuf( buf );
 
778
                return rc;
 
779
        }
 
780
 
 
781
        size = ExpBufDataSize( buf );
 
782
        if ( size > 0 ) {
 
783
                if ( mem_op )
 
784
                        nval->bv_val = CompAlloc ( mem_op, size );
 
785
                else
 
786
                        nval->bv_val = malloc( size );
 
787
                nval->bv_len = size;
 
788
                BufResetInReadMode(b);
 
789
                BufCopy( nval->bv_val, b, size );
 
790
        }
 
791
        ExpBufFreeBuf( buf );
 
792
        GenBufFreeBuf( b );
 
793
 
 
794
        return LDAP_SUCCESS;
 
795
}
 
796
 
 
797
#if SLAPD_COMP_MATCH == SLAPD_MOD_DYNAMIC
 
798
 
 
799
#include "certificate.h"
 
800
 
 
801
extern convert_attr_to_comp_func* attr_converter;
 
802
extern convert_assert_to_comp_func* assert_converter;
 
803
extern convert_asn_to_ldap_func* csi_converter;
 
804
extern free_component_func* component_destructor;
 
805
extern test_component_func* test_components;
 
806
extern alloc_nibble_func* nibble_mem_allocator;
 
807
extern free_nibble_func* nibble_mem_free;
 
808
extern test_membership_func* is_aliased_attribute;
 
809
extern get_component_info_func* get_component_description;
 
810
extern component_encoder_func* component_encoder;
 
811
 
 
812
 
 
813
int init_module(int argc, char *argv[]) {
 
814
        /*
 
815
         * Initialize function pointers in slapd
 
816
         */
 
817
        attr_converter = (convert_attr_to_comp_func*)comp_convert_attr_to_comp;
 
818
        assert_converter = (convert_assert_to_comp_func*)comp_convert_assert_to_comp;
 
819
        component_destructor = (free_component_func*)comp_free_component;
 
820
        test_components = (test_component_func*)comp_test_components;
 
821
        nibble_mem_allocator = (free_nibble_func*)comp_nibble_memory_allocator;
 
822
        nibble_mem_free = (free_nibble_func*)comp_nibble_memory_free;
 
823
        is_aliased_attribute = (test_membership_func*)comp_is_aliased_attribute;
 
824
        get_component_description = (get_component_info_func*)comp_get_component_description;
 
825
        component_encoder = (component_encoder_func*)comp_component_encoder;
 
826
 
 
827
        /* file path needs to be */
 
828
        load_derived_matching_rule ("derived_mr.cfg");
 
829
 
 
830
        /* the initialization for example X.509 certificate */
 
831
        init_module_AuthenticationFramework();
 
832
        init_module_AuthorityKeyIdentifierDefinition();
 
833
        init_module_CertificateRevokationList();
 
834
        init_attribute_aliasing_table ();
 
835
        init_component_description_table ();
 
836
        return 0;
 
837
}
 
838
 
 
839
#endif /* SLAPD_PASSWD */