Diff for /servers/slapd/filter.c between versions 1.13.4.7 and 1.56

version 1.13.4.7, 2001/06/02 00:47:49 version 1.56, 2001/01/15 18:17:30
Line 1 Line 1
 /* filter.c - routines for parsing and dealing with filters */  /* filter.c - routines for parsing and dealing with filters */
 /* $OpenLDAP: pkg/ldap/servers/slapd/filter.c,v 1.13.4.6 2000/10/11 02:43:58 kurt Exp $ */  /* $OpenLDAP: pkg/ldap/servers/slapd/filter.c,v 1.55 2000/10/15 17:12:21 jsanchez Exp $ */
 /*  /*
  * Copyright 1998-2000 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 47  get_filter( Line 47  get_filter(
         char            *ftmp = NULL;          char            *ftmp = NULL;
         struct berval escaped;          struct berval escaped;
   
   #ifdef NEW_LOGGING
           LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY, "get_filter: conn %d\n",
                      conn->c_connid ));
   #else
         Debug( LDAP_DEBUG_FILTER, "begin get_filter\n", 0, 0, 0 );          Debug( LDAP_DEBUG_FILTER, "begin get_filter\n", 0, 0, 0 );
   #endif
         /*          /*
          * A filter looks like this coming in:           * A filter looks like this coming in:
          *      Filter ::= CHOICE {           *      Filter ::= CHOICE {
Line 98  get_filter( Line 102  get_filter(
   
         switch ( f->f_choice ) {          switch ( f->f_choice ) {
         case LDAP_FILTER_EQUALITY:          case LDAP_FILTER_EQUALITY:
   #ifdef NEW_LOGGING
               LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL2,
                          "get_filter: conn %d  EQUALITY\n", conn->c_connid ));
   #else
                 Debug( LDAP_DEBUG_FILTER, "EQUALITY\n", 0, 0, 0 );                  Debug( LDAP_DEBUG_FILTER, "EQUALITY\n", 0, 0, 0 );
   #endif
                 err = get_ava( ber, &f->f_ava, SLAP_MR_EQUALITY, text );                  err = get_ava( ber, &f->f_ava, SLAP_MR_EQUALITY, text );
                 if ( err != LDAP_SUCCESS ) {                  if ( err != LDAP_SUCCESS ) {
                         break;                          break;
Line 121  get_filter( Line 129  get_filter(
                 break;                  break;
   
         case LDAP_FILTER_SUBSTRINGS:          case LDAP_FILTER_SUBSTRINGS:
   #ifdef NEW_LOGGING
               LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
                          "get_filter: conn %d  SUBSTRINGS\n", conn->c_connid ));
   #else
                 Debug( LDAP_DEBUG_FILTER, "SUBSTRINGS\n", 0, 0, 0 );                  Debug( LDAP_DEBUG_FILTER, "SUBSTRINGS\n", 0, 0, 0 );
   #endif
                 err = get_substring_filter( conn, ber, f, fstr, text );                  err = get_substring_filter( conn, ber, f, fstr, text );
                 break;                  break;
   
         case LDAP_FILTER_GE:          case LDAP_FILTER_GE:
   #ifdef NEW_LOGGING
               LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
                          "get_filter: conn %d  GE\n", conn->c_connid ));
   #else
                 Debug( LDAP_DEBUG_FILTER, "GE\n", 0, 0, 0 );                  Debug( LDAP_DEBUG_FILTER, "GE\n", 0, 0, 0 );
   #endif
                 err = get_ava( ber, &f->f_ava, SLAP_MR_ORDERING, text );                  err = get_ava( ber, &f->f_ava, SLAP_MR_ORDERING, text );
                 if ( err != LDAP_SUCCESS ) {                  if ( err != LDAP_SUCCESS ) {
                         break;                          break;
Line 147  get_filter( Line 164  get_filter(
                 break;                  break;
   
         case LDAP_FILTER_LE:          case LDAP_FILTER_LE:
   #ifdef NEW_LOGGING
               LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
                          "get_filter: conn %d  LE\n", conn->c_connid ));
   #else
                 Debug( LDAP_DEBUG_FILTER, "LE\n", 0, 0, 0 );                  Debug( LDAP_DEBUG_FILTER, "LE\n", 0, 0, 0 );
   #endif
                 err = get_ava( ber, &f->f_ava, SLAP_MR_ORDERING, text );                  err = get_ava( ber, &f->f_ava, SLAP_MR_ORDERING, text );
                 if ( err != LDAP_SUCCESS ) {                  if ( err != LDAP_SUCCESS ) {
                         break;                          break;
Line 171  get_filter( Line 192  get_filter(
         case LDAP_FILTER_PRESENT: {          case LDAP_FILTER_PRESENT: {
                 struct berval type;                  struct berval type;
   
   #ifdef NEW_LOGGING
                   LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
                              "get_filter: conn %d PRESENT\n", conn->c_connid ));
   #else
                 Debug( LDAP_DEBUG_FILTER, "PRESENT\n", 0, 0, 0 );                  Debug( LDAP_DEBUG_FILTER, "PRESENT\n", 0, 0, 0 );
   #endif
                 if ( ber_scanf( ber, "o", &type ) == LBER_ERROR ) {                  if ( ber_scanf( ber, "o", &type ) == LBER_ERROR ) {
                         err = SLAPD_DISCONNECT;                          err = SLAPD_DISCONNECT;
                         *text = "error decoding filter";                          *text = "error decoding filter";
Line 197  get_filter( Line 222  get_filter(
                 } break;                  } break;
   
         case LDAP_FILTER_APPROX:          case LDAP_FILTER_APPROX:
   #ifdef NEW_LOGGING
               LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
                          "get_filter: conn %d  APPROX\n", conn->c_connid ));
   #else
                 Debug( LDAP_DEBUG_FILTER, "APPROX\n", 0, 0, 0 );                  Debug( LDAP_DEBUG_FILTER, "APPROX\n", 0, 0, 0 );
   #endif
                 err = get_ava( ber, &f->f_ava, SLAP_MR_EQUALITY_APPROX, text );                  err = get_ava( ber, &f->f_ava, SLAP_MR_EQUALITY_APPROX, text );
                 if ( err != LDAP_SUCCESS ) {                  if ( err != LDAP_SUCCESS ) {
                         break;                          break;
Line 218  get_filter( Line 247  get_filter(
                 break;                  break;
   
         case LDAP_FILTER_AND:          case LDAP_FILTER_AND:
   #ifdef NEW_LOGGING
               LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
                          "get_filter: conn %d  AND\n", conn->c_connid ));
   #else
                 Debug( LDAP_DEBUG_FILTER, "AND\n", 0, 0, 0 );                  Debug( LDAP_DEBUG_FILTER, "AND\n", 0, 0, 0 );
   #endif
                 err = get_filter_list( conn, ber, &f->f_and, &ftmp, text );                  err = get_filter_list( conn, ber, &f->f_and, &ftmp, text );
                 if ( err != LDAP_SUCCESS ) {                  if ( err != LDAP_SUCCESS ) {
                         break;                          break;
Line 230  get_filter( Line 264  get_filter(
                 break;                  break;
   
         case LDAP_FILTER_OR:          case LDAP_FILTER_OR:
   #ifdef NEW_LOGGING
               LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
                          "get_filter: conn %d  OR\n", conn->c_connid  ));
   #else
                 Debug( LDAP_DEBUG_FILTER, "OR\n", 0, 0, 0 );                  Debug( LDAP_DEBUG_FILTER, "OR\n", 0, 0, 0 );
   #endif
                 err = get_filter_list( conn, ber, &f->f_and, &ftmp, text );                  err = get_filter_list( conn, ber, &f->f_and, &ftmp, text );
                 if ( err != LDAP_SUCCESS ) {                  if ( err != LDAP_SUCCESS ) {
                         break;                          break;
Line 242  get_filter( Line 281  get_filter(
                 break;                  break;
   
         case LDAP_FILTER_NOT:          case LDAP_FILTER_NOT:
   #ifdef NEW_LOGGING
               LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
                          "get_filter: conn %d  NOT\n", conn->c_connid ));
   #else
                 Debug( LDAP_DEBUG_FILTER, "NOT\n", 0, 0, 0 );                  Debug( LDAP_DEBUG_FILTER, "NOT\n", 0, 0, 0 );
   #endif
                 (void) ber_skip_tag( ber, &len );                  (void) ber_skip_tag( ber, &len );
                 err = get_filter( conn, ber, &f->f_not, &ftmp, text );                  err = get_filter( conn, ber, &f->f_not, &ftmp, text );
                 if ( err != LDAP_SUCCESS ) {                  if ( err != LDAP_SUCCESS ) {
Line 255  get_filter( Line 299  get_filter(
                 break;                  break;
   
         case LDAP_FILTER_EXT:          case LDAP_FILTER_EXT:
                 /* not yet implemented */  #ifdef NEW_LOGGING
                 Debug( LDAP_DEBUG_ANY, "extensible match not yet implemented.\n",              LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
                        0, 0, 0 );                         "get_filter: conn %d  EXTENSIBLE\n", conn->c_connid ));
                 (void) ber_skip_tag( ber, &len );  #else
                 f->f_choice = SLAPD_FILTER_COMPUTED;                  Debug( LDAP_DEBUG_FILTER, "EXTENSIBLE\n", 0, 0, 0 );
                 f->f_result = SLAPD_COMPARE_UNDEFINED;  #endif
                 *fstr = ch_strdup( "(extended)" );  
                   err = get_mra( ber, &f->f_mra, text );
                   if ( err != LDAP_SUCCESS ) {
                           break;
                   }
   
                   assert( f->f_mra != NULL );
   
                   filter_escape_value( f->f_mr_value, &escaped );
   
                   *fstr = ch_malloc( sizeof("(:dn::=)")
                           + (f->f_mr_desc ? f->f_mr_desc->ad_cname->bv_len : 0)
                           + (f->f_mr_rule_text ? strlen(f->f_mr_rule_text) : 0)
                           + escaped.bv_len );
   
                   sprintf( *fstr, "(%s%s%s%s:=%s)",
                            (f->f_mr_desc ? f->f_mr_desc->ad_cname->bv_val : ""),
                            (f->f_mr_dnattrs ? ":dn" : ""),
                            (f->f_mr_rule_text ? ":" : ""),
                            (f->f_mr_rule_text ? f->f_mr_rule_text : ""),
                            escaped.bv_val );
   
                   ber_memfree( escaped.bv_val );
                 break;                  break;
   
         default:          default:
                 (void) ber_skip_tag( ber, &len );                  (void) ber_skip_tag( ber, &len );
   #ifdef NEW_LOGGING
                   LDAP_LOG(( "filter", LDAP_LEVEL_ERR,
                              "get_filter: conn %d unknown filter type=%lu\n",
                              conn->c_connid, f->f_choice ));
   #else
                 Debug( LDAP_DEBUG_ANY, "get_filter: unknown filter type=%lu\n",                  Debug( LDAP_DEBUG_ANY, "get_filter: unknown filter type=%lu\n",
                        f->f_choice, 0, 0 );                         f->f_choice, 0, 0 );
   #endif
                 f->f_choice = SLAPD_FILTER_COMPUTED;                  f->f_choice = SLAPD_FILTER_COMPUTED;
                 f->f_result = SLAPD_COMPARE_UNDEFINED;                  f->f_result = SLAPD_COMPARE_UNDEFINED;
                 *fstr = ch_strdup( "(undefined)" );                  *fstr = ch_strdup( "(undefined)" );
