--- servers/slapd/filter.c 1999/06/28 22:03:34 1.12 +++ servers/slapd/filter.c 2000/03/01 21:59:34 1.25 @@ -1,4 +1,9 @@ /* filter.c - routines for parsing and dealing with filters */ +/* $OpenLDAP: pkg/ldap/servers/slapd/filter.c,v 1.24 2000/02/29 22:48:01 kurt Exp $ */ +/* + * Copyright 1998-1999 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ #include "portable.h" @@ -9,13 +14,29 @@ #include "slap.h" -static int get_filter_list(Connection *conn, BerElement *ber, Filter **f, char **fstr); -static int get_substring_filter(Connection *conn, BerElement *ber, Filter *f, char **fstr); +static int get_filter_list( + Connection *conn, + BerElement *ber, + Filter **f, + char **fstr, + char **text ); +static int get_substring_filter( + Connection *conn, + BerElement *ber, + Filter *f, + char **fstr, + char **text ); int -get_filter( Connection *conn, BerElement *ber, Filter **filt, char **fstr ) +get_filter( + Connection *conn, + BerElement *ber, + Filter **filt, + char **fstr, + char **text ) { - unsigned long len; + ber_tag_t tag; + ber_len_t len; int err; Filter *f; char *ftmp; @@ -34,6 +55,7 @@ get_filter( Connection *conn, BerElement * lessOrEqual [6] AttributeValueAssertion, * present [7] AttributeType,, * approxMatch [8] AttributeValueAssertion + * extensibleMatch [9] MatchingRuleAssertion * } * * SubstringFilter ::= SEQUENCE { @@ -44,114 +66,156 @@ get_filter( Connection *conn, BerElement * final [2] IA5String * } * } + * + * MatchingRuleAssertion ::= SEQUENCE { + * matchingRule [1] MatchingRuleId OPTIONAL, + * type [2] AttributeDescription OPTIONAL, + * matchValue [3] AssertionValue, + * dnAttributes [4] BOOLEAN DEFAULT FALSE + * } + * */ + tag = ber_peek_tag( ber, &len ); + + if( tag == LBER_ERROR ) { + *text = "error decoding filter"; + return SLAPD_DISCONNECT; + } + f = (Filter *) ch_malloc( sizeof(Filter) ); f->f_next = NULL; - err = 0; + err = LDAP_SUCCESS; *fstr = NULL; - f->f_choice = ber_peek_tag( ber, &len ); + f->f_choice = tag; switch ( f->f_choice ) { +#ifdef SLAPD_SCHEMA_NOT_COMPAT + /* not yet implemented */ +#else case LDAP_FILTER_EQUALITY: Debug( LDAP_DEBUG_FILTER, "EQUALITY\n", 0, 0, 0 ); - if ( (err = get_ava( ber, &f->f_ava )) == 0 ) { - *fstr = ch_malloc(4 + strlen( f->f_avtype ) + - f->f_avvalue.bv_len); - sprintf( *fstr, "(%s=%s)", f->f_avtype, - f->f_avvalue.bv_val ); + if ( (err = get_ava( ber, &f->f_ava )) != LDAP_SUCCESS ) { + *text = "error decoding filter"; + break; } + *fstr = ch_malloc(4 + strlen( f->f_avtype ) + + f->f_avvalue.bv_len); + sprintf( *fstr, "(%s=%s)", f->f_avtype, + f->f_avvalue.bv_val ); break; case LDAP_FILTER_SUBSTRINGS: Debug( LDAP_DEBUG_FILTER, "SUBSTRINGS\n", 0, 0, 0 ); - err = get_substring_filter( conn, ber, f, fstr ); + err = get_substring_filter( conn, ber, f, fstr, text ); break; case LDAP_FILTER_GE: Debug( LDAP_DEBUG_FILTER, "GE\n", 0, 0, 0 ); - if ( (err = get_ava( ber, &f->f_ava )) == 0 ) { - *fstr = ch_malloc(5 + strlen( f->f_avtype ) + - f->f_avvalue.bv_len); - sprintf( *fstr, "(%s>=%s)", f->f_avtype, - f->f_avvalue.bv_val ); + if ( (err = get_ava( ber, &f->f_ava )) != LDAP_SUCCESS ) { + *text = "decoding filter error"; + break; } + *fstr = ch_malloc(5 + strlen( f->f_avtype ) + + f->f_avvalue.bv_len); + sprintf( *fstr, "(%s>=%s)", f->f_avtype, + f->f_avvalue.bv_val ); break; case LDAP_FILTER_LE: Debug( LDAP_DEBUG_FILTER, "LE\n", 0, 0, 0 ); - if ( (err = get_ava( ber, &f->f_ava )) == 0 ) { - *fstr = ch_malloc(5 + strlen( f->f_avtype ) + - f->f_avvalue.bv_len); - sprintf( *fstr, "(%s<=%s)", f->f_avtype, - f->f_avvalue.bv_val ); + if ( (err = get_ava( ber, &f->f_ava )) != LDAP_SUCCESS ) { + *text = "error decoding filter"; + break; } + *fstr = ch_malloc(5 + strlen( f->f_avtype ) + + f->f_avvalue.bv_len); + sprintf( *fstr, "(%s<=%s)", f->f_avtype, + f->f_avvalue.bv_val ); break; case LDAP_FILTER_PRESENT: Debug( LDAP_DEBUG_FILTER, "PRESENT\n", 0, 0, 0 ); if ( ber_scanf( ber, "a", &f->f_type ) == LBER_ERROR ) { - err = LDAP_PROTOCOL_ERROR; - } else { - err = LDAP_SUCCESS; - attr_normalize( f->f_type ); - *fstr = ch_malloc( 5 + strlen( f->f_type ) ); - sprintf( *fstr, "(%s=*)", f->f_type ); + err = SLAPD_DISCONNECT; + *text = "error decoding filter"; + break; } + + err = LDAP_SUCCESS; + attr_normalize( f->f_type ); + *fstr = ch_malloc( 5 + strlen( f->f_type ) ); + sprintf( *fstr, "(%s=*)", f->f_type ); break; case LDAP_FILTER_APPROX: Debug( LDAP_DEBUG_FILTER, "APPROX\n", 0, 0, 0 ); - if ( (err = get_ava( ber, &f->f_ava )) == 0 ) { - *fstr = ch_malloc(5 + strlen( f->f_avtype ) + - f->f_avvalue.bv_len); - sprintf( *fstr, "(%s~=%s)", f->f_avtype, - f->f_avvalue.bv_val ); + if ( (err = get_ava( ber, &f->f_ava )) != LDAP_SUCCESS ) { + *text = "error decoding filter"; + break; } + *fstr = ch_malloc(5 + strlen( f->f_avtype ) + + f->f_avvalue.bv_len); + sprintf( *fstr, "(%s~=%s)", f->f_avtype, + f->f_avvalue.bv_val ); break; +#endif case LDAP_FILTER_AND: Debug( LDAP_DEBUG_FILTER, "AND\n", 0, 0, 0 ); - if ( (err = get_filter_list( conn, ber, &f->f_and, &ftmp )) - == 0 ) { - if (ftmp == NULL) ftmp = ch_strdup(""); - *fstr = ch_malloc( 4 + strlen( ftmp ) ); - sprintf( *fstr, "(&%s)", ftmp ); - free( ftmp ); + err = get_filter_list( conn, ber, &f->f_and, &ftmp, text ); + if ( err != LDAP_SUCCESS ) { + break; } + if (ftmp == NULL) ftmp = ch_strdup(""); + *fstr = ch_malloc( 4 + strlen( ftmp ) ); + sprintf( *fstr, "(&%s)", ftmp ); + free( ftmp ); break; case LDAP_FILTER_OR: Debug( LDAP_DEBUG_FILTER, "OR\n", 0, 0, 0 ); - if ( (err = get_filter_list( conn, ber, &f->f_or, &ftmp )) - == 0 ) { - if (ftmp == NULL) ftmp = ch_strdup(""); - *fstr = ch_malloc( 4 + strlen( ftmp ) ); - sprintf( *fstr, "(|%s)", ftmp ); - free( ftmp ); + err = get_filter_list( conn, ber, &f->f_and, &ftmp, text ); + if ( err != LDAP_SUCCESS ) { + break; } + if (ftmp == NULL) ftmp = ch_strdup(""); + *fstr = ch_malloc( 4 + strlen( ftmp ) ); + sprintf( *fstr, "(|%s)", ftmp ); + free( ftmp ); break; case LDAP_FILTER_NOT: Debug( LDAP_DEBUG_FILTER, "NOT\n", 0, 0, 0 ); (void) ber_skip_tag( ber, &len ); - if ( (err = get_filter( conn, ber, &f->f_not, &ftmp )) == 0 ) { - if (ftmp == NULL) ftmp = ch_strdup(""); - *fstr = ch_malloc( 4 + strlen( ftmp ) ); - sprintf( *fstr, "(!%s)", ftmp ); - free( ftmp ); + err = get_filter( conn, ber, &f->f_not, &ftmp, text ); + if ( err != LDAP_SUCCESS ) { + break; } + if (ftmp == NULL) ftmp = ch_strdup(""); + *fstr = ch_malloc( 4 + strlen( ftmp ) ); + sprintf( *fstr, "(!%s)", ftmp ); + free( ftmp ); + break; + + case LDAP_FILTER_EXT: + /* not yet implemented */ + Debug( LDAP_DEBUG_ANY, "extensible match not yet implemented.\n", + f->f_choice, 0, 0 ); + err = LDAP_PROTOCOL_ERROR; + *text = "extensible match not yet implemented"; break; default: Debug( LDAP_DEBUG_ANY, "unknown filter type %lu\n", f->f_choice, 0, 0 ); err = LDAP_PROTOCOL_ERROR; + *text = "unknown filter type"; break; } - if ( err != 0 ) { + if ( err != LDAP_SUCCESS ) { free( (char *) f ); if ( *fstr != NULL ) { free( *fstr ); @@ -165,7 +229,7 @@ get_filter( Connection *conn, BerElement } static int -get_filter_list( Connection *conn, BerElement *ber, Filter **f, char **fstr ) +get_filter_list( Connection *conn, BerElement *ber, Filter **f, char **fstr, char **text ) { Filter **new; int err; @@ -178,9 +242,12 @@ get_filter_list( Connection *conn, BerEl *fstr = NULL; new = f; for ( tag = ber_first_element( ber, &len, &last ); tag != LBER_DEFAULT; - tag = ber_next_element( ber, &len, last ) ) { - if ( (err = get_filter( conn, ber, new, &ftmp )) != 0 ) + tag = ber_next_element( ber, &len, last ) ) + { + err = get_filter( conn, ber, new, &ftmp, text ); + if ( err != LDAP_SUCCESS ) return( err ); + if ( *fstr == NULL ) { *fstr = ftmp; } else { @@ -194,99 +261,162 @@ get_filter_list( Connection *conn, BerEl *new = NULL; Debug( LDAP_DEBUG_FILTER, "end get_filter_list\n", 0, 0, 0 ); - return( 0 ); + return( LDAP_SUCCESS ); } +#ifndef SLAPD_SCHEMA_NOT_COMPAT + static int get_substring_filter( Connection *conn, BerElement *ber, Filter *f, - char **fstr + char **fstr, + char **text ) { ber_tag_t tag; ber_len_t len; ber_tag_t rc; - char *val, *last; + struct berval *val; + char *last; int syntax; + *text = "error decoding filter"; + Debug( LDAP_DEBUG_FILTER, "begin get_substring_filter\n", 0, 0, 0 ); if ( ber_scanf( ber, "{a" /*}*/, &f->f_sub_type ) == LBER_ERROR ) { - return( LDAP_PROTOCOL_ERROR ); + return SLAPD_DISCONNECT; } + +#ifdef SLAPD_SCHEMA_NOT_COMPAT + /* not yet implemented */ +#else attr_normalize( f->f_sub_type ); + + /* should get real syntax and see if we have a substring matching rule */ syntax = attr_syntax( f->f_sub_type ); +#endif + f->f_sub_initial = NULL; f->f_sub_any = NULL; f->f_sub_final = NULL; - *fstr = ch_malloc( strlen( f->f_sub_type ) + 3 ); - sprintf( *fstr, "(%s=", f->f_sub_type ); + if( fstr ) { + *fstr = ch_malloc( strlen( f->f_sub_type ) + 3 ); + sprintf( *fstr, "(%s=" /*)*/, f->f_sub_type ); + } + for ( tag = ber_first_element( ber, &len, &last ); tag != LBER_DEFAULT; - tag = ber_next_element( ber, &len, last ) ) { - rc = ber_scanf( ber, "a", &val ); + tag = ber_next_element( ber, &len, last ) ) + { + rc = ber_scanf( ber, "O", &val ); if ( rc == LBER_ERROR ) { - return( LDAP_PROTOCOL_ERROR ); - } - if ( val == NULL || *val == '\0' ) { - if ( val != NULL ) { - free( val ); - } - return( LDAP_INVALID_SYNTAX ); + rc = SLAPD_DISCONNECT; + goto return_error; } - value_normalize( val, syntax ); + + if ( val == NULL || val->bv_len == 0 ) { + ber_bvfree( val ); + rc = LDAP_INVALID_SYNTAX; + goto return_error; + } + + rc = LDAP_PROTOCOL_ERROR; + +#ifdef SLAPD_SCHEMA_NOT_COMPAT + /* not yet implemented */ +#else + /* we should call a substring syntax normalization routine */ + value_normalize( val->bv_val, syntax ); + /* this is bogus, value_normalize should take a berval */ + val->bv_len = strlen( val->bv_val ); +#endif switch ( tag ) { case LDAP_SUBSTRING_INITIAL: Debug( LDAP_DEBUG_FILTER, " INITIAL\n", 0, 0, 0 ); if ( f->f_sub_initial != NULL ) { - return( LDAP_PROTOCOL_ERROR ); + ber_bvfree( val ); + goto return_error; } f->f_sub_initial = val; - *fstr = ch_realloc( *fstr, strlen( *fstr ) + - strlen( val ) + 1 ); - strcat( *fstr, val ); + + if( fstr ) { + *fstr = ch_realloc( *fstr, + strlen( *fstr ) + val->bv_len + 1 ); + strcat( *fstr, val->bv_val ); + } break; case LDAP_SUBSTRING_ANY: Debug( LDAP_DEBUG_FILTER, " ANY\n", 0, 0, 0 ); - charray_add( &f->f_sub_any, val ); - *fstr = ch_realloc( *fstr, strlen( *fstr ) + - strlen( val ) + 2 ); - strcat( *fstr, "*" ); - strcat( *fstr, val ); + if( ber_bvecadd( &f->f_sub_any, val ) < 0 ) { + ber_bvfree( val ); + goto return_error; + } + + if( fstr ) { + *fstr = ch_realloc( *fstr, + strlen( *fstr ) + val->bv_len + 2 ); + strcat( *fstr, "*" ); + strcat( *fstr, val->bv_val ); + } break; case LDAP_SUBSTRING_FINAL: Debug( LDAP_DEBUG_FILTER, " FINAL\n", 0, 0, 0 ); if ( f->f_sub_final != NULL ) { - return( LDAP_PROTOCOL_ERROR ); + ber_bvfree( val ); + goto return_error; } f->f_sub_final = val; - *fstr = ch_realloc( *fstr, strlen( *fstr ) + - strlen( val ) + 2 ); - strcat( *fstr, "*" ); - strcat( *fstr, val ); + + if( fstr ) { + *fstr = ch_realloc( *fstr, + strlen( *fstr ) + val->bv_len + 2 ); + strcat( *fstr, "*" ); + strcat( *fstr, val->bv_val ); + } break; default: Debug( LDAP_DEBUG_FILTER, " unknown type\n", tag, 0, 0 ); - return( LDAP_PROTOCOL_ERROR ); + + ber_bvfree( val ); + +return_error: + Debug( LDAP_DEBUG_FILTER, " error=%d\n", rc, 0, 0 ); + + if( fstr ) { + free( *fstr ); + *fstr = NULL; + } + + ch_free( f->f_sub_type ); + ber_bvfree( f->f_sub_initial ); + ber_bvecfree( f->f_sub_any ); + ber_bvfree( f->f_sub_final ); + return rc; } } - *fstr = ch_realloc( *fstr, strlen( *fstr ) + 3 ); - if ( f->f_sub_final == NULL ) { - strcat( *fstr, "*" ); + + if( fstr ) { + *fstr = ch_realloc( *fstr, strlen( *fstr ) + 3 ); + if ( f->f_sub_final == NULL ) { + strcat( *fstr, "*" ); + } + strcat( *fstr, /*(*/ ")" ); } - strcat( *fstr, ")" ); Debug( LDAP_DEBUG_FILTER, "end get_substring_filter\n", 0, 0, 0 ); - return( 0 ); + return( LDAP_SUCCESS ); } +#endif /* not compat */ + void filter_free( Filter *f ) { @@ -297,30 +427,49 @@ filter_free( Filter *f ) } switch ( f->f_choice ) { + case LDAP_FILTER_PRESENT: +#ifdef SLAPD_SCHEMA_NOT_COMPAT + ad_free( f->f_desc, 1 ); +#else + if ( f->f_type != NULL ) { + free( f->f_type ); + } +#endif + break; + case LDAP_FILTER_EQUALITY: case LDAP_FILTER_GE: case LDAP_FILTER_LE: case LDAP_FILTER_APPROX: +#ifdef SLAPD_SCHEMA_NOT_COMPAT + ava_free( f->f_ava, 1 ); +#else ava_free( &f->f_ava, 0 ); +#endif break; case LDAP_FILTER_SUBSTRINGS: +#ifdef SLAPD_SCHEMA_NOT_COMPAT + ad_free( f->f_sub_desc, 1 ); + if ( f->f_sub_initial != NULL ) { + ber_bvfree( f->f_sub_initial ); + } + ber_bvecfree( f->f_sub_any ); + if ( f->f_sub_final != NULL ) { + ber_bvfree( f->f_sub_final ); + } +#else if ( f->f_sub_type != NULL ) { free( f->f_sub_type ); } if ( f->f_sub_initial != NULL ) { - free( f->f_sub_initial ); + ber_bvfree( f->f_sub_initial ); } - charray_free( f->f_sub_any ); + ber_bvecfree( f->f_sub_any ); if ( f->f_sub_final != NULL ) { - free( f->f_sub_final ); - } - break; - - case LDAP_FILTER_PRESENT: - if ( f->f_type != NULL ) { - free( f->f_type ); + ber_bvfree( f->f_sub_final ); } +#endif break; case LDAP_FILTER_AND: @@ -332,11 +481,15 @@ filter_free( Filter *f ) } break; + case SLAPD_FILTER_COMPUTED: + break; + default: Debug( LDAP_DEBUG_ANY, "unknown filter type %lu\n", f->f_choice, 0, 0 ); break; } + free( f ); } @@ -349,63 +502,105 @@ filter_print( Filter *f ) Filter *p; if ( f == NULL ) { - fprintf( stderr, "NULL" ); + fprintf( stderr, "No filter!" ); } switch ( f->f_choice ) { case LDAP_FILTER_EQUALITY: +#ifdef SLAPD_SCHEMA_NOT_COMPAT + fprintf( stderr, "(%s=%s)", + f->f_ava->aa_desc->ad_cname, + f->f_ava->aa_value->bv_val ); +#else fprintf( stderr, "(%s=%s)", f->f_ava.ava_type, f->f_ava.ava_value.bv_val ); +#endif break; case LDAP_FILTER_GE: +#ifdef SLAPD_SCHEMA_NOT_COMPAT + fprintf( stderr, "(%s>=%s)", + f->f_ava->aa_desc->ad_cname, + f->f_ava->aa_value->bv_val ); +#else fprintf( stderr, "(%s>=%s)", f->f_ava.ava_type, f->f_ava.ava_value.bv_val ); +#endif break; case LDAP_FILTER_LE: +#ifdef SLAPD_SCHEMA_NOT_COMPAT + fprintf( stderr, "(%s<=%s)", + f->f_ava->aa_desc->ad_cname, + f->f_ava->aa_value->bv_val ); +#else fprintf( stderr, "(%s<=%s)", f->f_ava.ava_type, f->f_ava.ava_value.bv_val ); +#endif break; case LDAP_FILTER_APPROX: +#ifdef SLAPD_SCHEMA_NOT_COMPAT + fprintf( stderr, "(%s~=%s)", + f->f_ava->aa_desc->ad_cname, + f->f_ava->aa_value->bv_val ); +#else fprintf( stderr, "(%s~=%s)", f->f_ava.ava_type, f->f_ava.ava_value.bv_val ); +#endif break; case LDAP_FILTER_SUBSTRINGS: - fprintf( stderr, "(%s=", f->f_sub_type ); +#ifdef SLAPD_SCHEMA_NOT_COMPAT + fprintf( stderr, "(%s=" /*)*/, f->f_sub_desc->ad_cname ); +#else + fprintf( stderr, "(%s=" /*)*/, f->f_sub_type ); +#endif if ( f->f_sub_initial != NULL ) { - fprintf( stderr, "%s", f->f_sub_initial ); + fprintf( stderr, "%s", f->f_sub_initial->bv_val ); } if ( f->f_sub_any != NULL ) { for ( i = 0; f->f_sub_any[i] != NULL; i++ ) { - fprintf( stderr, "*%s", f->f_sub_any[i] ); + fprintf( stderr, "*%s", f->f_sub_any[i]->bv_val ); } } - charray_free( f->f_sub_any ); if ( f->f_sub_final != NULL ) { - fprintf( stderr, "*%s", f->f_sub_final ); + fprintf( stderr, "*%s", f->f_sub_final->bv_val ); } + fprintf( stderr, /*(*/ ")" ); break; case LDAP_FILTER_PRESENT: - fprintf( stderr, "%s=*", f->f_type ); +#ifdef SLAPD_SCHEMA_NOT_COMPAT + fprintf( stderr, "(%s=*)", + f->f_desc->ad_cname ); +#else + fprintf( stderr, "(%s=*)", f->f_type ); +#endif break; case LDAP_FILTER_AND: case LDAP_FILTER_OR: case LDAP_FILTER_NOT: - fprintf( stderr, "(%c", f->f_choice == LDAP_FILTER_AND ? '&' : + fprintf( stderr, "(%c" /*)*/, + f->f_choice == LDAP_FILTER_AND ? '&' : f->f_choice == LDAP_FILTER_OR ? '|' : '!' ); for ( p = f->f_list; p != NULL; p = p->f_next ) { filter_print( p ); } - fprintf( stderr, ")" ); + fprintf( stderr, /*(*/ ")" ); + break; + + case SLAPD_FILTER_COMPUTED: + fprintf( stderr, "(%s)", + f->f_result == LDAP_COMPARE_FALSE ? "false" : + f->f_result == LDAP_COMPARE_TRUE ? "true" : + f->f_result == SLAPD_COMPARE_UNDEFINED ? "undefined" : + "error" ); break; default: - fprintf( stderr, "unknown type %lu", f->f_choice ); + fprintf( stderr, "(unknown filter %lu)", f->f_choice ); break; } }