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.72.2.8 and 1.72.2.9

version 1.72.2.8, 2002/11/26 18:24:54	version 1.72.2.9, 2003/02/09 16:31:36
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.72.2.7 2002/11/11 02:42:37 kurt Exp $ */	/* $OpenLDAP: pkg/ldap/servers/slapd/filter.c,v 1.89 2003/01/20 19:21:17 kurt Exp $ */
/*	/*
* Copyright 1998-2002 The OpenLDAP Foundation, All Rights Reserved.	* Copyright 1998-2003 The OpenLDAP Foundation, All Rights Reserved.
* COPYING RESTRICTIONS APPLY, see COPYRIGHT file	* COPYING RESTRICTIONS APPLY, see COPYRIGHT file
*/	*/

Line 822 get_simple_vrFilter(	Line 822 get_simple_vrFilter(
ber_tag_t tag;	ber_tag_t tag;
ber_len_t len;	ber_len_t len;
int err;	int err;
ValuesReturnFilter *f;	ValuesReturnFilter *vrf;

#ifdef NEW_LOGGING	#ifdef NEW_LOGGING
LDAP_LOG( FILTER, ENTRY,	LDAP_LOG( FILTER, ENTRY,
Line 838 get_simple_vrFilter(	Line 838 get_simple_vrFilter(
return SLAPD_DISCONNECT;	return SLAPD_DISCONNECT;
}	}

f = (ValuesReturnFilter *) ch_malloc( sizeof(ValuesReturnFilter) );	vrf = (ValuesReturnFilter *) ch_malloc( sizeof(ValuesReturnFilter) );
f->f_next = NULL;	vrf->vrf_next = NULL;

err = LDAP_SUCCESS;	err = LDAP_SUCCESS;
f->f_choice = tag;	vrf->vrf_choice = tag;

switch ( f->f_choice ) {	switch ( vrf->vrf_choice ) {
case LDAP_FILTER_EQUALITY:	case LDAP_FILTER_EQUALITY:
#ifdef NEW_LOGGING	#ifdef NEW_LOGGING
LDAP_LOG( FILTER, DETAIL2,	LDAP_LOG( FILTER, DETAIL2,
Line 852 get_simple_vrFilter(	Line 852 get_simple_vrFilter(
#else	#else
Debug( LDAP_DEBUG_FILTER, "EQUALITY\n", 0, 0, 0 );	Debug( LDAP_DEBUG_FILTER, "EQUALITY\n", 0, 0, 0 );
#endif	#endif
err = get_ava( ber, &f->f_ava, SLAP_MR_EQUALITY, text );	err = get_ava( ber, &vrf->vrf_ava, SLAP_MR_EQUALITY, text );
if ( err != LDAP_SUCCESS ) {	if ( err != LDAP_SUCCESS ) {
break;	break;
}	}

assert( f->f_ava != NULL );	assert( vrf->vrf_ava != NULL );
break;	break;

case LDAP_FILTER_SUBSTRINGS:	case LDAP_FILTER_SUBSTRINGS:
Line 867 get_simple_vrFilter(	Line 867 get_simple_vrFilter(
#else	#else
Debug( LDAP_DEBUG_FILTER, "SUBSTRINGS\n", 0, 0, 0 );	Debug( LDAP_DEBUG_FILTER, "SUBSTRINGS\n", 0, 0, 0 );
#endif	#endif
err = get_substring_filter( conn, ber, (Filter *)f, text );	err = get_substring_filter( conn, ber, (Filter *)vrf, text );
break;	break;

case LDAP_FILTER_GE:	case LDAP_FILTER_GE:
Line 877 get_simple_vrFilter(	Line 877 get_simple_vrFilter(
#else	#else
Debug( LDAP_DEBUG_FILTER, "GE\n", 0, 0, 0 );	Debug( LDAP_DEBUG_FILTER, "GE\n", 0, 0, 0 );
#endif	#endif
err = get_ava( ber, &f->f_ava, SLAP_MR_ORDERING, text );	err = get_ava( ber, &vrf->vrf_ava, SLAP_MR_ORDERING, text );
if ( err != LDAP_SUCCESS ) {	if ( err != LDAP_SUCCESS ) {
break;	break;
}	}
Line 890 get_simple_vrFilter(	Line 890 get_simple_vrFilter(
#else	#else
Debug( LDAP_DEBUG_FILTER, "LE\n", 0, 0, 0 );	Debug( LDAP_DEBUG_FILTER, "LE\n", 0, 0, 0 );
#endif	#endif
err = get_ava( ber, &f->f_ava, SLAP_MR_ORDERING, text );	err = get_ava( ber, &vrf->vrf_ava, SLAP_MR_ORDERING, text );
if ( err != LDAP_SUCCESS ) {	if ( err != LDAP_SUCCESS ) {
break;	break;
}	}
Line 911 get_simple_vrFilter(	Line 911 get_simple_vrFilter(
break;	break;
}	}

f->f_desc = NULL;	vrf->vrf_desc = NULL;
err = slap_bv2ad( &type, &f->f_desc, text );	err = slap_bv2ad( &type, &vrf->vrf_desc, text );

if( err != LDAP_SUCCESS ) {	if( err != LDAP_SUCCESS ) {
/* unrecognized attribute description or other error */	/* unrecognized attribute description or other error */
f->f_choice = SLAPD_FILTER_COMPUTED;	vrf->vrf_choice = SLAPD_FILTER_COMPUTED;
f->f_result = LDAP_COMPARE_FALSE;	vrf->vrf_result = LDAP_COMPARE_FALSE;
err = LDAP_SUCCESS;	err = LDAP_SUCCESS;
break;	break;
}	}
Line 930 get_simple_vrFilter(	Line 930 get_simple_vrFilter(
#else	#else
Debug( LDAP_DEBUG_FILTER, "APPROX\n", 0, 0, 0 );	Debug( LDAP_DEBUG_FILTER, "APPROX\n", 0, 0, 0 );
#endif	#endif
err = get_ava( ber, &f->f_ava, SLAP_MR_EQUALITY_APPROX, text );	err = get_ava( ber, &vrf->vrf_ava, SLAP_MR_EQUALITY_APPROX, text );
if ( err != LDAP_SUCCESS ) {	if ( err != LDAP_SUCCESS ) {
break;	break;
}	}
Line 944 get_simple_vrFilter(	Line 944 get_simple_vrFilter(
Debug( LDAP_DEBUG_FILTER, "EXTENSIBLE\n", 0, 0, 0 );	Debug( LDAP_DEBUG_FILTER, "EXTENSIBLE\n", 0, 0, 0 );
#endif	#endif

err = get_mra( ber, &f->f_mra, text );	err = get_mra( ber, &vrf->vrf_mra, text );
if ( err != LDAP_SUCCESS ) {	if ( err != LDAP_SUCCESS ) {
break;	break;
}	}

assert( f->f_mra != NULL );	assert( vrf->vrf_mra != NULL );
break;	break;

default:	default:
Line 957 get_simple_vrFilter(	Line 957 get_simple_vrFilter(
#ifdef NEW_LOGGING	#ifdef NEW_LOGGING
LDAP_LOG( FILTER, ERR,	LDAP_LOG( FILTER, ERR,
"get_simple_vrFilter: conn %d unknown filter type=%lu\n",	"get_simple_vrFilter: conn %d unknown filter type=%lu\n",
conn->c_connid, f->f_choice, 0 );	conn->c_connid, vrf->vrf_choice, 0 );
#else	#else
Debug( LDAP_DEBUG_ANY, "get_simple_vrFilter: unknown filter type=%lu\n",	Debug( LDAP_DEBUG_ANY, "get_simple_vrFilter: unknown filter type=%lu\n",
f->f_choice, 0, 0 );	vrf->vrf_choice, 0, 0 );
#endif	#endif
f->f_choice = SLAPD_FILTER_COMPUTED;	vrf->vrf_choice = SLAPD_FILTER_COMPUTED;
f->f_result = SLAPD_COMPARE_UNDEFINED;	vrf->vrf_result = SLAPD_COMPARE_UNDEFINED;
break;	break;
}	}

if ( err != LDAP_SUCCESS ) {	if ( err != LDAP_SUCCESS ) {
if( err != SLAPD_DISCONNECT ) {	if( err != SLAPD_DISCONNECT ) {
/* ignore error */	/* ignore error */
f->f_choice = SLAPD_FILTER_COMPUTED;	vrf->vrf_choice = SLAPD_FILTER_COMPUTED;
f->f_result = SLAPD_COMPARE_UNDEFINED;	vrf->vrf_result = SLAPD_COMPARE_UNDEFINED;
err = LDAP_SUCCESS;	err = LDAP_SUCCESS;
*filt = f;	*filt = vrf;

} else {	} else {
free(f);	free(vrf);
}	}

} else {	} else {
*filt = f;	*filt = vrf;
}	}

#ifdef NEW_LOGGING	#ifdef NEW_LOGGING
Line 994 get_simple_vrFilter(	Line 994 get_simple_vrFilter(

int	int
get_vrFilter( Connection conn, BerElement ber,	get_vrFilter( Connection conn, BerElement ber,
ValuesReturnFilter **f,	ValuesReturnFilter **vrf,
const char **text )	const char **text )
{	{
/*	/*
Line 1026 get_vrFilter( Connection *conn, BerEleme	Line 1026 get_vrFilter( Connection *conn, BerEleme
* matchValue [3] AssertionValue }	* matchValue [3] AssertionValue }
*/	*/

ValuesReturnFilter **new;	ValuesReturnFilter **n;
ber_tag_t tag;	ber_tag_t tag;
ber_len_t len;	ber_len_t len;
char *last;	char *last;
Line 1050 get_vrFilter( Connection *conn, BerEleme	Line 1050 get_vrFilter( Connection *conn, BerEleme
return SLAPD_DISCONNECT;	return SLAPD_DISCONNECT;
}	}

new = f;	n = vrf;
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 ) )
{	{
int err = get_simple_vrFilter( conn, ber, new, text );	int err = get_simple_vrFilter( conn, ber, n, text );
if ( err != LDAP_SUCCESS )	if ( err != LDAP_SUCCESS )
return( err );	return( err );
new = &(*new)->f_next;	n = &(*n)->vrf_next;
}	}
*new = NULL;	*n = NULL;

#ifdef NEW_LOGGING	#ifdef NEW_LOGGING
LDAP_LOG( FILTER, ENTRY,	LDAP_LOG( FILTER, ENTRY,
Line 1071 get_vrFilter( Connection *conn, BerEleme	Line 1072 get_vrFilter( Connection *conn, BerEleme
}	}

void	void
vrFilter_free( ValuesReturnFilter *f )	vrFilter_free( ValuesReturnFilter *vrf )
{	{
ValuesReturnFilter p, next;	ValuesReturnFilter p, next;

if ( f == NULL ) {	if ( vrf == NULL ) {
return;	return;
}	}

for ( p = f; p != NULL; p = next ) {	for ( p = vrf; p != NULL; p = next ) {
next = p->f_next;	next = p->vrf_next;

switch ( f->f_choice ) {	switch ( vrf->vrf_choice ) {
case LDAP_FILTER_PRESENT:	case LDAP_FILTER_PRESENT:
break;	break;

Line 1090 vrFilter_free( ValuesReturnFilter *f )	Line 1091 vrFilter_free( ValuesReturnFilter *f )
case LDAP_FILTER_GE:	case LDAP_FILTER_GE:
case LDAP_FILTER_LE:	case LDAP_FILTER_LE:
case LDAP_FILTER_APPROX:	case LDAP_FILTER_APPROX:
ava_free( f->f_ava, 1 );	ava_free( vrf->vrf_ava, 1 );
break;	break;

case LDAP_FILTER_SUBSTRINGS:	case LDAP_FILTER_SUBSTRINGS:
if ( f->f_sub_initial.bv_val != NULL ) {	if ( vrf->vrf_sub_initial.bv_val != NULL ) {
free( f->f_sub_initial.bv_val );	free( vrf->vrf_sub_initial.bv_val );
}	}
ber_bvarray_free( f->f_sub_any );	ber_bvarray_free( vrf->vrf_sub_any );
if ( f->f_sub_final.bv_val != NULL ) {	if ( vrf->vrf_sub_final.bv_val != NULL ) {
free( f->f_sub_final.bv_val );	free( vrf->vrf_sub_final.bv_val );
}	}
ch_free( f->f_sub );	ch_free( vrf->vrf_sub );
break;	break;

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

case SLAPD_FILTER_COMPUTED:	case SLAPD_FILTER_COMPUTED:
Line 1114 vrFilter_free( ValuesReturnFilter *f )	Line 1115 vrFilter_free( ValuesReturnFilter *f )
default:	default:
#ifdef NEW_LOGGING	#ifdef NEW_LOGGING
LDAP_LOG( FILTER, ERR,	LDAP_LOG( FILTER, ERR,
"filter_free: unknown filter type %lu\n", f->f_choice, 0, 0 );	"filter_free: unknown filter type %lu\n", vrf->vrf_choice, 0, 0 );
#else	#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 );	vrf->vrf_choice, 0, 0 );
#endif	#endif
break;	break;
}	}

free( f );	free( vrf );
}	}
}	}


void	void
vrFilter2bv( ValuesReturnFilter f, struct berval fstr )	vrFilter2bv( ValuesReturnFilter vrf, struct berval fstr )
{	{
ValuesReturnFilter *p;	ValuesReturnFilter *p;
struct berval tmp;	struct berval tmp;
ber_len_t len;	ber_len_t len;

if ( f == NULL ) {	if ( vrf == NULL ) {
ber_str2bv( "No filter!", sizeof("No filter!")-1, 1, fstr );	ber_str2bv( "No filter!", sizeof("No filter!")-1, 1, fstr );
return;	return;
}	}
Line 1144 vrFilter2bv( ValuesReturnFilter *f, stru	Line 1145 vrFilter2bv( ValuesReturnFilter *f, stru

snprintf( fstr->bv_val, fstr->bv_len + 1, "()");	snprintf( fstr->bv_val, fstr->bv_len + 1, "()");

for ( p = f; p != NULL; p = p->f_next ) {	for ( p = vrf; p != NULL; p = p->vrf_next ) {
len = fstr->bv_len;	len = fstr->bv_len;

simple_vrFilter2bv( p, &tmp );	simple_vrFilter2bv( p, &tmp );
Line 1160 vrFilter2bv( ValuesReturnFilter *f, stru	Line 1161 vrFilter2bv( ValuesReturnFilter *f, stru
}	}

static void	static void
simple_vrFilter2bv( ValuesReturnFilter f, struct berval fstr )	simple_vrFilter2bv( ValuesReturnFilter vrf, struct berval fstr )
{	{
struct berval tmp;	struct berval tmp;
ber_len_t len;	ber_len_t len;

if ( f == NULL ) {	if ( vrf == NULL ) {
ber_str2bv( "No filter!", sizeof("No filter!")-1, 1, fstr );	ber_str2bv( "No filter!", sizeof("No filter!")-1, 1, fstr );
return;	return;
}	}

switch ( f->f_choice ) {	switch ( vrf->vrf_choice ) {
case LDAP_FILTER_EQUALITY:	case LDAP_FILTER_EQUALITY:
filter_escape_value( &f->f_av_value, &tmp );	filter_escape_value( &vrf->vrf_av_value, &tmp );

fstr->bv_len = f->f_av_desc->ad_cname.bv_len +	fstr->bv_len = vrf->vrf_av_desc->ad_cname.bv_len +
tmp.bv_len + ( sizeof("(=)") - 1 );	tmp.bv_len + ( sizeof("(=)") - 1 );
fstr->bv_val = malloc( fstr->bv_len + 1 );	fstr->bv_val = malloc( fstr->bv_len + 1 );

snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s=%s)",	snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s=%s)",
f->f_av_desc->ad_cname.bv_val,	vrf->vrf_av_desc->ad_cname.bv_val,
tmp.bv_val );	tmp.bv_val );

ber_memfree( tmp.bv_val );	ber_memfree( tmp.bv_val );
break;	break;

case LDAP_FILTER_GE:	case LDAP_FILTER_GE:
filter_escape_value( &f->f_av_value, &tmp );	filter_escape_value( &vrf->vrf_av_value, &tmp );

fstr->bv_len = f->f_av_desc->ad_cname.bv_len +	fstr->bv_len = vrf->vrf_av_desc->ad_cname.bv_len +
tmp.bv_len + ( sizeof("(>=)") - 1 );	tmp.bv_len + ( sizeof("(>=)") - 1 );
fstr->bv_val = malloc( fstr->bv_len + 1 );	fstr->bv_val = malloc( fstr->bv_len + 1 );

snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s>=%s)",	snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s>=%s)",
f->f_av_desc->ad_cname.bv_val,	vrf->vrf_av_desc->ad_cname.bv_val,
tmp.bv_val );	tmp.bv_val );

ber_memfree( tmp.bv_val );	ber_memfree( tmp.bv_val );
break;	break;

case LDAP_FILTER_LE:	case LDAP_FILTER_LE:
filter_escape_value( &f->f_av_value, &tmp );	filter_escape_value( &vrf->vrf_av_value, &tmp );

fstr->bv_len = f->f_av_desc->ad_cname.bv_len +	fstr->bv_len = vrf->vrf_av_desc->ad_cname.bv_len +
tmp.bv_len + ( sizeof("(<=)") - 1 );	tmp.bv_len + ( sizeof("(<=)") - 1 );
fstr->bv_val = malloc( fstr->bv_len + 1 );	fstr->bv_val = malloc( fstr->bv_len + 1 );

snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s<=%s)",	snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s<=%s)",
f->f_av_desc->ad_cname.bv_val,	vrf->vrf_av_desc->ad_cname.bv_val,
tmp.bv_val );	tmp.bv_val );

ber_memfree( tmp.bv_val );	ber_memfree( tmp.bv_val );
break;	break;

case LDAP_FILTER_APPROX:	case LDAP_FILTER_APPROX:
filter_escape_value( &f->f_av_value, &tmp );	filter_escape_value( &vrf->vrf_av_value, &tmp );

fstr->bv_len = f->f_av_desc->ad_cname.bv_len +	fstr->bv_len = vrf->vrf_av_desc->ad_cname.bv_len +
tmp.bv_len + ( sizeof("(~=)") - 1 );	tmp.bv_len + ( sizeof("(~=)") - 1 );
fstr->bv_val = malloc( fstr->bv_len + 1 );	fstr->bv_val = malloc( fstr->bv_len + 1 );

snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s~=%s)",	snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s~=%s)",
f->f_av_desc->ad_cname.bv_val,	vrf->vrf_av_desc->ad_cname.bv_val,
tmp.bv_val );	tmp.bv_val );
ber_memfree( tmp.bv_val );	ber_memfree( tmp.bv_val );
break;	break;

case LDAP_FILTER_SUBSTRINGS:	case LDAP_FILTER_SUBSTRINGS:
fstr->bv_len = f->f_sub_desc->ad_cname.bv_len +	fstr->bv_len = vrf->vrf_sub_desc->ad_cname.bv_len +
( sizeof("(=*)") - 1 );	( sizeof("(=*)") - 1 );
fstr->bv_val = malloc( fstr->bv_len + 128 );	fstr->bv_val = malloc( fstr->bv_len + 128 );

snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s=*)",	snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s=*)",
f->f_sub_desc->ad_cname.bv_val );	vrf->vrf_sub_desc->ad_cname.bv_val );

if ( f->f_sub_initial.bv_val != NULL ) {	if ( vrf->vrf_sub_initial.bv_val != NULL ) {
len = fstr->bv_len;	len = fstr->bv_len;

filter_escape_value( &f->f_sub_initial, &tmp );	filter_escape_value( &vrf->vrf_sub_initial, &tmp );

fstr->bv_len += tmp.bv_len;	fstr->bv_len += tmp.bv_len;
fstr->bv_val = ch_realloc( fstr->bv_val, fstr->bv_len + 1 );	fstr->bv_val = ch_realloc( fstr->bv_val, fstr->bv_len + 1 );
Line 1249 simple_vrFilter2bv( ValuesReturnFilter *	Line 1250 simple_vrFilter2bv( ValuesReturnFilter *
ber_memfree( tmp.bv_val );	ber_memfree( tmp.bv_val );
}	}

if ( f->f_sub_any != NULL ) {	if ( vrf->vrf_sub_any != NULL ) {
int i;	int i;
for ( i = 0; f->f_sub_any[i].bv_val != NULL; i++ ) {	for ( i = 0; vrf->vrf_sub_any[i].bv_val != NULL; i++ ) {
len = fstr->bv_len;	len = fstr->bv_len;
filter_escape_value( &f->f_sub_any[i], &tmp );	filter_escape_value( &vrf->vrf_sub_any[i], &tmp );

fstr->bv_len += tmp.bv_len + 1;	fstr->bv_len += tmp.bv_len + 1;
fstr->bv_val = ch_realloc( fstr->bv_val, fstr->bv_len + 1 );	fstr->bv_val = ch_realloc( fstr->bv_val, fstr->bv_len + 1 );
Line 1265 simple_vrFilter2bv( ValuesReturnFilter *	Line 1266 simple_vrFilter2bv( ValuesReturnFilter *
}	}
}	}

if ( f->f_sub_final.bv_val != NULL ) {	if ( vrf->vrf_sub_final.bv_val != NULL ) {
len = fstr->bv_len;	len = fstr->bv_len;

filter_escape_value( &f->f_sub_final, &tmp );	filter_escape_value( &vrf->vrf_sub_final, &tmp );

fstr->bv_len += tmp.bv_len;	fstr->bv_len += tmp.bv_len;
fstr->bv_val = ch_realloc( fstr->bv_val, fstr->bv_len + 1 );	fstr->bv_val = ch_realloc( fstr->bv_val, fstr->bv_len + 1 );
Line 1283 simple_vrFilter2bv( ValuesReturnFilter *	Line 1284 simple_vrFilter2bv( ValuesReturnFilter *
break;	break;

case LDAP_FILTER_PRESENT:	case LDAP_FILTER_PRESENT:
fstr->bv_len = f->f_desc->ad_cname.bv_len +	fstr->bv_len = vrf->vrf_desc->ad_cname.bv_len +
( sizeof("(=*)") - 1 );	( sizeof("(=*)") - 1 );
fstr->bv_val = malloc( fstr->bv_len + 1 );	fstr->bv_val = malloc( fstr->bv_len + 1 );

snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s=*)",	snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s=*)",
f->f_desc->ad_cname.bv_val );	vrf->vrf_desc->ad_cname.bv_val );
break;	break;

case LDAP_FILTER_EXT: {	case LDAP_FILTER_EXT: {
struct berval ad;	struct berval ad;
filter_escape_value( &f->f_mr_value, &tmp );	filter_escape_value( &vrf->vrf_mr_value, &tmp );

if ( f->f_mr_desc ) {	if ( vrf->vrf_mr_desc ) {
ad = f->f_mr_desc->ad_cname;	ad = vrf->vrf_mr_desc->ad_cname;
} else {	} else {
ad.bv_len = 0;	ad.bv_len = 0;
ad.bv_val = "";	ad.bv_val = "";
}	}

fstr->bv_len = ad.bv_len +	fstr->bv_len = ad.bv_len +
( f->f_mr_dnattrs ? sizeof(":dn")-1 : 0 ) +	( vrf->vrf_mr_dnattrs ? sizeof(":dn")-1 : 0 ) +
( f->f_mr_rule_text.bv_len ? f->f_mr_rule_text.bv_len+1 : 0 ) +	( vrf->vrf_mr_rule_text.bv_len ? vrf->vrf_mr_rule_text.bv_len+1 : 0 ) +
tmp.bv_len + ( sizeof("(:=)") - 1 );	tmp.bv_len + ( sizeof("(:=)") - 1 );
fstr->bv_val = malloc( fstr->bv_len + 1 );	fstr->bv_val = malloc( fstr->bv_len + 1 );

snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s%s%s%s:=%s)",	snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s%s%s%s:=%s)",
ad.bv_val,	ad.bv_val,
f->f_mr_dnattrs ? ":dn" : "",	vrf->vrf_mr_dnattrs ? ":dn" : "",
f->f_mr_rule_text.bv_len ? ":" : "",	vrf->vrf_mr_rule_text.bv_len ? ":" : "",
f->f_mr_rule_text.bv_len ? f->f_mr_rule_text.bv_val : "",	vrf->vrf_mr_rule_text.bv_len ? vrf->vrf_mr_rule_text.bv_val : "",
tmp.bv_val );	tmp.bv_val );

ber_memfree( tmp.bv_val );	ber_memfree( tmp.bv_val );
Line 1320 simple_vrFilter2bv( ValuesReturnFilter *	Line 1321 simple_vrFilter2bv( ValuesReturnFilter *

case SLAPD_FILTER_COMPUTED:	case SLAPD_FILTER_COMPUTED:
ber_str2bv(	ber_str2bv(
f->f_result == LDAP_COMPARE_FALSE ? "(?=false)" :	vrf->vrf_result == LDAP_COMPARE_FALSE ? "(?=false)" :
f->f_result == LDAP_COMPARE_TRUE ? "(?=true)" :	vrf->vrf_result == LDAP_COMPARE_TRUE ? "(?=true)" :
f->f_result == SLAPD_COMPARE_UNDEFINED ? "(?=undefined)" :	vrf->vrf_result == SLAPD_COMPARE_UNDEFINED ? "(?=undefined)" :
"(?=error)",	"(?=error)",
f->f_result == LDAP_COMPARE_FALSE ? sizeof("(?=false)")-1 :	vrf->vrf_result == LDAP_COMPARE_FALSE ? sizeof("(?=false)")-1 :
f->f_result == LDAP_COMPARE_TRUE ? sizeof("(?=true)")-1 :	vrf->vrf_result == LDAP_COMPARE_TRUE ? sizeof("(?=true)")-1 :
f->f_result == SLAPD_COMPARE_UNDEFINED ? sizeof("(?=undefined)")-1 :	vrf->vrf_result == SLAPD_COMPARE_UNDEFINED ? sizeof("(?=undefined)")-1 :
sizeof("(?=error)")-1,	sizeof("(?=error)")-1,
1, fstr );	1, fstr );
break;	break;
Line 1341 static int	Line 1342 static int
get_substring_vrFilter(	get_substring_vrFilter(
Connection *conn,	Connection *conn,
BerElement *ber,	BerElement *ber,
ValuesReturnFilter *f,	ValuesReturnFilter *vrf,
const char **text )	const char **text )
{	{
ber_tag_t tag;	ber_tag_t tag;
Line 1362 get_substring_vrFilter(	Line 1363 get_substring_vrFilter(
return SLAPD_DISCONNECT;	return SLAPD_DISCONNECT;
}	}

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

if( rc != LDAP_SUCCESS ) {	if( rc != LDAP_SUCCESS ) {
text = NULL;	text = NULL;
ch_free( f->f_sub );	ch_free( vrf->vrf_sub );
f->f_choice = SLAPD_FILTER_COMPUTED;	vrf->vrf_choice = SLAPD_FILTER_COMPUTED;
f->f_result = SLAPD_COMPARE_UNDEFINED;	vrf->vrf_result = SLAPD_COMPARE_UNDEFINED;
return LDAP_SUCCESS;	return LDAP_SUCCESS;
}	}

f->f_sub_initial.bv_val = NULL;	vrf->vrf_sub_initial.bv_val = NULL;
f->f_sub_any = NULL;	vrf->vrf_sub_any = NULL;
f->f_sub_final.bv_val = NULL;	vrf->vrf_sub_final.bv_val = NULL;

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 1423 get_substring_vrFilter(	Line 1424 get_substring_vrFilter(
}	}

/* valiate using equality matching rule validator! */	/* valiate using equality matching rule validator! */
rc = value_validate( f->f_sub_desc->ad_type->sat_equality,	rc = value_validate( vrf->vrf_sub_desc->ad_type->sat_equality,
&value, text );	&value, text );
if( rc != LDAP_SUCCESS ) {	if( rc != LDAP_SUCCESS ) {
goto return_error;	goto return_error;
}	}

rc = value_normalize( f->f_sub_desc, usage,	rc = value_normalize( vrf->vrf_sub_desc, usage,
&value, &bv, text );	&value, &bv, text );
if( rc != LDAP_SUCCESS ) {	if( rc != LDAP_SUCCESS ) {
goto return_error;	goto return_error;
Line 1449 get_substring_vrFilter(	Line 1450 get_substring_vrFilter(
Debug( LDAP_DEBUG_FILTER, " INITIAL\n", 0, 0, 0 );	Debug( LDAP_DEBUG_FILTER, " INITIAL\n", 0, 0, 0 );
#endif	#endif

if ( f->f_sub_initial.bv_val != NULL	if ( vrf->vrf_sub_initial.bv_val != NULL
\|\| f->f_sub_any != NULL	\|\| vrf->vrf_sub_any != NULL
\|\| f->f_sub_final.bv_val != NULL )	\|\| vrf->vrf_sub_final.bv_val != NULL )
{	{
free( value.bv_val );	free( value.bv_val );
goto return_error;	goto return_error;
}	}

f->f_sub_initial = value;	vrf->vrf_sub_initial = value;
break;	break;

case LDAP_SUBSTRING_ANY:	case LDAP_SUBSTRING_ANY:
Line 1468 get_substring_vrFilter(	Line 1469 get_substring_vrFilter(
Debug( LDAP_DEBUG_FILTER, " ANY\n", 0, 0, 0 );	Debug( LDAP_DEBUG_FILTER, " ANY\n", 0, 0, 0 );
#endif	#endif

if ( f->f_sub_final.bv_val != NULL ) {	if ( vrf->vrf_sub_final.bv_val != NULL ) {
free( value.bv_val );	free( value.bv_val );
goto return_error;	goto return_error;
}	}

ber_bvarray_add( &f->f_sub_any, &value );	ber_bvarray_add( &vrf->vrf_sub_any, &value );
break;	break;

case LDAP_SUBSTRING_FINAL:	case LDAP_SUBSTRING_FINAL:
Line 1484 get_substring_vrFilter(	Line 1485 get_substring_vrFilter(
Debug( LDAP_DEBUG_FILTER, " FINAL\n", 0, 0, 0 );	Debug( LDAP_DEBUG_FILTER, " FINAL\n", 0, 0, 0 );
#endif	#endif

if ( f->f_sub_final.bv_val != NULL ) {	if ( vrf->vrf_sub_final.bv_val != NULL ) {
free( value.bv_val );	free( value.bv_val );
goto return_error;	goto return_error;
}	}

f->f_sub_final = value;	vrf->vrf_sub_final = value;
break;	break;

default:	default:
Line 1514 return_error:	Line 1515 return_error:
Debug( LDAP_DEBUG_FILTER, " error=%ld\n",	Debug( LDAP_DEBUG_FILTER, " error=%ld\n",
(long) rc, 0, 0 );	(long) rc, 0, 0 );
#endif	#endif
free( f->f_sub_initial.bv_val );	free( vrf->vrf_sub_initial.bv_val );
ber_bvarray_free( f->f_sub_any );	ber_bvarray_free( vrf->vrf_sub_any );
free( f->f_sub_final.bv_val );	free( vrf->vrf_sub_final.bv_val );
ch_free( f->f_sub );	ch_free( vrf->vrf_sub );
return rc;	return rc;
}	}
}	}

Removed from v.1.72.2.8
changed lines
	Added in v.1.72.2.9