From: Sang Seok Lim Date: Tue, 15 Feb 2005 05:24:48 +0000 (+0000) Subject: Attribute Aliasing : equality matching support X-Git-Tag: OPENLDAP_REL_ENG_2_3_BP~177 X-Git-Url: https://git.sur5r.net/?a=commitdiff_plain;h=9d59266e25dbeae63428f55f10588e4a78586b34;p=openldap Attribute Aliasing : equality matching support --- diff --git a/servers/slapd/ava.c b/servers/slapd/ava.c index 14112134cf..d0df3d7c26 100644 --- a/servers/slapd/ava.c +++ b/servers/slapd/ava.c @@ -33,6 +33,9 @@ #include "slap.h" +#ifdef LDAP_COMP_MATCH +#include "component.h" +#endif void ava_free( @@ -56,6 +59,9 @@ get_ava( ber_tag_t rtag; struct berval type, value; AttributeAssertion *aa; +#ifdef LDAP_COMP_MATCH + AttributeAliasing* a_alias = NULL; +#endif rtag = ber_scanf( ber, "{mm}", &type, &value ); @@ -68,6 +74,9 @@ get_ava( aa = op->o_tmpalloc( sizeof( AttributeAssertion ), op->o_tmpmemctx ); aa->aa_desc = NULL; aa->aa_value.bv_val = NULL; +#ifdef LDAP_COMP_MATCH + aa->aa_cf = NULL; +#endif rc = slap_bv2ad( &type, &aa->aa_desc, text ); @@ -89,6 +98,19 @@ get_ava( return rc; } +#ifdef LDAP_COMP_MATCH + if( is_aliased_attribute ) { + a_alias = is_aliased_attribute ( aa->aa_desc ); + if ( a_alias ) { + rc = get_aliased_filter_aa ( op, aa, a_alias, text ); + if( rc != LDAP_SUCCESS ) { + Debug( LDAP_DEBUG_FILTER, + "get_ava:Invalid Attribute Aliasing\n", 0, 0, 0 ); + return rc; + } + } + } +#endif *ava = aa; return LDAP_SUCCESS; } diff --git a/servers/slapd/back-bdb/filterindex.c b/servers/slapd/back-bdb/filterindex.c index d6fa3c32a6..4d9cb47f12 100644 --- a/servers/slapd/back-bdb/filterindex.c +++ b/servers/slapd/back-bdb/filterindex.c @@ -21,6 +21,9 @@ #include "back-bdb.h" #include "idl.h" +#ifdef LDAP_COMP_MATCH +#include +#endif static int presence_candidates( Operation *op, @@ -74,6 +77,15 @@ comp_candidates ( ID *ids, ID *tmp, ID *stack); + +static int +ava_comp_candidates ( + Operation *op, + AttributeAssertion *ava, + AttributeAliasing *aa, + ID *ids, + ID *tmp, + ID *stack); #endif int @@ -85,6 +97,9 @@ bdb_filter_candidates( ID *stack ) { int rc = 0; +#ifdef LDAP_COMP_MATCH + AttributeAliasing *aa; +#endif Debug( LDAP_DEBUG_FILTER, "=> bdb_filter_candidates\n", 0, 0, 0 ); switch ( f->f_choice ) { @@ -114,7 +129,15 @@ bdb_filter_candidates( case LDAP_FILTER_EQUALITY: Debug( LDAP_DEBUG_FILTER, "\tEQUALITY\n", 0, 0, 0 ); - rc = equality_candidates( op, f->f_ava, ids, tmp ); +#ifdef LDAP_COMP_MATCH + if ( is_aliased_attribute && ( aa = is_aliased_attribute ( f->f_ava->aa_desc ) ) ) { + rc = ava_comp_candidates ( op, f->f_ava, aa, ids, tmp, stack ); + } + else +#endif + { + rc = equality_candidates( op, f->f_ava, ids, tmp ); + } break; case LDAP_FILTER_APPROX: @@ -361,6 +384,29 @@ comp_equality_candidates ( return( rc ); } +static int +ava_comp_candidates ( + Operation *op, + AttributeAssertion *ava, + AttributeAliasing *aa, + ID *ids, + ID *tmp, + ID *stack ) +{ + MatchingRuleAssertion mra; + + mra.ma_rule = ava->aa_desc->ad_type->sat_equality; + if ( !mra.ma_rule ) { + struct bdb_info *bdb = (struct bdb_info *) op->o_bd->be_private; + BDB_IDL_ALL( bdb, ids ); + return 0; + } + mra.ma_desc = aa->aa_aliased_ad; + mra.ma_rule = ava->aa_desc->ad_type->sat_equality; + + return comp_candidates ( op, &mra, ava->aa_cf, ids, tmp, stack ); +} + static int comp_candidates ( Operation *op, diff --git a/servers/slapd/component.c b/servers/slapd/component.c index 7d74c19111..bb66c4cee7 100644 --- a/servers/slapd/component.c +++ b/servers/slapd/component.c @@ -298,6 +298,26 @@ dup_comp_filter ( return( rc ); } +int +get_aliased_filter_aa ( Operation* op, AttributeAssertion* a_assert, AttributeAliasing* aa, const char** text ) +{ + int rc; + struct berval assert_bv; + ComponentAssertion* ca; + + Debug( LDAP_DEBUG_FILTER, "get_aliased_filter\n", 0, 0, 0 ); + + if ( !aa->aa_cf ) + return LDAP_PROTOCOL_ERROR; + + assert_bv = a_assert->aa_value; + /* + * Duplicate aa->aa_cf to ma->ma_cf by replacing the + * the component assertion value in assert_bv + * Multiple values may be separated with '$' + */ + return dup_comp_filter ( op, &assert_bv, aa->aa_cf, &a_assert->aa_cf ); +} int get_aliased_filter( Operation* op, @@ -1369,4 +1389,11 @@ component_free( ComponentFilter *f ) { free_comp_filter( f ); } +void +free_ComponentData( Attribute *a ) { + if ( a->a_comp_data->cd_mem_op ) + component_destructor( a->a_comp_data->cd_mem_op ); + free ( a->a_comp_data ); + a->a_comp_data = NULL; +} #endif diff --git a/servers/slapd/filterentry.c b/servers/slapd/filterentry.c index 005c6f7aa4..fe8a9f66f8 100644 --- a/servers/slapd/filterentry.c +++ b/servers/slapd/filterentry.c @@ -31,9 +31,12 @@ #include #include - #include "slap.h" +#ifdef LDAP_COMP_MATCH +#include "component.h" +#endif + static int test_filter_and( Operation *op, Entry *e, Filter *flist ); static int test_filter_or( Operation *op, Entry *e, Filter *flist ); static int test_substrings_filter( Operation *op, Entry *e, Filter *f); @@ -500,6 +503,10 @@ test_ava_filter( { int rc; Attribute *a; +#ifdef LDAP_COMP_MATCH + int i, num_attr_vals; + AttributeAliasing *a_alias = NULL; +#endif if ( !access_allowed( op, e, ava->aa_desc, &ava->aa_value, ACL_SEARCH, NULL ) ) @@ -565,6 +572,17 @@ test_ava_filter( rc = LDAP_COMPARE_FALSE; +#ifdef LDAP_COMP_MATCH + if ( is_aliased_attribute && ava->aa_cf ) + { + a_alias = is_aliased_attribute ( ava->aa_desc ); + if ( a_alias ) + ava->aa_desc = a_alias->aa_aliased_ad; + else + ava->aa_cf = NULL; + } +#endif + for(a = attrs_find( e->e_attrs, ava->aa_desc ); a != NULL; a = attrs_find( a->a_next, ava->aa_desc ) ) @@ -604,12 +622,76 @@ test_ava_filter( continue; } +#ifdef LDAP_COMP_MATCH + if ( nibble_mem_allocator && ava->aa_cf && !a->a_comp_data ) { + /* Component Matching */ + for ( num_attr_vals = 0; a->a_vals[num_attr_vals].bv_val != NULL; num_attr_vals++ ); + if ( num_attr_vals <= 0 )/* no attribute value */ + return LDAP_INAPPROPRIATE_MATCHING; + num_attr_vals++;/* for NULL termination */ + + /* following malloced will be freed by comp_tree_free () */ + a->a_comp_data = malloc( sizeof( ComponentData ) + sizeof( ComponentSyntaxInfo* )*num_attr_vals ); + + if ( !a->a_comp_data ) { + return LDAP_NO_MEMORY; + } + + a->a_comp_data->cd_tree = (ComponentSyntaxInfo**)((char*)a->a_comp_data + sizeof(ComponentData)); + i = num_attr_vals; + for ( ; i ; i-- ) { + a->a_comp_data->cd_tree[ i-1 ] = (ComponentSyntaxInfo*)NULL; + } + + a->a_comp_data->cd_mem_op = nibble_mem_allocator ( 1024*10*(num_attr_vals-1), 1024 ); + if ( a->a_comp_data->cd_mem_op == NULL ) { + fprintf(stderr,"nibble mem allocation error\n"); + free ( a->a_comp_data ); + a->a_comp_data = NULL; + return LDAP_OPERATIONS_ERROR; + } + } + + i = 0; +#endif + for ( bv = a->a_nvals; !BER_BVISNULL( bv ); bv++ ) { int ret, match; const char *text; - ret = value_match( &match, a->a_desc, mr, 0, - bv, &ava->aa_value, &text ); +#ifdef LDAP_COMP_MATCH + if( attr_converter && ava->aa_cf && a->a_comp_data ) { + /* Check if decoded component trees are already linked */ + struct berval cf_bv = { 20, "componentFilterMatch" }; + MatchingRule* cf_mr = mr_bvfind( &cf_bv ); + MatchingRuleAssertion mra; + mra.ma_cf = ava->aa_cf; + + if ( a->a_comp_data->cd_tree[i] == NULL ) + a->a_comp_data->cd_tree[i] = attr_converter (a, a->a_desc->ad_type->sat_syntax, (a->a_vals + i)); + /* decoding error */ + if ( !a->a_comp_data->cd_tree[i] ) { + free_ComponentData ( a ); + return LDAP_OPERATIONS_ERROR; + } + + ret = value_match( &match, a->a_desc, cf_mr, 0, + (struct berval*)a->a_comp_data->cd_tree[i++], (void*)&mra, &text ); + if ( ret == LDAP_INAPPROPRIATE_MATCHING ) { + /* cached component tree is broken, just remove it */ + free_ComponentData ( a ); + return ret; + } + if ( a_alias ) + ava->aa_desc = a_alias->aa_aliasing_ad; + } + else +#endif + { + + ret = value_match( &match, a->a_desc, mr, 0, + bv, &ava->aa_value, &text ); + } if( ret != LDAP_SUCCESS ) { rc = ret; @@ -633,6 +715,11 @@ test_ava_filter( } } +#ifdef LDAP_COMP_MATCH + if ( a_alias ) + ava->aa_desc = a_alias->aa_aliasing_ad; +#endif + return rc; } diff --git a/servers/slapd/slap.h b/servers/slapd/slap.h index 7e79c0a28c..568cdd2334 100644 --- a/servers/slapd/slap.h +++ b/servers/slapd/slap.h @@ -903,6 +903,9 @@ struct slap_internal_schema { typedef struct slap_attr_assertion { AttributeDescription *aa_desc; struct berval aa_value; +#ifdef LDAP_COMP_MATCH + struct slap_component_filter *aa_cf;/* for attribute aliasing */ +#endif } AttributeAssertion; typedef struct slap_ss_assertion {