servers/slapd/filter.c - diff

Return to filter.c CVS log

Up to [OpenLDAP] / servers / slapd

Diff for /servers/slapd/filter.c between versions 1.13.4.9 and 1.60

version 1.13.4.9, 2001/08/31 20:24:17	version 1.60, 2001/06/22 16:09:19
Line 1	Line 1
/* filter.c - routines for parsing and dealing with filters */	/* filter.c - routines for parsing and dealing with filters */
/* $OpenLDAP$ */	/* $OpenLDAP: pkg/ldap/servers/slapd/filter.c,v 1.59 2001/06/16 00:20:48 kurt Exp $ */
/*	/*
* Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.	* Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.
* COPYING RESTRICTIONS APPLY, see COPYRIGHT file	* COPYING RESTRICTIONS APPLY, see COPYRIGHT file
Line 47 get_filter(	Line 47 get_filter(
char *ftmp = NULL;	char *ftmp = NULL;
struct berval escaped;	struct berval escaped;

	#ifdef NEW_LOGGING
	LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY, "get_filter: conn %d\n",
	conn->c_connid ));
	#else
Debug( LDAP_DEBUG_FILTER, "begin get_filter\n", 0, 0, 0 );	Debug( LDAP_DEBUG_FILTER, "begin get_filter\n", 0, 0, 0 );
	#endif
/*	/*
* A filter looks like this coming in:	* A filter looks like this coming in:
* Filter ::= CHOICE {	* Filter ::= CHOICE {
Line 65 get_filter(	Line 69 get_filter(
* }	* }
*	*
* SubstringFilter ::= SEQUENCE {	* SubstringFilter ::= SEQUENCE {
* type AttributeType,	* type AttributeType,
* SEQUENCE OF CHOICE {	* SEQUENCE OF CHOICE {
* initial [0] IA5String,	* initial [0] IA5String,
* any [1] IA5String,	* any [1] IA5String,
* final [2] IA5String	* final [2] IA5String
* }	* }
* }	* }
*	*
* MatchingRuleAssertion ::= SEQUENCE {	* MatchingRuleAssertion ::= SEQUENCE {
* matchingRule [1] MatchingRuleId OPTIONAL,	* matchingRule [1] MatchingRuleId OPTIONAL,
* type [2] AttributeDescription OPTIONAL,	* type [2] AttributeDescription OPTIONAL,
* matchValue [3] AssertionValue,	* matchValue [3] AssertionValue,
* dnAttributes [4] BOOLEAN DEFAULT FALSE	* dnAttributes [4] BOOLEAN DEFAULT FALSE
* }	* }
*	*
*/	*/
Line 98 get_filter(	Line 102 get_filter(

switch ( f->f_choice ) {	switch ( f->f_choice ) {
case LDAP_FILTER_EQUALITY:	case LDAP_FILTER_EQUALITY:
	#ifdef NEW_LOGGING
	LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL2,
	"get_filter: conn %d EQUALITY\n", conn->c_connid ));
	#else
Debug( LDAP_DEBUG_FILTER, "EQUALITY\n", 0, 0, 0 );	Debug( LDAP_DEBUG_FILTER, "EQUALITY\n", 0, 0, 0 );
	#endif
err = get_ava( ber, &f->f_ava, SLAP_MR_EQUALITY, text );	err = get_ava( ber, &f->f_ava, SLAP_MR_EQUALITY, text );
if ( err != LDAP_SUCCESS ) {	if ( err != LDAP_SUCCESS ) {
break;	break;
Line 121 get_filter(	Line 129 get_filter(
break;	break;

case LDAP_FILTER_SUBSTRINGS:	case LDAP_FILTER_SUBSTRINGS:
	#ifdef NEW_LOGGING
	LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
	"get_filter: conn %d SUBSTRINGS\n", conn->c_connid ));
	#else
Debug( LDAP_DEBUG_FILTER, "SUBSTRINGS\n", 0, 0, 0 );	Debug( LDAP_DEBUG_FILTER, "SUBSTRINGS\n", 0, 0, 0 );
	#endif
err = get_substring_filter( conn, ber, f, fstr, text );	err = get_substring_filter( conn, ber, f, fstr, text );
break;	break;

case LDAP_FILTER_GE:	case LDAP_FILTER_GE:
	#ifdef NEW_LOGGING
	LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
	"get_filter: conn %d GE\n", conn->c_connid ));
	#else
Debug( LDAP_DEBUG_FILTER, "GE\n", 0, 0, 0 );	Debug( LDAP_DEBUG_FILTER, "GE\n", 0, 0, 0 );
	#endif
err = get_ava( ber, &f->f_ava, SLAP_MR_ORDERING, text );	err = get_ava( ber, &f->f_ava, SLAP_MR_ORDERING, text );
if ( err != LDAP_SUCCESS ) {	if ( err != LDAP_SUCCESS ) {
break;	break;
Line 147 get_filter(	Line 164 get_filter(
break;	break;

case LDAP_FILTER_LE:	case LDAP_FILTER_LE:
	#ifdef NEW_LOGGING
	LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
	"get_filter: conn %d LE\n", conn->c_connid ));
	#else
Debug( LDAP_DEBUG_FILTER, "LE\n", 0, 0, 0 );	Debug( LDAP_DEBUG_FILTER, "LE\n", 0, 0, 0 );
	#endif
err = get_ava( ber, &f->f_ava, SLAP_MR_ORDERING, text );	err = get_ava( ber, &f->f_ava, SLAP_MR_ORDERING, text );
if ( err != LDAP_SUCCESS ) {	if ( err != LDAP_SUCCESS ) {
break;	break;
Line 171 get_filter(	Line 192 get_filter(
case LDAP_FILTER_PRESENT: {	case LDAP_FILTER_PRESENT: {
struct berval type;	struct berval type;

	#ifdef NEW_LOGGING
	LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
	"get_filter: conn %d PRESENT\n", conn->c_connid ));
	#else
Debug( LDAP_DEBUG_FILTER, "PRESENT\n", 0, 0, 0 );	Debug( LDAP_DEBUG_FILTER, "PRESENT\n", 0, 0, 0 );
	#endif
if ( ber_scanf( ber, "o", &type ) == LBER_ERROR ) {	if ( ber_scanf( ber, "o", &type ) == LBER_ERROR ) {
err = SLAPD_DISCONNECT;	err = SLAPD_DISCONNECT;
*text = "error decoding filter";	*text = "error decoding filter";
Line 197 get_filter(	Line 222 get_filter(
} break;	} break;

case LDAP_FILTER_APPROX:	case LDAP_FILTER_APPROX:
	#ifdef NEW_LOGGING
	LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
	"get_filter: conn %d APPROX\n", conn->c_connid ));
	#else
Debug( LDAP_DEBUG_FILTER, "APPROX\n", 0, 0, 0 );	Debug( LDAP_DEBUG_FILTER, "APPROX\n", 0, 0, 0 );
	#endif
err = get_ava( ber, &f->f_ava, SLAP_MR_EQUALITY_APPROX, text );	err = get_ava( ber, &f->f_ava, SLAP_MR_EQUALITY_APPROX, text );
if ( err != LDAP_SUCCESS ) {	if ( err != LDAP_SUCCESS ) {
break;	break;
Line 218 get_filter(	Line 247 get_filter(
break;	break;

case LDAP_FILTER_AND:	case LDAP_FILTER_AND:
	#ifdef NEW_LOGGING
	LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
	"get_filter: conn %d AND\n", conn->c_connid ));
	#else
Debug( LDAP_DEBUG_FILTER, "AND\n", 0, 0, 0 );	Debug( LDAP_DEBUG_FILTER, "AND\n", 0, 0, 0 );
	#endif
err = get_filter_list( conn, ber, &f->f_and, &ftmp, text );	err = get_filter_list( conn, ber, &f->f_and, &ftmp, text );
if ( err != LDAP_SUCCESS ) {	if ( err != LDAP_SUCCESS ) {
break;	break;
Line 230 get_filter(	Line 264 get_filter(
break;	break;

case LDAP_FILTER_OR:	case LDAP_FILTER_OR:
	#ifdef NEW_LOGGING
	LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
	"get_filter: conn %d OR\n", conn->c_connid ));
	#else
Debug( LDAP_DEBUG_FILTER, "OR\n", 0, 0, 0 );	Debug( LDAP_DEBUG_FILTER, "OR\n", 0, 0, 0 );
	#endif
err = get_filter_list( conn, ber, &f->f_and, &ftmp, text );	err = get_filter_list( conn, ber, &f->f_and, &ftmp, text );
if ( err != LDAP_SUCCESS ) {	if ( err != LDAP_SUCCESS ) {
break;	break;
Line 242 get_filter(	Line 281 get_filter(
break;	break;

case LDAP_FILTER_NOT:	case LDAP_FILTER_NOT:
	#ifdef NEW_LOGGING
	LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
	"get_filter: conn %d NOT\n", conn->c_connid ));
	#else
Debug( LDAP_DEBUG_FILTER, "NOT\n", 0, 0, 0 );	Debug( LDAP_DEBUG_FILTER, "NOT\n", 0, 0, 0 );
	#endif
(void) ber_skip_tag( ber, &len );	(void) ber_skip_tag( ber, &len );
err = get_filter( conn, ber, &f->f_not, &ftmp, text );	err = get_filter( conn, ber, &f->f_not, &ftmp, text );
if ( err != LDAP_SUCCESS ) {	if ( err != LDAP_SUCCESS ) {
Line 255 get_filter(	Line 299 get_filter(
break;	break;

case LDAP_FILTER_EXT:	case LDAP_FILTER_EXT:
/* not yet implemented */	#ifdef NEW_LOGGING
Debug( LDAP_DEBUG_ANY, "extensible match not yet implemented.\n",	LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
0, 0, 0 );	"get_filter: conn %d EXTENSIBLE\n", conn->c_connid ));
(void) ber_skip_tag( ber, &len );	#else
f->f_choice = SLAPD_FILTER_COMPUTED;	Debug( LDAP_DEBUG_FILTER, "EXTENSIBLE\n", 0, 0, 0 );
f->f_result = SLAPD_COMPARE_UNDEFINED;	#endif
*fstr = ch_strdup( "(extended)" );
	err = get_mra( ber, &f->f_mra, text );
	if ( err != LDAP_SUCCESS ) {
	break;
	}

	assert( f->f_mra != NULL );

	filter_escape_value( f->f_mr_value, &escaped );

	*fstr = ch_malloc( sizeof("(:dn::=)")
	+ (f->f_mr_desc ? f->f_mr_desc->ad_cname->bv_len : 0)
	+ (f->f_mr_rule_text ? strlen(f->f_mr_rule_text) : 0)
	+ escaped.bv_len );

	sprintf( *fstr, "(%s%s%s%s:=%s)",
	(f->f_mr_desc ? f->f_mr_desc->ad_cname->bv_val : ""),
	(f->f_mr_dnattrs ? ":dn" : ""),
	(f->f_mr_rule_text ? ":" : ""),
	(f->f_mr_rule_text ? f->f_mr_rule_text : ""),
	escaped.bv_val );

	ber_memfree( escaped.bv_val );
break;	break;

default:	default:
(void) ber_scanf( ber, "x" ); /* skip the element */	(void) ber_scanf( ber, "x" ); /* skip the element */
	#ifdef NEW_LOGGING
	LDAP_LOG(( "filter", LDAP_LEVEL_ERR,
	"get_filter: conn %d unknown filter type=%lu\n",
	conn->c_connid, f->f_choice ));
	#else
Debug( LDAP_DEBUG_ANY, "get_filter: unknown filter type=%lu\n",	Debug( LDAP_DEBUG_ANY, "get_filter: unknown filter type=%lu\n",
f->f_choice, 0, 0 );	f->f_choice, 0, 0 );
	#endif
f->f_choice = SLAPD_FILTER_COMPUTED;	f->f_choice = SLAPD_FILTER_COMPUTED;
f->f_result = SLAPD_COMPARE_UNDEFINED;	f->f_result = SLAPD_COMPARE_UNDEFINED;
*fstr = ch_strdup( "(undefined)" );	*fstr = ch_strdup( "(undefined)" );
Line 296 get_filter(	Line 368 get_filter(
*filt = f;	*filt = f;
}	}

	#ifdef NEW_LOGGING
	LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL2,
	"get_filter: conn %d exit\n", conn->c_connid ));
	#else
Debug( LDAP_DEBUG_FILTER, "end get_filter %d\n", err, 0, 0 );	Debug( LDAP_DEBUG_FILTER, "end get_filter %d\n", err, 0, 0 );
	#endif
return( err );	return( err );
}	}

Line 311 get_filter_list( Connection *conn, BerEl	Line 388 get_filter_list( Connection *conn, BerEl
ber_len_t len;	ber_len_t len;
char last, ftmp;	char last, ftmp;

	#ifdef NEW_LOGGING
	LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
	"get_filter_list: conn %d start\n", conn->c_connid ));
	#else
Debug( LDAP_DEBUG_FILTER, "begin get_filter_list\n", 0, 0, 0 );	Debug( LDAP_DEBUG_FILTER, "begin get_filter_list\n", 0, 0, 0 );
	#endif
*fstr = NULL;	*fstr = NULL;
new = f;	new = f;
for ( tag = ber_first_element( ber, &len, &last ); tag != LBER_DEFAULT;	for ( tag = ber_first_element( ber, &len, &last ); tag != LBER_DEFAULT;
Line 334 get_filter_list( Connection *conn, BerEl	Line 415 get_filter_list( Connection *conn, BerEl
}	}
*new = NULL;	*new = NULL;

	#ifdef NEW_LOGGING
	LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
	"get_filter_list: conn %d exit\n", conn->c_connid ));
	#else
Debug( LDAP_DEBUG_FILTER, "end get_filter_list\n", 0, 0, 0 );	Debug( LDAP_DEBUG_FILTER, "end get_filter_list\n", 0, 0, 0 );
	#endif
return( LDAP_SUCCESS );	return( LDAP_SUCCESS );
}	}

Line 357 get_substring_filter(	Line 443 get_substring_filter(
struct berval *nvalue;	struct berval *nvalue;
*text = "error decoding filter";	*text = "error decoding filter";

	#ifdef NEW_LOGGING
	LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
	"get_substring_filter: conn %d begin\n", conn->c_connid ));
	#else
Debug( LDAP_DEBUG_FILTER, "begin get_substring_filter\n", 0, 0, 0 );	Debug( LDAP_DEBUG_FILTER, "begin get_substring_filter\n", 0, 0, 0 );
	#endif
if ( ber_scanf( ber, "{o" /}/, &type ) == LBER_ERROR ) {	if ( ber_scanf( ber, "{o" /}/, &type ) == LBER_ERROR ) {
return SLAPD_DISCONNECT;	return SLAPD_DISCONNECT;
}	}
Line 421 get_substring_filter(	Line 511 get_substring_filter(
default:	default:
rc = LDAP_PROTOCOL_ERROR;	rc = LDAP_PROTOCOL_ERROR;

	#ifdef NEW_LOGGING
	LDAP_LOG(( "filter", LDAP_LEVEL_ERR,
	"get_filter_substring: conn %d unknown substring choice=%ld\n",
	conn->c_connid, (long)tag ));
	#else
Debug( LDAP_DEBUG_FILTER,	Debug( LDAP_DEBUG_FILTER,
" unknown substring choice=%ld\n",	" unknown substring choice=%ld\n",
(long) tag, 0, 0 );	(long) tag, 0, 0 );
	#endif
ber_bvfree( value );	ber_bvfree( value );
goto return_error;	goto return_error;
}	}
Line 442 get_substring_filter(	Line 537 get_substring_filter(

switch ( tag ) {	switch ( tag ) {
case LDAP_SUBSTRING_INITIAL:	case LDAP_SUBSTRING_INITIAL:
	#ifdef NEW_LOGGING
	LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
	"get_substring_filter: conn %d INITIAL\n",
	conn->c_connid ));
	#else
Debug( LDAP_DEBUG_FILTER, " INITIAL\n", 0, 0, 0 );	Debug( LDAP_DEBUG_FILTER, " INITIAL\n", 0, 0, 0 );
	#endif

if ( f->f_sub_initial != NULL	if ( f->f_sub_initial != NULL
\|\| f->f_sub_any != NULL	\|\| f->f_sub_any != NULL
\|\| f->f_sub_final != NULL )	\|\| f->f_sub_final != NULL )
Line 463 get_substring_filter(	Line 565 get_substring_filter(
break;	break;

case LDAP_SUBSTRING_ANY:	case LDAP_SUBSTRING_ANY:
	#ifdef NEW_LOGGING
	LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
	"get_substring_filter: conn %d ANY\n",
	conn->c_connid ));
	#else
Debug( LDAP_DEBUG_FILTER, " ANY\n", 0, 0, 0 );	Debug( LDAP_DEBUG_FILTER, " ANY\n", 0, 0, 0 );
	#endif

if ( f->f_sub_final != NULL ) {	if ( f->f_sub_final != NULL ) {
ber_bvfree( value );	ber_bvfree( value );
Line 486 get_substring_filter(	Line 594 get_substring_filter(
break;	break;

case LDAP_SUBSTRING_FINAL:	case LDAP_SUBSTRING_FINAL:
	#ifdef NEW_LOGGING
	LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
	"get_substring_filter: conn %d FINAL\n",
	conn->c_connid ));
	#else
Debug( LDAP_DEBUG_FILTER, " FINAL\n", 0, 0, 0 );	Debug( LDAP_DEBUG_FILTER, " FINAL\n", 0, 0, 0 );
	#endif

if ( f->f_sub_final != NULL ) {	if ( f->f_sub_final != NULL ) {
ber_bvfree( value );	ber_bvfree( value );
Line 506 get_substring_filter(	Line 620 get_substring_filter(
break;	break;

default:	default:
	#ifdef NEW_LOGGING
	LDAP_LOG(( "filter", LDAP_LEVEL_INFO,
	"get_substring_filter: conn %d unknown substring type %ld\n",
	conn->c_connid, (long)tag ));
	#else
Debug( LDAP_DEBUG_FILTER,	Debug( LDAP_DEBUG_FILTER,
" unknown substring type=%ld\n",	" unknown substring type=%ld\n",
(long) tag, 0, 0 );	(long) tag, 0, 0 );
	#endif

ber_bvfree( value );	ber_bvfree( value );

return_error:	return_error:
	#ifdef NEW_LOGGING
	LDAP_LOG(( "filter", LDAP_LEVEL_INFO,
	"get_substring_filter: conn %d error %ld\n",
	conn->c_connid, (long)rc ));
	#else
Debug( LDAP_DEBUG_FILTER, " error=%ld\n",	Debug( LDAP_DEBUG_FILTER, " error=%ld\n",
(long) rc, 0, 0 );	(long) rc, 0, 0 );
	#endif
if( fstr ) {	if( fstr ) {
free( *fstr );	free( *fstr );
*fstr = NULL;	*fstr = NULL;
Line 538 return_error:	Line 663 return_error:
strcat( fstr, /(*/ ")" );	strcat( fstr, /(*/ ")" );
}	}

	#ifdef NEW_LOGGING
	LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
	"get_substring_filter: conn %d exit\n", conn->c_connid ));
	#else
Debug( LDAP_DEBUG_FILTER, "end get_substring_filter\n", 0, 0, 0 );	Debug( LDAP_DEBUG_FILTER, "end get_substring_filter\n", 0, 0, 0 );
	#endif
return( LDAP_SUCCESS );	return( LDAP_SUCCESS );
}	}

Line 588 filter_free( Filter *f )	Line 718 filter_free( Filter *f )
break;	break;

default:	default:
	#ifdef NEW_LOGGING
	LDAP_LOG(( "filter", LDAP_LEVEL_ERR,
	"filter_free: unknown filter type %lu\n", f->f_choice ));
	#else
Debug( LDAP_DEBUG_ANY, "filter_free: unknown filter type=%lu\n",	Debug( LDAP_DEBUG_ANY, "filter_free: unknown filter type=%lu\n",
f->f_choice, 0, 0 );	f->f_choice, 0, 0 );
	#endif
break;	break;
}	}

Removed from v.1.13.4.9
changed lines
	Added in v.1.60