Line 296  get_filter( Line 368  get_filter(
                 *filt = f;                  *filt = f;
         }          }
   
   #ifdef NEW_LOGGING
           LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL2,
                      "get_filter: conn %d  exit\n", conn->c_connid ));
   #else
         Debug( LDAP_DEBUG_FILTER, "end get_filter %d\n", err, 0, 0 );          Debug( LDAP_DEBUG_FILTER, "end get_filter %d\n", err, 0, 0 );
   #endif
         return( err );          return( err );
 }  }
   
Line 311  get_filter_list( Connection *conn, BerEl Line 388  get_filter_list( Connection *conn, BerEl
         ber_len_t       len;          ber_len_t       len;
         char            *last, *ftmp;          char            *last, *ftmp;
   
   #ifdef NEW_LOGGING
           LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
                      "get_filter_list: conn %d start\n", conn->c_connid ));
   #else
         Debug( LDAP_DEBUG_FILTER, "begin get_filter_list\n", 0, 0, 0 );          Debug( LDAP_DEBUG_FILTER, "begin get_filter_list\n", 0, 0, 0 );
   #endif
         *fstr = NULL;          *fstr = NULL;
         new = f;          new = f;
         for ( tag = ber_first_element( ber, &len, &last ); tag != LBER_DEFAULT;          for ( tag = ber_first_element( ber, &len, &last ); tag != LBER_DEFAULT;
Line 334  get_filter_list( Connection *conn, BerEl Line 415  get_filter_list( Connection *conn, BerEl
         }          }
         *new = NULL;          *new = NULL;
   
   #ifdef NEW_LOGGING
           LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
                      "get_filter_list: conn %d exit\n", conn->c_connid ));
   #else
         Debug( LDAP_DEBUG_FILTER, "end get_filter_list\n", 0, 0, 0 );          Debug( LDAP_DEBUG_FILTER, "end get_filter_list\n", 0, 0, 0 );
   #endif
         return( LDAP_SUCCESS );          return( LDAP_SUCCESS );
 }  }
   
