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.51 and 1.71

version 1.51, 2000/07/02 15:14:37	version 1.71, 2002/01/06 05:21:30
Line 1	Line 1
/* filter.c - routines for parsing and dealing with filters */	/* filter.c - routines for parsing and dealing with filters */
/* $OpenLDAP: pkg/ldap/servers/slapd/filter.c,v 1.50 2000/07/02 05:18:55 mrv Exp $ */	/* $OpenLDAP: pkg/ldap/servers/slapd/filter.c,v 1.70 2002/01/06 05:11:01 hyc Exp $ */
/*	/*
* Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.	* Copyright 1998-2002 The OpenLDAP Foundation, All Rights Reserved.
* COPYING RESTRICTIONS APPLY, see COPYRIGHT file	* COPYING RESTRICTIONS APPLY, see COPYRIGHT file
*/	*/

Line 18 static int get_filter_list(	Line 18 static int get_filter_list(
Connection *conn,	Connection *conn,
BerElement *ber,	BerElement *ber,
Filter **f,	Filter **f,
char **fstr,	struct berval *fstr,
const char **text );	const char **text );

static int get_substring_filter(	static int get_substring_filter(
Connection *conn,	Connection *conn,
BerElement *ber,	BerElement *ber,
Filter *f,	Filter *f,
char **fstr,	struct berval *fstr,
const char **text );	const char **text );

