mirror/openldap
2
0
Fork 0
mirror of https://git.openldap.org/openldap/openldap.git synced 2025-03-13 14:27:59 +08:00
Code Issues Packages Projects Releases Wiki Activity

Replace get_filter generation of fstr with filter2bv().

Browse Source
This commit is contained in:
Kurt Zeilenga 2002-03-07 03:13:11 +00:00
parent 025e612920
commit 1880c23029
4 changed files with 242 additions and 238 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

465
servers/slapd/filter.c
View File

@ -18,14 +18,12 @@ static int get_filter_list(
Connection *conn,
BerElement *ber,
Filter **f,
struct berval *fstr,
const char **text );
static int get_substring_filter(
Connection *conn,
BerElement *ber,
Filter *f,
struct berval *fstr,
const char **text );
static int filter_escape_value(
@ -37,19 +35,16 @@ get_filter(
Connection *conn,
BerElement *ber,
Filter **filt,
struct berval *fstr,
const char **text )
{
ber_tag_t tag;
ber_len_t len;
int err;
Filter *f;
struct berval ftmp = { 0, 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
@ -77,11 +72,11 @@ get_filter(
* }
* }
*
* 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
* }
*
*/
@ -97,14 +92,13 @@ get_filter(
f->f_next = NULL;
err = LDAP_SUCCESS;
*fstr = ftmp;
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
@ -114,36 +108,22 @@ get_filter(
}
assert( f->f_ava != NULL );
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->bv_val = ch_malloc( fstr->bv_len + 1 );
sprintf( fstr->bv_val, "(%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
@ -151,26 +131,12 @@ get_filter(
if ( err != LDAP_SUCCESS ) {
break;
}
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->bv_val = ch_malloc( fstr->bv_len + 1 );
sprintf( fstr->bv_val, "(%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
@ -178,21 +144,6 @@ get_filter(
if ( err != LDAP_SUCCESS ) {
break;
}
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->bv_val = ch_malloc( fstr->bv_len + 1 );
sprintf( fstr->bv_val, "(%s<=%s)",
f->f_av_desc->ad_cname.bv_val,
escaped.bv_val );
ber_memfree( escaped.bv_val );
break;
case LDAP_FILTER_PRESENT: {
@ -200,7 +151,7 @@ get_filter(
#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
@ -217,24 +168,15 @@ get_filter(
/* 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;
}
fstr->bv_len = sizeof("(=*)") - 1
+ f->f_desc->ad_cname.bv_len;
fstr->bv_val = ch_malloc( fstr->bv_len + 1);
sprintf( fstr->bv_val, "(%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
@ -242,77 +184,52 @@ get_filter(
if ( err != LDAP_SUCCESS ) {
break;
}
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->bv_val = ch_malloc( fstr->bv_len + 1);
sprintf( fstr->bv_val, "(%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->bv_len = sizeof("(&)") - 1 + ftmp.bv_len;
fstr->bv_val = ch_malloc( fstr->bv_len + 1 );
sprintf( fstr->bv_val, "(&%s)",
ftmp.bv_len ? ftmp.bv_val : "" );
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_or, &ftmp, text );
err = get_filter_list( conn, ber, &f->f_or, text );
if ( err != LDAP_SUCCESS ) {
break;
}
fstr->bv_len = sizeof("(|)") - 1 + ftmp.bv_len;
fstr->bv_val = ch_malloc( fstr->bv_len + 1 );
sprintf( fstr->bv_val, "(|%s)",
ftmp.bv_len ? ftmp.bv_val : "" );
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->bv_len = sizeof("(!)") - 1 + ftmp.bv_len;
fstr->bv_val = ch_malloc( fstr->bv_len + 1 );
sprintf( fstr->bv_val, "(!%s)",
ftmp.bv_len ? ftmp.bv_val : "" );
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
@ -324,54 +241,28 @@ get_filter(
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;
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;
ber_str2bv( "(undefined)", sizeof("(undefined)") - 1,
1, fstr );
break;
}
if ( ftmp.bv_val ) free( ftmp.bv_val );
if ( err != LDAP_SUCCESS ) {
if ( fstr->bv_val != NULL ) {
free( fstr->bv_val );
}
if( err != SLAPD_DISCONNECT ) {
/* ignore error */
f->f_choice = SLAPD_FILTER_COMPUTED;
f->f_result = SLAPD_COMPARE_UNDEFINED;
ber_str2bv( "(badfilter)", sizeof("(badfilter)") - 1,
1, fstr );
err = LDAP_SUCCESS;
*filt = f;
@ -393,7 +284,7 @@ get_filter(
static int
get_filter_list( Connection *conn, BerElement *ber,
Filter **f, struct berval *fstr,
Filter **f,
const char **text )
{
Filter **new;
@ -401,39 +292,27 @@ get_filter_list( Connection *conn, BerElement *ber,
ber_tag_t tag;
ber_len_t len;
char *last;
struct berval ftmp;
#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
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->bv_len ) {
*fstr = ftmp;
} else {
int i = fstr->bv_len;
fstr->bv_len += ftmp.bv_len;
fstr->bv_val = ch_realloc( fstr->bv_val,
fstr->bv_len + 1 );
strcpy( fstr->bv_val+i, ftmp.bv_val );
free( ftmp.bv_val );
}
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
@ -442,12 +321,10 @@ get_filter_list( Connection *conn, BerElement *ber,
static int
get_substring_filter(
Connection *conn,
BerElement *ber,
Filter *f,
struct berval *fstr,
const char **text
)
Connection *conn,
BerElement *ber,
Filter *f,
const char **text )
{
ber_tag_t tag;
ber_len_t len;
@ -460,7 +337,7 @@ get_substring_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
@ -477,7 +354,6 @@ get_substring_filter(
ch_free( f->f_sub );
f->f_choice = SLAPD_FILTER_COMPUTED;
f->f_result = SLAPD_COMPARE_UNDEFINED;
ber_str2bv( "(undefined)", sizeof("(undefined)")-1, 1, fstr );
return LDAP_SUCCESS;
}
@ -485,13 +361,8 @@ get_substring_filter(
f->f_sub_any = NULL;
f->f_sub_final.bv_val = NULL;
fstr->bv_len = sizeof("(=" /*)*/) - 1 +
f->f_sub_desc->ad_cname.bv_len;
fstr->bv_val = ch_malloc( fstr->bv_len + 1 );
sprintf( fstr->bv_val, "(%s=" /*)*/, f->f_sub_desc->ad_cname.bv_val );
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;
@ -524,8 +395,8 @@ get_substring_filter(
#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",
@ -555,8 +426,8 @@ get_substring_filter(
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
@ -570,23 +441,13 @@ get_substring_filter(
}
f->f_sub_initial = value;
if( fstr->bv_val ) {
int i = fstr->bv_len;
filter_escape_value( &value, &escaped );
fstr->bv_len += escaped.bv_len;
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 );
}
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
@ -597,24 +458,13 @@ get_substring_filter(
}
ber_bvarray_add( &f->f_sub_any, &value );
if( fstr->bv_val ) {
int i = fstr->bv_len;
filter_escape_value( &value, &escaped );
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 );
}
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
@ -625,24 +475,13 @@ get_substring_filter(
}
f->f_sub_final = value;
if( fstr->bv_val ) {
int i = fstr->bv_len;
filter_escape_value( &value, &escaped );
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 );
}
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",
@ -654,18 +493,12 @@ get_substring_filter(
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->bv_val ) {
free( fstr->bv_val );
fstr->bv_val = NULL;
fstr->bv_len = 0;
}
free( f->f_sub_initial.bv_val );
ber_bvarray_free( f->f_sub_any );
free( f->f_sub_final.bv_val );
@ -674,20 +507,9 @@ return_error:
}
}
if( fstr->bv_val ) {
int i = fstr->bv_len;
fstr->bv_len += 3;
fstr->bv_val = ch_realloc( fstr->bv_val, fstr->bv_len + 3 );
if ( f->f_sub_final.bv_val == NULL ) {
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 ));
"get_substring_filter: conn %d exit\n", conn->c_connid ));
#else
Debug( LDAP_DEBUG_FILTER, "end get_substring_filter\n", 0, 0, 0 );
#endif
@ -744,10 +566,10 @@ filter_free( Filter *f )
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;
}
@ -772,7 +594,7 @@ filter_print( Filter *f )
filter_escape_value( &f->f_av_value, &escaped );
fprintf( stderr, "(%s=%s)",
f->f_av_desc->ad_cname.bv_val,
escaped.bv_val );
escaped.bv_val );
ber_memfree( escaped.bv_val );
break;
@ -780,7 +602,7 @@ filter_print( Filter *f )
filter_escape_value( &f->f_av_value, &escaped );
fprintf( stderr, "(%s>=%s)",
f->f_av_desc->ad_cname.bv_val,
escaped.bv_val );
escaped.bv_val );
ber_memfree( escaped.bv_val );
break;
@ -788,7 +610,7 @@ filter_print( Filter *f )
filter_escape_value( &f->f_av_value, &escaped );
fprintf( stderr, "(%s<=%s)",
f->f_ava->aa_desc->ad_cname.bv_val,
escaped.bv_val );
escaped.bv_val );
ber_memfree( escaped.bv_val );
break;
@ -796,7 +618,7 @@ filter_print( Filter *f )
filter_escape_value( &f->f_av_value, &escaped );
fprintf( stderr, "(%s~=%s)",
f->f_ava->aa_desc->ad_cname.bv_val,
escaped.bv_val );
escaped.bv_val );
ber_memfree( escaped.bv_val );
break;
@ -836,7 +658,7 @@ filter_print( Filter *f )
case LDAP_FILTER_NOT:
fprintf( stderr, "(%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 );
}
@ -856,9 +678,186 @@ filter_print( Filter *f )
break;
}
}
#endif /* ldap_debug */
void
filter2bv( Filter *f, struct berval *fstr )
{
int i;
Filter *p;
struct berval tmp;
ber_len_t len;
if ( f == NULL ) {
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, &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_GE:
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_LE:
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, &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:
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.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].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.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 );
}
break;
case LDAP_FILTER_PRESENT:
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:
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 ? '|' : '!' );
for ( p = f->f_list; p != NULL; p = p->f_next ) {
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 );
}
break;
case SLAPD_FILTER_COMPUTED:
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:
ber_str2bv( "(?=unknown)", sizeof("(?=unknown)")-1, 1, fstr );
break;
}
}
static int filter_escape_value(
struct berval *in,
struct berval *out )

