mirror/openldap
2
0
Fork 0
mirror of https://git.openldap.org/openldap/openldap.git synced 2024-12-21 03:10:25 +08:00
Code Issues Packages Projects Releases Wiki Activity

Attribute Aliasing : equality matching support

Browse Source
This commit is contained in:
Sang Seok Lim 2005-02-15 05:24:48 +00:00
parent 6e9703f241
commit 9d59266e25
5 changed files with 189 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
servers/slapd/ava.c
View File

@ -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;
}

48
servers/slapd/back-bdb/filterindex.c
View File

@ -21,6 +21,9 @@
#include "back-bdb.h"
#include "idl.h"
#ifdef LDAP_COMP_MATCH
#include <component.h>
#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,

27
servers/slapd/component.c
View File

@ -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

93
servers/slapd/filterentry.c
View File

@ -31,9 +31,12 @@
#include <ac/socket.h>
#include <ac/string.h>
#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;
}

3
servers/slapd/slap.h
View File

@ -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 {