static int filter_escape_value(	static int filter_escape_value(
Line 37 get_filter(	Line 37 get_filter(
Connection *conn,	Connection *conn,
BerElement *ber,	BerElement *ber,
Filter **filt,	Filter **filt,
char **fstr,	struct berval *fstr,
const char **text )	const char **text )
{	{
ber_tag_t tag;	ber_tag_t tag;
ber_len_t len;	ber_len_t len;
int err;	int err;
Filter *f;	Filter *f;
char *ftmp = NULL;	struct berval ftmp = { 0, 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 93 get_filter(	Line 97 get_filter(
f->f_next = NULL;	f->f_next = NULL;

err = LDAP_SUCCESS;	err = LDAP_SUCCESS;
*fstr = NULL;	*fstr = ftmp;
f->f_choice = tag;	f->f_choice = tag;

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 107 get_filter(	Line 115 get_filter(

assert( f->f_ava != NULL );	assert( f->f_ava != NULL );

filter_escape_value( f->f_av_value, &escaped );	filter_escape_value( &f->f_av_value, &escaped );

	fstr->bv_len = sizeof("(=)")-1
	+ f->f_av_desc->ad_cname.bv_len
	+ escaped.bv_len;

*fstr = ch_malloc( sizeof("(=)")	fstr->bv_val = ch_malloc( fstr->bv_len + 1 );
+ f->f_av_desc->ad_cname->bv_len
+ escaped.bv_len );

sprintf( *fstr, "(%s=%s)",	sprintf( fstr->bv_val, "(%s=%s)",
f->f_av_desc->ad_cname->bv_val,	f->f_av_desc->ad_cname.bv_val,
escaped.bv_val );	escaped.bv_val );

ber_memfree( escaped.bv_val );	ber_memfree( escaped.bv_val );
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;
}	}

filter_escape_value( f->f_av_value, &escaped );	filter_escape_value( &f->f_av_value, &escaped );

	fstr->bv_len = sizeof("(>=)")-1
	+ f->f_av_desc->ad_cname.bv_len
	+ escaped.bv_len;

*fstr = ch_malloc( sizeof("(>=)")	fstr->bv_val = ch_malloc( fstr->bv_len + 1 );
+ f->f_av_desc->ad_cname->bv_len
+ escaped.bv_len );

sprintf( *fstr, "(%s>=%s)",	sprintf( fstr->bv_val, "(%s>=%s)",
f->f_av_desc->ad_cname->bv_val,	f->f_av_desc->ad_cname.bv_val,
escaped.bv_val );	escaped.bv_val );

ber_memfree( escaped.bv_val );	ber_memfree( escaped.bv_val );
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;
}	}


filter_escape_value( f->f_av_value, &escaped );	filter_escape_value( &f->f_av_value, &escaped );

*fstr = ch_malloc( sizeof("(<=)")	fstr->bv_len = sizeof("(<=)")-1
+ f->f_av_desc->ad_cname->bv_len	+ f->f_av_desc->ad_cname.bv_len
+ escaped.bv_len );	+ escaped.bv_len;

sprintf( *fstr, "(%s<=%s)",	fstr->bv_val = ch_malloc( fstr->bv_len + 1 );
f->f_av_desc->ad_cname->bv_val,
	sprintf( fstr->bv_val, "(%s<=%s)",
	f->f_av_desc->ad_cname.bv_val,
escaped.bv_val );	escaped.bv_val );

ber_memfree( escaped.bv_val );	ber_memfree( escaped.bv_val );
Line 171 get_filter(	Line 198 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, "m", &type ) == LBER_ERROR ) {
err = SLAPD_DISCONNECT;	err = SLAPD_DISCONNECT;
*text = "error decoding filter";	*text = "error decoding filter";
break;	break;
Line 183 get_filter(	Line 214 get_filter(
err = slap_bv2ad( &type, &f->f_desc, text );	err = slap_bv2ad( &type, &f->f_desc, text );

if( err != LDAP_SUCCESS ) {	if( err != LDAP_SUCCESS ) {
ch_free( type.bv_val );	/* unrecognized attribute description or other error */
	f->f_choice = SLAPD_FILTER_COMPUTED;
	f->f_result = LDAP_COMPARE_FALSE;
	ber_str2bv("(unrecognized=*)",
	sizeof("(unrecognized=*)")-1, 1, fstr);
	err = LDAP_SUCCESS;
break;	break;
}	}

ch_free( type.bv_val );	fstr->bv_len = sizeof("(=*)") - 1
	+ f->f_desc->ad_cname.bv_len;
fstr = ch_malloc( sizeof("(=)")	fstr->bv_val = ch_malloc( fstr->bv_len + 1);
+ f->f_desc->ad_cname->bv_len );	sprintf( fstr->bv_val, "(%s=*)",
sprintf( fstr, "(%s=)",	f->f_desc->ad_cname.bv_val );
f->f_desc->ad_cname->bv_val );

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

filter_escape_value( f->f_av_value, &escaped );	filter_escape_value( &f->f_av_value, &escaped );

*fstr = ch_malloc( sizeof("(~=)")	fstr->bv_len = sizeof("(~=)") - 1
+ f->f_av_desc->ad_cname->bv_len	+ f->f_av_desc->ad_cname.bv_len
+ escaped.bv_len );	+ escaped.bv_len;
	fstr->bv_val = ch_malloc( fstr->bv_len + 1);

sprintf( *fstr, "(%s~=%s)",	sprintf( fstr->bv_val, "(%s~=%s)",
f->f_av_desc->ad_cname->bv_val,	f->f_av_desc->ad_cname.bv_val,
escaped.bv_val );	escaped.bv_val );

ber_memfree( escaped.bv_val );	ber_memfree( escaped.bv_val );
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;
}	}
*fstr = ch_malloc( sizeof("(&)")	fstr->bv_len = sizeof("(&)") - 1 + ftmp.bv_len;
+ ( ftmp == NULL ? 0 : strlen( ftmp ) ) );	fstr->bv_val = ch_malloc( fstr->bv_len + 1 );
sprintf( *fstr, "(&%s)",	sprintf( fstr->bv_val, "(&%s)",
ftmp == NULL ? "" : ftmp );	ftmp.bv_len ? ftmp.bv_val : "" );
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;
}	}
*fstr = ch_malloc( sizeof("(!)")	fstr->bv_len = sizeof("(\|)") - 1 + ftmp.bv_len;
+ ( ftmp == NULL ? 0 : strlen( ftmp ) ) );	fstr->bv_val = ch_malloc( fstr->bv_len + 1 );
sprintf( *fstr, "(\|%s)",	sprintf( fstr->bv_val, "(\|%s)",
ftmp == NULL ? "" : ftmp );	ftmp.bv_len ? ftmp.bv_val : "" );
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 ) {
break;	break;
}	}
*fstr = ch_malloc( sizeof("(!)")	fstr->bv_len = sizeof("(!)") - 1 + ftmp.bv_len;
+ ( ftmp == NULL ? 0 : strlen( ftmp ) ) );	fstr->bv_val = ch_malloc( fstr->bv_len + 1 );
sprintf( *fstr, "(!%s)",	sprintf( fstr->bv_val, "(!%s)",
ftmp == NULL ? "" : ftmp );	ftmp.bv_len ? ftmp.bv_val : "" );
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,
f->f_choice, 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->bv_len = sizeof("(:dn::=)") - 1
	+ (f->f_mr_desc ? f->f_mr_desc->ad_cname.bv_len : 0)
	+ f->f_mr_rule_text.bv_len
	+ escaped.bv_len;

	fstr->bv_val = ch_malloc( fstr->bv_len + 1 );
	sprintf( fstr->bv_val, "(%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.bv_len ? ":" : ""),
	(f->f_mr_rule_text.bv_len ? f->f_mr_rule_text.bv_val : ""),
	escaped.bv_val );

	ber_memfree( escaped.bv_val );
break;	break;

default:	default:
(void) ber_skip_tag( ber, &len );	(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)" );	ber_str2bv( "(undefined)", sizeof("(undefined)") - 1,
	1, fstr );
