Add a default case with assert() just in case.

[openldap] / servers / slapd / str2filter.c

diff --git a/servers/slapd/str2filter.c b/servers/slapd/str2filter.c
index 2f686094412988552c4542c1f583b3676c9af3ca..8d36467dde6489217589afb7129fa166410621c8 100644 (file)
--- a/servers/slapd/str2filter.c
+++ b/servers/slapd/str2filter.c
@@ -1,7 +1,7 @@
 /* str2filter.c - parse an rfc 1588 string filter */
 /* $OpenLDAP$ */
 /*
- * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.
+ * Copyright 1998-2002 The OpenLDAP Foundation, All Rights Reserved.
  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
  */
 
@@ -29,14 +29,13 @@ str2filter( const char *str )
 
 #ifdef NEW_LOGGING
        LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
-                  "str2filter: \"%s\"\n", str ));
+               "str2filter: \"%s\"\n", str ));
 #else
        Debug( LDAP_DEBUG_FILTER, "str2filter \"%s\"\n", str, 0, 0 );
 #endif
 
-
        if ( str == NULL || *str == '\0' ) {
-               return( NULL );
+               return NULL;
        }
 
        str = freeme = ch_strdup( str );
@@ -46,7 +45,7 @@ str2filter( const char *str )
                if ( (end = find_matching_paren( str )) == NULL ) {
                        filter_free( f );
                        free( freeme );
-                       return( NULL );
+                       return NULL;
                }
                *end = '\0';
 
@@ -55,13 +54,12 @@ str2filter( const char *str )
                case '&':
 #ifdef NEW_LOGGING
                        LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
-                                  "str2filter:  AND\n" ));
+                               "str2filter:  AND\n" ));
 #else
                        Debug( LDAP_DEBUG_FILTER, "str2filter: AND\n",
                            0, 0, 0 );
 #endif
 
-
                        str++;
                        f = str2list( str, LDAP_FILTER_AND );
                        break;
@@ -69,13 +67,12 @@ str2filter( const char *str )
                case '|':
 #ifdef NEW_LOGGING
                        LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
-                                  "str2filter:  OR\n" ));
+                               "str2filter:  OR\n" ));
 #else
                        Debug( LDAP_DEBUG_FILTER, "put_filter: OR\n",
                            0, 0, 0 );
 #endif
 
-
                        str++;
                        f = str2list( str, LDAP_FILTER_OR );
                        break;
@@ -83,13 +80,12 @@ str2filter( const char *str )
                case '!':
 #ifdef NEW_LOGGING
                        LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
-                                  "str2filter:  NOT\n" ));
+                               "str2filter:  NOT\n" ));
 #else
                        Debug( LDAP_DEBUG_FILTER, "put_filter: NOT\n",
                            0, 0, 0 );
 #endif
 
-
                        str++;
                        f = str2list( str, LDAP_FILTER_NOT );
                        break;
@@ -97,13 +93,12 @@ str2filter( const char *str )
                default:
 #ifdef NEW_LOGGING
                        LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
-                                  "str2filter:  simple\n" ));
+                               "str2filter:  simple\n" ));
 #else
                        Debug( LDAP_DEBUG_FILTER, "str2filter: simple\n",
                            0, 0, 0 );
 #endif
 
-
                        f = str2simple( str );
                        break;
                }
@@ -113,13 +108,12 @@ str2filter( const char *str )
        default:        /* assume it's a simple type=value filter */
 #ifdef NEW_LOGGING
                LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
-                          "str2filter: default\n" ));
+                       "str2filter: default\n" ));
 #else
-               Debug( LDAP_DEBUG_FILTER, "str2filter: default\n", 0, 0,
-                   0 );
+               Debug( LDAP_DEBUG_FILTER, "str2filter: default\n",
+                       0, 0, 0 );
 #endif
 
-
                f = str2simple( str );
                break;
        }
@@ -142,12 +136,11 @@ str2list( const char *str, unsigned long ftype )
 
 #ifdef NEW_LOGGING
        LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
-                  "str2list: \"%s\"\n", str ));
+               "str2list: \"%s\"\n", str ));
 #else
        Debug( LDAP_DEBUG_FILTER, "str2list \"%s\"\n", str, 0, 0 );
 #endif
 
-
        f = (Filter *) ch_calloc( 1, sizeof(Filter) );
        f->f_choice = ftype;
        fp = &f->f_list;
