Diff for /servers/slapd/str2filter.c between versions 1.6.8.2 and 1.6.8.3

version 1.6.8.2, 1999/09/10 20:25:31 version 1.6.8.3, 2000/06/13 17:57:30
Line 1 Line 1
 /* str2filter.c - parse an rfc 1588 string filter */  /* str2filter.c - parse an rfc 1588 string filter */
 /* $OpenLDAP: pkg/ldap/servers/slapd/str2filter.c,v 1.9 1999/09/08 17:06:34 kdz Exp $ */  /* $OpenLDAP: pkg/ldap/servers/slapd/str2filter.c,v 1.17 2000/06/06 17:43:20 kurt Exp $ */
 /*  /*
  * Copyright 1998-1999 The OpenLDAP Foundation, All Rights Reserved.   * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.
  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file   * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
  */   */
   
Line 16 Line 16
 #include "slap.h"  #include "slap.h"
 #include <ldap_pvt.h>  #include <ldap_pvt.h>
   
 static char     *find_matching_paren(char *s);  static char     *find_matching_paren( const char *s );
 static Filter   *str2list(char *str, long unsigned int ftype);  static Filter   *str2list( const char *str, long unsigned int ftype);
 static Filter   *str2simple(char *str);  static Filter   *str2simple( const char *str);
 static int      str2subvals(char *val, Filter *f);  static int      str2subvals( const char *val, Filter *f);
   
 Filter *  Filter *
 str2filter( char *str )  str2filter( const char *str )
 {  {
         Filter  *f = NULL;          Filter  *f = NULL;
         char    *end, *freeme;          char    *end, *freeme;
Line 97  str2filter( char *str ) Line 97  str2filter( char *str )
  */   */
   
 static Filter *  static Filter *
 str2list( char *str, unsigned long ftype )  str2list( const char *str, unsigned long ftype )
 {  {
         Filter  *f;          Filter  *f;
         Filter  **fp;          Filter  **fp;
Line 140  str2list( char *str, unsigned long ftype Line 140  str2list( char *str, unsigned long ftype
 }  }
   
 static Filter *  static Filter *
 str2simple( char *str )  str2simple( const char *str )
 {  {
         Filter          *f;          Filter          *f;
         char            *s;          char            *s;
         char            *value, savechar;          char            *value, savechar;
           int                     rc;
           const char              *text;
   
         Debug( LDAP_DEBUG_FILTER, "str2simple \"%s\"\n", str, 0, 0 );          Debug( LDAP_DEBUG_FILTER, "str2simple \"%s\"\n", str, 0, 0 );
   
         if ( (s = strchr( str, '=' )) == NULL ) {          if ( (s = strchr( str, '=' )) == NULL ) {
                 return( NULL );                  return( NULL );
         }          }
         value = s + 1;          value = &s[1];
         *s-- = '\0';  
           *s-- = '\0';    /* we shouldn't be mucking with str */
         savechar = *s;          savechar = *s;
   
         f = (Filter *) ch_calloc( 1, sizeof(Filter) );          f = (Filter *) ch_calloc( 1, sizeof(Filter) );
Line 170  str2simple( char *str ) Line 173  str2simple( char *str )
                 f->f_choice = LDAP_FILTER_APPROX;                  f->f_choice = LDAP_FILTER_APPROX;
                 *s = '\0';                  *s = '\0';
                 break;                  break;
           case ':':
                   f->f_choice = LDAP_FILTER_EXT;
                   *s = '\0';
                   return NULL;
                   break;
   
         default:          default:
                 if ( ldap_pvt_find_wildcard( value ) == NULL ) {                  if ( ldap_pvt_find_wildcard( value ) == NULL ) {
                         f->f_choice = LDAP_FILTER_EQUALITY;                          f->f_choice = LDAP_FILTER_EQUALITY;
Line 177  str2simple( char *str ) Line 186  str2simple( char *str )
                         f->f_choice = LDAP_FILTER_PRESENT;                          f->f_choice = LDAP_FILTER_PRESENT;
                 } else {                  } else {
                         f->f_choice = LDAP_FILTER_SUBSTRINGS;                          f->f_choice = LDAP_FILTER_SUBSTRINGS;
                         f->f_sub_type = ch_strdup( str );                          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 ) {                          if ( str2subvals( value, f ) != 0 ) {
                                 filter_free( f );                                  filter_free( f );
                                 *(value-1) = '=';                                  *(value-1) = '=';
Line 190  str2simple( char *str ) Line 205  str2simple( char *str )
         }          }
   
         if ( f->f_choice == LDAP_FILTER_PRESENT ) {          if ( f->f_choice == LDAP_FILTER_PRESENT ) {
                 f->f_type = ch_strdup( str );                  rc = slap_str2ad( str, &f->f_desc, &text );
                   if( rc != LDAP_SUCCESS ) {
                           filter_free( f );
                           *(value-1) = '=';
                           return NULL;
                   }
         } else {          } else {
                 f->f_avtype = ch_strdup( str );                  char *tmp;
                 f->f_avvalue.bv_val = ch_strdup( value );  
                 ldap_pvt_filter_value_unescape( f->f_avvalue.bv_val );                  f->f_ava = ch_calloc( 1, sizeof( AttributeAssertion ) );
                 f->f_avvalue.bv_len = strlen( value );                  f->f_av_desc = NULL;
                   rc = slap_str2ad( str, &f->f_av_desc, &text );
                   if( rc != LDAP_SUCCESS ) {
                           filter_free( f );
                           *(value-1) = '=';
                           return NULL;
                   }
   
                   tmp = ch_strdup( value );
                   ldap_pvt_filter_value_unescape( tmp );
                   f->f_av_value = ber_bvstr( tmp );
         }          }
   
         *s = savechar;          *s = savechar;
         *(value-1) = '=';          *(value-1) = '=';
   
         return( f );          return( f );
 }  }
   
 static int  static int
 str2subvals( char *val, Filter *f )  str2subvals( const char *in, Filter *f )
 {  {
         char    *nextstar, *freeme;          char    *nextstar, *val, *freeme;
         int     gotstar;          int     gotstar;
   
         Debug( LDAP_DEBUG_FILTER, "str2subvals \"%s\"\n", val, 0, 0 );          Debug( LDAP_DEBUG_FILTER, "str2subvals \"%s\"\n", in, 0, 0 );
   
         val = freeme = ch_strdup( val );          if( in == NULL ) return 0;
   
           val = freeme = ch_strdup( in );
         gotstar = 0;          gotstar = 0;
         while ( val != NULL && *val ) {  
           while ( *val ) {
                 if ( (nextstar = ldap_pvt_find_wildcard( val )) != NULL )                  if ( (nextstar = ldap_pvt_find_wildcard( val )) != NULL )
                         *nextstar++ = '\0';                          *nextstar++ = '\0';
   
                 ldap_pvt_filter_value_unescape( val );                  ldap_pvt_filter_value_unescape( val );
   
                 if ( gotstar == 0 ) {                  if ( gotstar == 0 ) {
                         f->f_sub_initial = ch_strdup( val );                          f->f_sub_initial = ber_bvstrdup( val );
   
                 } else if ( nextstar == NULL ) {                  } else if ( nextstar == NULL ) {
                         f->f_sub_final = ch_strdup( val );                          f->f_sub_final = ber_bvstrdup( val );
   
                 } else {                  } else {
                         charray_add( &f->f_sub_any, val );                          charray_add( (char ***) &f->f_sub_any, (char *) ber_bvstrdup( val ) );
                 }                  }
   
                 gotstar = 1;                  gotstar = 1;
Line 240  str2subvals( char *val, Filter *f ) Line 277  str2subvals( char *val, Filter *f )
  */   */
   
 static char *  static char *
 find_matching_paren( char *s )  find_matching_paren( const char *s )
 {  {
         int     balance, escape;          int     balance, escape;
   
Line 254  find_matching_paren( char *s ) Line 291  find_matching_paren( char *s )
                                 balance--;                                  balance--;
                 }                  }
                 if ( balance == 0 ) {                  if ( balance == 0 ) {
                         return( s );                          return (char *) s;
                 }                  }
                 if ( *s == '\\' && ! escape )                  if ( *s == '\\' && ! escape )
                         escape = 1;                          escape = 1;
Line 262  find_matching_paren( char *s ) Line 299  find_matching_paren( char *s )
                         escape = 0;                          escape = 0;
         }          }
   
         return( NULL );          return NULL;
 }  }

Removed from v.1.6.8.2  
changed lines
  Added in v.1.6.8.3


______________
© Copyright 1998-2020, OpenLDAP Foundation, info@OpenLDAP.org