break;	break;
}	}

free( ftmp );	if ( ftmp.bv_val ) free( ftmp.bv_val );

if ( err != LDAP_SUCCESS ) {	if ( err != LDAP_SUCCESS ) {
if ( *fstr != NULL ) {	if ( fstr->bv_val != NULL ) {
free( *fstr );	free( fstr->bv_val );
}	}

if( err != SLAPD_DISCONNECT ) {	if( err != SLAPD_DISCONNECT ) {
/* ignore error */	/* ignore error */
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( "(badfilter)" );	ber_str2bv( "(badfilter)", sizeof("(badfilter)") - 1,
	1, fstr );
err = LDAP_SUCCESS;	err = LDAP_SUCCESS;
*filt = f;	*filt = f;

Line 296 get_filter(	Line 382 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 );
}	}

static int	static int
get_filter_list( Connection conn, BerElement ber,	get_filter_list( Connection conn, BerElement ber,
Filter f, char fstr,	Filter *f, struct berval fstr,
const char **text )	const char **text )
{	{
Filter **new;	Filter **new;
int err;	int err;
ber_tag_t tag;	ber_tag_t tag;
ber_len_t len;	ber_len_t len;
char last, ftmp;	char *last;
	struct berval 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;
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;
tag = ber_next_element( ber, &len, last ) )	tag = ber_next_element( ber, &len, last ) )
Line 322 get_filter_list( Connection *conn, BerEl	Line 417 get_filter_list( Connection *conn, BerEl
if ( err != LDAP_SUCCESS )	if ( err != LDAP_SUCCESS )
return( err );	return( err );

if ( *fstr == NULL ) {	if ( !fstr->bv_len ) {
*fstr = ftmp;	*fstr = ftmp;
} else {	} else {
fstr = ch_realloc( fstr, strlen( *fstr ) +	int i = fstr->bv_len;
strlen( ftmp ) + 1 );	fstr->bv_len += ftmp.bv_len;
strcat( *fstr, ftmp );	fstr->bv_val = ch_realloc( fstr->bv_val,
free( ftmp );	fstr->bv_len + 1 );
	strcpy( fstr->bv_val+i, ftmp.bv_val );
	free( ftmp.bv_val );
}	}
new = &(*new)->f_next;	new = &(*new)->f_next;
}	}
*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 343 get_substring_filter(	Line 445 get_substring_filter(
Connection *conn,	Connection *conn,
BerElement *ber,	BerElement *ber,
Filter *f,	Filter *f,
char **fstr,	struct berval *fstr,
const char **text	const char **text
)	)
{	{
ber_tag_t tag;	ber_tag_t tag;
ber_len_t len;	ber_len_t len;
ber_tag_t rc;	ber_tag_t rc;
struct berval *value;	struct berval value;
struct berval escaped;	struct berval escaped;
char *last;	char *last;
struct berval type;	struct berval bv;
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, "{m" /}/, &bv ) == LBER_ERROR ) {
return SLAPD_DISCONNECT;	return SLAPD_DISCONNECT;
}	}

