git.sur5r.net Git - openldap/blob - servers/slapd/str2filter.c

   1 /* str2filter.c - parse an rfc 1588 string filter */
   2
   3 #include "portable.h"
   4
   5 #include <stdio.h>
   6
   7 #include <ac/string.h>
   8 #include <ac/socket.h>
   9
  10 #include "slap.h"
  11
  12 static char     *find_matching_paren();
  13 static Filter   *str2list();
  14 static Filter   *str2simple();
  15 static int      str2subvals();
  16
  17 Filter *
  18 str2filter( char *str )
  19 {
  20         Filter  *f;
  21         char    *end;
  22
  23         Debug( LDAP_DEBUG_FILTER, "str2filter \"%s\"\n", str, 0, 0 );
  24
  25         if ( str == NULL || *str == '\0' ) {
  26                 return( NULL );
  27         }
  28
  29         switch ( *str ) {
  30         case '(':
  31                 if ( (end = find_matching_paren( str )) == NULL ) {
  32                         filter_free( f );
  33                         return( NULL );
  34                 }
  35                 *end = '\0';
  36
  37                 str++;
  38                 switch ( *str ) {
  39                 case '&':
  40                         Debug( LDAP_DEBUG_FILTER, "str2filter: AND\n",
  41                             0, 0, 0 );
  42
  43                         str++;
  44                         f = str2list( str, LDAP_FILTER_AND );
  45                         break;
  46
  47                 case '|':
  48                         Debug( LDAP_DEBUG_FILTER, "put_filter: OR\n",
  49                             0, 0, 0 );
  50
  51                         str++;
  52                         f = str2list( str, LDAP_FILTER_OR );
  53                         break;
  54
  55                 case '!':
  56                         Debug( LDAP_DEBUG_FILTER, "put_filter: NOT\n",
  57                             0, 0, 0 );
  58
  59                         str++;
  60                         f = str2list( str, LDAP_FILTER_NOT );
  61                         break;
  62
  63                 default:
  64                         Debug( LDAP_DEBUG_FILTER, "str2filter: simple\n",
  65                             0, 0, 0 );
  66
  67                         f = str2simple( str );
  68                         break;
  69                 }
  70                 *end = ')';
  71                 break;
  72
  73         default:        /* assume it's a simple type=value filter */
  74                 Debug( LDAP_DEBUG_FILTER, "str2filter: default\n", 0, 0,
  75                     0 );
  76
  77                 f = str2simple( str );
  78                 break;
  79         }
  80
  81         return( f );
  82 }
  83
  84 /*
  85  * Put a list of filters like this "(filter1)(filter2)..."
  86  */
  87
  88 static Filter *
  89 str2list( char *str, unsigned long ftype )
  90 {
  91         Filter  *f;
  92         Filter  **fp;
  93         char    *next;
  94         char    save;
  95
  96         Debug( LDAP_DEBUG_FILTER, "str2list \"%s\"\n", str, 0, 0 );
  97
  98         f = (Filter *) ch_calloc( 1, sizeof(Filter) );
  99         f->f_choice = ftype;
 100         fp = &f->f_list;
 101
 102         while ( *str ) {
 103                 while ( *str && isspace( *str ) )
 104                         str++;
 105                 if ( *str == '\0' )
 106                         break;
 107
 108                 if ( (next = find_matching_paren( str )) == NULL ) {
 109                         filter_free( f );
 110                         return( NULL );
 111                 }
 112                 save = *++next;
 113                 *next = '\0';
 114
 115                 /* now we have "(filter)" with str pointing to it */
 116                 if ( (*fp = str2filter( str )) == NULL ) {
 117                         filter_free( f );
 118                         *next = save;
 119                         return( NULL );
 120                 }
 121                 *next = save;
 122
 123                 str = next;
 124                 fp = &(*fp)->f_next;
 125         }
 126         *fp = NULL;
 127
 128         return( f );
 129 }
 130
 131 static Filter *
 132 str2simple( char *str )
 133 {
 134         Filter          *f;
 135         char            *s;
 136         char            *value, savechar;
 137
 138         Debug( LDAP_DEBUG_FILTER, "str2simple \"%s\"\n", str, 0, 0 );
 139
 140         if ( (s = strchr( str, '=' )) == NULL ) {
 141                 return( NULL );
 142         }
 143         value = s + 1;
 144         *s-- = '\0';
 145         savechar = *s;
 146
 147         f = (Filter *) ch_calloc( 1, sizeof(Filter) );
 148
 149         switch ( *s ) {
 150         case '<':
 151                 f->f_choice = LDAP_FILTER_LE;
 152                 *s = '\0';
 153                 break;
 154         case '>':
 155                 f->f_choice = LDAP_FILTER_GE;
 156                 *s = '\0';
 157                 break;
 158         case '~':
 159                 f->f_choice = LDAP_FILTER_APPROX;
 160                 *s = '\0';
 161                 break;
 162         default:
 163                 if ( strchr( value, '*' ) == NULL ) {
 164                         f->f_choice = LDAP_FILTER_EQUALITY;
 165                 } else if ( strcmp( value, "*" ) == 0 ) {
 166                         f->f_choice = LDAP_FILTER_PRESENT;
 167                 } else {
 168                         f->f_choice = LDAP_FILTER_SUBSTRINGS;
 169                         f->f_sub_type = strdup( str );
 170                         if ( str2subvals( value, f ) != 0 ) {
 171                                 filter_free( f );
 172                                 *(value-1) = '=';
 173                                 return( NULL );
 174                         }
 175                         *(value-1) = '=';
 176                         return( f );
 177                 }
 178                 break;
 179         }
 180
 181         if ( f->f_choice == LDAP_FILTER_PRESENT ) {
 182                 f->f_type = strdup( str );
 183         } else {
 184                 f->f_avtype = strdup( str );
 185                 f->f_avvalue.bv_val = strdup( value );
 186                 f->f_avvalue.bv_len = strlen( value );
 187         }
 188
 189         *s = savechar;
 190         *(value-1) = '=';
 191         return( f );
 192 }
 193
 194 static int
 195 str2subvals( char *val, Filter *f )
 196 {
 197         char    *nextstar;
 198         int     gotstar;
 199
 200         Debug( LDAP_DEBUG_FILTER, "str2subvals \"%s\"\n", val, 0, 0 );
 201
 202         gotstar = 0;
 203         while ( val != NULL && *val ) {
 204                 if ( (nextstar = strchr( val, '*' )) != NULL )
 205                         *nextstar++ = '\0';
 206
 207                 if ( gotstar == 0 ) {
 208                         f->f_sub_initial = strdup( val );
 209                 } else if ( nextstar == NULL ) {
 210                         f->f_sub_final = strdup( val );
 211                 } else {
 212                         charray_add( &f->f_sub_any, strdup( val ) );
 213                 }
 214
 215                 gotstar = 1;
 216                 if ( nextstar != NULL )
 217                         *(nextstar-1) = '*';
 218                 val = nextstar;
 219         }
 220
 221         return( 0 );
 222 }
 223
 224 /*
 225  * find_matching_paren - return a pointer to the right paren in s matching
 226  * the left paren to which *s currently points
 227  */
 228
 229 static char *
 230 find_matching_paren( char *s )
 231 {
 232         int     balance, escape;
 233
 234         balance = 0;
 235         escape = 0;
 236         for ( ; *s; s++ ) {
 237                 if ( escape == 0 ) {
 238                         if ( *s == '(' )
 239                                 balance++;
 240                         else if ( *s == ')' )
 241                                 balance--;
 242                 }
 243                 if ( balance == 0 ) {
 244                         return( s );
 245                 }
 246                 if ( *s == '\\' && ! escape )
 247                         escape = 1;
 248                 else
 249                         escape = 0;
 250         }
 251
 252         return( NULL );
 253 }