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