]> git.sur5r.net Git - openldap/blobdiff - servers/slapd/str2filter.c
Don't use 'shtool mkln' as ln(1) replacement.
[openldap] / servers / slapd / str2filter.c
index 9ce1371bb1884463f74ada69402012741250e3f9..8d36467dde6489217589afb7129fa166410621c8 100644 (file)
@@ -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
  */
 
@@ -28,15 +28,14 @@ str2filter( const char *str )
        char    *end, *freeme;
 
 #ifdef NEW_LOGGING
-        LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
-                   "str2filter: \"%s\"\n", str ));
+       LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
+               "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';
 
@@ -54,56 +53,52 @@ str2filter( const char *str )
                switch ( *str ) {
                case '&':
 #ifdef NEW_LOGGING
-                    LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
-                               "str2filter:  AND\n" ));
+                       LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
+                               "str2filter:  AND\n" ));
 #else
                        Debug( LDAP_DEBUG_FILTER, "str2filter: AND\n",
                            0, 0, 0 );
 #endif
 
-
                        str++;
                        f = str2list( str, LDAP_FILTER_AND );
                        break;
 
                case '|':
 #ifdef NEW_LOGGING
-                    LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
-                               "str2filter:  OR\n" ));
+                       LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
+                               "str2filter:  OR\n" ));
 #else
                        Debug( LDAP_DEBUG_FILTER, "put_filter: OR\n",
                            0, 0, 0 );
 #endif
 
-
                        str++;
                        f = str2list( str, LDAP_FILTER_OR );
                        break;
 
                case '!':
 #ifdef NEW_LOGGING
-                    LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
-                               "str2filter:  NOT\n" ));
+                       LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
+                               "str2filter:  NOT\n" ));
 #else
                        Debug( LDAP_DEBUG_FILTER, "put_filter: NOT\n",
                            0, 0, 0 );
 #endif
 
-
                        str++;
                        f = str2list( str, LDAP_FILTER_NOT );
                        break;
 
                default:
 #ifdef NEW_LOGGING
-                    LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
-                               "str2filter:  simple\n" ));
+                       LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
+                               "str2filter:  simple\n" ));
 #else
                        Debug( LDAP_DEBUG_FILTER, "str2filter: simple\n",
                            0, 0, 0 );
 #endif
 
-
                        f = str2simple( str );
                        break;
                }
@@ -112,14 +107,13 @@ 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" ));
+               LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
+                       "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;
        }
@@ -141,13 +135,12 @@ str2list( const char *str, unsigned long ftype )
        char    save;
 
 #ifdef NEW_LOGGING
-        LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
-                   "str2list: \"%s\"\n", str ));
+       LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
+               "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;
@@ -191,15 +184,14 @@ str2simple( const char *str )
        const char              *text;
 
 #ifdef NEW_LOGGING
-        LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
-                   "str2simple:  \"%s\"\n", str ));
+       LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
+               "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];
 
@@ -227,29 +219,40 @@ str2simple( const char *str )
                return NULL;
                break;
 
-       default:
-               if ( ldap_pvt_find_wildcard( value ) == NULL ) {
-                       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 ) {
+       default: {
+                       char *nextstar = ldap_pvt_find_wildcard( value );
+
+                       if ( nextstar == NULL ) {
                                filter_free( f );
                                *(value-1) = '=';
                                return NULL;
-                       }
-                       if ( str2subvals( value, f ) != 0 ) {
-                               filter_free( f );
+
+                       } 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;
+                               }
                                *(value-1) = '=';
-                               return( NULL );
+                               return f;
                        }
-                       *(value-1) = '=';
-                       return( f );
-               }
-               break;
+               } break;
        }
 
        if ( f->f_choice == LDAP_FILTER_PRESENT ) {
@@ -259,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 ) );
@@ -272,57 +277,79 @@ str2simple( const char *str )
                }
 
                tmp = ch_strdup( value );
-               ldap_pvt_filter_value_unescape( tmp );
-               f->f_av_value = ber_bvstr( 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 ));
+       LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
+               "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 );
-       gotstar = 0;
+       gotstar = final = 0;
 
        while ( *val ) {
-               if ( (nextstar = ldap_pvt_find_wildcard( val )) != NULL )
-                       *nextstar++ = '\0';
+               nextstar = ldap_pvt_find_wildcard( val );
+
+               if ( nextstar == NULL ) {
+                       free( freeme );
+                       return -1;
 
-               ldap_pvt_filter_value_unescape( val );
+               } else if( *nextstar == '\0' ) {
+                       final = 1;
+
+               } else {
+                       gotstar++;
+                       *nextstar = '\0';
+               }
+
+               len = ldap_pvt_filter_value_unescape( val );
+               if( len < 0 ) {
+                       free( freeme );
+                       return -1;
+               }
 
-               if ( gotstar == 0 ) {
-                       f->f_sub_initial = ber_bvstrdup( val );
+               if ( final ) {
+                       ber_str2bv( val, 0, 1, &f->f_sub_final );
 
-               } else if ( nextstar == NULL ) {
-                       f->f_sub_final = ber_bvstrdup( val );
+               } else if ( gotstar <= 1 ) {
+                       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 ) );
                }
 
-               gotstar = 1;
-               val = nextstar;
+               val = nextstar+1;
        }
 
        free( freeme );
-       return( 0 );
+       return 0;
 }
 
 /*