@@ -192,14 +185,13 @@ str2simple( const char *str )
 
 #ifdef NEW_LOGGING
        LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
-                  "str2simple:  \"%s\"\n", str ));
+               "str2simple: \"%s\"\n", str ));
 #else
        Debug( LDAP_DEBUG_FILTER, "str2simple \"%s\"\n", str, 0, 0 );
 #endif
 
-
        if ( (s = strchr( str, '=' )) == NULL ) {
-               return( NULL );
+               return NULL;
        }
        value = &s[1];
 
@@ -229,30 +221,36 @@ str2simple( const char *str )
 
        default: {
                        char *nextstar = ldap_pvt_find_wildcard( value );
+
                        if ( nextstar == NULL ) {
                                filter_free( f );
                                *(value-1) = '=';
                                return NULL;
-                       } else if ( nextstar == '\0' ) {
+
+                       } else if ( *nextstar == '\0' ) {
                                f->f_choice = LDAP_FILTER_EQUALITY;
+
                        } else if ( strcmp( value, "*" ) == 0 ) {
                                f->f_choice = LDAP_FILTER_PRESENT;
+
                        } else {
                                f->f_choice = LDAP_FILTER_SUBSTRINGS;
                                f->f_sub = ch_calloc( 1, sizeof( SubstringsAssertion ) );
+
                                rc = slap_str2ad( str, &f->f_sub_desc, &text );
                                if( rc != LDAP_SUCCESS ) {
                                        filter_free( f );
                                        *(value-1) = '=';
                                        return NULL;
                                }
+
                                if ( str2subvals( value, f ) != 0 ) {
                                        filter_free( f );
                                        *(value-1) = '=';
-                                       return( NULL );
+                                       return NULL;
                                }
                                *(value-1) = '=';
-                               return( f );
+                               return f;
                        }
                } break;
        }
@@ -264,7 +262,9 @@ str2simple( const char *str )
                        *(value-1) = '=';
                        return NULL;
                }
+
        } else {
+               ber_slen_t len;
                char *tmp;
 
                f->f_ava = ch_calloc( 1, sizeof( AttributeAssertion ) );
@@ -277,31 +277,37 @@ str2simple( const char *str )
                }
 
                tmp = ch_strdup( value );
-               ldap_pvt_filter_value_unescape( tmp );
+               len = ldap_pvt_filter_value_unescape( tmp );
+               if( len < 0 ) {
+                       filter_free( f );
+                       *(value-1) = '=';
+                       free( tmp );
+                       return NULL;
+               }
                ber_str2bv( tmp, 0, 0, &f->f_av_value );
        }
 
        *s = savechar;
        *(value-1) = '=';
 
-       return( f );
+       return f;
 }
 
 static int
 str2subvals( const char *in, Filter *f )
 {
+       ber_slen_t len;
        char    *nextstar, *val, *freeme;
        int     gotstar;
        int final;
 
 #ifdef NEW_LOGGING
        LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
-                  "str2subvals: \"%s\"\n", in ));
+               "str2subvals: \"%s\"\n", in ));
 #else
        Debug( LDAP_DEBUG_FILTER, "str2subvals \"%s\"\n", in, 0, 0 );
 #endif
 
-
        if( in == NULL ) return 0;
 
        val = freeme = ch_strdup( in );
@@ -313,16 +319,20 @@ str2subvals( const char *in, Filter *f )
                if ( nextstar == NULL ) {
                        free( freeme );
                        return -1;
-               }
 
-               if( *nextstar == '\0' ) {
+               } else if( *nextstar == '\0' ) {
                        final = 1;
+
                } else {
                        gotstar++;
                        *nextstar = '\0';
                }
 
-               ldap_pvt_filter_value_unescape( val );
+               len = ldap_pvt_filter_value_unescape( val );
+               if( len < 0 ) {
+                       free( freeme );
+                       return -1;
+               }
 
                if ( final ) {
                        ber_str2bv( val, 0, 1, &f->f_sub_final );
@@ -331,14 +341,15 @@ str2subvals( const char *in, Filter *f )
                        ber_str2bv( val, 0, 1, &f->f_sub_initial );
 
                } else {
-                       charray_add( (char ***) &f->f_sub_any, (char *) ber_bvstrdup( val ) );
+                       charray_add( (char ***) &f->f_sub_any,
+                               (char *) ber_bvstrdup( val ) );
                }
 
                val = nextstar+1;
        }
 
        free( freeme );
-       return( 0 );
+       return 0;
 }
 
 /*