f->f_sub = ch_calloc( 1, sizeof(SubstringsAssertion) );	f->f_sub = ch_calloc( 1, sizeof(SubstringsAssertion) );
f->f_sub_desc = NULL;	f->f_sub_desc = NULL;
rc = slap_bv2ad( &type, &f->f_sub_desc, text );	rc = slap_bv2ad( &bv, &f->f_sub_desc, text );

ch_free( type.bv_val );

if( rc != LDAP_SUCCESS ) {	if( rc != LDAP_SUCCESS ) {
text = NULL;	text = NULL;
ch_free( f->f_sub );	ch_free( f->f_sub );
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)" );	ber_str2bv( "(undefined)", sizeof("(undefined)")-1, 1, fstr );
return LDAP_SUCCESS;	return LDAP_SUCCESS;
}	}

f->f_sub_initial = NULL;	f->f_sub_initial.bv_val = NULL;
f->f_sub_any = NULL;	f->f_sub_any = NULL;
f->f_sub_final = NULL;	f->f_sub_final.bv_val = NULL;

if( fstr ) {	fstr->bv_len = sizeof("(=" /)/) - 1 +
fstr = ch_malloc( sizeof("(=" /)*/) +	f->f_sub_desc->ad_cname.bv_len;
f->f_sub_desc->ad_cname->bv_len );	fstr->bv_val = ch_malloc( fstr->bv_len + 1 );
sprintf( fstr, "(%s=" /)*/, f->f_sub_desc->ad_cname->bv_val );	sprintf( fstr->bv_val, "(%s=" /)/, f->f_sub_desc->ad_cname.bv_val );
}

for ( tag = ber_first_element( ber, &len, &last ); tag != LBER_DEFAULT;	for ( tag = ber_first_element( ber, &len, &last ); tag != LBER_DEFAULT;
tag = ber_next_element( ber, &len, last ) )	tag = ber_next_element( ber, &len, last ) )
{	{
unsigned usage;	unsigned usage;

rc = ber_scanf( ber, "O", &value );	rc = ber_scanf( ber, "m", &value );
if ( rc == LBER_ERROR ) {	if ( rc == LBER_ERROR ) {
rc = SLAPD_DISCONNECT;	rc = SLAPD_DISCONNECT;
goto return_error;	goto return_error;
}	}

if ( value == NULL \|\| value->bv_len == 0 ) {	if ( value.bv_val == NULL \|\| value.bv_len == 0 ) {
ber_bvfree( value );
rc = LDAP_INVALID_SYNTAX;	rc = LDAP_INVALID_SYNTAX;
goto return_error;	goto return_error;
}	}
Line 421 get_substring_filter(	Line 522 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 );
goto return_error;	goto return_error;
}	}

rc = value_normalize( f->f_sub_desc, usage, value, &nvalue, text );	rc = value_normalize( f->f_sub_desc, usage, &value, &bv, text );
ber_bvfree( value );

if( rc != LDAP_SUCCESS ) {	if( rc != LDAP_SUCCESS ) {
goto return_error;	goto return_error;
}	}

value = nvalue;	value = bv;

rc = LDAP_PROTOCOL_ERROR;	rc = LDAP_PROTOCOL_ERROR;

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 );
if ( f->f_sub_initial != NULL ) {	#endif
ber_bvfree( value );
	if ( f->f_sub_initial.bv_val != NULL
	\|\| f->f_sub_any != NULL
	\|\| f->f_sub_final.bv_val != NULL )
	{
	free( value.bv_val );
goto return_error;	goto return_error;
}	}

f->f_sub_initial = value;	f->f_sub_initial = value;