2
servers/slapd/proto-slap.h
View File

@ -458,11 +458,11 @@ LDAP_SLAPD_F (int) get_filter LDAP_P((
Connection *conn,
BerElement *ber,
Filter **filt,
struct berval *fstr,
const char **text ));
LDAP_SLAPD_F (void) filter_free LDAP_P(( Filter *f ));
LDAP_SLAPD_F (void) filter_print LDAP_P(( Filter *f ));
LDAP_SLAPD_F (void) filter2bv LDAP_P(( Filter *f, struct berval *bv ));
/*
* filterentry.c

11
servers/slapd/search.c
View File

@ -136,7 +136,7 @@ do_search(
#endif
/* filter - returns a "normalized" version */
rc = get_filter( conn, op->o_ber, &filter, &fstr, &text );
rc = get_filter( conn, op->o_ber, &filter, &text );
if( rc != LDAP_SUCCESS ) {
if( rc == SLAPD_DISCONNECT ) {
send_ldap_disconnect( conn, op,
@ -146,13 +146,18 @@ do_search(
NULL, text, NULL, NULL );
}
goto return_results;
} else {
filter2bv( filter, &fstr );
}
#ifdef NEW_LOGGING
LDAP_LOG(( "operation", LDAP_LEVEL_ARGS,
"do_search: conn %d filter: %s\n", conn->c_connid, fstr.bv_val ));
"do_search: conn %d filter: %s\n", conn->c_connid,
fstr.bv_len ? fstr.bv_val : "empty" ));
#else
Debug( LDAP_DEBUG_ARGS, " filter: %s\n", fstr.bv_val, 0, 0 );
Debug( LDAP_DEBUG_ARGS, " filter: %s\n",
fstr.bv_len ? fstr.bv_val : "empty", 0, 0 );
#endif
/* attributes */

2
tests/scripts/test003-search
View File

@ -77,7 +77,7 @@ fi
echo "Testing OR searching..."
$LDAPSEARCH -S "" -b "$BASEDN" -h $LOCALHOST -p $PORT \
'(|(cn=)(undef=*)(objectclass=groupofnames)(sn=jones))' >> $SEARCHOUT 2>&1
'(|(givenName=XX*YY*Z)(cn=)(undef=*)(objectclass=groupofnames)(sn=jones))' >> $SEARCHOUT 2>&1
if test $RC != 0 ; then
echo "ldapsearch failed ($RC)!"
kill -HUP $PID