[BACK]Return to filter.c CVS log [TXT] [DIR] Up to [OpenLDAP] / servers / slapd

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

version 1.55, 2000/10/15 17:12:21 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.54 2000/10/13 18:41:56 jsanchez 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:
   #ifdef NEW_LOGGING
               LDAP_LOG(( "filter", LDAP_LEVEL_DETAIL1,
                          "get_filter: conn %d  EXTENSIBLE\n", conn->c_connid ));
   #else
                 Debug( LDAP_DEBUG_FILTER, "EXTENSIBLE\n", 0, 0, 0 );                  Debug( LDAP_DEBUG_FILTER, "EXTENSIBLE\n", 0, 0, 0 );
   #endif
   
                 err = get_mra( ber, &f->f_mra, text );                  err = get_mra( ber, &f->f_mra, text );
                 if ( err != LDAP_SUCCESS ) {                  if ( err != LDAP_SUCCESS ) {
Line 283  get_filter( Line 332  get_filter(
   
         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 313  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 328  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 351  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 374  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 438  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 459  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 );
   #endif
                         if ( f->f_sub_initial != NULL ) {                          if ( f->f_sub_initial != NULL ) {
                                 ber_bvfree( value );                                  ber_bvfree( value );
                                 goto return_error;                                  goto return_error;
Line 477  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( 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 494  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;
Line 512  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 544  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 593  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.55  
changed lines
  Added in v.1.56

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