if( fstr ) {	if( fstr->bv_val ) {
filter_escape_value( value, &escaped );	int i = fstr->bv_len;
fstr = ch_realloc( fstr,	filter_escape_value( &value, &escaped );
strlen( *fstr ) + escaped.bv_len + 1 );	fstr->bv_len += escaped.bv_len;
strcat( *fstr, escaped.bv_val );	fstr->bv_val = ch_realloc( fstr->bv_val,
	fstr->bv_len + 1 );
	strcpy( fstr->bv_val+i, escaped.bv_val );
ber_memfree( escaped.bv_val );	ber_memfree( escaped.bv_val );
}	}
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 );
if( ber_bvecadd( &f->f_sub_any, value ) < 0 ) {	#endif
ber_bvfree( value );
	if ( f->f_sub_final.bv_val != NULL ) {
	free( value.bv_val );
goto return_error;	goto return_error;
}	}

if( fstr ) {	bvarray_add( &f->f_sub_any, &value );
filter_escape_value( value, &escaped );
fstr = ch_realloc( fstr,	if( fstr->bv_val ) {
strlen( *fstr ) + escaped.bv_len + 2 );	int i = fstr->bv_len;
strcat( fstr, "" );	filter_escape_value( &value, &escaped );
strcat( *fstr, escaped.bv_val );	fstr->bv_len += escaped.bv_len + 2;
	fstr->bv_val = ch_realloc( fstr->bv_val,
	fstr->bv_len + 1 );
	strcpy( fstr->bv_val+i, "*" );
	strcpy( fstr->bv_val+i+1, escaped.bv_val );
ber_memfree( escaped.bv_val );	ber_memfree( escaped.bv_val );
}	}
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 );
if ( f->f_sub_final != NULL ) {	#endif
ber_bvfree( value );
	if ( f->f_sub_final.bv_val != NULL ) {
	free( value.bv_val );
goto return_error;	goto return_error;
}	}

f->f_sub_final = value;	f->f_sub_final = value;

if( fstr ) {	if( fstr->bv_val ) {
filter_escape_value( value, &escaped );	int i = fstr->bv_len;
fstr = ch_realloc( fstr,	filter_escape_value( &value, &escaped );
strlen( *fstr ) + escaped.bv_len + 2 );	fstr->bv_len += escaped.bv_len + 2;
strcat( fstr, "" );	fstr->bv_val = ch_realloc( fstr->bv_val,
strcat( *fstr, escaped.bv_val );	fstr->bv_len + 1 );
	strcpy( fstr->bv_val+i, "*" );
	strcpy( fstr->bv_val+i+1, escaped.bv_val );
ber_memfree( escaped.bv_val );	ber_memfree( escaped.bv_val );
}	}
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 );	free( value.bv_val );

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->bv_val ) {
free( *fstr );	free( fstr->bv_val );
*fstr = NULL;	fstr->bv_val = NULL;
	fstr->bv_len = 0;
}	}

ad_free( f->f_sub_desc, 1 );	free( f->f_sub_initial.bv_val );
ber_bvfree( f->f_sub_initial );	bvarray_free( f->f_sub_any );
ber_bvecfree( f->f_sub_any );	free( f->f_sub_final.bv_val );
ber_bvfree( f->f_sub_final );
ch_free( f->f_sub );	ch_free( f->f_sub );
return rc;	return rc;
}	}
}	}

