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

   1 /* str2filter.c - parse an rfc 1588 string filter */
   2 /* $OpenLDAP$ */
   3 /*
   4  * Copyright 1998-2002 The OpenLDAP Foundation, All Rights Reserved.
   5  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   6  */
   7
   8 #include "portable.h"
   9
  10 #include <stdio.h>
  11
  12 #include <ac/string.h>
  13 #include <ac/ctype.h>
  14 #include <ac/socket.h>
  15
  16 #include "slap.h"
  17 #include <ldap_pvt.h>
  18
  19 static char     *find_matching_paren( const char *s );
  20 static Filter   *str2list( const char *str, long unsigned int ftype);
  21 static Filter   *str2simple( const char *str);
  22 static int      str2subvals( const char *val, Filter *f);
  23
  24 Filter *
  25 str2filter( const char *str )
  26 {
  27         Filter  *f = NULL;
  28         char    *end, *freeme;
  29
  30 #ifdef NEW_LOGGING
  31         LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
  32                 "str2filter: \"%s\"\n", str ));
  33 #else
  34         Debug( LDAP_DEBUG_FILTER, "str2filter \"%s\"\n", str, 0, 0 );
  35 #endif
  36
  37         if ( str == NULL || *str == '\0' ) {
  38                 return NULL;
  39         }
  40
  41         str = freeme = ch_strdup( str );
  42
  43         switch ( *str ) {
  44         case '(':
  45                 if ( (end = find_matching_paren( str )) == NULL ) {
  46                         filter_free( f );
  47                         free( freeme );
  48                         return NULL;
  49                 }
  50                 *end = '\0';
  51
  52                 str++;
  53                 switch ( *str ) {
  54                 case '&':
  55 #ifdef NEW_LOGGING
  56                         LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
  57                                 "str2filter:  AND\n" ));
  58 #else
  59                         Debug( LDAP_DEBUG_FILTER, "str2filter: AND\n",
  60                             0, 0, 0 );
  61 #endif
  62
  63                         str++;
  64                         f = str2list( str, LDAP_FILTER_AND );
  65                         break;
  66
  67                 case '|':
  68 #ifdef NEW_LOGGING
  69                         LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
  70                                 "str2filter:  OR\n" ));
  71 #else
  72                         Debug( LDAP_DEBUG_FILTER, "put_filter: OR\n",
  73                             0, 0, 0 );
  74 #endif
  75
  76                         str++;
  77                         f = str2list( str, LDAP_FILTER_OR );
  78                         break;
  79
  80                 case '!':
  81 #ifdef NEW_LOGGING
  82                         LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
  83                                 "str2filter:  NOT\n" ));
  84 #else
  85                         Debug( LDAP_DEBUG_FILTER, "put_filter: NOT\n",
  86                             0, 0, 0 );
  87 #endif
  88
  89                         str++;
  90                         f = str2list( str, LDAP_FILTER_NOT );
  91                         break;
  92
  93                 default:
  94 #ifdef NEW_LOGGING
  95                         LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
  96                                 "str2filter:  simple\n" ));
  97 #else
  98                         Debug( LDAP_DEBUG_FILTER, "str2filter: simple\n",
  99                             0, 0, 0 );
 100 #endif
 101
 102                         f = str2simple( str );
 103                         break;
 104                 }
 105                 *end = ')';
 106                 break;
 107
 108         default:        /* assume it's a simple type=value filter */
 109 #ifdef NEW_LOGGING
 110                 LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
 111                         "str2filter: default\n" ));
 112 #else
 113                 Debug( LDAP_DEBUG_FILTER, "str2filter: default\n",
 114                         0, 0, 0 );
 115 #endif
 116
 117                 f = str2simple( str );
 118                 break;
 119         }
 120
 121         free( freeme );
 122         return( f );
 123 }
 124
 125 /*
 126  * Put a list of filters like this "(filter1)(filter2)..."
 127  */
 128
 129 static Filter *
 130 str2list( const char *str, unsigned long ftype )
 131 {
 132         Filter  *f;
 133         Filter  **fp;
 134         char    *next;
 135         char    save;
 136
 137 #ifdef NEW_LOGGING
 138         LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
 139                 "str2list: \"%s\"\n", str ));
 140 #else
 141         Debug( LDAP_DEBUG_FILTER, "str2list \"%s\"\n", str, 0, 0 );
 142 #endif
 143
 144         f = (Filter *) ch_calloc( 1, sizeof(Filter) );
 145         f->f_choice = ftype;
 146         fp = &f->f_list;
 147
 148         while ( *str ) {
 149                 while ( *str && isspace( (unsigned char) *str ) )
 150                         str++;
 151                 if ( *str == '\0' )
 152                         break;
 153
 154                 if ( (next = find_matching_paren( str )) == NULL ) {
 155                         filter_free( f );
 156                         return( NULL );
 157                 }
 158                 save = *++next;
 159                 *next = '\0';
 160
 161                 /* now we have "(filter)" with str pointing to it */
 162                 if ( (*fp = str2filter( str )) == NULL ) {
 163                         filter_free( f );
 164                         *next = save;
 165                         return( NULL );
 166                 }
 167                 *next = save;
 168
 169                 str = next;
 170                 fp = &(*fp)->f_next;
 171         }
 172         *fp = NULL;
 173
 174         return( f );
 175 }
 176
 177 static Filter *
 178 str2simple( const char *str )
 179 {
 180         Filter          *f;
 181         char            *s;
 182         char            *value, savechar;
 183         int                     rc;
 184         const char              *text;
 185
 186 #ifdef NEW_LOGGING
 187         LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
 188                 "str2simple: \"%s\"\n", str ));
 189 #else
 190         Debug( LDAP_DEBUG_FILTER, "str2simple \"%s\"\n", str, 0, 0 );
 191 #endif
 192
 193         if ( (s = strchr( str, '=' )) == NULL ) {
 194                 return NULL;
 195         }
 196         value = &s[1];
 197
 198         *s-- = '\0';    /* we shouldn't be mucking with str */
 199         savechar = *s;
 200
 201         f = (Filter *) ch_calloc( 1, sizeof(Filter) );
 202
 203         switch ( *s ) {
 204         case '<':
 205                 f->f_choice = LDAP_FILTER_LE;
 206                 *s = '\0';
 207                 break;
 208         case '>':
 209                 f->f_choice = LDAP_FILTER_GE;
 210                 *s = '\0';
 211                 break;
 212         case '~':
 213                 f->f_choice = LDAP_FILTER_APPROX;
 214                 *s = '\0';
 215                 break;
 216         case ':':
 217                 f->f_choice = LDAP_FILTER_EXT;
 218                 *s = '\0';
 219                 return NULL;
 220                 break;
 221
 222         default: {
 223                         char *nextstar = ldap_pvt_find_wildcard( value );
 224
 225                         if ( nextstar == NULL ) {
 226                                 filter_free( f );
 227                                 *(value-1) = '=';
 228                                 return NULL;
 229
 230                         } else if ( *nextstar == '\0' ) {
 231                                 f->f_choice = LDAP_FILTER_EQUALITY;
 232
 233                         } else if ( strcmp( value, "*" ) == 0 ) {
 234                                 f->f_choice = LDAP_FILTER_PRESENT;
 235
 236                         } else {
 237                                 f->f_choice = LDAP_FILTER_SUBSTRINGS;
 238                                 f->f_sub = ch_calloc( 1, sizeof( SubstringsAssertion ) );
 239
 240                                 rc = slap_str2ad( str, &f->f_sub_desc, &text );
 241                                 if( rc != LDAP_SUCCESS ) {
 242                                         filter_free( f );
 243                                         *(value-1) = '=';
 244                                         return NULL;
 245                                 }
 246
 247                                 if ( str2subvals( value, f ) != 0 ) {
 248                                         filter_free( f );
 249                                         *(value-1) = '=';
 250                                         return NULL;
 251                                 }
 252                                 *(value-1) = '=';
 253                                 return f;
 254                         }
 255                 } break;
 256         }
 257
 258         if ( f->f_choice == LDAP_FILTER_PRESENT ) {
 259                 rc = slap_str2ad( str, &f->f_desc, &text );
 260                 if( rc != LDAP_SUCCESS ) {
 261                         filter_free( f );
 262                         *(value-1) = '=';
 263                         return NULL;
 264                 }
 265
 266         } else {
 267                 ber_slen_t len;
 268                 char *tmp;
 269
 270                 f->f_ava = ch_calloc( 1, sizeof( AttributeAssertion ) );
 271                 f->f_av_desc = NULL;
 272                 rc = slap_str2ad( str, &f->f_av_desc, &text );
 273                 if( rc != LDAP_SUCCESS ) {
 274                         filter_free( f );
 275                         *(value-1) = '=';
 276                         return NULL;
 277                 }
 278
 279                 tmp = ch_strdup( value );
 280                 len = ldap_pvt_filter_value_unescape( tmp );
 281                 if( len < 0 ) {
 282                         filter_free( f );
 283                         *(value-1) = '=';
 284                         free( tmp );
 285                         return NULL;
 286                 }
 287                 ber_str2bv( tmp, 0, 0, &f->f_av_value );
 288         }
 289
 290         *s = savechar;
 291         *(value-1) = '=';
 292
 293         return f;
 294 }
 295
 296 static int
 297 str2subvals( const char *in, Filter *f )
 298 {
 299         ber_slen_t len;
 300         char    *nextstar, *val, *freeme;
 301         int     gotstar;
 302         int final;
 303
 304 #ifdef NEW_LOGGING
 305         LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
 306                 "str2subvals: \"%s\"\n", in ));
 307 #else
 308         Debug( LDAP_DEBUG_FILTER, "str2subvals \"%s\"\n", in, 0, 0 );
 309 #endif
 310
 311         if( in == NULL ) return 0;
 312
 313         val = freeme = ch_strdup( in );
 314         gotstar = final = 0;
 315
 316         while ( *val ) {
 317                 nextstar = ldap_pvt_find_wildcard( val );
 318
 319                 if ( nextstar == NULL ) {
 320                         free( freeme );
 321                         return -1;
 322
 323                 } else if( *nextstar == '\0' ) {
 324                         final = 1;
 325
 326                 } else {
 327                         gotstar++;
 328                         *nextstar = '\0';
 329                 }
 330
 331                 len = ldap_pvt_filter_value_unescape( val );
 332                 if( len < 0 ) {
 333                         free( freeme );
 334                         return -1;
 335                 }
 336
 337                 if ( final ) {
 338                         ber_str2bv( val, 0, 1, &f->f_sub_final );
 339
 340                 } else if ( gotstar <= 1 ) {
 341                         ber_str2bv( val, 0, 1, &f->f_sub_initial );
 342
 343                 } else {
 344                         charray_add( (char ***) &f->f_sub_any,
 345                                 (char *) ber_bvstrdup( val ) );
 346                 }
 347
 348                 val = nextstar+1;
 349         }
 350
 351         free( freeme );
 352         return 0;
 353 }
 354
 355 /*
 356  * find_matching_paren - return a pointer to the right paren in s matching
 357  * the left paren to which *s currently points
 358  */
 359
 360 static char *
 361 find_matching_paren( const char *s )
 362 {
 363         int     balance, escape;
 364
 365         balance = 0;
 366         escape = 0;
 367         for ( ; *s; s++ ) {
 368                 if ( escape == 0 ) {
 369                         if ( *s == '(' )
 370                                 balance++;
 371                         else if ( *s == ')' )
 372                                 balance--;
 373                 }
 374                 if ( balance == 0 ) {
 375                         return (char *) s;
 376                 }
 377                 if ( *s == '\\' && ! escape )
 378                         escape = 1;
 379                 else
 380                         escape = 0;
 381         }
 382
 383         return NULL;
 384 }