Line 357  get_substring_filter( Line 443  get_substring_filter(
         struct berval *nvalue;          struct berval *nvalue;
         *text = "error decoding filter";          *text = "error decoding filter";
   
   #ifdef NEW_LOGGING
           LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
                      "get_substring_filter: conn %d  begin\n", conn->c_connid ));
   #else
         Debug( LDAP_DEBUG_FILTER, "begin get_substring_filter\n", 0, 0, 0 );          Debug( LDAP_DEBUG_FILTER, "begin get_substring_filter\n", 0, 0, 0 );
   #endif
         if ( ber_scanf( ber, "{o" /*}*/, &type ) == LBER_ERROR ) {          if ( ber_scanf( ber, "{o" /*}*/, &type ) == LBER_ERROR ) {
                 return SLAPD_DISCONNECT;                  return SLAPD_DISCONNECT;
         }          }
Line 421  get_substring_filter( Line 511  get_substring_filter(
                 default:                  default:
                         rc = LDAP_PROTOCOL_ERROR;                          rc = LDAP_PROTOCOL_ERROR;
   
   #ifdef NEW_LOGGING
                           LDAP_LOG(( "filter", LDAP_LEVEL_ERR,
                                      "get_filter_substring: conn %d  unknown substring choice=%ld\n",
                                      conn->c_connid, (long)tag ));
   #else
                         Debug( LDAP_DEBUG_FILTER,                          Debug( LDAP_DEBUG_FILTER,
                                 "  unknown substring choice=%ld\n",                                  "  unknown substring choice=%ld\n",
                                 (long) tag, 0, 0 );                                  (long) tag, 0, 0 );
   #endif
                         ber_bvfree( value );                          ber_bvfree( value );
                         goto return_error;                          goto return_error;
                 }                  }
