/* $OpenLDAP$ */
/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
*
- * Copyright 2003-2004 The OpenLDAP Foundation.
+ * Copyright 2003-2005 The OpenLDAP Foundation.
* Portions Copyright 2004 by IBM Corporation.
* All rights reserved.
*
free_comp_filter( ComponentFilter* f );
static int
-test_comp_filter( Syntax *syn, ComponentSyntaxInfo *a, struct berval *bv,
- ComponentFilter *f );
+test_comp_filter( Syntax *syn, ComponentSyntaxInfo *a, ComponentFilter *f );
int
componentCertificateValidate(
struct berval *value,
void *assertedValue )
{
- struct berval* bv;
- Attribute *a = (Attribute*)value;
+ ComponentSyntaxInfo *csi_attr = (ComponentSyntaxInfo*)value;
MatchingRuleAssertion * ma = (MatchingRuleAssertion*)assertedValue;
- void* assert_nm;
int num_attr, rc, i;
- if ( !mr || !ma->ma_cf )
- return LDAP_INAPPROPRIATE_MATCHING;
- /* Check if the component module is loaded */
- if ( !attr_converter || !nibble_mem_allocator )
- return LDAP_INAPPROPRIATE_MATCHING;
+ if ( !mr || !ma->ma_cf ) return LDAP_INAPPROPRIATE_MATCHING;
- /* Check if decoded component trees are already linked */
- num_attr = 0;
- if ( !a->a_comp_data ) {
- for ( ; a->a_vals[num_attr].bv_val != NULL; num_attr++ );
- if ( num_attr <= 0 )/* no attribute value */
- return LDAP_INAPPROPRIATE_MATCHING;
- num_attr++;
- /* following malloced will be freed by comp_tree_free () */
- a->a_comp_data = malloc( sizeof( ComponentData ) + sizeof( ComponentSyntaxInfo* )*num_attr );
- if ( !a->a_comp_data )
- return LDAP_NO_MEMORY;
- a->a_comp_data->cd_tree = (ComponentSyntaxInfo**)((char*)a->a_comp_data + sizeof(ComponentData));
- a->a_comp_data->cd_tree[ num_attr - 1] = (ComponentSyntaxInfo*)NULL;
- a->a_comp_data->cd_mem_op = nibble_mem_allocator ( 1024*16, 1024 );
+ /* Check if the component module is loaded */
+ if ( !attr_converter || !nibble_mem_allocator ) {
+ return LDAP_OTHER;
}
- for ( bv = a->a_vals, i = 0 ; bv->bv_val != NULL; bv++, i++ ) {
- /* decodes current attribute into components */
- if ( num_attr != 0 ) {
- a->a_comp_data->cd_tree[i] = attr_converter (a, syntax, bv);
- }
- /* decoding error */
- if ( !a->a_comp_data->cd_tree[i] )
- return LDAP_OPERATIONS_ERROR;
+ rc = test_comp_filter( syntax, csi_attr, ma->ma_cf );
- rc = test_comp_filter( syntax, a->a_comp_data->cd_tree[i], bv, ma->ma_cf );
-
- if ( rc == LDAP_COMPARE_TRUE ) {
- *matchp = 0;
- return LDAP_SUCCESS;
- }
- else if ( rc == LDAP_COMPARE_FALSE ) {
- continue;
- }
- else {
- return LDAP_INAPPROPRIATE_MATCHING;
- }
+ if ( rc == LDAP_COMPARE_TRUE ) {
+ *matchp = 0;
+ return LDAP_SUCCESS;
+ }
+ else if ( rc == LDAP_COMPARE_FALSE ) {
+ *matchp = 1;
+ return LDAP_SUCCESS;
+ }
+ else {
+ return LDAP_INAPPROPRIATE_MATCHING;
}
- *matchp = 1;
- return LDAP_SUCCESS;
-
}
int
struct berval *value,
void *assertedValue )
{
- /* Only for Registeration */
+ /* Only for registration */
*matchp = 0;
return LDAP_SUCCESS;
}
struct berval *value,
void *assertedValue )
{
- /* Only for Registeration */
+ /* Only for registration */
*matchp = 0;
return LDAP_SUCCESS;
}
ci_temp = &dup_cr->cr_list;
ci_curr = cr->cr_list;
- for ( ; ci_curr ; ci_curr = ci_curr->ci_next, ci_temp = &(*ci_temp)->ci_next ) {
+ for ( ; ci_curr != NULL ;
+ ci_curr = ci_curr->ci_next, ci_temp = &(*ci_temp)->ci_next )
+ {
*ci_temp = op->o_tmpalloc( sizeof( ComponentId ), op->o_tmpmemctx );
if ( !ci_temp ) return NULL;
**ci_temp = *ci_curr;
ComponentAssertion* ca;
int len;
- if ( !in_ca->ca_comp_ref )
- return SLAPD_DISCONNECT;
+ if ( !in_ca->ca_comp_ref ) return SLAPD_DISCONNECT;
*out_ca = op->o_tmpalloc( sizeof( ComponentAssertion ), op->o_tmpmemctx );
- if ( !(*out_ca) )
- return LDAP_NO_MEMORY;
+ if ( !(*out_ca) ) return LDAP_NO_MEMORY;
(*out_ca)->ca_comp_data.cd_tree = NULL;
(*out_ca)->ca_comp_data.cd_mem_op = NULL;
(*out_ca)->ca_ma_value.bv_val = assert_bv->bv_val;
len = get_len_of_next_assert_value ( assert_bv, '$' );
- if ( len <= 0 )
- return SLAPD_DISCONNECT;
+ if ( len <= 0 ) return SLAPD_DISCONNECT;
(*out_ca)->ca_ma_value.bv_len = len;
return LDAP_SUCCESS;
int
-get_aliased_filter ( Operation* op, MatchingRuleAssertion* ma, AttributeAliasing* aa, const char** text )
+get_aliased_filter( Operation* op,
+ MatchingRuleAssertion* ma, AttributeAliasing* aa,
+ const char** text )
{
int rc;
struct berval assert_bv;
}
int
-get_comp_filter( Operation* op, struct berval* bv, ComponentFilter** filt,
- const char **text )
+get_comp_filter( Operation* op, struct berval* bv,
+ ComponentFilter** filt, const char **text )
{
ComponentAssertionValue cav;
int rc;
eat_whsp( cav );
if ( cav_cur_len( cav ) >= 8 && strncmp( cav->cav_ptr, "item", 4 ) == 0 ) {
return LDAP_COMP_FILTER_ITEM;
- }
- else if ( cav_cur_len( cav ) >= 7 && strncmp( cav->cav_ptr, "and", 3 ) == 0 ) {
+
+ } else if ( cav_cur_len( cav ) >= 7 &&
+ strncmp( cav->cav_ptr, "and", 3 ) == 0 )
+ {
return LDAP_COMP_FILTER_AND;
- }
- else if ( cav_cur_len( cav ) >= 6 && strncmp( cav->cav_ptr, "or" , 2 ) == 0 ) {
+
+ } else if ( cav_cur_len( cav ) >= 6 &&
+ strncmp( cav->cav_ptr, "or" , 2 ) == 0 )
+ {
return LDAP_COMP_FILTER_OR;
- }
- else if ( cav_cur_len( cav ) >= 7 && strncmp( cav->cav_ptr, "not", 3 ) == 0 ) {
+
+ } else if ( cav_cur_len( cav ) >= 7 &&
+ strncmp( cav->cav_ptr, "not", 3 ) == 0 )
+ {
return LDAP_COMP_FILTER_NOT;
- }
- else
+
+ } else {
return LDAP_COMP_FILTER_UNDEFINED;
+ }
}
static ber_tag_t
comp_next_element( ComponentAssertionValue* cav )
{
-
eat_whsp( cav );
if ( *(cav->cav_ptr) == ',' ) {
/* move pointer to the next CA */
static int
get_comp_filter_list( Operation *op, ComponentAssertionValue *cav,
- ComponentFilter** f, const char** text )
+ ComponentFilter** f, const char** text )
{
ComponentFilter **new;
int err;
Debug( LDAP_DEBUG_FILTER, "get_comp_filter_list\n", 0, 0, 0 );
new = f;
- for ( tag = comp_first_element( cav ); tag != LDAP_COMP_FILTER_UNDEFINED;
+ for ( tag = comp_first_element( cav );
+ tag != LDAP_COMP_FILTER_UNDEFINED;
tag = comp_next_element( cav ) )
{
err = parse_comp_filter( op, cav, new, text );
- if ( err != LDAP_SUCCESS )
- return ( err );
+ if ( err != LDAP_SUCCESS ) return ( err );
new = &(*new)->cf_next;
}
*new = NULL;
static int
get_componentId( Operation *op, ComponentAssertionValue* cav,
- ComponentId ** cid, const char** text )
+ ComponentId ** cid, const char** text )
{
ber_tag_t type;
ComponentId _cid;
cav->cav_ptr += strlen("content");
break;
case LDAP_COMPREF_SELECT :
- if ( cav->cav_ptr[len] != '(' )
- return LDAP_COMPREF_UNDEFINED;
+ if ( cav->cav_ptr[len] != '(' ) return LDAP_COMPREF_UNDEFINED;
for( ;cav->cav_ptr[len] != ' ' && cav->cav_ptr[len] != '\0' &&
cav->cav_ptr[len] != '\"' && cav->cav_ptr[len] != ')'
; len++ );
return LDAP_COMPREF_UNDEFINED;
}
- if ( op )
+ if ( op ) {
*cid = op->o_tmpalloc( sizeof( ComponentId ), op->o_tmpmemctx );
- else
+ } else {
*cid = malloc( sizeof( ComponentId ) );
+ }
**cid = _cid;
return LDAP_SUCCESS;
}
peek_componentId_type( ComponentAssertionValue* cav )
{
eat_whsp( cav );
- if ( cav->cav_ptr[0] == '-' )
+
+ if ( cav->cav_ptr[0] == '-' ) {
return LDAP_COMPREF_FROM_END;
- else if ( cav->cav_ptr[0] == '(' )
+
+ } else if ( cav->cav_ptr[0] == '(' ) {
return LDAP_COMPREF_SELECT;
- else if ( cav->cav_ptr[0] == '*' )
+
+ } else if ( cav->cav_ptr[0] == '*' ) {
return LDAP_COMPREF_ALL;
- else if ( cav->cav_ptr[0] == '0' )
+
+ } else if ( cav->cav_ptr[0] == '0' ) {
return LDAP_COMPREF_COUNT;
- else if ( cav->cav_ptr[0] > '0' && cav->cav_ptr[0] <= '9' )
+
+ } else if ( cav->cav_ptr[0] > '0' && cav->cav_ptr[0] <= '9' ) {
return LDAP_COMPREF_FROM_BEGINNING;
- else if ( (cav->cav_end - cav->cav_ptr) >= 7 &&
+
+ } else if ( (cav->cav_end - cav->cav_ptr) >= 7 &&
strncmp(cav->cav_ptr,"content",7) == 0 )
+ {
return LDAP_COMPREF_CONTENT;
- else if ( (cav->cav_ptr[0] >= 'a' && cav->cav_ptr[0] <= 'z') ||
+ } else if ( (cav->cav_ptr[0] >= 'a' && cav->cav_ptr[0] <= 'z') ||
(cav->cav_ptr[0] >= 'A' && cav->cav_ptr[0] <= 'Z') )
-
+ {
return LDAP_COMPREF_IDENTIFIER;
- else
- return LDAP_COMPREF_UNDEFINED;
+ }
+
+ return LDAP_COMPREF_UNDEFINED;
}
static ber_tag_t
comp_next_id( ComponentAssertionValue* cav )
{
-
if ( *(cav->cav_ptr) == '.' ) {
cav->cav_ptr++;
return LDAP_COMPREF_DEFINED;
}
- else return LDAP_COMPREF_UNDEFINED;
+
+ return LDAP_COMPREF_UNDEFINED;
}
static int
-get_component_reference( Operation *op, ComponentAssertionValue* cav,
- ComponentReference** cr, const char** text )
+get_component_reference(
+ Operation *op,
+ ComponentAssertionValue* cav,
+ ComponentReference** cr,
+ const char** text )
{
int rc, count = 0;
ber_int_t type;
eat_whsp( cav );
start = cav->cav_ptr;
- if ( ( rc = strip_cav_str( cav,"\"") ) != LDAP_SUCCESS )
- return rc;
- if ( op )
- ca_comp_ref = op->o_tmpalloc( sizeof( ComponentReference ), op->o_tmpmemctx );
- else
+ if ( ( rc = strip_cav_str( cav,"\"") ) != LDAP_SUCCESS ) return rc;
+ if ( op ) {
+ ca_comp_ref = op->o_tmpalloc( sizeof( ComponentReference ),
+ op->o_tmpmemctx );
+ } else {
ca_comp_ref = malloc( sizeof( ComponentReference ) );
+ }
if ( !ca_comp_ref ) return LDAP_NO_MEMORY;
cr_list = &ca_comp_ref->cr_list;
for ( type = peek_componentId_type( cav ) ; type != LDAP_COMPREF_UNDEFINED
- ; type = comp_next_id( cav ), count++ ) {
+ ; type = comp_next_id( cav ), count++ )
+ {
rc = get_componentId( op, cav, cr_list, text );
if ( rc == LDAP_SUCCESS ) {
if ( count == 0 ) ca_comp_ref->cr_curr = ca_comp_ref->cr_list;
cr_list = &(*cr_list)->ci_next;
- }
- else if ( rc == LDAP_COMPREF_UNDEFINED )
+
+ } else if ( rc == LDAP_COMPREF_UNDEFINED ) {
return rc;
+ }
}
ca_comp_ref->cr_len = count;
end = cav->cav_ptr;
if ( ( rc = strip_cav_str( cav,"\"") ) != LDAP_SUCCESS ) {
- if ( op )
+ if ( op ) {
op->o_tmpfree( ca_comp_ref , op->o_tmpmemctx );
- else
+ } else {
free( ca_comp_ref );
+ }
return rc;
}
if ( rc == LDAP_SUCCESS ) {
*cr = ca_comp_ref;
**cr = *ca_comp_ref;
- }
- else if ( op )
+
+ } else if ( op ) {
op->o_tmpfree( ca_comp_ref , op->o_tmpmemctx );
- else
+
+ } else {
free( ca_comp_ref ) ;
+ }
(*cr)->cr_string.bv_val = start;
(*cr)->cr_string.bv_len = end - start + 1;
}
int
-insert_component_reference( ComponentReference *cr, ComponentReference** cr_list) {
- if ( !cr )
- return LDAP_PARAM_ERROR;
+insert_component_reference(
+ ComponentReference *cr,
+ ComponentReference** cr_list)
+{
+ if ( !cr ) return LDAP_PARAM_ERROR;
+
if ( !(*cr_list) ) {
*cr_list = cr;
cr->cr_next = NULL;
is_component_reference( char* attr ) {
int i;
for ( i=0; attr[i] != '\0' ; i++ ) {
- if ( attr[i] == '.' )
- return (1);
+ if ( attr[i] == '.' ) return (1);
}
return (0);
}
int
-extract_component_reference( char* attr, ComponentReference** cr ) {
- int i, rc;
- char* cr_ptr;
- int cr_len;
- ComponentAssertionValue cav;
+extract_component_reference(
+ char* attr,
+ ComponentReference** cr )
+{
+ int i, rc;
+ char* cr_ptr;
+ int cr_len;
+ ComponentAssertionValue cav;
char text[1][128];
- for ( i=0; attr[i] != '\0' ; i++ ) {
- if ( attr[i] == '.' ) break;
- }
+ for ( i=0; attr[i] != '\0' ; i++ ) {
+ if ( attr[i] == '.' ) break;
+ }
+
+ if (attr[i] != '.' ) return LDAP_PARAM_ERROR;
+ attr[i] = '\0';
- if (attr[i] != '.' )
- return LDAP_PARAM_ERROR;
- else
- attr[i] = '\0';
- cr_ptr = attr + i + 1 ;
- cr_len = strlen ( cr_ptr );
- if ( cr_len <= 0 )
- return LDAP_PARAM_ERROR;
+ cr_ptr = attr + i + 1 ;
+ cr_len = strlen ( cr_ptr );
+ if ( cr_len <= 0 ) return LDAP_PARAM_ERROR;
/* enclosed between double quotes*/
cav.cav_ptr = cav.cav_buf = ch_malloc (cr_len+2);
memcpy( cav.cav_buf+1, cr_ptr, cr_len );
cav.cav_buf[0] = '"';
cav.cav_buf[cr_len+1] = '"';
- cav.cav_end = cr_ptr + cr_len + 2;
+ cav.cav_end = cr_ptr + cr_len + 2;
- rc = get_component_reference ( NULL, &cav, cr, (const char**)text );
- if ( rc != LDAP_SUCCESS )
- return rc;
+ rc = get_component_reference ( NULL, &cav, cr, (const char**)text );
+ if ( rc != LDAP_SUCCESS ) return rc;
(*cr)->cr_string.bv_val = cav.cav_buf;
(*cr)->cr_string.bv_len = cr_len + 2;
return LDAP_SUCCESS;
}
+
static int
-get_ca_use_default( Operation *op, ComponentAssertionValue* cav,
- int* ca_use_def, const char** text )
+get_ca_use_default( Operation *op,
+ ComponentAssertionValue* cav,
+ int* ca_use_def, const char** text )
{
strip_cav_str( cav, "useDefaultValues" );
+
if ( peek_cav_str( cav, "TRUE" ) == LDAP_SUCCESS ) {
strip_cav_str( cav, "TRUE" );
*ca_use_def = 1;
+
} else if ( peek_cav_str( cav, "FALSE" ) == LDAP_SUCCESS ) {
strip_cav_str( cav, "FALSE" );
*ca_use_def = 0;
+
} else {
return LDAP_INVALID_SYNTAX;
}
if ( cav->cav_ptr[count] == ' ' || cav->cav_ptr[count] == ',' ||
cav->cav_ptr[count] == '\0' || cav->cav_ptr[count] == '{' ||
cav->cav_ptr[count] == '}' || cav->cav_ptr[count] == '\n' )
+ {
break;
+ }
}
if ( count == 0 ) {
rule_text.bv_val = cav->cav_ptr;
*mr = mr_bvfind( &rule_text );
cav->cav_ptr += count;
- Debug( LDAP_DEBUG_FILTER, "get_matching_rule: %s\n", (*mr)->smr_mrule.mr_oid, 0, 0 );
+ Debug( LDAP_DEBUG_FILTER, "get_matching_rule: %s\n",
+ (*mr)->smr_mrule.mr_oid, 0, 0 );
if ( *mr == NULL ) {
*text = "component matching rule not recognized";
return LDAP_INAPPROPRIATE_MATCHING;
if ( cav->cav_ptr[count] == '"' ) sequent_dquote++;
else sequent_dquote = 0;
- if ( cav->cav_ptr[count] == '\0' || (cav->cav_ptr+count) > cav->cav_end ) {
+ if ( cav->cav_ptr[count] == '\0' ||
+ (cav->cav_ptr+count) > cav->cav_end )
+ {
break;
}
- if ( ( cav->cav_ptr[count] == '"' && cav->cav_ptr[count-1] != '"') ||
- ( sequent_dquote > 2 && (sequent_dquote%2) == 1 ) ) {
+ if ( ( cav->cav_ptr[count] == '"' &&
+ cav->cav_ptr[count-1] != '"') ||
+ ( sequent_dquote > 2 && (sequent_dquote%2) == 1 ) )
+ {
succeed = 1;
break;
}
}
- if ( !succeed || cav->cav_ptr[count] != '"' )
+ if ( !succeed || cav->cav_ptr[count] != '"' ) {
return LDAP_FILTER_ERROR;
+ }
bv->bv_val = cav->cav_ptr + 1;
bv->bv_len = count - 1; /* exclude '"' */
- }
- else if ( cav->cav_ptr[0] == '\'' ) {
+
+ } else if ( cav->cav_ptr[0] == '\'' ) {
for( count = 1 ; ; count++ ) {
- if ( cav->cav_ptr[count] == '\0' || (cav->cav_ptr+count) > cav->cav_end ) {
+ if ( cav->cav_ptr[count] == '\0' ||
+ (cav->cav_ptr+count) > cav->cav_end )
+ {
break;
}
- if ((cav->cav_ptr[count-1] == '\'' && cav->cav_ptr[count] == 'B')||
- (cav->cav_ptr[count-1] == '\'' && cav->cav_ptr[count] == 'H') ) {
+ if ((cav->cav_ptr[count-1] == '\'' && cav->cav_ptr[count] == 'B') ||
+ (cav->cav_ptr[count-1] == '\'' && cav->cav_ptr[count] == 'H') )
+ {
succeed = 1;
break;
}
}
- if ( !succeed || !(cav->cav_ptr[count] == 'H' || cav->cav_ptr[count] == 'B') )
- return LDAP_FILTER_ERROR;
+ if ( !succeed ||
+ !(cav->cav_ptr[count] == 'H' || cav->cav_ptr[count] == 'B') )
+ {
+ return LDAP_FILTER_ERROR;
+ }
bv->bv_val = cav->cav_ptr + 1;/*the next to '"' */
bv->bv_len = count - 2;/* exclude "'H" or "'B" */
- }
- else if ( cav->cav_ptr[0] == '{' ) {
+ } else if ( cav->cav_ptr[0] == '{' ) {
for( count = 1, unclosed_brace = 1 ; ; count++ ) {
if ( cav->cav_ptr[count] == '{' ) unclosed_brace++;
if ( cav->cav_ptr[count] == '}' ) unclosed_brace--;
- if ( cav->cav_ptr[count] == '\0' || (cav->cav_ptr+count) > cav->cav_end )
+ if ( cav->cav_ptr[count] == '\0' ||
+ (cav->cav_ptr+count) > cav->cav_end )
+ {
break;
+ }
if ( unclosed_brace == 0 ) {
succeed = 1;
break;
}
}
- if ( !succeed || cav->cav_ptr[count] != '}' )
- return LDAP_FILTER_ERROR;
+ if ( !succeed || cav->cav_ptr[count] != '}' ) return LDAP_FILTER_ERROR;
bv->bv_val = cav->cav_ptr + 1;/*the next to '"' */
bv->bv_len = count - 1;/* exclude "'B" */
- }
- else {
+
+ } else {
succeed = 1;
/*Find following white space where the value is ended*/
for( count = 1 ; ; count++ ) {
- if ( cav->cav_ptr[count] == '\0' || cav->cav_ptr[count] == ' ' || cav->cav_ptr[count] == '}' || cav->cav_ptr[count] == '{' || (cav->cav_ptr+count) > cav->cav_end ) {
+ if ( cav->cav_ptr[count] == '\0' ||
+ cav->cav_ptr[count] == ' ' || cav->cav_ptr[count] == '}' ||
+ cav->cav_ptr[count] == '{' ||
+ (cav->cav_ptr+count) > cav->cav_end )
+ {
break;
}
}
}
cav->cav_ptr += bv->bv_len;
-
return LDAP_SUCCESS;
}
static int
get_matching_value( Operation *op, ComponentAssertion* ca,
- ComponentAssertionValue* cav, struct berval* bv,
- const char** text )
+ ComponentAssertionValue* cav, struct berval* bv,
+ const char** text )
{
if ( !(ca->ca_ma_rule->smr_usage & (SLAP_MR_COMPONENT)) ) {
if ( get_GSER_value( cav, bv ) != LDAP_SUCCESS ) {
eat_whsp( cav );
if ( cav_cur_len( cav ) >= strlen( str ) &&
strncmp( cav->cav_ptr, str, strlen( str ) ) == 0 )
+ {
return LDAP_SUCCESS;
- else
- return LDAP_INVALID_SYNTAX;
+ }
+
+ return LDAP_INVALID_SYNTAX;
}
static int
{
eat_whsp( cav );
if ( cav_cur_len( cav ) >= strlen( str ) &&
- strncmp( cav->cav_ptr, str, strlen( str ) ) == 0 ) {
+ strncmp( cav->cav_ptr, str, strlen( str ) ) == 0 )
+ {
cav->cav_ptr += strlen( str );
return LDAP_SUCCESS;
}
- else
- return LDAP_INVALID_SYNTAX;
+
+ return LDAP_INVALID_SYNTAX;
}
/*
if ( cav_cur_len( cav ) >= 8 && strncmp( cav->cav_ptr, "item", 4 ) == 0 ) {
strip_cav_str( cav , "item:" );
return LDAP_COMP_FILTER_ITEM;
- }
- else if ( cav_cur_len( cav ) >= 7 && strncmp( cav->cav_ptr, "and", 3 ) == 0 ) {
+
+ } else if ( cav_cur_len( cav ) >= 7 &&
+ strncmp( cav->cav_ptr, "and", 3 ) == 0 )
+ {
strip_cav_str( cav , "and:" );
return LDAP_COMP_FILTER_AND;
- }
- else if ( cav_cur_len( cav ) >= 6 && strncmp( cav->cav_ptr, "or" , 2 ) == 0 ) {
+
+ } else if ( cav_cur_len( cav ) >= 6 &&
+ strncmp( cav->cav_ptr, "or" , 2 ) == 0 )
+ {
strip_cav_str( cav , "or:" );
return LDAP_COMP_FILTER_OR;
- }
- else if ( cav_cur_len( cav ) >= 7 && strncmp( cav->cav_ptr, "not", 3 ) == 0 ) {
+
+ } else if ( cav_cur_len( cav ) >= 7 &&
+ strncmp( cav->cav_ptr, "not", 3 ) == 0 )
+ {
strip_cav_str( cav , "not:" );
return LDAP_COMP_FILTER_NOT;
}
- else
- return LBER_ERROR;
+
+ return LBER_ERROR;
}
/*
test_comp_filter_and(
Syntax *syn,
ComponentSyntaxInfo *a,
- struct berval *bv,
ComponentFilter *flist )
{
ComponentFilter *f;
int rtn = LDAP_COMPARE_TRUE;
for ( f = flist ; f != NULL; f = f->cf_next ) {
- int rc = test_comp_filter( syn, a, bv, f );
+ int rc = test_comp_filter( syn, a, f );
if ( rc == LDAP_COMPARE_FALSE ) {
rtn = rc;
break;
test_comp_filter_or(
Syntax *syn,
ComponentSyntaxInfo *a,
- struct berval *bv,
ComponentFilter *flist )
{
ComponentFilter *f;
int rtn = LDAP_COMPARE_TRUE;
for ( f = flist ; f != NULL; f = f->cf_next ) {
- int rc = test_comp_filter( syn, a, bv, f );
+ int rc = test_comp_filter( syn, a, f );
if ( rc == LDAP_COMPARE_TRUE ) {
rtn = rc;
break;
int
csi_value_match( MatchingRule *mr, struct berval* bv_attr,
- struct berval* bv_assert )
+ struct berval* bv_assert )
{
int rc;
int match;
assert( mr != NULL );
assert( !(mr->smr_usage & SLAP_MR_COMPONENT) );
- if( !mr->smr_match ) {
- return LDAP_INAPPROPRIATE_MATCHING;
- }
+ if( !mr->smr_match ) return LDAP_INAPPROPRIATE_MATCHING;
rc = (mr->smr_match)( &match, 0, NULL /*ad->ad_type->sat_syntax*/,
- mr, bv_attr, bv_assert );
- if ( rc == LDAP_SUCCESS )
- return match? LDAP_COMPARE_FALSE:LDAP_COMPARE_TRUE;
- else
- return rc;
+ mr, bv_attr, bv_assert );
+
+ if ( rc != LDAP_SUCCESS ) return rc;
+
+ return match ? LDAP_COMPARE_FALSE : LDAP_COMPARE_TRUE;
}
/*
test_comp_filter_item(
Syntax *syn,
ComponentSyntaxInfo *csi_attr,
- struct berval *bv,
ComponentAssertion *ca )
{
int rc, len;
if ( strcmp(ca->ca_ma_rule->smr_mrule.mr_oid,
OID_COMP_FILTER_MATCH ) == 0 && ca->ca_cf ) {
/* componentFilterMatch inside of componentFilterMatch */
- rc = test_comp_filter( syn, csi_attr, bv, ca->ca_cf );
+ rc = test_comp_filter( syn, csi_attr, ca->ca_cf );
return rc;
}
return LDAP_PROTOCOL_ERROR;
}
ca->ca_comp_data.cd_mem_op = assert_nm;
- }
- else {
+
+ } else {
assert_nm = ca->ca_comp_data.cd_mem_op;
}
/* component reference initialization */
- if ( ca->ca_comp_ref )
+ if ( ca->ca_comp_ref ) {
ca->ca_comp_ref->cr_curr = ca->ca_comp_ref->cr_list;
+ }
rc = test_components( attr_nm, assert_nm, csi_attr, ca );
/* free memory used for storing extracted attribute value */
test_comp_filter(
Syntax *syn,
ComponentSyntaxInfo *a,
- struct berval *bv,
ComponentFilter *f )
{
int rc;
rc = f->cf_result;
break;
case LDAP_COMP_FILTER_AND:
- rc = test_comp_filter_and( syn, a, bv, f->cf_and );
+ rc = test_comp_filter_and( syn, a, f->cf_and );
break;
case LDAP_COMP_FILTER_OR:
- rc = test_comp_filter_or( syn, a, bv, f->cf_or );
+ rc = test_comp_filter_or( syn, a, f->cf_or );
break;
case LDAP_COMP_FILTER_NOT:
- rc = test_comp_filter( syn, a, bv, f->cf_not );
+ rc = test_comp_filter( syn, a, f->cf_not );
switch ( rc ) {
case LDAP_COMPARE_TRUE:
}
break;
case LDAP_COMP_FILTER_ITEM:
- rc = test_comp_filter_item( syn, a, bv, f->cf_ca );
+ rc = test_comp_filter_item( syn, a, f->cf_ca );
break;
default:
rc = LDAP_PROTOCOL_ERROR;
free_comp_filter_list( ComponentFilter* f )
{
ComponentFilter* tmp;
- for ( tmp = f; tmp; tmp = tmp->cf_next )
- {
+ for ( tmp = f; tmp; tmp = tmp->cf_next ) {
free_comp_filter( tmp );
}
}
free_comp_filter( ComponentFilter* f )
{
if ( !f ) {
- Debug( LDAP_DEBUG_FILTER, "free_comp_filter:Invalid filter so failed to release memory\n", 0, 0, 0 );
+ Debug( LDAP_DEBUG_FILTER,
+ "free_comp_filter: Invalid filter so failed to release memory\n",
+ 0, 0, 0 );
return;
}
switch ( f->cf_choice ) {
free_comp_filter( f->cf_any );
break;
case LDAP_COMP_FILTER_ITEM:
- if ( nibble_mem_free && f->cf_ca->ca_comp_data.cd_mem_op )
+ if ( nibble_mem_free && f->cf_ca->ca_comp_data.cd_mem_op ) {
nibble_mem_free( f->cf_ca->ca_comp_data.cd_mem_op );
+ }
break;
-
default:
break;
}
projects / openldap / blobdiff