/* filter.c - routines for parsing and dealing with filters */
/* $OpenLDAP$ */
/*
- * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.
+ * Copyright 1998-2002 The OpenLDAP Foundation, All Rights Reserved.
* COPYING RESTRICTIONS APPLY, see COPYRIGHT file
*/
Connection *conn,
BerElement *ber,
Filter **f,
- char **fstr,
const char **text );
static int get_substring_filter(
Connection *conn,
BerElement *ber,
Filter *f,
- char **fstr,
const char **text );
static int filter_escape_value(
Connection *conn,
BerElement *ber,
Filter **filt,
- char **fstr,
const char **text )
{
ber_tag_t tag;
ber_len_t len;
int err;
Filter *f;
- char *ftmp = NULL;
- struct berval escaped;
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY, "get_filter: conn %d\n",
- conn->c_connid ));
+ conn->c_connid ));
#else
Debug( LDAP_DEBUG_FILTER, "begin get_filter\n", 0, 0, 0 );
#endif
* }
* }
*
- * MatchingRuleAssertion ::= SEQUENCE {
- * matchingRule [1] MatchingRuleId OPTIONAL,
- * type [2] AttributeDescription OPTIONAL,
- * matchValue [3] AssertionValue,
- * dnAttributes [4] BOOLEAN DEFAULT FALSE
+ * MatchingRuleAssertion ::= SEQUENCE {
+ * matchingRule [1] MatchingRuleId OPTIONAL,
+ * type [2] AttributeDescription OPTIONAL,
+ * matchValue [3] AssertionValue,
+ * dnAttributes [4] BOOLEAN DEFAULT FALSE
* }
*
*/
f->f_next = NULL;
err = LDAP_SUCCESS;
- *fstr = NULL;
f->f_choice = tag;
switch ( f->f_choice ) {
case LDAP_FILTER_EQUALITY:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL2,
- "get_filter: conn %d EQUALITY\n", conn->c_connid ));
+ "get_filter: conn %d EQUALITY\n", conn->c_connid ));
#else
Debug( LDAP_DEBUG_FILTER, "EQUALITY\n", 0, 0, 0 );
#endif
}
assert( f->f_ava != NULL );
-
- filter_escape_value( f->f_av_value, &escaped );
-
- *fstr = ch_malloc( sizeof("(=)")
- + f->f_av_desc->ad_cname.bv_len
- + escaped.bv_len );
-
- sprintf( *fstr, "(%s=%s)",
- f->f_av_desc->ad_cname.bv_val,
- escaped.bv_val );
-
- ber_memfree( escaped.bv_val );
break;
case LDAP_FILTER_SUBSTRINGS:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
- "get_filter: conn %d SUBSTRINGS\n", conn->c_connid ));
+ "get_filter: conn %d SUBSTRINGS\n", conn->c_connid ));
#else
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, text );
break;
case LDAP_FILTER_GE:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
- "get_filter: conn %d GE\n", conn->c_connid ));
+ "get_filter: conn %d GE\n", conn->c_connid ));
#else
Debug( LDAP_DEBUG_FILTER, "GE\n", 0, 0, 0 );
#endif
if ( err != LDAP_SUCCESS ) {
break;
}
-
- filter_escape_value( f->f_av_value, &escaped );
-
- *fstr = ch_malloc( sizeof("(>=)")
- + f->f_av_desc->ad_cname.bv_len
- + escaped.bv_len );
-
- sprintf( *fstr, "(%s>=%s)",
- f->f_av_desc->ad_cname.bv_val,
- escaped.bv_val );
-
- ber_memfree( escaped.bv_val );
break;
case LDAP_FILTER_LE:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
- "get_filter: conn %d LE\n", conn->c_connid ));
+ "get_filter: conn %d LE\n", conn->c_connid ));
#else
Debug( LDAP_DEBUG_FILTER, "LE\n", 0, 0, 0 );
#endif
if ( err != LDAP_SUCCESS ) {
break;
}
-
-
- filter_escape_value( f->f_av_value, &escaped );
-
- *fstr = ch_malloc( sizeof("(<=)")
- + f->f_av_desc->ad_cname.bv_len
- + escaped.bv_len );
-
- sprintf( *fstr, "(%s<=%s)",
- f->f_av_desc->ad_cname.bv_val,
- escaped.bv_val );
-
- ber_memfree( escaped.bv_val );
break;
case LDAP_FILTER_PRESENT: {
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
- "get_filter: conn %d PRESENT\n", conn->c_connid ));
+ "get_filter: conn %d PRESENT\n", conn->c_connid ));
#else
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;
*text = "error decoding filter";
break;
/* unrecognized attribute description or other error */
f->f_choice = SLAPD_FILTER_COMPUTED;
f->f_result = LDAP_COMPARE_FALSE;
- *fstr = ch_strdup( "(unrecogized=*)" );
- ch_free( type.bv_val );
err = LDAP_SUCCESS;
break;
}
-
- ch_free( type.bv_val );
-
- *fstr = ch_malloc( sizeof("(=*)")
- + f->f_desc->ad_cname.bv_len );
- sprintf( *fstr, "(%s=*)",
- f->f_desc->ad_cname.bv_val );
-
} break;
case LDAP_FILTER_APPROX:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
- "get_filter: conn %d APPROX\n", conn->c_connid ));
+ "get_filter: conn %d APPROX\n", conn->c_connid ));
#else
Debug( LDAP_DEBUG_FILTER, "APPROX\n", 0, 0, 0 );
#endif
if ( err != LDAP_SUCCESS ) {
break;
}
-
- filter_escape_value( f->f_av_value, &escaped );
-
- *fstr = ch_malloc( sizeof("(~=)")
- + f->f_av_desc->ad_cname.bv_len
- + escaped.bv_len );
-
- sprintf( *fstr, "(%s~=%s)",
- f->f_av_desc->ad_cname.bv_val,
- escaped.bv_val );
-
- ber_memfree( escaped.bv_val );
break;
case LDAP_FILTER_AND:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
- "get_filter: conn %d AND\n", conn->c_connid ));
+ "get_filter: conn %d AND\n", conn->c_connid ));
#else
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, text );
if ( err != LDAP_SUCCESS ) {
break;
}
- *fstr = ch_malloc( sizeof("(&)")
- + ( ftmp == NULL ? 0 : strlen( ftmp ) ) );
- sprintf( *fstr, "(&%s)",
- ftmp == NULL ? "" : ftmp );
break;
case LDAP_FILTER_OR:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
- "get_filter: conn %d OR\n", conn->c_connid ));
+ "get_filter: conn %d OR\n", conn->c_connid ));
#else
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_or, text );
if ( err != LDAP_SUCCESS ) {
break;
}
- *fstr = ch_malloc( sizeof("(!)")
- + ( ftmp == NULL ? 0 : strlen( ftmp ) ) );
- sprintf( *fstr, "(|%s)",
- ftmp == NULL ? "" : ftmp );
break;
case LDAP_FILTER_NOT:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
- "get_filter: conn %d NOT\n", conn->c_connid ));
+ "get_filter: conn %d NOT\n", conn->c_connid ));
#else
Debug( LDAP_DEBUG_FILTER, "NOT\n", 0, 0, 0 );
#endif
(void) ber_skip_tag( ber, &len );
- err = get_filter( conn, ber, &f->f_not, &ftmp, text );
+ err = get_filter( conn, ber, &f->f_not, text );
if ( err != LDAP_SUCCESS ) {
break;
}
- *fstr = ch_malloc( sizeof("(!)")
- + ( ftmp == NULL ? 0 : strlen( ftmp ) ) );
- sprintf( *fstr, "(!%s)",
- ftmp == NULL ? "" : ftmp );
break;
case LDAP_FILTER_EXT:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
- "get_filter: conn %d EXTENSIBLE\n", conn->c_connid ));
+ "get_filter: conn %d EXTENSIBLE\n", conn->c_connid ));
#else
Debug( LDAP_DEBUG_FILTER, "EXTENSIBLE\n", 0, 0, 0 );
#endif
}
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;
default:
(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 ));
+ "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",
- f->f_choice, 0, 0 );
+ f->f_choice, 0, 0 );
#endif
f->f_choice = SLAPD_FILTER_COMPUTED;
f->f_result = SLAPD_COMPARE_UNDEFINED;
- *fstr = ch_strdup( "(undefined)" );
break;
}
- free( ftmp );
-
if ( err != LDAP_SUCCESS ) {
- if ( *fstr != NULL ) {
- free( *fstr );
- }
-
if( err != SLAPD_DISCONNECT ) {
/* ignore error */
f->f_choice = SLAPD_FILTER_COMPUTED;
f->f_result = SLAPD_COMPARE_UNDEFINED;
- *fstr = ch_strdup( "(badfilter)" );
err = LDAP_SUCCESS;
*filt = f;
} else {
free(f);
}
+
} else {
*filt = f;
}
static int
get_filter_list( Connection *conn, BerElement *ber,
- Filter **f, char **fstr,
+ Filter **f,
const char **text )
{
Filter **new;
int err;
ber_tag_t tag;
ber_len_t len;
- char *last, *ftmp;
+ char *last;
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
- "get_filter_list: conn %d start\n", conn->c_connid ));
+ "get_filter_list: conn %d start\n", conn->c_connid ));
#else
Debug( LDAP_DEBUG_FILTER, "begin get_filter_list\n", 0, 0, 0 );
#endif
- *fstr = NULL;
new = f;
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 ) )
{
- err = get_filter( conn, ber, new, &ftmp, text );
+ err = get_filter( conn, ber, new, text );
if ( err != LDAP_SUCCESS )
return( err );
-
- if ( *fstr == NULL ) {
- *fstr = ftmp;
- } else {
- *fstr = ch_realloc( *fstr, strlen( *fstr ) +
- strlen( ftmp ) + 1 );
- strcat( *fstr, ftmp );
- free( ftmp );
- }
new = &(*new)->f_next;
}
*new = NULL;
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
- "get_filter_list: conn %d exit\n", conn->c_connid ));
+ "get_filter_list: conn %d exit\n", conn->c_connid ));
#else
Debug( LDAP_DEBUG_FILTER, "end get_filter_list\n", 0, 0, 0 );
#endif
static int
get_substring_filter(
- Connection *conn,
- BerElement *ber,
- Filter *f,
- char **fstr,
- const char **text
-)
+ Connection *conn,
+ BerElement *ber,
+ Filter *f,
+ const char **text )
{
ber_tag_t tag;
ber_len_t len;
ber_tag_t rc;
- struct berval *value;
- struct berval escaped;
+ struct berval value;
char *last;
- struct berval type;
- struct berval *nvalue;
+ struct berval bv;
*text = "error decoding filter";
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
- "get_substring_filter: conn %d begin\n", conn->c_connid ));
+ "get_substring_filter: conn %d begin\n", conn->c_connid ));
#else
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;
}
f->f_sub = ch_calloc( 1, sizeof(SubstringsAssertion) );
f->f_sub_desc = NULL;
- rc = slap_bv2ad( &type, &f->f_sub_desc, text );
-
- ch_free( type.bv_val );
+ rc = slap_bv2ad( &bv, &f->f_sub_desc, text );
if( rc != LDAP_SUCCESS ) {
text = NULL;
ch_free( f->f_sub );
f->f_choice = SLAPD_FILTER_COMPUTED;
f->f_result = SLAPD_COMPARE_UNDEFINED;
- *fstr = ch_strdup( "(undefined)" );
return LDAP_SUCCESS;
}
- f->f_sub_initial = NULL;
+ f->f_sub_initial.bv_val = NULL;
f->f_sub_any = NULL;
- f->f_sub_final = NULL;
-
- if( fstr ) {
- *fstr = ch_malloc( sizeof("(=" /*)*/) +
- f->f_sub_desc->ad_cname.bv_len );
- sprintf( *fstr, "(%s=" /*)*/, f->f_sub_desc->ad_cname.bv_val );
- }
+ f->f_sub_final.bv_val = NULL;
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;
- rc = ber_scanf( ber, "O", &value );
+ rc = ber_scanf( ber, "m", &value );
if ( rc == LBER_ERROR ) {
rc = SLAPD_DISCONNECT;
goto return_error;
}
- if ( value == NULL || value->bv_len == 0 ) {
- ber_bvfree( value );
+ if ( value.bv_val == NULL || value.bv_len == 0 ) {
rc = LDAP_INVALID_SYNTAX;
goto return_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 ));
+ "get_filter_substring: conn %d unknown substring choice=%ld\n",
+ conn->c_connid, (long)tag ));
#else
Debug( LDAP_DEBUG_FILTER,
" unknown substring choice=%ld\n",
(long) tag, 0, 0 );
#endif
- ber_bvfree( value );
goto return_error;
}
- rc = value_normalize( f->f_sub_desc, usage, value, &nvalue, text );
- ber_bvfree( value );
+ /* valiate using equality matching rule validator! */
+ rc = value_validate( f->f_sub_desc->ad_type->sat_equality,
+ &value, text );
+ if( rc != LDAP_SUCCESS ) {
+ goto return_error;
+ }
+ rc = value_normalize( f->f_sub_desc, usage,
+ &value, &bv, text );
if( rc != LDAP_SUCCESS ) {
goto return_error;
}
- value = nvalue;
+ value = bv;
rc = LDAP_PROTOCOL_ERROR;
case LDAP_SUBSTRING_INITIAL:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
- "get_substring_filter: conn %d INITIAL\n",
- conn->c_connid ));
+ "get_substring_filter: conn %d INITIAL\n",
+ conn->c_connid ));
#else
Debug( LDAP_DEBUG_FILTER, " INITIAL\n", 0, 0, 0 );
#endif
- if ( f->f_sub_initial != NULL
+ if ( f->f_sub_initial.bv_val != NULL
|| f->f_sub_any != NULL
- || f->f_sub_final != NULL )
+ || f->f_sub_final.bv_val != NULL )
{
- ber_bvfree( value );
+ free( value.bv_val );
goto return_error;
}
f->f_sub_initial = value;
-
- if( fstr ) {
- filter_escape_value( value, &escaped );
- *fstr = ch_realloc( *fstr,
- strlen( *fstr ) + escaped.bv_len + 1 );
- strcat( *fstr, escaped.bv_val );
- ber_memfree( escaped.bv_val );
- }
break;
case LDAP_SUBSTRING_ANY:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
- "get_substring_filter: conn %d ANY\n",
- conn->c_connid ));
+ "get_substring_filter: conn %d ANY\n",
+ conn->c_connid ));
#else
Debug( LDAP_DEBUG_FILTER, " ANY\n", 0, 0, 0 );
#endif
- if ( f->f_sub_final != NULL ) {
- ber_bvfree( value );
- goto return_error;
- }
-
- if( ber_bvecadd( &f->f_sub_any, value ) < 0 ) {
- ber_bvfree( value );
+ if ( f->f_sub_final.bv_val != NULL ) {
+ free( value.bv_val );
goto return_error;
}
- if( fstr ) {
- filter_escape_value( value, &escaped );
- *fstr = ch_realloc( *fstr,
- strlen( *fstr ) + escaped.bv_len + 2 );
- strcat( *fstr, "*" );
- strcat( *fstr, escaped.bv_val );
- ber_memfree( escaped.bv_val );
- }
+ ber_bvarray_add( &f->f_sub_any, &value );
break;
case LDAP_SUBSTRING_FINAL:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
- "get_substring_filter: conn %d FINAL\n",
- conn->c_connid ));
+ "get_substring_filter: conn %d FINAL\n",
+ conn->c_connid ));
#else
Debug( LDAP_DEBUG_FILTER, " FINAL\n", 0, 0, 0 );
#endif
- if ( f->f_sub_final != NULL ) {
- ber_bvfree( value );
+ if ( f->f_sub_final.bv_val != NULL ) {
+ free( value.bv_val );
goto return_error;
}
f->f_sub_final = value;
-
- if( fstr ) {
- filter_escape_value( value, &escaped );
- *fstr = ch_realloc( *fstr,
- strlen( *fstr ) + escaped.bv_len + 2 );
- strcat( *fstr, "*" );
- strcat( *fstr, escaped.bv_val );
- ber_memfree( escaped.bv_val );
- }
break;
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 ));
+ "get_substring_filter: conn %d unknown substring type %ld\n",
+ conn->c_connid, (long)tag ));
#else
Debug( LDAP_DEBUG_FILTER,
" unknown substring type=%ld\n",
(long) tag, 0, 0 );
#endif
- ber_bvfree( value );
+ free( value.bv_val );
return_error:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_INFO,
- "get_substring_filter: conn %d error %ld\n",
- conn->c_connid, (long)rc ));
+ "get_substring_filter: conn %d error %ld\n",
+ conn->c_connid, (long)rc ));
#else
Debug( LDAP_DEBUG_FILTER, " error=%ld\n",
(long) rc, 0, 0 );
#endif
- if( fstr ) {
- free( *fstr );
- *fstr = NULL;
- }
-
- ber_bvfree( f->f_sub_initial );
- ber_bvecfree( f->f_sub_any );
- ber_bvfree( f->f_sub_final );
+ free( f->f_sub_initial.bv_val );
+ ber_bvarray_free( f->f_sub_any );
+ free( f->f_sub_final.bv_val );
ch_free( f->f_sub );
return rc;
}
}
- if( fstr ) {
- *fstr = ch_realloc( *fstr, strlen( *fstr ) + 3 );
- if ( f->f_sub_final == NULL ) {
- strcat( *fstr, "*" );
- }
- strcat( *fstr, /*(*/ ")" );
- }
-
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
- "get_substring_filter: conn %d exit\n", conn->c_connid ));
+ "get_substring_filter: conn %d exit\n", conn->c_connid ));
#else
Debug( LDAP_DEBUG_FILTER, "end get_substring_filter\n", 0, 0, 0 );
#endif
break;
case LDAP_FILTER_SUBSTRINGS:
- if ( f->f_sub_initial != NULL ) {
- ber_bvfree( f->f_sub_initial );
+ if ( f->f_sub_initial.bv_val != NULL ) {
+ free( f->f_sub_initial.bv_val );
}
- ber_bvecfree( f->f_sub_any );
- if ( f->f_sub_final != NULL ) {
- ber_bvfree( f->f_sub_final );
+ ber_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_EXT:
+ mra_free( f->f_mra, 1 );
+ break;
+
case SLAPD_FILTER_COMPUTED:
break;
default:
#ifdef NEW_LOGGING
LDAP_LOG(( "filter", LDAP_LEVEL_ERR,
- "filter_free: unknown filter type %lu\n", f->f_choice ));
+ "filter_free: unknown filter type %lu\n", f->f_choice ));
#else
Debug( LDAP_DEBUG_ANY, "filter_free: unknown filter type=%lu\n",
- f->f_choice, 0, 0 );
+ f->f_choice, 0, 0 );
#endif
break;
}
free( f );
}
-#ifdef LDAP_DEBUG
void
-filter_print( Filter *f )
+filter2bv( Filter *f, struct berval *fstr )
{
int i;
Filter *p;
- struct berval escaped;
+ struct berval tmp;
+ ber_len_t len;
if ( f == NULL ) {
- fprintf( stderr, "No filter!" );
+ ber_str2bv( "No filter!", sizeof("No filter!")-1, 1, fstr );
+ return;
}
switch ( f->f_choice ) {
case LDAP_FILTER_EQUALITY:
- filter_escape_value( f->f_av_value, &escaped );
- fprintf( stderr, "(%s=%s)",
+ filter_escape_value( &f->f_av_value, &tmp );
+
+ fstr->bv_len = f->f_av_desc->ad_cname.bv_len +
+ tmp.bv_len + ( sizeof("(=)") - 1 );
+ fstr->bv_val = malloc( fstr->bv_len + 1 );
+
+ snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s=%s)",
f->f_av_desc->ad_cname.bv_val,
- escaped.bv_val );
- ber_memfree( escaped.bv_val );
+ tmp.bv_val );
+
+ ber_memfree( tmp.bv_val );
break;
case LDAP_FILTER_GE:
- filter_escape_value( f->f_av_value, &escaped );
- fprintf( stderr, "(%s>=%s)",
+ filter_escape_value( &f->f_av_value, &tmp );
+
+ fstr->bv_len = f->f_av_desc->ad_cname.bv_len +
+ tmp.bv_len + ( sizeof("(>=)") - 1 );
+ fstr->bv_val = malloc( fstr->bv_len + 1 );
+
+ snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s>=%s)",
f->f_av_desc->ad_cname.bv_val,
- escaped.bv_val );
- ber_memfree( escaped.bv_val );
+ tmp.bv_val );
+
+ ber_memfree( tmp.bv_val );
break;
case LDAP_FILTER_LE:
- filter_escape_value( f->f_av_value, &escaped );
- fprintf( stderr, "(%s<=%s)",
- f->f_ava->aa_desc->ad_cname.bv_val,
- escaped.bv_val );
- ber_memfree( escaped.bv_val );
+ filter_escape_value( &f->f_av_value, &tmp );
+
+ fstr->bv_len = f->f_av_desc->ad_cname.bv_len +
+ tmp.bv_len + ( sizeof("(<=)") - 1 );
+ fstr->bv_val = malloc( fstr->bv_len + 1 );
+
+ snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s<=%s)",
+ f->f_av_desc->ad_cname.bv_val,
+ tmp.bv_val );
+
+ ber_memfree( tmp.bv_val );
break;
case LDAP_FILTER_APPROX:
- filter_escape_value( f->f_av_value, &escaped );
- fprintf( stderr, "(%s~=%s)",
- f->f_ava->aa_desc->ad_cname.bv_val,
- escaped.bv_val );
- ber_memfree( escaped.bv_val );
+ filter_escape_value( &f->f_av_value, &tmp );
+
+ fstr->bv_len = f->f_av_desc->ad_cname.bv_len +
+ tmp.bv_len + ( sizeof("(~=)") - 1 );
+ fstr->bv_val = malloc( fstr->bv_len + 1 );
+
+ snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s~=%s)",
+ f->f_av_desc->ad_cname.bv_val,
+ tmp.bv_val );
+ ber_memfree( tmp.bv_val );
break;
case LDAP_FILTER_SUBSTRINGS:
- fprintf( stderr, "(%s=" /*)*/,
+ fstr->bv_len = f->f_sub_desc->ad_cname.bv_len +
+ ( sizeof("(=*)") - 1 );
+ fstr->bv_val = malloc( fstr->bv_len + 128 );
+
+ snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s=*)",
f->f_sub_desc->ad_cname.bv_val );
- if ( f->f_sub_initial != NULL ) {
- filter_escape_value( f->f_sub_initial, &escaped );
- fprintf( stderr, "%s",
- escaped.bv_val );
- ber_memfree( escaped.bv_val );
+
+ if ( f->f_sub_initial.bv_val != NULL ) {
+ len = fstr->bv_len;
+
+ filter_escape_value( &f->f_sub_initial, &tmp );
+
+ fstr->bv_len += tmp.bv_len;
+ fstr->bv_val = ch_realloc( fstr->bv_val, fstr->bv_len + 1 );
+
+ snprintf( &fstr->bv_val[len-2], tmp.bv_len+3,
+ /* "(attr=" */ "%s*)",
+ tmp.bv_val );
+
+ ber_memfree( tmp.bv_val );
}
+
if ( f->f_sub_any != NULL ) {
- for ( i = 0; f->f_sub_any[i] != NULL; i++ ) {
- filter_escape_value( f->f_sub_any[i], &escaped );
- fprintf( stderr, "*%s",
- escaped.bv_val );
- ber_memfree( escaped.bv_val );
+ for ( i = 0; f->f_sub_any[i].bv_val != NULL; i++ ) {
+ len = fstr->bv_len;
+ filter_escape_value( &f->f_sub_any[i], &tmp );
+
+ fstr->bv_len += tmp.bv_len + 1;
+ fstr->bv_val = ch_realloc( fstr->bv_val, fstr->bv_len + 1 );
+
+ snprintf( &fstr->bv_val[len-1], tmp.bv_len+3,
+ /* "(attr=[init]*[any*]" */ "%s*)",
+ tmp.bv_val );
+ ber_memfree( tmp.bv_val );
}
}
- if ( f->f_sub_final != NULL ) {
- filter_escape_value( f->f_sub_final, &escaped );
- fprintf( stderr,
- "*%s", escaped.bv_val );
- ber_memfree( escaped.bv_val );
+
+ if ( f->f_sub_final.bv_val != NULL ) {
+ len = fstr->bv_len;
+
+ filter_escape_value( &f->f_sub_final, &tmp );
+
+ fstr->bv_len += tmp.bv_len;
+ fstr->bv_val = ch_realloc( fstr->bv_val, fstr->bv_len + 1 );
+
+ snprintf( &fstr->bv_val[len-1], tmp.bv_len+3,
+ /* "(attr=[init*][any*]" */ "%s)",
+ tmp.bv_val );
+
+ ber_memfree( tmp.bv_val );
}
- fprintf( stderr, /*(*/ ")" );
+
break;
case LDAP_FILTER_PRESENT:
- fprintf( stderr, "(%s=*)",
+ fstr->bv_len = f->f_desc->ad_cname.bv_len +
+ ( sizeof("(=*)") - 1 );
+ fstr->bv_val = malloc( fstr->bv_len + 1 );
+
+ snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s=*)",
f->f_desc->ad_cname.bv_val );
break;
case LDAP_FILTER_AND:
case LDAP_FILTER_OR:
case LDAP_FILTER_NOT:
- fprintf( stderr, "(%c" /*)*/,
+ fstr->bv_len = sizeof("(%)") - 1;
+ fstr->bv_val = malloc( fstr->bv_len + 128 );
+
+ snprintf( fstr->bv_val, fstr->bv_len + 1, "(%c)",
f->f_choice == LDAP_FILTER_AND ? '&' :
- f->f_choice == LDAP_FILTER_OR ? '|' : '!' );
+ f->f_choice == LDAP_FILTER_OR ? '|' : '!' );
+
for ( p = f->f_list; p != NULL; p = p->f_next ) {
- filter_print( p );
+ len = fstr->bv_len;
+
+ filter2bv( p, &tmp );
+
+ fstr->bv_len += tmp.bv_len;
+ fstr->bv_val = ch_realloc( fstr->bv_val, fstr->bv_len + 1 );
+
+ snprintf( &fstr->bv_val[len-1], tmp.bv_len + 2,
+ /*"("*/ "%s)", tmp.bv_val );
+
+ ch_free( tmp.bv_val );
}
- fprintf( stderr, /*(*/ ")" );
+
+ break;
+
+ case LDAP_FILTER_EXT:
+ filter_escape_value( &f->f_mr_value, &tmp );
+
+ fstr->bv_len = f->f_mr_desc->ad_cname.bv_len +
+ ( f->f_mr_dnattrs ? sizeof(":dn")-1 : 0 ) +
+ ( f->f_mr_rule_text.bv_len ? f->f_mr_rule_text.bv_len+1 : 0 ) +
+ tmp.bv_len + ( sizeof("(:=)") - 1 );
+ fstr->bv_val = malloc( fstr->bv_len + 1 );
+
+ snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s%s%s%s:=%s)",
+ 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 : "",
+ tmp.bv_val );
+ ber_memfree( tmp.bv_val );
break;
case SLAPD_FILTER_COMPUTED:
- fprintf( stderr, "(?=%s)",
- f->f_result == LDAP_COMPARE_FALSE ? "false" :
- f->f_result == LDAP_COMPARE_TRUE ? "true" :
- f->f_result == SLAPD_COMPARE_UNDEFINED ? "undefined" :
- "error" );
+ ber_str2bv(
+ f->f_result == LDAP_COMPARE_FALSE ? "(?=false)" :
+ f->f_result == LDAP_COMPARE_TRUE ? "(?=true)" :
+ f->f_result == SLAPD_COMPARE_UNDEFINED ? "(?=undefined)" :
+ "(?=error)",
+ f->f_result == LDAP_COMPARE_FALSE ? sizeof("(?=false)")-1 :
+ f->f_result == LDAP_COMPARE_TRUE ? sizeof("(?=true)")-1 :
+ f->f_result == SLAPD_COMPARE_UNDEFINED ? sizeof("(?=undefined)")-1 :
+ sizeof("(?=error)")-1,
+ 1, fstr );
break;
default:
- fprintf( stderr, "(unknown-filter=%lu)", f->f_choice );
+ ber_str2bv( "(?=unknown)", sizeof("(?=unknown)")-1, 1, fstr );
break;
}
}
-#endif /* ldap_debug */
-
static int filter_escape_value(
struct berval *in,
struct berval *out )