if( fstr ) {	if( fstr->bv_val ) {
fstr = ch_realloc( fstr, strlen( *fstr ) + 3 );	int i = fstr->bv_len;
if ( f->f_sub_final == NULL ) {	fstr->bv_len += 3;
strcat( fstr, "" );	fstr->bv_val = ch_realloc( fstr->bv_val, fstr->bv_len + 3 );
}	if ( f->f_sub_final.bv_val == NULL ) {
strcat( fstr, /(*/ ")" );	strcpy( fstr->bv_val+i, "*" );
	i++;
	}
	strcpy( fstr->bv_val+i, /(/ ")" );
}	}

	#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 542 filter_free( Filter *f )	Line 698 filter_free( Filter *f )

switch ( f->f_choice ) {	switch ( f->f_choice ) {
case LDAP_FILTER_PRESENT:	case LDAP_FILTER_PRESENT:
ad_free( f->f_desc, 1 );
break;	break;

case LDAP_FILTER_EQUALITY:	case LDAP_FILTER_EQUALITY:
Line 553 filter_free( Filter *f )	Line 708 filter_free( Filter *f )
break;	break;

case LDAP_FILTER_SUBSTRINGS:	case LDAP_FILTER_SUBSTRINGS:
ad_free( f->f_sub_desc, 1 );	if ( f->f_sub_initial.bv_val != NULL ) {
if ( f->f_sub_initial != NULL ) {	free( f->f_sub_initial.bv_val );
ber_bvfree( f->f_sub_initial );
}
ber_bvecfree( f->f_sub_any );
if ( f->f_sub_final != NULL ) {
ber_bvfree( f->f_sub_final );
}	}
	bvarray_free( f->f_sub_any );
	if ( f->f_sub_final.bv_val != NULL ) {
	free( f->f_sub_final.bv_val );
	}
	ch_free( f->f_sub );
break;	break;

case LDAP_FILTER_AND:	case LDAP_FILTER_AND:
Line 572 filter_free( Filter *f )	Line 727 filter_free( Filter *f )
}	}
break;	break;

	case LDAP_FILTER_EXT:
	mra_free( f->f_mra, 1 );
	break;

case SLAPD_FILTER_COMPUTED:	case SLAPD_FILTER_COMPUTED:
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;
}	}

Line 598 filter_print( Filter *f )	Line 762 filter_print( Filter *f )

