Replace get_filter generation of fstr with filter2bv().

diff --git a/servers/slapd/filter.c b/servers/slapd/filter.c
index 23dc37620e9ce865dd8165e93b15a5f2abdfdd60..11ce1afdef71c08853976f7d047f32b6b592a6cb 100644 (file)
--- a/servers/slapd/filter.c
+++ b/servers/slapd/filter.c
@@ -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 )

diff --git a/servers/slapd/proto-slap.h b/servers/slapd/proto-slap.h
index 444fbe4b5b5fcf0527e6386253e13710d62dc619..b890a83164ef2ddc75b98e93744f6ecb8815aa6e 100644 (file)
--- a/servers/slapd/proto-slap.h
+++ b/servers/slapd/proto-slap.h
@@ -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

diff --git a/servers/slapd/search.c b/servers/slapd/search.c
index 95a278947063c450f59ac6a5c655b071903ea8c8..6ba03faf3a19d9f507edf35e2271c493a0acf1c9 100644 (file)
--- a/servers/slapd/search.c
+++ b/servers/slapd/search.c
@@ -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 */

diff --git a/tests/scripts/test003-search b/tests/scripts/test003-search
index 17f6fb5834df4d2cbf9d7d70b38540a4f70622b8..d0173fbac2b50bfad713b6dc8fca6a306fbae510 100755 (executable)
--- a/tests/scripts/test003-search
+++ b/tests/scripts/test003-search
@@ -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