--- servers/slapd/filter.c 2004/05/19 17:39:40 1.123 +++ servers/slapd/filter.c 2009/08/13 00:48:32 1.134.2.17 @@ -1,8 +1,8 @@ /* filter.c - routines for parsing and dealing with filters */ -/* $OpenLDAP: pkg/ldap/servers/slapd/filter.c,v 1.122 2004/04/20 01:44:57 kurt Exp $ */ +/* $OpenLDAP: pkg/ldap/servers/slapd/filter.c,v 1.134.2.16 2009/01/22 00:01:01 kurt Exp $ */ /* This work is part of OpenLDAP Software . * - * Copyright 1998-2004 The OpenLDAP Foundation. + * Copyright 1998-2009 The OpenLDAP Foundation. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -32,6 +32,10 @@ #include #include "slap.h" +#include "lutil.h" + +const Filter *slap_filter_objectClass_pres; +const struct berval *slap_filterstr_objectClass_pres; static int get_filter_list( Operation *op, @@ -42,14 +46,9 @@ static int get_filter_list( static int get_ssa( Operation *op, BerElement *ber, - SubstringsAssertion **s, + Filter *f, const char **text ); -static int filter_escape_value_x( - struct berval *in, - struct berval *out, - void *ctx ); - static void simple_vrFilter2bv( Operation *op, ValuesReturnFilter *f, @@ -62,6 +61,26 @@ static int get_simple_vrFilter( const char **text ); int +filter_init( void ) +{ + static Filter filter_objectClass_pres = { LDAP_FILTER_PRESENT }; + static struct berval filterstr_objectClass_pres = BER_BVC("(objectClass=*)"); + + filter_objectClass_pres.f_desc = slap_schema.si_ad_objectClass; + + slap_filter_objectClass_pres = &filter_objectClass_pres; + slap_filterstr_objectClass_pres = &filterstr_objectClass_pres; + + return 0; +} + +void +filter_destroy( void ) +{ + return; +} + +int get_filter( Operation *op, BerElement *ber, @@ -73,11 +92,7 @@ get_filter( int err; Filter f; -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, ENTRY, "get_filter: conn %d\n", op->o_connid, 0, 0 ); -#else Debug( LDAP_DEBUG_FILTER, "begin get_filter\n", 0, 0, 0 ); -#endif /* * A filter looks like this coming in: * Filter ::= CHOICE { @@ -88,8 +103,8 @@ get_filter( * substrings [4] SubstringFilter, * greaterOrEqual [5] AttributeValueAssertion, * lessOrEqual [6] AttributeValueAssertion, - * present [7] AttributeType,, - * approxMatch [8] AttributeValueAssertion + * present [7] AttributeType, + * approxMatch [8] AttributeValueAssertion, * extensibleMatch [9] MatchingRuleAssertion * } * @@ -125,13 +140,8 @@ get_filter( switch ( f.f_choice ) { case LDAP_FILTER_EQUALITY: -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, DETAIL2, - "get_filter: conn %d EQUALITY\n", op->o_connid, 0, 0 ); -#else Debug( LDAP_DEBUG_FILTER, "EQUALITY\n", 0, 0, 0 ); -#endif - err = get_ava( op, ber, &f.f_ava, SLAP_MR_EQUALITY, text ); + err = get_ava( op, ber, &f, SLAP_MR_EQUALITY, text ); if ( err != LDAP_SUCCESS ) { break; } @@ -140,13 +150,8 @@ get_filter( break; case LDAP_FILTER_SUBSTRINGS: -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, DETAIL1, - "get_filter: conn %d SUBSTRINGS\n", op->o_connid, 0, 0 ); -#else Debug( LDAP_DEBUG_FILTER, "SUBSTRINGS\n", 0, 0, 0 ); -#endif - err = get_ssa( op, ber, &f.f_sub, text ); + err = get_ssa( op, ber, &f, text ); if( err != LDAP_SUCCESS ) { break; } @@ -154,13 +159,8 @@ get_filter( break; case LDAP_FILTER_GE: -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, DETAIL1, - "get_filter: conn %d GE\n", op->o_connid, 0, 0 ); -#else Debug( LDAP_DEBUG_FILTER, "GE\n", 0, 0, 0 ); -#endif - err = get_ava( op, ber, &f.f_ava, SLAP_MR_ORDERING, text ); + err = get_ava( op, ber, &f, SLAP_MR_ORDERING, text ); if ( err != LDAP_SUCCESS ) { break; } @@ -168,13 +168,8 @@ get_filter( break; case LDAP_FILTER_LE: -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, DETAIL1, - "get_filter: conn %d LE\n", op->o_connid, 0, 0 ); -#else Debug( LDAP_DEBUG_FILTER, "LE\n", 0, 0, 0 ); -#endif - err = get_ava( op, ber, &f.f_ava, SLAP_MR_ORDERING, text ); + err = get_ava( op, ber, &f, SLAP_MR_ORDERING, text ); if ( err != LDAP_SUCCESS ) { break; } @@ -184,12 +179,7 @@ get_filter( case LDAP_FILTER_PRESENT: { struct berval type; -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, DETAIL1, - "get_filter: conn %d PRESENT\n", op->o_connid, 0, 0 ); -#else Debug( LDAP_DEBUG_FILTER, "PRESENT\n", 0, 0, 0 ); -#endif if ( ber_scanf( ber, "m", &type ) == LBER_ERROR ) { err = SLAPD_DISCONNECT; *text = "error decoding filter"; @@ -200,37 +190,29 @@ get_filter( err = slap_bv2ad( &type, &f.f_desc, text ); if( err != LDAP_SUCCESS ) { - /* unrecognized attribute description or other error */ -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, ERR, - "get_filter: conn %d unknown attribute " - "type=%s (%d)\n", - op->o_connid, type.bv_val, err ); -#else - Debug( LDAP_DEBUG_ANY, - "get_filter: conn %d unknown attribute " - "type=%s (%d)\n", - op->o_connid, type.bv_val, err ); -#endif + f.f_choice |= SLAPD_FILTER_UNDEFINED; + err = slap_bv2undef_ad( &type, &f.f_desc, text, + SLAP_AD_PROXIED|SLAP_AD_NOINSERT ); + + if ( err != LDAP_SUCCESS ) { + /* unrecognized attribute description or other error */ + Debug( LDAP_DEBUG_ANY, + "get_filter: conn %lu unknown attribute " + "type=%s (%d)\n", + op->o_connid, type.bv_val, err ); - f.f_choice = SLAPD_FILTER_COMPUTED; - f.f_result = LDAP_COMPARE_FALSE; - err = LDAP_SUCCESS; + err = LDAP_SUCCESS; + f.f_desc = slap_bv2tmp_ad( &type, op->o_tmpmemctx ); + } *text = NULL; - break; } assert( f.f_desc != NULL ); } break; case LDAP_FILTER_APPROX: -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, DETAIL1, - "get_filter: conn %d APPROX\n", op->o_connid, 0, 0 ); -#else Debug( LDAP_DEBUG_FILTER, "APPROX\n", 0, 0, 0 ); -#endif - err = get_ava( op, ber, &f.f_ava, SLAP_MR_EQUALITY_APPROX, text ); + err = get_ava( op, ber, &f, SLAP_MR_EQUALITY_APPROX, text ); if ( err != LDAP_SUCCESS ) { break; } @@ -238,12 +220,7 @@ get_filter( break; case LDAP_FILTER_AND: -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, DETAIL1, - "get_filter: conn %d AND\n", op->o_connid, 0, 0 ); -#else Debug( LDAP_DEBUG_FILTER, "AND\n", 0, 0, 0 ); -#endif err = get_filter_list( op, ber, &f.f_and, text ); if ( err != LDAP_SUCCESS ) { break; @@ -256,12 +233,7 @@ get_filter( break; case LDAP_FILTER_OR: -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, DETAIL1, - "get_filter: conn %d OR\n", op->o_connid, 0, 0 ); -#else Debug( LDAP_DEBUG_FILTER, "OR\n", 0, 0, 0 ); -#endif err = get_filter_list( op, ber, &f.f_or, text ); if ( err != LDAP_SUCCESS ) { break; @@ -274,12 +246,7 @@ get_filter( break; case LDAP_FILTER_NOT: -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, DETAIL1, - "get_filter: conn %d NOT\n", op->o_connid, 0, 0 ); -#else Debug( LDAP_DEBUG_FILTER, "NOT\n", 0, 0, 0 ); -#endif (void) ber_skip_tag( ber, &len ); err = get_filter( op, ber, &f.f_not, text ); if ( err != LDAP_SUCCESS ) { @@ -307,14 +274,9 @@ get_filter( break; case LDAP_FILTER_EXT: -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, DETAIL1, - "get_filter: conn %d EXTENSIBLE\n", op->o_connid, 0, 0 ); -#else Debug( LDAP_DEBUG_FILTER, "EXTENSIBLE\n", 0, 0, 0 ); -#endif - err = get_mra( op, ber, &f.f_mra, text ); + err = get_mra( op, ber, &f, text ); if ( err != LDAP_SUCCESS ) { break; } @@ -324,14 +286,8 @@ get_filter( default: (void) ber_scanf( ber, "x" ); /* skip the element */ -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, ERR, - "get_filter: conn %d unknown filter type=%lu\n", - op->o_connid, f.f_choice, 0 ); -#else Debug( LDAP_DEBUG_ANY, "get_filter: unknown filter type=%lu\n", f.f_choice, 0, 0 ); -#endif f.f_choice = SLAPD_FILTER_COMPUTED; f.f_result = SLAPD_COMPARE_UNDEFINED; break; @@ -350,12 +306,7 @@ get_filter( **filt = f; } -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, DETAIL2, - "get_filter: conn %d exit\n", op->o_connid, 0, 0 ); -#else Debug( LDAP_DEBUG_FILTER, "end get_filter %d\n", err, 0, 0 ); -#endif return( err ); } @@ -371,12 +322,7 @@ get_filter_list( Operation *op, BerEleme ber_len_t len; char *last; -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, ENTRY, - "get_filter_list: conn %d start\n", op->o_connid, 0, 0 ); -#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; @@ -389,12 +335,7 @@ get_filter_list( Operation *op, BerEleme } *new = NULL; -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, ENTRY, - "get_filter_list: conn %d exit\n", op->o_connid, 0, 0 ); -#else Debug( LDAP_DEBUG_FILTER, "end get_filter_list\n", 0, 0, 0 ); -#endif return( LDAP_SUCCESS ); } @@ -402,25 +343,19 @@ static int get_ssa( Operation *op, BerElement *ber, - SubstringsAssertion **out, + Filter *f, const char **text ) { ber_tag_t tag; ber_len_t len; - ber_tag_t rc; + int rc; struct berval desc, value, nvalue; char *last; SubstringsAssertion ssa; *text = "error decoding filter"; - *out = NULL; -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, ENTRY, - "get_ssa: conn %d begin\n", op->o_connid, 0, 0 ); -#else Debug( LDAP_DEBUG_FILTER, "begin get_ssa\n", 0, 0, 0 ); -#endif if ( ber_scanf( ber, "{m" /*}*/, &desc ) == LBER_ERROR ) { return SLAPD_DISCONNECT; } @@ -435,27 +370,32 @@ get_ssa( rc = slap_bv2ad( &desc, &ssa.sa_desc, text ); if( rc != LDAP_SUCCESS ) { -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, ERR, - "get_ssa: conn %d d unknown attribute type=%s (%d)\n", - op->o_connid, desc.bv_val, rc ); -#else - Debug( LDAP_DEBUG_ANY, - "get_ssa: conn %d unknown attribute type=%s (%d)\n", - op->o_connid, desc.bv_val, rc ); -#endif - - /* skip over the rest of this filter */ - for ( tag = ber_first_element( ber, &len, &last ); - tag != LBER_DEFAULT; - tag = ber_next_element( ber, &len, last ) ) { - ber_scanf( ber, "x" ); + f->f_choice |= SLAPD_FILTER_UNDEFINED; + rc = slap_bv2undef_ad( &desc, &ssa.sa_desc, text, + SLAP_AD_PROXIED|SLAP_AD_NOINSERT ); + + if( rc != LDAP_SUCCESS ) { + Debug( LDAP_DEBUG_ANY, + "get_ssa: conn %lu unknown attribute type=%s (%ld)\n", + op->o_connid, desc.bv_val, (long) rc ); + + ssa.sa_desc = slap_bv2tmp_ad( &desc, op->o_tmpmemctx ); } - return rc; } rc = LDAP_PROTOCOL_ERROR; + /* If there is no substring matching rule, there's nothing + * we can do with this filter. But we continue to parse it + * for logging purposes. + */ + if ( ssa.sa_desc->ad_type->sat_substr == NULL ) { + f->f_choice |= SLAPD_FILTER_UNDEFINED; + Debug( LDAP_DEBUG_FILTER, + "get_ssa: no substring matching rule for attributeType %s\n", + desc.bv_val, 0, 0 ); + } + for ( tag = ber_first_element( ber, &len, &last ); tag != LBER_DEFAULT; tag = ber_next_element( ber, &len, last ) ) @@ -475,30 +415,39 @@ get_ssa( switch ( tag ) { case LDAP_SUBSTRING_INITIAL: + if ( ssa.sa_initial.bv_val != NULL + || ssa.sa_any != NULL + || ssa.sa_final.bv_val != NULL ) + { + rc = LDAP_PROTOCOL_ERROR; + goto return_error; + } usage = SLAP_MR_SUBSTR_INITIAL; break; case LDAP_SUBSTRING_ANY: + if ( ssa.sa_final.bv_val != NULL ) { + rc = LDAP_PROTOCOL_ERROR; + goto return_error; + } usage = SLAP_MR_SUBSTR_ANY; break; case LDAP_SUBSTRING_FINAL: + if ( ssa.sa_final.bv_val != NULL ) { + rc = LDAP_PROTOCOL_ERROR; + goto return_error; + } + usage = SLAP_MR_SUBSTR_FINAL; break; default: - rc = LDAP_PROTOCOL_ERROR; - -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, ERR, - "get_filter_substring: conn %d unknown substring choice=%ld\n", - op->o_connid, (long)tag, 0 ); -#else Debug( LDAP_DEBUG_FILTER, " unknown substring choice=%ld\n", (long) tag, 0, 0 ); -#endif + rc = LDAP_PROTOCOL_ERROR; goto return_error; } @@ -506,117 +455,61 @@ get_ssa( rc = asserted_value_validate_normalize( ssa.sa_desc, ssa.sa_desc->ad_type->sat_equality, usage, &value, &nvalue, text, op->o_tmpmemctx ); - if( rc != LDAP_SUCCESS ) { - goto return_error; + f->f_choice |= SLAPD_FILTER_UNDEFINED; + Debug( LDAP_DEBUG_FILTER, + "get_ssa: illegal value for attributeType %s (%d) %s\n", + desc.bv_val, rc, *text ); + ber_dupbv_x( &nvalue, &value, op->o_tmpmemctx ); } - rc = LDAP_PROTOCOL_ERROR; - switch ( tag ) { case LDAP_SUBSTRING_INITIAL: -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, DETAIL1, - "get_ssa: conn %d INITIAL\n", - op->o_connid, 0, 0 ); -#else Debug( LDAP_DEBUG_FILTER, " INITIAL\n", 0, 0, 0 ); -#endif - - if ( ssa.sa_initial.bv_val != NULL - || ssa.sa_any != NULL - || ssa.sa_final.bv_val != NULL ) - { - slap_sl_free( nvalue.bv_val, op->o_tmpmemctx ); - goto return_error; - } - ssa.sa_initial = nvalue; break; case LDAP_SUBSTRING_ANY: -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, DETAIL1, - "get_ssa: conn %d ANY\n", - op->o_connid, 0, 0 ); -#else Debug( LDAP_DEBUG_FILTER, " ANY\n", 0, 0, 0 ); -#endif - - if ( ssa.sa_final.bv_val != NULL ) { - slap_sl_free( nvalue.bv_val, op->o_tmpmemctx ); - goto return_error; - } - ber_bvarray_add_x( &ssa.sa_any, &nvalue, op->o_tmpmemctx ); break; case LDAP_SUBSTRING_FINAL: -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, DETAIL1, - "get_ssa: conn %d FINAL\n", - op->o_connid, 0, 0 ); -#else Debug( LDAP_DEBUG_FILTER, " FINAL\n", 0, 0, 0 ); -#endif - - if ( ssa.sa_final.bv_val != NULL ) { - slap_sl_free( nvalue.bv_val, op->o_tmpmemctx ); - goto return_error; - } - ssa.sa_final = nvalue; break; default: -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, INFO, - "get_ssa: conn %d unknown substring type %ld\n", - op->o_connid, (long)tag, 0 ); -#else - Debug( LDAP_DEBUG_FILTER, - " unknown substring type=%ld\n", - (long) tag, 0, 0 ); -#endif - assert( 0 ); slap_sl_free( nvalue.bv_val, op->o_tmpmemctx ); + rc = LDAP_PROTOCOL_ERROR; return_error: -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, INFO, - "get_ssa: conn %d error %ld\n", - op->o_connid, (long)rc, 0 ); -#else Debug( LDAP_DEBUG_FILTER, " error=%ld\n", (long) rc, 0, 0 ); -#endif slap_sl_free( ssa.sa_initial.bv_val, op->o_tmpmemctx ); ber_bvarray_free_x( ssa.sa_any, op->o_tmpmemctx ); + if ( ssa.sa_desc->ad_flags & SLAP_DESC_TEMPORARY ) + op->o_tmpfree( ssa.sa_desc, op->o_tmpmemctx ); slap_sl_free( ssa.sa_final.bv_val, op->o_tmpmemctx ); return rc; } + *text = NULL; rc = LDAP_SUCCESS; } if( rc == LDAP_SUCCESS ) { - *out = op->o_tmpalloc( sizeof( ssa ), op->o_tmpmemctx ); - **out = ssa; + f->f_sub = op->o_tmpalloc( sizeof( ssa ), op->o_tmpmemctx ); + *f->f_sub = ssa; } -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, ENTRY, - "get_ssa: conn %d exit\n", op->o_connid, 0, 0 ); -#else Debug( LDAP_DEBUG_FILTER, "end get_ssa\n", 0, 0, 0 ); -#endif - return rc /* LDAP_SUCCESS */ ; } void -filter_free_x( Operation *op, Filter *f ) +filter_free_x( Operation *op, Filter *f, int freeme ) { Filter *p, *next; @@ -624,6 +517,8 @@ filter_free_x( Operation *op, Filter *f return; } + f->f_choice &= SLAPD_FILTER_MASK; + switch ( f->f_choice ) { case LDAP_FILTER_PRESENT: break; @@ -643,6 +538,8 @@ filter_free_x( Operation *op, Filter *f if ( f->f_sub_final.bv_val != NULL ) { op->o_tmpfree( f->f_sub_final.bv_val, op->o_tmpmemctx ); } + if ( f->f_sub->sa_desc->ad_flags & SLAP_DESC_TEMPORARY ) + op->o_tmpfree( f->f_sub->sa_desc, op->o_tmpmemctx ); op->o_tmpfree( f->f_sub, op->o_tmpmemctx ); break; @@ -651,7 +548,7 @@ filter_free_x( Operation *op, Filter *f case LDAP_FILTER_NOT: for ( p = f->f_list; p != NULL; p = next ) { next = p->f_next; - filter_free_x( op, p ); + filter_free_x( op, p, 1 ); } break; @@ -663,27 +560,26 @@ filter_free_x( Operation *op, Filter *f break; default: -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, ERR, - "filter_free: unknown filter type %lu\n", f->f_choice, 0, 0 ); -#else Debug( LDAP_DEBUG_ANY, "filter_free: unknown filter type=%lu\n", f->f_choice, 0, 0 ); -#endif break; } - op->o_tmpfree( f, op->o_tmpmemctx ); + if ( freeme ) { + op->o_tmpfree( f, op->o_tmpmemctx ); + } } void filter_free( Filter *f ) { Operation op; + Opheader ohdr; + op.o_hdr = &ohdr; op.o_tmpmemctx = slap_sl_context( f ); op.o_tmpmfuncs = &slap_sl_mfuncs; - filter_free_x( &op, f ); + filter_free_x( &op, f, 1 ); } void @@ -691,7 +587,7 @@ filter2bv_x( Operation *op, Filter *f, s { int i; Filter *p; - struct berval tmp; + struct berval tmp, value; static struct berval ber_bvfalse = BER_BVC( "(?=false)" ), ber_bvtrue = BER_BVC( "(?=true)" ), @@ -700,121 +596,137 @@ filter2bv_x( Operation *op, Filter *f, s ber_bvunknown = BER_BVC( "(?=unknown)" ), ber_bvnone = BER_BVC( "(?=none)" ); ber_len_t len; + ber_tag_t choice; + int undef; + char *sign; if ( f == NULL ) { ber_dupbv_x( fstr, &ber_bvnone, op->o_tmpmemctx ); return; } - switch ( f->f_choice ) { - case LDAP_FILTER_EQUALITY: - filter_escape_value_x( &f->f_av_value, &tmp, op->o_tmpmemctx ); - - fstr->bv_len = f->f_av_desc->ad_cname.bv_len + - tmp.bv_len + ( sizeof("(=)") - 1 ); - fstr->bv_val = op->o_tmpalloc( fstr->bv_len + 1, op->o_tmpmemctx ); - - snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s=%s)", - f->f_av_desc->ad_cname.bv_val, - tmp.bv_val ); - - ber_memfree_x( tmp.bv_val, op->o_tmpmemctx ); - break; + undef = f->f_choice & SLAPD_FILTER_UNDEFINED; + choice = f->f_choice & SLAPD_FILTER_MASK; + switch ( choice ) { + case LDAP_FILTER_EQUALITY: + fstr->bv_len = STRLENOF("(=)"); + sign = "="; + goto simple; case LDAP_FILTER_GE: - filter_escape_value_x( &f->f_av_value, &tmp, op->o_tmpmemctx ); - - fstr->bv_len = f->f_av_desc->ad_cname.bv_len + - tmp.bv_len + ( sizeof("(>=)") - 1 ); - fstr->bv_val = op->o_tmpalloc( fstr->bv_len + 1, op->o_tmpmemctx ); - - snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s>=%s)", - f->f_av_desc->ad_cname.bv_val, - tmp.bv_val ); - - ber_memfree_x( tmp.bv_val, op->o_tmpmemctx ); - break; - + fstr->bv_len = STRLENOF("(>=)"); + sign = ">="; + goto simple; case LDAP_FILTER_LE: - filter_escape_value_x( &f->f_av_value, &tmp, op->o_tmpmemctx ); + fstr->bv_len = STRLENOF("(<=)"); + sign = "<="; + goto simple; + case LDAP_FILTER_APPROX: + fstr->bv_len = STRLENOF("(~=)"); + sign = "~="; - fstr->bv_len = f->f_av_desc->ad_cname.bv_len + - tmp.bv_len + ( sizeof("(<=)") - 1 ); +simple: + value = f->f_av_value; + if ( f->f_av_desc->ad_type->sat_equality && + !undef && + ( f->f_av_desc->ad_type->sat_equality->smr_usage & SLAP_MR_MUTATION_NORMALIZER )) + { + f->f_av_desc->ad_type->sat_equality->smr_normalize( + (SLAP_MR_DENORMALIZE|SLAP_MR_VALUE_OF_ASSERTION_SYNTAX), + NULL, NULL, &f->f_av_value, &value, op->o_tmpmemctx ); + } + + filter_escape_value_x( &value, &tmp, op->o_tmpmemctx ); + /* NOTE: tmp can legitimately be NULL (meaning empty) + * since in a Filter values in AVAs are supposed + * to have been normalized, meaning that an empty value + * is legal for that attribute's syntax */ + + fstr->bv_len += f->f_av_desc->ad_cname.bv_len + tmp.bv_len; + if ( undef ) + fstr->bv_len++; fstr->bv_val = op->o_tmpalloc( fstr->bv_len + 1, op->o_tmpmemctx ); - snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s<=%s)", - f->f_av_desc->ad_cname.bv_val, - tmp.bv_val ); + snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s%s%s%s)", + undef ? "?" : "", + f->f_av_desc->ad_cname.bv_val, sign, + tmp.bv_len ? tmp.bv_val : "" ); - ber_memfree_x( tmp.bv_val, op->o_tmpmemctx ); - break; - - case LDAP_FILTER_APPROX: - filter_escape_value_x( &f->f_av_value, &tmp, op->o_tmpmemctx ); - - fstr->bv_len = f->f_av_desc->ad_cname.bv_len + - tmp.bv_len + ( sizeof("(~=)") - 1 ); - fstr->bv_val = op->o_tmpalloc( fstr->bv_len + 1, op->o_tmpmemctx ); + if ( value.bv_val != f->f_av_value.bv_val ) { + ber_memfree_x( value.bv_val, op->o_tmpmemctx ); + } - snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s~=%s)", - f->f_av_desc->ad_cname.bv_val, - tmp.bv_val ); ber_memfree_x( tmp.bv_val, op->o_tmpmemctx ); break; case LDAP_FILTER_SUBSTRINGS: fstr->bv_len = f->f_sub_desc->ad_cname.bv_len + - ( sizeof("(=*)") - 1 ); + STRLENOF("(=*)"); + if ( undef ) + fstr->bv_len++; fstr->bv_val = op->o_tmpalloc( fstr->bv_len + 128, op->o_tmpmemctx ); - snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s=*)", + snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s%s=*)", + undef ? "?" : "", f->f_sub_desc->ad_cname.bv_val ); if ( f->f_sub_initial.bv_val != NULL ) { + ber_len_t tmplen; + len = fstr->bv_len; filter_escape_value_x( &f->f_sub_initial, &tmp, op->o_tmpmemctx ); + tmplen = tmp.bv_len; - fstr->bv_len += tmp.bv_len; - fstr->bv_val = op->o_tmprealloc( fstr->bv_val, fstr->bv_len + 1, - op->o_tmpmemctx ); + fstr->bv_len += tmplen; + fstr->bv_val = op->o_tmprealloc( fstr->bv_val, + fstr->bv_len + 1, op->o_tmpmemctx ); - snprintf( &fstr->bv_val[len-2], tmp.bv_len+3, + snprintf( &fstr->bv_val[len - 2], + tmplen + STRLENOF( /*(*/ "*)" ) + 1, /* "(attr=" */ "%s*)", - tmp.bv_val ); + tmp.bv_len ? tmp.bv_val : ""); ber_memfree_x( tmp.bv_val, op->o_tmpmemctx ); } if ( f->f_sub_any != NULL ) { for ( i = 0; f->f_sub_any[i].bv_val != NULL; i++ ) { + ber_len_t tmplen; + len = fstr->bv_len; filter_escape_value_x( &f->f_sub_any[i], &tmp, op->o_tmpmemctx ); + tmplen = tmp.bv_len; - fstr->bv_len += tmp.bv_len + 1; - fstr->bv_val = op->o_tmprealloc( fstr->bv_val, fstr->bv_len + 1, - op->o_tmpmemctx ); + fstr->bv_len += tmplen + STRLENOF( /*(*/ ")" ); + fstr->bv_val = op->o_tmprealloc( fstr->bv_val, + fstr->bv_len + 1, op->o_tmpmemctx ); - snprintf( &fstr->bv_val[len-1], tmp.bv_len+3, + snprintf( &fstr->bv_val[len - 1], + tmplen + STRLENOF( /*(*/ "*)" ) + 1, /* "(attr=[init]*[any*]" */ "%s*)", - tmp.bv_val ); + tmp.bv_len ? tmp.bv_val : ""); ber_memfree_x( tmp.bv_val, op->o_tmpmemctx ); } } if ( f->f_sub_final.bv_val != NULL ) { + ber_len_t tmplen; + len = fstr->bv_len; filter_escape_value_x( &f->f_sub_final, &tmp, op->o_tmpmemctx ); + tmplen = tmp.bv_len; - fstr->bv_len += tmp.bv_len; - fstr->bv_val = op->o_tmprealloc( fstr->bv_val, fstr->bv_len + 1, - op->o_tmpmemctx ); + fstr->bv_len += tmplen; + fstr->bv_val = op->o_tmprealloc( fstr->bv_val, + fstr->bv_len + 1, op->o_tmpmemctx ); - snprintf( &fstr->bv_val[len-1], tmp.bv_len+3, + snprintf( &fstr->bv_val[len - 1], + tmplen + STRLENOF( /*(*/ ")" ) + 1, /* "(attr=[init*][any*]" */ "%s)", - tmp.bv_val ); + tmp.bv_len ? tmp.bv_val : ""); ber_memfree_x( tmp.bv_val, op->o_tmpmemctx ); } @@ -823,17 +735,21 @@ filter2bv_x( Operation *op, Filter *f, s case LDAP_FILTER_PRESENT: fstr->bv_len = f->f_desc->ad_cname.bv_len + - ( sizeof("(=*)") - 1 ); + STRLENOF("(=*)"); + if ( undef ) + fstr->bv_len++; + fstr->bv_val = op->o_tmpalloc( fstr->bv_len + 1, op->o_tmpmemctx ); - snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s=*)", + snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s%s=*)", + undef ? "?" : "", 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_len = STRLENOF("(%)"); fstr->bv_val = op->o_tmpalloc( fstr->bv_len + 128, op->o_tmpmemctx ); snprintf( fstr->bv_val, fstr->bv_len + 1, "(%c)", @@ -849,7 +765,8 @@ filter2bv_x( Operation *op, Filter *f, s fstr->bv_val = op->o_tmprealloc( fstr->bv_val, fstr->bv_len + 1, op->o_tmpmemctx ); - snprintf( &fstr->bv_val[len-1], tmp.bv_len + 2, + snprintf( &fstr->bv_val[len-1], + tmp.bv_len + STRLENOF( /*(*/ ")" ) + 1, /*"("*/ "%s)", tmp.bv_val ); op->o_tmpfree( tmp.bv_val, op->o_tmpmemctx ); @@ -858,29 +775,35 @@ filter2bv_x( Operation *op, Filter *f, s break; case LDAP_FILTER_EXT: { - struct berval ad; - filter_escape_value_x( &f->f_mr_value, &tmp, op->o_tmpmemctx ); + struct berval ad; - if ( f->f_mr_desc ) { - ad = f->f_mr_desc->ad_cname; - } else { - ad.bv_len = 0; - ad.bv_val = ""; - } - - fstr->bv_len = ad.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 = op->o_tmpalloc( fstr->bv_len + 1, op->o_tmpmemctx ); - - snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s%s%s%s:=%s)", - ad.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_x( tmp.bv_val, op->o_tmpmemctx ); + filter_escape_value_x( &f->f_mr_value, &tmp, op->o_tmpmemctx ); + /* NOTE: tmp can legitimately be NULL (meaning empty) + * since in a Filter values in MRAs are supposed + * to have been normalized, meaning that an empty value + * is legal for that attribute's syntax */ + + if ( f->f_mr_desc ) { + ad = f->f_mr_desc->ad_cname; + } else { + ad.bv_len = 0; + ad.bv_val = ""; + } + + fstr->bv_len = ad.bv_len + + ( f->f_mr_dnattrs ? STRLENOF(":dn") : 0 ) + + ( f->f_mr_rule_text.bv_len ? f->f_mr_rule_text.bv_len+1 : 0 ) + + tmp.bv_len + STRLENOF("(:=)"); + fstr->bv_val = op->o_tmpalloc( fstr->bv_len + 1, op->o_tmpmemctx ); + + snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s%s%s%s%s:=%s)", + undef ? "?" : "", + ad.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_len ? tmp.bv_val : "" ); + ber_memfree_x( tmp.bv_val, op->o_tmpmemctx ); } break; case SLAPD_FILTER_COMPUTED: @@ -915,46 +838,98 @@ void filter2bv( Filter *f, struct berval *fstr ) { Operation op; + Opheader ohdr; + + op.o_hdr = &ohdr; op.o_tmpmemctx = NULL; op.o_tmpmfuncs = &ch_mfuncs; filter2bv_x( &op, f, fstr ); } -static int -filter_escape_value_x( - struct berval *in, - struct berval *out, - void *ctx ) +Filter * +filter_dup( Filter *f, void *memctx ) { - ber_len_t i; - assert( in ); - assert( out ); - - i = in->bv_len * 3 + 1; - out->bv_val = ctx ? slap_sl_malloc( i, ctx ) : ch_malloc( i ); - out->bv_len = 0; - - for( i=0; i < in->bv_len ; i++ ) { - if( FILTER_ESCAPE(in->bv_val[i]) ) { - out->bv_val[out->bv_len++] = SLAP_ESCAPE_CHAR; - out->bv_val[out->bv_len++] = SLAP_ESCAPE_HI( in->bv_val[i] ); - out->bv_val[out->bv_len++] = SLAP_ESCAPE_LO( in->bv_val[i] ); - } else { - out->bv_val[out->bv_len++] = in->bv_val[i]; - } - } + BerMemoryFunctions *mf = &slap_sl_mfuncs; + Filter *n; - out->bv_val[out->bv_len] = '\0'; - return LDAP_SUCCESS; -} + if ( !f ) + return NULL; -int -filter_escape_value( - struct berval *in, - struct berval *out ) -{ - return filter_escape_value_x( in, out, NULL ); + n = mf->bmf_malloc( sizeof(Filter), memctx ); + n->f_choice = f->f_choice; + n->f_next = NULL; + + switch( f->f_choice & SLAPD_FILTER_MASK ) { + case SLAPD_FILTER_COMPUTED: + n->f_result = f->f_result; + break; + case LDAP_FILTER_PRESENT: + if ( f->f_desc->ad_flags & SLAP_DESC_TEMPORARY ) + n->f_desc = slap_bv2tmp_ad( &f->f_desc->ad_cname, memctx ); + else + n->f_desc = f->f_desc; + break; + case LDAP_FILTER_EQUALITY: + case LDAP_FILTER_GE: + case LDAP_FILTER_LE: + case LDAP_FILTER_APPROX: + /* Should this be ava_dup() ? */ + n->f_ava = mf->bmf_calloc( 1, sizeof(AttributeAssertion), memctx ); + *n->f_ava = *f->f_ava; + if ( f->f_av_desc->ad_flags & SLAP_DESC_TEMPORARY ) + n->f_av_desc = slap_bv2tmp_ad( &f->f_av_desc->ad_cname, memctx ); + ber_dupbv_x( &n->f_av_value, &f->f_av_value, memctx ); + break; + case LDAP_FILTER_SUBSTRINGS: + n->f_sub = mf->bmf_calloc( 1, sizeof(SubstringsAssertion), memctx ); + if ( f->f_sub_desc->ad_flags & SLAP_DESC_TEMPORARY ) + n->f_sub_desc = slap_bv2tmp_ad( &f->f_sub_desc->ad_cname, memctx ); + else + n->f_sub_desc = f->f_sub_desc; + if ( !BER_BVISNULL( &f->f_sub_initial )) + ber_dupbv_x( &n->f_sub_initial, &f->f_sub_initial, memctx ); + if ( f->f_sub_any ) { + int i; + for ( i = 0; !BER_BVISNULL( &f->f_sub_any[i] ); i++ ); + n->f_sub_any = mf->bmf_malloc(( i+1 )*sizeof( struct berval ), + memctx ); + for ( i = 0; !BER_BVISNULL( &f->f_sub_any[i] ); i++ ) { + ber_dupbv_x( &n->f_sub_any[i], &f->f_sub_any[i], memctx ); + } + BER_BVZERO( &n->f_sub_any[i] ); + } + if ( !BER_BVISNULL( &f->f_sub_final )) + ber_dupbv_x( &n->f_sub_final, &f->f_sub_final, memctx ); + break; + case LDAP_FILTER_EXT: { + /* Should this be mra_dup() ? */ + ber_len_t length; + length = sizeof(MatchingRuleAssertion); + if ( !BER_BVISNULL( &f->f_mr_rule_text )) + length += f->f_mr_rule_text.bv_len + 1; + n->f_mra = mf->bmf_calloc( 1, length, memctx ); + *n->f_mra = *f->f_mra; + if ( f->f_mr_desc && ( f->f_sub_desc->ad_flags & SLAP_DESC_TEMPORARY )) + n->f_mr_desc = slap_bv2tmp_ad( &f->f_mr_desc->ad_cname, memctx ); + ber_dupbv_x( &n->f_mr_value, &f->f_mr_value, memctx ); + if ( !BER_BVISNULL( &f->f_mr_rule_text )) { + n->f_mr_rule_text.bv_val = (char *)(n->f_mra+1); + AC_MEMCPY(n->f_mr_rule_text.bv_val, + f->f_mr_rule_text.bv_val, f->f_mr_rule_text.bv_len ); + } + } break; + case LDAP_FILTER_AND: + case LDAP_FILTER_OR: + case LDAP_FILTER_NOT: { + Filter **p; + for ( p = &n->f_list, f = f->f_list; f; f = f->f_next ) { + *p = filter_dup( f, memctx ); + p = &(*p)->f_next; + } + } break; + } + return n; } static int @@ -969,12 +944,7 @@ get_simple_vrFilter( int err; ValuesReturnFilter vrf; -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, ENTRY, - "get_simple_vrFilter: conn %d\n", op->o_connid, 0, 0 ); -#else Debug( LDAP_DEBUG_FILTER, "begin get_simple_vrFilter\n", 0, 0, 0 ); -#endif tag = ber_peek_tag( ber, &len ); @@ -990,13 +960,8 @@ get_simple_vrFilter( switch ( vrf.vrf_choice ) { case LDAP_FILTER_EQUALITY: -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, DETAIL2, - "get_simple_vrFilter: conn %d EQUALITY\n", op->o_connid, 0, 0 ); -#else Debug( LDAP_DEBUG_FILTER, "EQUALITY\n", 0, 0, 0 ); -#endif - err = get_ava( op, ber, &vrf.vrf_ava, SLAP_MR_EQUALITY, text ); + err = get_ava( op, ber, (Filter *)&vrf, SLAP_MR_EQUALITY, text ); if ( err != LDAP_SUCCESS ) { break; } @@ -1005,36 +970,21 @@ get_simple_vrFilter( break; case LDAP_FILTER_SUBSTRINGS: -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, DETAIL1, - "get_simple_vrFilter: conn %d SUBSTRINGS\n", op->o_connid, 0, 0 ); -#else Debug( LDAP_DEBUG_FILTER, "SUBSTRINGS\n", 0, 0, 0 ); -#endif - err = get_ssa( op, ber, &vrf.vrf_sub, text ); + err = get_ssa( op, ber, (Filter *)&vrf, text ); break; case LDAP_FILTER_GE: -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, DETAIL1, - "get_simple_vrFilter: conn %d GE\n", op->o_connid, 0, 0 ); -#else Debug( LDAP_DEBUG_FILTER, "GE\n", 0, 0, 0 ); -#endif - err = get_ava( op, ber, &vrf.vrf_ava, SLAP_MR_ORDERING, text ); + err = get_ava( op, ber, (Filter *)&vrf, SLAP_MR_ORDERING, text ); if ( err != LDAP_SUCCESS ) { break; } break; case LDAP_FILTER_LE: -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, DETAIL1, - "get_simple_vrFilter: conn %d LE\n", op->o_connid, 0, 0 ); -#else Debug( LDAP_DEBUG_FILTER, "LE\n", 0, 0, 0 ); -#endif - err = get_ava( op, ber, &vrf.vrf_ava, SLAP_MR_ORDERING, text ); + err = get_ava( op, ber, (Filter *)&vrf, SLAP_MR_ORDERING, text ); if ( err != LDAP_SUCCESS ) { break; } @@ -1043,12 +993,7 @@ get_simple_vrFilter( case LDAP_FILTER_PRESENT: { struct berval type; -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, DETAIL1, - "get_simple_vrFilter: conn %d PRESENT\n", op->o_connid, 0, 0 ); -#else Debug( LDAP_DEBUG_FILTER, "PRESENT\n", 0, 0, 0 ); -#endif if ( ber_scanf( ber, "m", &type ) == LBER_ERROR ) { err = SLAPD_DISCONNECT; *text = "error decoding filter"; @@ -1059,48 +1004,37 @@ get_simple_vrFilter( err = slap_bv2ad( &type, &vrf.vrf_desc, text ); if( err != LDAP_SUCCESS ) { - /* unrecognized attribute description or other error */ -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, ERR, - "get_simple_vrFilter: conn %d unknown " - "attribute type=%s (%d)\n", - op->o_connid, type.bv_val, err ); -#else - Debug( LDAP_DEBUG_ANY, - "get_simple_vrFilter: conn %d unknown " - "attribute type=%s (%d)\n", - op->o_connid, type.bv_val, err ); -#endif - - vrf.vrf_choice = SLAPD_FILTER_COMPUTED; - vrf.vrf_result = LDAP_COMPARE_FALSE; - err = LDAP_SUCCESS; - break; + vrf.vrf_choice |= SLAPD_FILTER_UNDEFINED; + err = slap_bv2undef_ad( &type, &vrf.vrf_desc, text, + SLAP_AD_PROXIED); + + if( err != LDAP_SUCCESS ) { + /* unrecognized attribute description or other error */ + Debug( LDAP_DEBUG_ANY, + "get_simple_vrFilter: conn %lu unknown " + "attribute type=%s (%d)\n", + op->o_connid, type.bv_val, err ); + + vrf.vrf_choice = SLAPD_FILTER_COMPUTED; + vrf.vrf_result = LDAP_COMPARE_FALSE; + err = LDAP_SUCCESS; + break; + } } } break; case LDAP_FILTER_APPROX: -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, DETAIL1, - "get_simple_vrFilter: conn %d APPROX\n", op->o_connid, 0, 0 ); -#else Debug( LDAP_DEBUG_FILTER, "APPROX\n", 0, 0, 0 ); -#endif - err = get_ava( op, ber, &vrf.vrf_ava, SLAP_MR_EQUALITY_APPROX, text ); + err = get_ava( op, ber, (Filter *)&vrf, SLAP_MR_EQUALITY_APPROX, text ); if ( err != LDAP_SUCCESS ) { break; } break; case LDAP_FILTER_EXT: -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, DETAIL1, - "get_simple_vrFilter: conn %d EXTENSIBLE\n", op->o_connid, 0, 0 ); -#else Debug( LDAP_DEBUG_FILTER, "EXTENSIBLE\n", 0, 0, 0 ); -#endif - err = get_mra( op, ber, &vrf.vrf_mra, text ); + err = get_mra( op, ber, (Filter *)&vrf, text ); if ( err != LDAP_SUCCESS ) { break; } @@ -1110,14 +1044,8 @@ get_simple_vrFilter( default: (void) ber_scanf( ber, "x" ); /* skip the element */ -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, ERR, - "get_simple_vrFilter: conn %d unknown filter type=%lu\n", - op->o_connid, vrf.vrf_choice, 0 ); -#else Debug( LDAP_DEBUG_ANY, "get_simple_vrFilter: unknown filter type=%lu\n", vrf.vrf_choice, 0, 0 ); -#endif vrf.vrf_choice = SLAPD_FILTER_COMPUTED; vrf.vrf_result = SLAPD_COMPARE_UNDEFINED; break; @@ -1131,16 +1059,11 @@ get_simple_vrFilter( } if ( err == LDAP_SUCCESS ) { - *filt = ch_malloc( sizeof vrf ); + *filt = op->o_tmpalloc( sizeof vrf, op->o_tmpmemctx ); **filt = vrf; } -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, DETAIL2, - "get_simple_vrFilter: conn %d exit\n", op->o_connid, 0, 0 ); -#else Debug( LDAP_DEBUG_FILTER, "end get_simple_vrFilter %d\n", err, 0, 0 ); -#endif return err; } @@ -1184,12 +1107,7 @@ get_vrFilter( Operation *op, BerElement ber_len_t len; char *last; -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, ENTRY, - "get_vrFilter: conn %d start\n", op->o_connid, 0, 0 ); -#else Debug( LDAP_DEBUG_FILTER, "begin get_vrFilter\n", 0, 0, 0 ); -#endif tag = ber_peek_tag( ber, &len ); @@ -1216,12 +1134,7 @@ get_vrFilter( Operation *op, BerElement } *n = NULL; -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, ENTRY, - "get_vrFilter: conn %d exit\n", op->o_connid, 0, 0 ); -#else Debug( LDAP_DEBUG_FILTER, "end get_vrFilter\n", 0, 0, 0 ); -#endif return( LDAP_SUCCESS ); } @@ -1237,7 +1150,7 @@ vrFilter_free( Operation *op, ValuesRetu for ( p = vrf; p != NULL; p = next ) { next = p->vrf_next; - switch ( vrf->vrf_choice ) { + switch ( vrf->vrf_choice & SLAPD_FILTER_MASK ) { case LDAP_FILTER_PRESENT: break; @@ -1267,13 +1180,8 @@ vrFilter_free( Operation *op, ValuesRetu break; default: -#ifdef NEW_LOGGING - LDAP_LOG( FILTER, ERR, "filter_free: unknown filter type %lu\n", - vrf->vrf_choice, 0, 0 ); -#else Debug( LDAP_DEBUG_ANY, "filter_free: unknown filter type=%lu\n", vrf->vrf_choice, 0, 0 ); -#endif break; } @@ -1289,12 +1197,12 @@ vrFilter2bv( Operation *op, ValuesReturn ber_len_t len; if ( vrf == NULL ) { - ber_str2bv_x( "No filter!", sizeof("No filter!")-1, + ber_str2bv_x( "No filter!", STRLENOF("No filter!"), 1, fstr, op->o_tmpmemctx ); return; } - fstr->bv_len = sizeof("()") - 1; + fstr->bv_len = STRLENOF("()"); fstr->bv_val = op->o_tmpalloc( fstr->bv_len + 128, op->o_tmpmemctx ); snprintf( fstr->bv_val, fstr->bv_len + 1, "()"); @@ -1320,19 +1228,22 @@ simple_vrFilter2bv( Operation *op, Value { struct berval tmp; ber_len_t len; + int undef; if ( vrf == NULL ) { - ber_str2bv_x( "No filter!", sizeof("No filter!")-1, 1, fstr, + ber_str2bv_x( "No filter!", STRLENOF("No filter!"), 1, fstr, op->o_tmpmemctx ); return; } + undef = vrf->vrf_choice & SLAPD_FILTER_UNDEFINED; - switch ( vrf->vrf_choice ) { + switch ( vrf->vrf_choice & SLAPD_FILTER_MASK ) { case LDAP_FILTER_EQUALITY: filter_escape_value_x( &vrf->vrf_av_value, &tmp, op->o_tmpmemctx ); fstr->bv_len = vrf->vrf_av_desc->ad_cname.bv_len + - tmp.bv_len + ( sizeof("(=)") - 1 ); + tmp.bv_len + STRLENOF("(=)"); + if ( undef ) fstr->bv_len++; fstr->bv_val = op->o_tmpalloc( fstr->bv_len + 1, op->o_tmpmemctx ); snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s=%s)", @@ -1346,7 +1257,8 @@ simple_vrFilter2bv( Operation *op, Value filter_escape_value_x( &vrf->vrf_av_value, &tmp, op->o_tmpmemctx ); fstr->bv_len = vrf->vrf_av_desc->ad_cname.bv_len + - tmp.bv_len + ( sizeof("(>=)") - 1 ); + tmp.bv_len + STRLENOF("(>=)"); + if ( undef ) fstr->bv_len++; fstr->bv_val = op->o_tmpalloc( fstr->bv_len + 1, op->o_tmpmemctx ); snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s>=%s)", @@ -1360,7 +1272,8 @@ simple_vrFilter2bv( Operation *op, Value filter_escape_value_x( &vrf->vrf_av_value, &tmp, op->o_tmpmemctx ); fstr->bv_len = vrf->vrf_av_desc->ad_cname.bv_len + - tmp.bv_len + ( sizeof("(<=)") - 1 ); + tmp.bv_len + STRLENOF("(<=)"); + if ( undef ) fstr->bv_len++; fstr->bv_val = op->o_tmpalloc( fstr->bv_len + 1, op->o_tmpmemctx ); snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s<=%s)", @@ -1374,7 +1287,8 @@ simple_vrFilter2bv( Operation *op, Value filter_escape_value_x( &vrf->vrf_av_value, &tmp, op->o_tmpmemctx ); fstr->bv_len = vrf->vrf_av_desc->ad_cname.bv_len + - tmp.bv_len + ( sizeof("(~=)") - 1 ); + tmp.bv_len + STRLENOF("(~=)"); + if ( undef ) fstr->bv_len++; fstr->bv_val = op->o_tmpalloc( fstr->bv_len + 1, op->o_tmpmemctx ); snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s~=%s)", @@ -1385,7 +1299,8 @@ simple_vrFilter2bv( Operation *op, Value case LDAP_FILTER_SUBSTRINGS: fstr->bv_len = vrf->vrf_sub_desc->ad_cname.bv_len + - ( sizeof("(=*)") - 1 ); + STRLENOF("(=*)"); + if ( undef ) fstr->bv_len++; fstr->bv_val = op->o_tmpalloc( fstr->bv_len + 128, op->o_tmpmemctx ); snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s=*)", @@ -1445,7 +1360,8 @@ simple_vrFilter2bv( Operation *op, Value case LDAP_FILTER_PRESENT: fstr->bv_len = vrf->vrf_desc->ad_cname.bv_len + - ( sizeof("(=*)") - 1 ); + STRLENOF("(=*)"); + if ( undef ) fstr->bv_len++; fstr->bv_val = op->o_tmpalloc( fstr->bv_len + 1, op->o_tmpmemctx ); snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s=*)", @@ -1464,10 +1380,11 @@ simple_vrFilter2bv( Operation *op, Value } fstr->bv_len = ad.bv_len + - ( vrf->vrf_mr_dnattrs ? sizeof(":dn")-1 : 0 ) + + ( vrf->vrf_mr_dnattrs ? STRLENOF(":dn") : 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 + STRLENOF("(:=)"); + if ( undef ) fstr->bv_len++; fstr->bv_val = op->o_tmpalloc( fstr->bv_len + 1, op->o_tmpmemctx ); snprintf( fstr->bv_val, fstr->bv_len + 1, "(%s%s%s%s:=%s)", @@ -1486,15 +1403,15 @@ simple_vrFilter2bv( Operation *op, Value vrf->vrf_result == LDAP_COMPARE_TRUE ? "(?=true)" : vrf->vrf_result == SLAPD_COMPARE_UNDEFINED ? "(?=undefined)" : "(?=error)", - vrf->vrf_result == LDAP_COMPARE_FALSE ? sizeof("(?=false)")-1 : - vrf->vrf_result == LDAP_COMPARE_TRUE ? sizeof("(?=true)")-1 : + vrf->vrf_result == LDAP_COMPARE_FALSE ? STRLENOF("(?=false)") : + vrf->vrf_result == LDAP_COMPARE_TRUE ? STRLENOF("(?=true)") : vrf->vrf_result == SLAPD_COMPARE_UNDEFINED - ? sizeof("(?=undefined)")-1 : sizeof("(?=error)")-1, + ? STRLENOF("(?=undefined)") : STRLENOF("(?=error)"), 1, fstr, op->o_tmpmemctx ); break; default: - ber_str2bv_x( "(?=unknown)", sizeof("(?=unknown)")-1, + ber_str2bv_x( "(?=unknown)", STRLENOF("(?=unknown)"), 1, fstr, op->o_tmpmemctx ); break; }