switch ( f->f_choice ) {	switch ( f->f_choice ) {
case LDAP_FILTER_EQUALITY:	case LDAP_FILTER_EQUALITY:
filter_escape_value( f->f_av_value, &escaped );	filter_escape_value( &f->f_av_value, &escaped );
fprintf( stderr, "(%s=%s)",	fprintf( stderr, "(%s=%s)",
f->f_av_desc->ad_cname->bv_val,	f->f_av_desc->ad_cname.bv_val,
escaped.bv_val );	escaped.bv_val );
ber_memfree( escaped.bv_val );	ber_memfree( escaped.bv_val );
break;	break;

case LDAP_FILTER_GE:	case LDAP_FILTER_GE:
filter_escape_value( f->f_av_value, &escaped );	filter_escape_value( &f->f_av_value, &escaped );
fprintf( stderr, "(%s>=%s)",	fprintf( stderr, "(%s>=%s)",
f->f_av_desc->ad_cname->bv_val,	f->f_av_desc->ad_cname.bv_val,
escaped.bv_val );	escaped.bv_val );
ber_memfree( escaped.bv_val );	ber_memfree( escaped.bv_val );
break;	break;

case LDAP_FILTER_LE:	case LDAP_FILTER_LE:
filter_escape_value( f->f_av_value, &escaped );	filter_escape_value( &f->f_av_value, &escaped );
fprintf( stderr, "(%s<=%s)",	fprintf( stderr, "(%s<=%s)",
f->f_ava->aa_desc->ad_cname->bv_val,	f->f_ava->aa_desc->ad_cname.bv_val,
escaped.bv_val );	escaped.bv_val );
ber_memfree( escaped.bv_val );	ber_memfree( escaped.bv_val );
break;	break;

case LDAP_FILTER_APPROX:	case LDAP_FILTER_APPROX:
filter_escape_value( f->f_av_value, &escaped );	filter_escape_value( &f->f_av_value, &escaped );
fprintf( stderr, "(%s~=%s)",	fprintf( stderr, "(%s~=%s)",
f->f_ava->aa_desc->ad_cname->bv_val,	f->f_ava->aa_desc->ad_cname.bv_val,
escaped.bv_val );	escaped.bv_val );
ber_memfree( escaped.bv_val );	ber_memfree( escaped.bv_val );
break;	break;

case LDAP_FILTER_SUBSTRINGS:	case LDAP_FILTER_SUBSTRINGS:
fprintf( stderr, "(%s=" /)/,	fprintf( stderr, "(%s=" /)/,
f->f_sub_desc->ad_cname->bv_val );	f->f_sub_desc->ad_cname.bv_val );
if ( f->f_sub_initial != NULL ) {	if ( f->f_sub_initial.bv_val != NULL ) {
filter_escape_value( f->f_sub_initial, &escaped );	filter_escape_value( &f->f_sub_initial, &escaped );
fprintf( stderr, "%s",	fprintf( stderr, "%s",
escaped.bv_val );	escaped.bv_val );
ber_memfree( escaped.bv_val );	ber_memfree( escaped.bv_val );
}	}
if ( f->f_sub_any != NULL ) {	if ( f->f_sub_any != NULL ) {
for ( i = 0; f->f_sub_any[i] != NULL; i++ ) {	for ( i = 0; f->f_sub_any[i].bv_val != NULL; i++ ) {
filter_escape_value( f->f_sub_any[i], &escaped );	filter_escape_value( &f->f_sub_any[i], &escaped );
fprintf( stderr, "*%s",	fprintf( stderr, "*%s",
escaped.bv_val );	escaped.bv_val );
ber_memfree( escaped.bv_val );	ber_memfree( escaped.bv_val );
}	}
}	}
if ( f->f_sub_final != NULL ) {	if ( f->f_sub_final.bv_val != NULL ) {
filter_escape_value( f->f_sub_final, &escaped );	filter_escape_value( &f->f_sub_final, &escaped );
fprintf( stderr,	fprintf( stderr,
"*%s", escaped.bv_val );	"*%s", escaped.bv_val );
ber_memfree( escaped.bv_val );	ber_memfree( escaped.bv_val );
Line 657 filter_print( Filter *f )	Line 821 filter_print( Filter *f )

case LDAP_FILTER_PRESENT:	case LDAP_FILTER_PRESENT:
fprintf( stderr, "(%s=*)",	fprintf( stderr, "(%s=*)",
f->f_desc->ad_cname->bv_val );	f->f_desc->ad_cname.bv_val );
break;	break;

case LDAP_FILTER_AND:	case LDAP_FILTER_AND:
Line 688 filter_print( Filter *f )	Line 852 filter_print( Filter *f )

#endif /* ldap_debug */	#endif /* ldap_debug */

int filter_escape_value(	static int filter_escape_value(
struct berval *in,	struct berval *in,
struct berval *out )	struct berval *out )
{	{
Line 699 int filter_escape_value(	Line 863 int filter_escape_value(
out->bv_val = (char ) ch_malloc( ( in->bv_len 3 ) + 1 );	out->bv_val = (char ) ch_malloc( ( in->bv_len 3 ) + 1 );
out->bv_len = 0;	out->bv_len = 0;

#undef NIBBLE
#undef ESCAPE_LO
#undef ESCAPE_HI
#define NIBBLE(c) ((c)&0x0f)
#define ESCAPE_LO(c) ( NIBBLE(c) + ( NIBBLE(c) < 10 ? '0' : 'A' - 10 ) )
#define ESCAPE_HI(c) ( ESCAPE_LO((c)>>4) )

for( i=0; i < in->bv_len ; i++ ) {	for( i=0; i < in->bv_len ; i++ ) {
if( FILTER_ESCAPE(in->bv_val[i]) ) {	if( FILTER_ESCAPE(in->bv_val[i]) ) {
out->bv_val[out->bv_len++] = '\\';	out->bv_val[out->bv_len++] = SLAP_ESCAPE_CHAR;
out->bv_val[out->bv_len++] = ESCAPE_HI( in->bv_val[i] );	out->bv_val[out->bv_len++] = SLAP_ESCAPE_HI( in->bv_val[i] );
out->bv_val[out->bv_len++] = ESCAPE_LO( in->bv_val[i] );	out->bv_val[out->bv_len++] = SLAP_ESCAPE_LO( in->bv_val[i] );
} else {	} else {
out->bv_val[out->bv_len++] = in->bv_val[i];	out->bv_val[out->bv_len++] = in->bv_val[i];
}	}
Line 719 int filter_escape_value(	Line 876 int filter_escape_value(
out->bv_val[out->bv_len] = '\0';	out->bv_val[out->bv_len] = '\0';
return LDAP_SUCCESS;	return LDAP_SUCCESS;
}	}

Removed from v.1.51
changed lines
	Added in v.1.71