Line 442  get_substring_filter( Line 537  get_substring_filter(
   
                 switch ( tag ) {                  switch ( tag ) {
                 case LDAP_SUBSTRING_INITIAL:                  case LDAP_SUBSTRING_INITIAL:
   #ifdef NEW_LOGGING
                       LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
                                  "get_substring_filter: conn %d  INITIAL\n",
                                  conn->c_connid ));
   #else
                         Debug( LDAP_DEBUG_FILTER, "  INITIAL\n", 0, 0, 0 );                          Debug( LDAP_DEBUG_FILTER, "  INITIAL\n", 0, 0, 0 );
                         if ( f->f_sub_initial != NULL  #endif
                                 || f->f_sub_any != NULL                           if ( f->f_sub_initial != NULL ) {
                                 || f->f_sub_final != NULL )  
                         {  
                                 ber_bvfree( value );                                  ber_bvfree( value );
                                 goto return_error;                                  goto return_error;
                         }                          }
Line 463  get_substring_filter( Line 561  get_substring_filter(
                         break;                          break;
   
                 case LDAP_SUBSTRING_ANY:                  case LDAP_SUBSTRING_ANY:
   #ifdef NEW_LOGGING
                       LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
                                  "get_substring_filter: conn %d  ANY\n",
                                  conn->c_connid ));
   #else
                         Debug( LDAP_DEBUG_FILTER, "  ANY\n", 0, 0, 0 );                          Debug( LDAP_DEBUG_FILTER, "  ANY\n", 0, 0, 0 );
   #endif
                         if ( f->f_sub_final != NULL ) {  
                                 ber_bvfree( value );  
                                 goto return_error;  
                         }  
   
                         if( ber_bvecadd( &f->f_sub_any, value ) < 0 ) {                          if( ber_bvecadd( &f->f_sub_any, value ) < 0 ) {
                                 ber_bvfree( value );                                  ber_bvfree( value );
                                 goto return_error;                                  goto return_error;
Line 486  get_substring_filter( Line 584  get_substring_filter(
                         break;                          break;
   
                 case LDAP_SUBSTRING_FINAL:                  case LDAP_SUBSTRING_FINAL:
   #ifdef NEW_LOGGING
                       LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
                                  "get_substring_filter: conn %d  FINAL\n",
                                  conn->c_connid ));
   #else
                         Debug( LDAP_DEBUG_FILTER, "  FINAL\n", 0, 0, 0 );                          Debug( LDAP_DEBUG_FILTER, "  FINAL\n", 0, 0, 0 );
   #endif
                         if ( f->f_sub_final != NULL ) {                          if ( f->f_sub_final != NULL ) {
                                 ber_bvfree( value );                                  ber_bvfree( value );
                                 goto return_error;                                  goto return_error;
                         }                          }
   
                         f->f_sub_final = value;                          f->f_sub_final = value;
   
                         if( fstr ) {                          if( fstr ) {
Line 506  get_substring_filter( Line 608  get_substring_filter(
                         break;                          break;
   
                 default:                  default:
   #ifdef NEW_LOGGING
                       LDAP_LOG(( "filter", LDAP_LEVEL_INFO,
                                  "get_substring_filter: conn %d  unknown substring type %ld\n",
                                  conn->c_connid, (long)tag ));
   #else
                         Debug( LDAP_DEBUG_FILTER,                          Debug( LDAP_DEBUG_FILTER,
                                 "  unknown substring type=%ld\n",                                  "  unknown substring type=%ld\n",
                                 (long) tag, 0, 0 );                                  (long) tag, 0, 0 );
   #endif
   
                         ber_bvfree( value );                          ber_bvfree( value );
   
 return_error:  return_error:
   #ifdef NEW_LOGGING
                           LDAP_LOG(( "filter", LDAP_LEVEL_INFO,
                                      "get_substring_filter: conn %d  error %ld\n",
                                      conn->c_connid, (long)rc ));
   #else
                         Debug( LDAP_DEBUG_FILTER, "  error=%ld\n",                          Debug( LDAP_DEBUG_FILTER, "  error=%ld\n",
                                 (long) rc, 0, 0 );                                  (long) rc, 0, 0 );
   #endif
                         if( fstr ) {                          if( fstr ) {
                                 free( *fstr );                                  free( *fstr );
                                 *fstr = NULL;                                  *fstr = NULL;
Line 538  return_error: Line 651  return_error:
                 strcat( *fstr, /*(*/ ")" );                  strcat( *fstr, /*(*/ ")" );
         }          }
   
   #ifdef NEW_LOGGING
           LDAP_LOG(( "filter", LDAP_LEVEL_ENTRY,
                      "get_substring_filter: conn %d exit\n", conn->c_connid ));
   #else
         Debug( LDAP_DEBUG_FILTER, "end get_substring_filter\n", 0, 0, 0 );          Debug( LDAP_DEBUG_FILTER, "end get_substring_filter\n", 0, 0, 0 );
   #endif
         return( LDAP_SUCCESS );          return( LDAP_SUCCESS );
 }  }
   
Line 587  filter_free( Filter *f ) Line 705  filter_free( Filter *f )
                 break;                  break;
   
         default:          default:
   #ifdef NEW_LOGGING
               LDAP_LOG(( "filter", LDAP_LEVEL_ERR,
                          "filter_free: unknown filter type %lu\n", f->f_choice ));
   #else
                 Debug( LDAP_DEBUG_ANY, "filter_free: unknown filter type=%lu\n",                  Debug( LDAP_DEBUG_ANY, "filter_free: unknown filter type=%lu\n",
                        f->f_choice, 0, 0 );                         f->f_choice, 0, 0 );
   #endif
                 break;                  break;
         }          }
   

Removed from v.1.13.4.7  
changed lines
  Added in v.1.56


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