Diff for /servers/slapd/component.c between versions 1.13 and 1.13.2.5

version 1.13, 2004/12/01 21:11:55 version 1.13.2.5, 2005/08/09 21:03:58
Line 1 Line 1
 /* component.c -- Component Filter Match Routines */  /* component.c -- Component Filter Match Routines */
 /* $OpenLDAP: pkg/ldap/servers/slapd/component.c,v 1.12 2004/11/29 19:21:43 slim Exp $ */  /* $OpenLDAP: pkg/ldap/servers/slapd/component.c,v 1.27 2005/07/18 03:11:11 hallvard Exp $ */
 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.  /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
  *   *
  * Copyright 2003-2004 The OpenLDAP Foundation.   * Copyright 2003-2005 The OpenLDAP Foundation.
  * Portions Copyright 2004 by IBM Corporation.   * Portions Copyright 2004 by IBM Corporation.
  * All rights reserved.   * All rights reserved.
  *   *
Line 29 Line 29
 #include "component.h"  #include "component.h"
   
 /*  /*
  * This three function pointers are initialized   * Following function pointers are initialized
  * when a component module is loaded   * when a component module is loaded
  */   */
 alloc_nibble_func* nibble_mem_allocator = NULL;  alloc_nibble_func* nibble_mem_allocator = NULL;
 free_nibble_func* nibble_mem_free = NULL;  free_nibble_func* nibble_mem_free = NULL;
 convert_attr_to_comp_func* attr_converter = NULL ;  convert_attr_to_comp_func* attr_converter = NULL;
 convert_assert_to_comp_func* assert_converter = NULL ;  convert_assert_to_comp_func* assert_converter = NULL ;
 free_component_func* component_destructor = NULL ;  free_component_func* component_destructor = NULL ;
 test_component_func* test_one_component = NULL;  test_component_func* test_components = NULL;
 test_component_func* test_all_components = NULL;  test_membership_func* is_aliased_attribute = NULL;
   component_encoder_func* component_encoder = NULL;
   get_component_info_func* get_component_description = NULL;
 #define OID_ALL_COMP_MATCH "1.2.36.79672281.1.13.6"  #define OID_ALL_COMP_MATCH "1.2.36.79672281.1.13.6"
 #define OID_COMP_FILTER_MATCH "1.2.36.79672281.1.13.2"  #define OID_COMP_FILTER_MATCH "1.2.36.79672281.1.13.2"
 #define MAX_LDAP_STR_LEN 128  #define MAX_LDAP_STR_LEN 128
Line 61  static void Line 62  static void
 free_comp_filter( ComponentFilter* f );  free_comp_filter( ComponentFilter* f );
   
 static int  static int
 test_comp_filter( Syntax *syn, Attribute        *a, struct berval *bv,  test_comp_filter( Syntax *syn, ComponentSyntaxInfo *a, ComponentFilter *f );
                         ComponentFilter *f );  
   
 int  int
 componentCertificateValidate(  componentCertificateValidate(
Line 97  componentFilterMatch ( Line 97  componentFilterMatch (
         struct berval *value,           struct berval *value, 
         void *assertedValue )          void *assertedValue )
 {  {
         Attribute *a = (Attribute*)value;          ComponentSyntaxInfo *csi_attr = (ComponentSyntaxInfo*)value;
         MatchingRuleAssertion * ma = (MatchingRuleAssertion*)assertedValue;          MatchingRuleAssertion * ma = (MatchingRuleAssertion*)assertedValue;
   
         int rc;          int rc;
   
         if ( !(mr && mr->smr_usage & SLAP_MR_COMPONENT) || !ma->ma_cf )          if ( !mr || !ma->ma_cf ) return LDAP_INAPPROPRIATE_MATCHING;
                 return LDAP_INAPPROPRIATE_MATCHING;  
                           /* Check if the component module is loaded */
         rc = test_comp_filter( syntax, a, a->a_vals, ma->ma_cf );          if ( !attr_converter || !nibble_mem_allocator ) {
                   return LDAP_OTHER;
           }
   
           rc = test_comp_filter( syntax, csi_attr, ma->ma_cf );
   
         if ( rc == LDAP_COMPARE_TRUE ) {          if ( rc == LDAP_COMPARE_TRUE ) {
                 *matchp = 0;                  *matchp = 0;
Line 118  componentFilterMatch ( Line 121  componentFilterMatch (
         else {          else {
                 return LDAP_INAPPROPRIATE_MATCHING;                  return LDAP_INAPPROPRIATE_MATCHING;
         }          }
           
 }  }
   
 int  int
 directoryComponentsMatch(   directoryComponentsMatch( 
         int *matchp,           int *matchp, 
Line 129  directoryComponentsMatch( Line 132  directoryComponentsMatch(
         struct berval *value,           struct berval *value, 
         void *assertedValue )          void *assertedValue )
 {  {
         /* Only for Registeration */          /* Only for registration */
         *matchp = 0;          *matchp = 0;
         return LDAP_SUCCESS;          return LDAP_SUCCESS;
 }  }
Line 143  allComponentsMatch( Line 146  allComponentsMatch(
         struct berval *value,           struct berval *value, 
         void *assertedValue )          void *assertedValue )
 {  {
         /* Only for Registeration */          /* Only for registration */
         *matchp = 0;          *matchp = 0;
         return LDAP_SUCCESS;          return LDAP_SUCCESS;
 }  }
   
 static int  static int
 slapd_ber2cav( struct berval* bv, ComponentAssertionValue* cav)  slapd_ber2cav( struct berval* bv, ComponentAssertionValue* cav )
 {  {
         int len;  
   
         cav->cav_ptr = cav->cav_buf = bv->bv_val;          cav->cav_ptr = cav->cav_buf = bv->bv_val;
         cav->cav_end = bv->bv_val + bv->bv_len;          cav->cav_end = bv->bv_val + bv->bv_len;
   
         return LDAP_SUCCESS;          return LDAP_SUCCESS;
 }  }
   
   ComponentReference*
   dup_comp_ref ( Operation* op, ComponentReference* cr )
   {
           ComponentReference* dup_cr;
           ComponentId* ci_curr;
           ComponentId** ci_temp;
   
           dup_cr = op->o_tmpalloc( sizeof( ComponentReference ), op->o_tmpmemctx );
   
           dup_cr->cr_len = cr->cr_len;
           dup_cr->cr_string = cr->cr_string;
   
           ci_temp = &dup_cr->cr_list;
           ci_curr = cr->cr_list;
   
           for ( ; ci_curr != NULL ;
                   ci_curr = ci_curr->ci_next, ci_temp = &(*ci_temp)->ci_next )
           {
                   *ci_temp = op->o_tmpalloc( sizeof( ComponentId ), op->o_tmpmemctx );
                   if ( !ci_temp ) return NULL;
                   **ci_temp = *ci_curr;
           }
   
           dup_cr->cr_curr = dup_cr->cr_list;
   
           return dup_cr;
   }
   
   static int
   dup_comp_filter_list (
           Operation *op,
           struct berval *bv,
           ComponentFilter* in_f,
           ComponentFilter** out_f )
   {
           ComponentFilter **new, *f;
           int             rc;
   
           new = out_f;
           for ( f = in_f; f != NULL; f = f->cf_next ) {
                   rc = dup_comp_filter( op, bv, f, new );
                   if ( rc != LDAP_SUCCESS ) {
                           return rc;
                   }
                   new = &(*new)->cf_next;
           }
           return LDAP_SUCCESS;
   }
   
   int
   get_len_of_next_assert_value ( struct berval* bv, char separator )
   {
           int i = 0;
           while (1) {
                   if ( (bv->bv_val[ i ] == separator) || ( i >= bv->bv_len) )
                           break;
                   i++;
           }
           bv->bv_val += (i + 1);
           bv->bv_len -= (i + 1);
           return i;
   }
   
   int
   dup_comp_filter_item (
           Operation *op,
           struct berval* assert_bv,
           ComponentAssertion* in_ca,
           ComponentAssertion** out_ca )
   {
           int len;
   
           if ( !in_ca->ca_comp_ref ) return SLAPD_DISCONNECT;
   
           *out_ca = op->o_tmpalloc( sizeof( ComponentAssertion ), op->o_tmpmemctx );
           if ( !(*out_ca) ) return LDAP_NO_MEMORY;
   
           (*out_ca)->ca_comp_data.cd_tree = NULL;
           (*out_ca)->ca_comp_data.cd_mem_op = NULL;
   
           (*out_ca)->ca_comp_ref = dup_comp_ref ( op, in_ca->ca_comp_ref );
           (*out_ca)->ca_use_def = 0;
           (*out_ca)->ca_ma_rule = in_ca->ca_ma_rule;
   
           (*out_ca)->ca_ma_value.bv_val = assert_bv->bv_val;
           len = get_len_of_next_assert_value ( assert_bv, '$' );
           if ( len <= 0 ) return SLAPD_DISCONNECT;
           (*out_ca)->ca_ma_value.bv_len = len;
           
           return LDAP_SUCCESS;
   }
   
   int
   dup_comp_filter (
           Operation* op,
           struct berval *bv,
           ComponentFilter *in_f,
           ComponentFilter **out_f )
   {
           int     rc;
           ComponentFilter dup_f = {0};
   
           if ( !in_f ) return LDAP_PROTOCOL_ERROR;
   
           switch ( in_f->cf_choice ) {
           case LDAP_COMP_FILTER_AND:
                   rc = dup_comp_filter_list( op, bv, in_f->cf_and, &dup_f.cf_and);
                   dup_f.cf_choice = LDAP_COMP_FILTER_AND;
                   break;
           case LDAP_COMP_FILTER_OR:
                   rc = dup_comp_filter_list( op, bv, in_f->cf_or, &dup_f.cf_or);
                   dup_f.cf_choice = LDAP_COMP_FILTER_OR;
                   break;
           case LDAP_COMP_FILTER_NOT:
                   rc = dup_comp_filter( op, bv, in_f->cf_not, &dup_f.cf_not);
                   dup_f.cf_choice = LDAP_COMP_FILTER_NOT;
                   break;
           case LDAP_COMP_FILTER_ITEM:
                   rc = dup_comp_filter_item( op, bv, in_f->cf_ca ,&dup_f.cf_ca );
                   dup_f.cf_choice = LDAP_COMP_FILTER_ITEM;
                   break;
           default:
                   rc = LDAP_PROTOCOL_ERROR;
           }
   
           if ( rc == LDAP_SUCCESS ) {
                   *out_f = op->o_tmpalloc( sizeof(dup_f), op->o_tmpmemctx );
                   **out_f = dup_f;
           }
   
           return( rc );
   }
   
   int
   get_aliased_filter_aa ( Operation* op, AttributeAssertion* a_assert, AttributeAliasing* aa, const char** text )
   {
           struct berval assert_bv;
   
           Debug( LDAP_DEBUG_FILTER, "get_aliased_filter\n", 0, 0, 0 );
   
           if ( !aa->aa_cf  )
                   return LDAP_PROTOCOL_ERROR;
   
           assert_bv = a_assert->aa_value;
           /*
            * Duplicate aa->aa_cf to ma->ma_cf by replacing the
            * the component assertion value in assert_bv
            * Multiple values may be separated with '$'
            */
           return dup_comp_filter ( op, &assert_bv, aa->aa_cf, &a_assert->aa_cf );
   }
   
   int
   get_aliased_filter( Operation* op,
           MatchingRuleAssertion* ma, AttributeAliasing* aa,
           const char** text )
   {
           struct berval assert_bv;
   
           Debug( LDAP_DEBUG_FILTER, "get_aliased_filter\n", 0, 0, 0 );
   
           if ( !aa->aa_cf  ) return LDAP_PROTOCOL_ERROR;
   
           assert_bv = ma->ma_value;
           /* Attribute Description is replaced with aliased one */
           ma->ma_desc = aa->aa_aliased_ad;
           ma->ma_rule = aa->aa_mr;
           /*
            * Duplicate aa->aa_cf to ma->ma_cf by replacing the
            * the component assertion value in assert_bv
            * Multiple values may be separated with '$'
            */
           return dup_comp_filter ( op, &assert_bv, aa->aa_cf, &ma->ma_cf );
   }
   
 int  int
 get_comp_filter( Operation* op, struct berval* bv, ComponentFilter** filt,  get_comp_filter( Operation* op, struct berval* bv,
                  const char **text )          ComponentFilter** filt, const char **text )
 {  {
         ComponentAssertionValue cav;          ComponentAssertionValue cav;
         int rc;          int rc;
Line 196  comp_first_element( ComponentAssertionVa Line 372  comp_first_element( ComponentAssertionVa
         eat_whsp( cav );          eat_whsp( cav );
         if ( cav_cur_len( cav ) >= 8 && strncmp( cav->cav_ptr, "item", 4 ) == 0 ) {          if ( cav_cur_len( cav ) >= 8 && strncmp( cav->cav_ptr, "item", 4 ) == 0 ) {
                 return LDAP_COMP_FILTER_ITEM;                  return LDAP_COMP_FILTER_ITEM;
         }  
         else if ( cav_cur_len( cav ) >= 7 && strncmp( cav->cav_ptr, "and", 3 ) == 0 ) {          } else if ( cav_cur_len( cav ) >= 7 &&
                   strncmp( cav->cav_ptr, "and", 3 ) == 0 )
           {
                 return LDAP_COMP_FILTER_AND;                  return LDAP_COMP_FILTER_AND;
         }  
         else if ( cav_cur_len( cav ) >= 6 && strncmp( cav->cav_ptr, "or" , 2 ) == 0 ) {          } else if ( cav_cur_len( cav ) >= 6 &&
                   strncmp( cav->cav_ptr, "or" , 2 ) == 0 )
           {
                 return LDAP_COMP_FILTER_OR;                  return LDAP_COMP_FILTER_OR;
         }  
         else if ( cav_cur_len( cav ) >= 7 && strncmp( cav->cav_ptr, "not", 3 ) == 0 ) {          } else if ( cav_cur_len( cav ) >= 7 &&
                   strncmp( cav->cav_ptr, "not", 3 ) == 0 )
           {
                 return LDAP_COMP_FILTER_NOT;                  return LDAP_COMP_FILTER_NOT;
         }  
         else          } else {
                 return LDAP_COMP_FILTER_UNDEFINED;                  return LDAP_COMP_FILTER_UNDEFINED;
           }
 }  }
   
 static ber_tag_t  static ber_tag_t
 comp_next_element( ComponentAssertionValue* cav )  comp_next_element( ComponentAssertionValue* cav )
 {  {
   
         eat_whsp( cav );          eat_whsp( cav );
         if ( *(cav->cav_ptr) == ',' ) {          if ( *(cav->cav_ptr) == ',' ) {
                 /* move pointer to the next CA */                  /* move pointer to the next CA */
Line 225  comp_next_element( ComponentAssertionVal Line 407  comp_next_element( ComponentAssertionVal
   
 static int  static int
 get_comp_filter_list( Operation *op, ComponentAssertionValue *cav,  get_comp_filter_list( Operation *op, ComponentAssertionValue *cav,
                         ComponentFilter** f, const char** text )          ComponentFilter** f, const char** text )
 {  {
         ComponentFilter **new;          ComponentFilter **new;
         int             err;          int             err;
Line 233  get_comp_filter_list( Operation *op, Com Line 415  get_comp_filter_list( Operation *op, Com
   
         Debug( LDAP_DEBUG_FILTER, "get_comp_filter_list\n", 0, 0, 0 );          Debug( LDAP_DEBUG_FILTER, "get_comp_filter_list\n", 0, 0, 0 );
         new = f;          new = f;
         for ( tag = comp_first_element( cav ); tag != LDAP_COMP_FILTER_UNDEFINED;          for ( tag = comp_first_element( cav );
                   tag != LDAP_COMP_FILTER_UNDEFINED;
                 tag = comp_next_element( cav ) )                  tag = comp_next_element( cav ) )
         {          {
                 err = parse_comp_filter( op, cav, new, text );                  err = parse_comp_filter( op, cav, new, text );
                 if ( err != LDAP_SUCCESS )                  if ( err != LDAP_SUCCESS ) return ( err );
                         return ( err );  
                 new = &(*new)->cf_next;                  new = &(*new)->cf_next;
         }          }
         *new = NULL;          *new = NULL;
Line 248  get_comp_filter_list( Operation *op, Com Line 430  get_comp_filter_list( Operation *op, Com
   
 static int  static int
 get_componentId( Operation *op, ComponentAssertionValue* cav,  get_componentId( Operation *op, ComponentAssertionValue* cav,
                         ComponentId ** cid, const char** text )          ComponentId ** cid, const char** text )
 {  {
         ber_tag_t type;          ber_tag_t type;
         ComponentId _cid;          ComponentId _cid;
Line 256  get_componentId( Operation *op, Componen Line 438  get_componentId( Operation *op, Componen
   
         type = peek_componentId_type( cav );          type = peek_componentId_type( cav );
   
         Debug( LDAP_DEBUG_FILTER, "get_compId [%d]\n", type, 0, 0 );          Debug( LDAP_DEBUG_FILTER, "get_compId [%lu]\n",
                   (unsigned long) type, 0, 0 );
         len = 0;          len = 0;
         _cid.ci_type = type;          _cid.ci_type = type;
         _cid.ci_next = NULL;          _cid.ci_next = NULL;
Line 289  get_componentId( Operation *op, Componen Line 472  get_componentId( Operation *op, Componen
                 cav->cav_ptr += strlen("content");                  cav->cav_ptr += strlen("content");
                 break;                  break;
         case LDAP_COMPREF_SELECT :          case LDAP_COMPREF_SELECT :
                 if ( cav->cav_ptr[len] != '(' )                  if ( cav->cav_ptr[len] != '(' ) return LDAP_COMPREF_UNDEFINED;
                         return LDAP_COMPREF_UNDEFINED;  
                 for( ;cav->cav_ptr[len] != ' ' && cav->cav_ptr[len] != '\0' &&                  for( ;cav->cav_ptr[len] != ' ' && cav->cav_ptr[len] != '\0' &&
                       cav->cav_ptr[len] != '.' && cav->cav_ptr[len] != '\"' &&                        cav->cav_ptr[len] != '\"' && cav->cav_ptr[len] != ')'
                       cav->cav_ptr[len] != ')' ; len++ );                          ; len++ );
                 _cid.ci_val.ci_select_value.bv_val = cav->cav_ptr + 1;                  _cid.ci_val.ci_select_value.bv_val = cav->cav_ptr + 1;
                 _cid.ci_val.ci_select_value.bv_len = len - 1 ;                  _cid.ci_val.ci_select_value.bv_len = len - 1 ;
                 cav->cav_ptr += len;                  cav->cav_ptr += len + 1;
                 break;                  break;
         case LDAP_COMPREF_ALL :          case LDAP_COMPREF_ALL :
                 _cid.ci_val.ci_all = '*';                  _cid.ci_val.ci_all = '*';
Line 306  get_componentId( Operation *op, Componen Line 488  get_componentId( Operation *op, Componen
                 return LDAP_COMPREF_UNDEFINED;                  return LDAP_COMPREF_UNDEFINED;
         }          }
   
         *cid = op->o_tmpalloc( sizeof( ComponentId ), op->o_tmpmemctx );          if ( op ) {
                   *cid = op->o_tmpalloc( sizeof( ComponentId ), op->o_tmpmemctx );
           } else {
                   *cid = malloc( sizeof( ComponentId ) );
           }
         **cid = _cid;          **cid = _cid;
         return LDAP_SUCCESS;          return LDAP_SUCCESS;
 }  }
Line 315  static int Line 501  static int
 peek_componentId_type( ComponentAssertionValue* cav )  peek_componentId_type( ComponentAssertionValue* cav )
 {  {
         eat_whsp( cav );          eat_whsp( cav );
         if ( cav->cav_ptr[0] == '-' )  
           if ( cav->cav_ptr[0] == '-' ) {
                 return LDAP_COMPREF_FROM_END;                  return LDAP_COMPREF_FROM_END;
         else if ( cav->cav_ptr[0] == '(' )  
           } else if ( cav->cav_ptr[0] == '(' ) {
                 return LDAP_COMPREF_SELECT;                  return LDAP_COMPREF_SELECT;
         else if ( cav->cav_ptr[0] == '*' )  
                 return LDAP_COMPREF_ALL;          } else if ( cav->cav_ptr[0] == '*' ) {
         else if ( strncmp(cav->cav_ptr,"all",3) == 0 )  
                 return LDAP_COMPREF_ALL;                  return LDAP_COMPREF_ALL;
         else if ( cav->cav_ptr[0] == '0' )  
           } else if ( cav->cav_ptr[0] == '0' ) {
                 return LDAP_COMPREF_COUNT;                  return LDAP_COMPREF_COUNT;
         else if ( cav->cav_ptr[0] > '0' && cav->cav_ptr[0] <= '9' )  
           } else if ( cav->cav_ptr[0] > '0' && cav->cav_ptr[0] <= '9' ) {
                 return LDAP_COMPREF_FROM_BEGINNING;                  return LDAP_COMPREF_FROM_BEGINNING;
         else if ( (cav->cav_end - cav->cav_ptr) >= 7 &&  
           } else if ( (cav->cav_end - cav->cav_ptr) >= 7 &&
                 strncmp(cav->cav_ptr,"content",7) == 0 )                  strncmp(cav->cav_ptr,"content",7) == 0 )
           {
                 return LDAP_COMPREF_CONTENT;                  return LDAP_COMPREF_CONTENT;
         else if ( (cav->cav_ptr[0] >= 'a' && cav->cav_ptr[0] <= 'z') ||          } else if ( (cav->cav_ptr[0] >= 'a' && cav->cav_ptr[0] <= 'z') ||
                         (cav->cav_ptr[0] >= 'A' && cav->cav_ptr[0] <= 'Z') )                          (cav->cav_ptr[0] >= 'A' && cav->cav_ptr[0] <= 'Z') )
                            {
                 return LDAP_COMPREF_IDENTIFIER;                  return LDAP_COMPREF_IDENTIFIER;
         else          }
                 return LDAP_COMPREF_UNDEFINED;  
           return LDAP_COMPREF_UNDEFINED;
 }  }
   
 static ber_tag_t  static ber_tag_t
 comp_next_id( ComponentAssertionValue* cav )  comp_next_id( ComponentAssertionValue* cav )
 {  {
   
         if ( *(cav->cav_ptr) == '.' ) {          if ( *(cav->cav_ptr) == '.' ) {
                 cav->cav_ptr++;                  cav->cav_ptr++;
                 return LDAP_COMPREF_DEFINED;                  return LDAP_COMPREF_DEFINED;
         }          }
         else return LDAP_COMPREF_UNDEFINED;  
           return LDAP_COMPREF_UNDEFINED;
 }  }
   
   
   
 static int  static int
 get_component_reference( Operation *op, ComponentAssertionValue* cav,  get_component_reference(
                         ComponentReference** cr, const char** text )          Operation *op,
           ComponentAssertionValue* cav,
           ComponentReference** cr,
           const char** text )
 {  {
         int rc,count=0;          int rc, count = 0;
         ber_int_t type;          ber_int_t type;
         ComponentReference* ca_comp_ref;          ComponentReference* ca_comp_ref;
         ComponentId** cr_list;          ComponentId** cr_list;
           char* start, *end;
   
         eat_whsp( cav );          eat_whsp( cav );
   
         if ( ( rc = strip_cav_str( cav,"\"") ) != LDAP_SUCCESS )          start = cav->cav_ptr;
                 return rc;          if ( ( rc = strip_cav_str( cav,"\"") ) != LDAP_SUCCESS ) return rc;
           if ( op ) {
                   ca_comp_ref = op->o_tmpalloc( sizeof( ComponentReference ),
                           op->o_tmpmemctx );
           } else {
                   ca_comp_ref = malloc( sizeof( ComponentReference ) );
           }
   
         ca_comp_ref =          if ( !ca_comp_ref ) return LDAP_NO_MEMORY;
                 op->o_tmpalloc( sizeof( ComponentReference ), op->o_tmpmemctx );  
   
         cr_list = &ca_comp_ref->cr_list;          cr_list = &ca_comp_ref->cr_list;
   
         for ( type = peek_componentId_type( cav ) ; type != LDAP_COMPREF_UNDEFINED          for ( type = peek_componentId_type( cav ) ; type != LDAP_COMPREF_UNDEFINED
                 ; type = comp_next_id( cav ), count++ ) {                  ; type = comp_next_id( cav ), count++ )
           {
                 rc = get_componentId( op, cav, cr_list, text );                  rc = get_componentId( op, cav, cr_list, text );
                 if ( rc == LDAP_SUCCESS ) {                  if ( rc == LDAP_SUCCESS ) {
                         if ( count == 0 ) ca_comp_ref->cr_curr = ca_comp_ref->cr_list;                          if ( count == 0 ) ca_comp_ref->cr_curr = ca_comp_ref->cr_list;
                         cr_list = &(*cr_list)->ci_next;                          cr_list = &(*cr_list)->ci_next;
                 }  
                 else if ( rc == LDAP_COMPREF_UNDEFINED )                  } else if ( rc == LDAP_COMPREF_UNDEFINED ) {
                         return rc;                          return rc;
                   }
         }          }
         ca_comp_ref->cr_len = count;          ca_comp_ref->cr_len = count;
           end = cav->cav_ptr;
         if ( ( rc = strip_cav_str( cav,"\"") ) != LDAP_SUCCESS ) {          if ( ( rc = strip_cav_str( cav,"\"") ) != LDAP_SUCCESS ) {
                 op->o_tmpfree( ca_comp_ref , op->o_tmpmemctx );                  if ( op ) {
                           op->o_tmpfree( ca_comp_ref , op->o_tmpmemctx );
                   } else {
                           free( ca_comp_ref );
                   }
                 return rc;                  return rc;
         }          }
   
         if ( rc == LDAP_SUCCESS ) {               if ( rc == LDAP_SUCCESS ) {     
                 *cr = ca_comp_ref;                  *cr = ca_comp_ref;
                 **cr = *ca_comp_ref;                      **cr = *ca_comp_ref;    
   
           } else if ( op ) {
                    op->o_tmpfree( ca_comp_ref , op->o_tmpmemctx );
   
           } else {
                    free( ca_comp_ref ) ;
         }          }
         else op->o_tmpfree( ca_comp_ref , op->o_tmpmemctx );  
   
           (*cr)->cr_string.bv_val = start;
           (*cr)->cr_string.bv_len = end - start + 1;
           
         return rc;          return rc;
 }  }
   
   int
   insert_component_reference(
           ComponentReference *cr,
           ComponentReference** cr_list)
   {
           if ( !cr ) return LDAP_PARAM_ERROR;
   
           if ( !(*cr_list) ) {
                   *cr_list = cr;
                   cr->cr_next = NULL;
           } else {
                   cr->cr_next = *cr_list;
                   *cr_list = cr;
           }
           return LDAP_SUCCESS;
   }
   
   /*
    * If there is '.' in the name of a given attribute
    * the first '.'- following characters are considered
    * as a component reference of the attribute
    * EX) userCertificate.toBeSigned.serialNumber
    * attribute : userCertificate
    * component reference : toBeSigned.serialNumber
    */
   int
   is_component_reference( char* attr ) {
           int i;
           for ( i=0; attr[i] != '\0' ; i++ ) {
                   if ( attr[i] == '.' ) return (1);
           }
           return (0);
   }
   
   int
   extract_component_reference(
           char* attr,
           ComponentReference** cr )
   {
           int i, rc;
           char* cr_ptr;
           int cr_len;
           ComponentAssertionValue cav;
           char text[1][128];
   
           for ( i=0; attr[i] != '\0' ; i++ ) {
                   if ( attr[i] == '.' ) break;
           }
   
           if (attr[i] != '.' ) return LDAP_PARAM_ERROR;
           attr[i] = '\0';
   
           cr_ptr = attr + i + 1 ;
           cr_len = strlen ( cr_ptr );
           if ( cr_len <= 0 ) return LDAP_PARAM_ERROR;
   
           /* enclosed between double quotes*/
           cav.cav_ptr = cav.cav_buf = ch_malloc (cr_len+2);
           memcpy( cav.cav_buf+1, cr_ptr, cr_len );
           cav.cav_buf[0] = '"';
           cav.cav_buf[cr_len+1] = '"';
           cav.cav_end = cr_ptr + cr_len + 2;
   
           rc = get_component_reference ( NULL, &cav, cr, (const char**)text );
           if ( rc != LDAP_SUCCESS ) return rc;
           (*cr)->cr_string.bv_val = cav.cav_buf;
           (*cr)->cr_string.bv_len = cr_len + 2;
   
           return LDAP_SUCCESS;
   }
   
 static int  static int
 get_ca_use_default( Operation *op, ComponentAssertionValue* cav,  get_ca_use_default( Operation *op,
                 int* ca_use_def, const char**  text )          ComponentAssertionValue* cav,
           int* ca_use_def, const char**  text )
 {  {
         strip_cav_str( cav, "useDefaultValues" );          strip_cav_str( cav, "useDefaultValues" );
   
         if ( peek_cav_str( cav, "TRUE" ) == LDAP_SUCCESS ) {          if ( peek_cav_str( cav, "TRUE" ) == LDAP_SUCCESS ) {
                 strip_cav_str( cav, "TRUE" );                  strip_cav_str( cav, "TRUE" );
                 *ca_use_def = 1;                  *ca_use_def = 1;
   
         } else if ( peek_cav_str( cav, "FALSE" ) == LDAP_SUCCESS ) {          } else if ( peek_cav_str( cav, "FALSE" ) == LDAP_SUCCESS ) {
                 strip_cav_str( cav, "FALSE" );                  strip_cav_str( cav, "FALSE" );
                 *ca_use_def = 0;                  *ca_use_def = 0;
   
         } else {          } else {
                 return LDAP_INVALID_SYNTAX;                  return LDAP_INVALID_SYNTAX;
         }          }
Line 425  get_matching_rule( Operation *op, Compon Line 717  get_matching_rule( Operation *op, Compon
                 if ( cav->cav_ptr[count] == ' ' || cav->cav_ptr[count] == ',' ||                  if ( cav->cav_ptr[count] == ' ' || cav->cav_ptr[count] == ',' ||
                         cav->cav_ptr[count] == '\0' || cav->cav_ptr[count] == '{' ||                          cav->cav_ptr[count] == '\0' || cav->cav_ptr[count] == '{' ||
                         cav->cav_ptr[count] == '}' || cav->cav_ptr[count] == '\n' )                          cav->cav_ptr[count] == '}' || cav->cav_ptr[count] == '\n' )
                   {
                         break;                          break;
                   }
         }          }
   
         if ( count == 0 ) {          if ( count == 0 ) {
Line 437  get_matching_rule( Operation *op, Compon Line 731  get_matching_rule( Operation *op, Compon
         rule_text.bv_val = cav->cav_ptr;          rule_text.bv_val = cav->cav_ptr;
         *mr = mr_bvfind( &rule_text );          *mr = mr_bvfind( &rule_text );
         cav->cav_ptr += count;          cav->cav_ptr += count;
         Debug( LDAP_DEBUG_FILTER, "get_matching_rule: %s\n", (*mr)->smr_mrule.mr_oid, 0, 0 );          Debug( LDAP_DEBUG_FILTER, "get_matching_rule: %s\n",
                   (*mr)->smr_mrule.mr_oid, 0, 0 );
         if ( *mr == NULL ) {          if ( *mr == NULL ) {
                 *text = "component matching rule not recognized";                  *text = "component matching rule not recognized";
                 return LDAP_INAPPROPRIATE_MATCHING;                  return LDAP_INAPPROPRIATE_MATCHING;
Line 470  get_GSER_value( ComponentAssertionValue* Line 765  get_GSER_value( ComponentAssertionValue*
                         if ( cav->cav_ptr[count] == '"' ) sequent_dquote++;                          if ( cav->cav_ptr[count] == '"' ) sequent_dquote++;
                         else sequent_dquote = 0;                          else sequent_dquote = 0;
   
                         if ( cav->cav_ptr[count] == '\0' || (cav->cav_ptr+count) > cav->cav_end ) {                          if ( cav->cav_ptr[count] == '\0' ||
                                   (cav->cav_ptr+count) > cav->cav_end )
                           {
                                 break;                                  break;
                         }                          }
                                                                   
                         if ( ( cav->cav_ptr[count] == '"' && cav->cav_ptr[count-1] != '"') ||                          if ( ( cav->cav_ptr[count] == '"' &&
                         ( sequent_dquote > 2 && (sequent_dquote%2) == 1 ) ) {                                  cav->cav_ptr[count-1] != '"') ||
                                   ( sequent_dquote > 2 && (sequent_dquote%2) == 1 ) )
                           {
                                 succeed = 1;                                  succeed = 1;
                                 break;                                  break;
                         }                          }
                 }                  }
         }                  
         else if ( cav->cav_ptr[0] == '\'' ) {                  if ( !succeed || cav->cav_ptr[count] != '"' ) {
                           return LDAP_FILTER_ERROR;
                   }
   
                   bv->bv_val = cav->cav_ptr + 1;
                   bv->bv_len = count - 1; /* exclude '"' */
   
           } else if ( cav->cav_ptr[0] == '\'' ) {
                 for( count = 1 ; ; count++ ) {                  for( count = 1 ; ; count++ ) {
                         if ( cav->cav_ptr[count] == '\0' || (cav->cav_ptr+count) > cav->cav_end ) {                          if ( cav->cav_ptr[count] == '\0' ||
                                   (cav->cav_ptr+count) > cav->cav_end )
                           {
                                 break;                                  break;
                         }                          }
                         if ((cav->cav_ptr[count-1] == '\'' && cav->cav_ptr[count] == 'B')||                          if ((cav->cav_ptr[count-1] == '\'' && cav->cav_ptr[count] == 'B') ||
                         (cav->cav_ptr[count-1] == '\'' && cav->cav_ptr[count] == 'H') ) {                                  (cav->cav_ptr[count-1] == '\'' && cav->cav_ptr[count] == 'H') )
                           {
                                 succeed = 1;                                  succeed = 1;
                                 break;                                  break;
                         }                          }
                 }                  }
   
                   if ( !succeed ||
                           !(cav->cav_ptr[count] == 'H' || cav->cav_ptr[count] == 'B') )
                   {
                           return LDAP_FILTER_ERROR;
                   }
   
                   bv->bv_val = cav->cav_ptr + 1;/*the next to '"' */
                   bv->bv_len = count - 2;/* exclude "'H" or "'B" */
                                                                   
         }          } else if ( cav->cav_ptr[0] == '{' ) {
         else if ( cav->cav_ptr[0] == '{' ) {  
                 for( count = 1, unclosed_brace = 1 ; ; count++ ) {                  for( count = 1, unclosed_brace = 1 ; ; count++ ) {
                         if ( cav->cav_ptr[count] == '{' ) unclosed_brace++;                          if ( cav->cav_ptr[count] == '{' ) unclosed_brace++;
                         if ( cav->cav_ptr[count] == '}' ) unclosed_brace--;                          if ( cav->cav_ptr[count] == '}' ) unclosed_brace--;
   
                         if ( cav->cav_ptr[count] == '\0' || (cav->cav_ptr+count) > cav->cav_end )                          if ( cav->cav_ptr[count] == '\0' ||
                                   (cav->cav_ptr+count) > cav->cav_end )
                           {
                                 break;                                  break;
                           }
                         if ( unclosed_brace == 0 ) {                          if ( unclosed_brace == 0 ) {
                                 succeed = 1;                                  succeed = 1;
                                 break;                                  break;
                         }                          }
                 }                  }
         }  
         else {                  if ( !succeed || cav->cav_ptr[count] != '}' ) return LDAP_FILTER_ERROR;
   
                   bv->bv_val = cav->cav_ptr + 1;/*the next to '"' */
                   bv->bv_len = count - 1;/* exclude  "'B" */
   
           } else {
                 succeed = 1;                  succeed = 1;
                 /*Find  following white space where the value is ended*/                  /*Find  following white space where the value is ended*/
                 for( count = 1 ; ; count++ ) {                  for( count = 1 ; ; count++ ) {
                         if ( cav->cav_ptr[count] == '\0' || cav->cav_ptr[count] == ' ' || (cav->cav_ptr+count) > cav->cav_end ) {                          if ( cav->cav_ptr[count] == '\0' ||
                                   cav->cav_ptr[count] == ' ' || cav->cav_ptr[count] == '}' ||
                                   cav->cav_ptr[count] == '{' ||
                                   (cav->cav_ptr+count) > cav->cav_end )
                           {
                                 break;                                  break;
                         }                          }
                 }                  }
                   bv->bv_val = cav->cav_ptr;
                   bv->bv_len = count;
         }          }
   
         if ( !succeed ) return LDAP_FILTER_ERROR;          cav->cav_ptr += bv->bv_len;
   
         bv->bv_val = cav->cav_ptr;  
         bv->bv_len = count ;  
         cav->cav_ptr += count;  
         return LDAP_SUCCESS;          return LDAP_SUCCESS;
 }  }
   
 static int  static int
 get_matching_value( Operation *op, ComponentAssertion* ca,  get_matching_value( Operation *op, ComponentAssertion* ca,
                         ComponentAssertionValue* cav, struct berval* bv,          ComponentAssertionValue* cav, struct berval* bv,
                         const char**  text )          const char**  text )
 {  {
         if ( !(ca->ca_ma_rule->smr_usage & (SLAP_MR_COMPONENT)) ) {          if ( !(ca->ca_ma_rule->smr_usage & (SLAP_MR_COMPONENT)) ) {
                 if ( get_GSER_value( cav, bv ) != LDAP_SUCCESS ) {                  if ( get_GSER_value( cav, bv ) != LDAP_SUCCESS ) {
Line 551  peek_cav_str( ComponentAssertionValue* c Line 878  peek_cav_str( ComponentAssertionValue* c
         eat_whsp( cav );          eat_whsp( cav );
         if ( cav_cur_len( cav ) >= strlen( str ) &&          if ( cav_cur_len( cav ) >= strlen( str ) &&
                 strncmp( cav->cav_ptr, str, strlen( str ) ) == 0 )                  strncmp( cav->cav_ptr, str, strlen( str ) ) == 0 )
           {
                 return LDAP_SUCCESS;                  return LDAP_SUCCESS;
         else           }
                 return LDAP_INVALID_SYNTAX;  
           return LDAP_INVALID_SYNTAX;
 }  }
   
 static int  static int
Line 561  strip_cav_str( ComponentAssertionValue* Line 890  strip_cav_str( ComponentAssertionValue*
 {  {
         eat_whsp( cav );          eat_whsp( cav );
         if ( cav_cur_len( cav ) >= strlen( str ) &&          if ( cav_cur_len( cav ) >= strlen( str ) &&
                 strncmp( cav->cav_ptr, str, strlen( str ) ) == 0 ) {                  strncmp( cav->cav_ptr, str, strlen( str ) ) == 0 )
           {
                 cav->cav_ptr += strlen( str );                  cav->cav_ptr += strlen( str );
                 return LDAP_SUCCESS;                  return LDAP_SUCCESS;
         }          }
         else   
                 return LDAP_INVALID_SYNTAX;          return LDAP_INVALID_SYNTAX;
 }  }
   
 /*  /*
  * TAG : "item", "and", "or", "not"   * TAG : "item", "and", "or", "not"
  */   */
 static int  static ber_tag_t
 strip_cav_tag( ComponentAssertionValue* cav )  strip_cav_tag( ComponentAssertionValue* cav )
 {  {
   
Line 580  strip_cav_tag( ComponentAssertionValue* Line 910  strip_cav_tag( ComponentAssertionValue*
         if ( cav_cur_len( cav ) >= 8 && strncmp( cav->cav_ptr, "item", 4 ) == 0 ) {          if ( cav_cur_len( cav ) >= 8 && strncmp( cav->cav_ptr, "item", 4 ) == 0 ) {
                 strip_cav_str( cav , "item:" );                  strip_cav_str( cav , "item:" );
                 return LDAP_COMP_FILTER_ITEM;                  return LDAP_COMP_FILTER_ITEM;
         }  
         else if ( cav_cur_len( cav ) >= 7 && strncmp( cav->cav_ptr, "and", 3 ) == 0 ) {          } else if ( cav_cur_len( cav ) >= 7 &&
                   strncmp( cav->cav_ptr, "and", 3 ) == 0 )
           {
                 strip_cav_str( cav , "and:" );                  strip_cav_str( cav , "and:" );
                 return LDAP_COMP_FILTER_AND;                  return LDAP_COMP_FILTER_AND;
         }  
         else if ( cav_cur_len( cav ) >= 6 && strncmp( cav->cav_ptr, "or" , 2 ) == 0 ) {          } else if ( cav_cur_len( cav ) >= 6 &&
                   strncmp( cav->cav_ptr, "or" , 2 ) == 0 )
           {
                 strip_cav_str( cav , "or:" );                  strip_cav_str( cav , "or:" );
                 return LDAP_COMP_FILTER_OR;                  return LDAP_COMP_FILTER_OR;
         }  
         else if ( cav_cur_len( cav ) >= 7 && strncmp( cav->cav_ptr, "not", 3 ) == 0 ) {          } else if ( cav_cur_len( cav ) >= 7 &&
                   strncmp( cav->cav_ptr, "not", 3 ) == 0 )
           {
                 strip_cav_str( cav , "not:" );                  strip_cav_str( cav , "not:" );
                 return LDAP_COMP_FILTER_NOT;                  return LDAP_COMP_FILTER_NOT;
         }          }
         else  
                 return LBER_ERROR;          return LBER_ERROR;
 }  }
   
 /*  /*
Line 611  get_item( Operation *op, ComponentAssert Line 947  get_item( Operation *op, ComponentAssert
 {  {
         int rc;          int rc;
         ComponentAssertion* _ca;          ComponentAssertion* _ca;
           struct berval value;
           MatchingRule* mr;
   
           Debug( LDAP_DEBUG_FILTER, "get_item \n", 0, 0, 0 );
           if ( op )
                   _ca = op->o_tmpalloc( sizeof( ComponentAssertion ), op->o_tmpmemctx );
           else
                   _ca = malloc( sizeof( ComponentAssertion ) );
   
         Debug( LDAP_DEBUG_FILTER, "get_item: %s\n", 0, 0, 0 );          if ( !_ca ) return LDAP_NO_MEMORY;
         _ca = op->o_tmpalloc( sizeof( ComponentAssertion ), op->o_tmpmemctx );  
   
         _ca->ca_comp_data.cd_tree = NULL;          _ca->ca_comp_data.cd_tree = NULL;
         _ca->ca_comp_data.cd_mem_op = NULL;          _ca->ca_comp_data.cd_mem_op = NULL;
Line 623  get_item( Operation *op, ComponentAssert Line 966  get_item( Operation *op, ComponentAssert
                 strip_cav_str( cav, "component" );                  strip_cav_str( cav, "component" );
                 rc = get_component_reference( op, cav, &_ca->ca_comp_ref, text );                  rc = get_component_reference( op, cav, &_ca->ca_comp_ref, text );
                 if ( rc != LDAP_SUCCESS ) {                  if ( rc != LDAP_SUCCESS ) {
                         rc = LDAP_INVALID_SYNTAX;                          if ( op )
                         op->o_tmpfree( _ca, op->o_tmpmemctx );                                  op->o_tmpfree( _ca, op->o_tmpmemctx );
                         return rc;                          else
                                   free( _ca );
                           return LDAP_INVALID_SYNTAX;
                 }                  }
                   if ( ( rc = strip_cav_str( cav,",") ) != LDAP_SUCCESS )
                           return rc;
           } else {
                   _ca->ca_comp_ref = NULL;
         }          }
   
         if ( ( rc = strip_cav_str( cav,",") ) != LDAP_SUCCESS )  
                 return rc;  
   
         rc = peek_cav_str( cav, "useDefaultValues");          rc = peek_cav_str( cav, "useDefaultValues");
         if ( rc == LDAP_SUCCESS ) {          if ( rc == LDAP_SUCCESS ) {
                 rc = get_ca_use_default( op, cav, &_ca->ca_use_def, text );                  rc = get_ca_use_default( op, cav, &_ca->ca_use_def, text );
                 if ( rc != LDAP_SUCCESS ) {                  if ( rc != LDAP_SUCCESS ) {
                         rc = LDAP_INVALID_SYNTAX;                          if ( op )
                         op->o_tmpfree( _ca, op->o_tmpmemctx );                                  op->o_tmpfree( _ca, op->o_tmpmemctx );
                         return rc;                          else
                                   free( _ca );
                           return LDAP_INVALID_SYNTAX;
                 }                  }
                 if ( ( rc = strip_cav_str( cav,",") ) != LDAP_SUCCESS )                  if ( ( rc = strip_cav_str( cav,",") ) != LDAP_SUCCESS )
                         return rc;                          return rc;
Line 647  get_item( Operation *op, ComponentAssert Line 995  get_item( Operation *op, ComponentAssert
   
         if ( !( strip_cav_str( cav, "rule" ) == LDAP_SUCCESS &&          if ( !( strip_cav_str( cav, "rule" ) == LDAP_SUCCESS &&
                 get_matching_rule( op, cav , &_ca->ca_ma_rule, text ) == LDAP_SUCCESS )) {                  get_matching_rule( op, cav , &_ca->ca_ma_rule, text ) == LDAP_SUCCESS )) {
                 rc = LDAP_INAPPROPRIATE_MATCHING;                  if ( op )
                 op->o_tmpfree( _ca, op->o_tmpmemctx );                          op->o_tmpfree( _ca, op->o_tmpmemctx );
                 return rc;                  else
                           free( _ca );
                   return LDAP_INAPPROPRIATE_MATCHING;
         }          }
                   
         if ( ( rc = strip_cav_str( cav,",") ) != LDAP_SUCCESS )          if ( ( rc = strip_cav_str( cav,",") ) != LDAP_SUCCESS )
                 return rc;                  return rc;
         if ( !(strip_cav_str( cav, "value" ) == LDAP_SUCCESS &&          if ( !(strip_cav_str( cav, "value" ) == LDAP_SUCCESS &&
                 get_matching_value( op, _ca, cav, &_ca->ca_ma_value,text ) == LDAP_SUCCESS )) {                  get_matching_value( op, _ca, cav,&value ,text ) == LDAP_SUCCESS )) {
                 rc = LDAP_INVALID_SYNTAX;                  if ( op )
                 op->o_tmpfree( _ca, op->o_tmpmemctx );                          op->o_tmpfree( _ca, op->o_tmpmemctx );
                 return rc;                  else
                           free( _ca );
                   return LDAP_INVALID_SYNTAX;
         }          }
   
           /*
            * Normalize the value of this component assertion when the matching
            * rule is one of existing matching rules
            */
           mr = _ca->ca_ma_rule;
           if ( op && !(mr->smr_usage & (SLAP_MR_COMPONENT)) && mr->smr_normalize ) {
   
                   value.bv_val[value.bv_len] = '\0';
                   rc = mr->smr_normalize (
                           SLAP_MR_VALUE_OF_ASSERTION_SYNTAX,
                           NULL, mr,
                           &value, &_ca->ca_ma_value, op->o_tmpmemctx );
                   if ( rc != LDAP_SUCCESS )
                           return rc;
           }
           else
                   _ca->ca_ma_value = value;
           /*
            * Validate the value of this component assertion
            */
           if ( op && mr->smr_syntax->ssyn_validate( mr->smr_syntax, &_ca->ca_ma_value) != LDAP_SUCCESS ) {
                   return LDAP_INVALID_SYNTAX;
           }
   
   
         /* componentFilterMatch contains componentFilterMatch in it */          /* componentFilterMatch contains componentFilterMatch in it */
         if ( strcmp(_ca->ca_ma_rule->smr_mrule.mr_oid, OID_COMP_FILTER_MATCH ) == 0) {          if ( strcmp(_ca->ca_ma_rule->smr_mrule.mr_oid, OID_COMP_FILTER_MATCH ) == 0) {
                 struct berval bv;                  struct berval bv;
Line 668  get_item( Operation *op, ComponentAssert Line 1045  get_item( Operation *op, ComponentAssert
                 bv.bv_len = cav_cur_len( cav );                  bv.bv_len = cav_cur_len( cav );
                 rc = get_comp_filter( op, &bv,(ComponentFilter**)&_ca->ca_cf, text );                  rc = get_comp_filter( op, &bv,(ComponentFilter**)&_ca->ca_cf, text );
                 if ( rc != LDAP_SUCCESS ) {                  if ( rc != LDAP_SUCCESS ) {
                         op->o_tmpfree( _ca, op->o_tmpmemctx );                          if ( op )
                                   op->o_tmpfree( _ca, op->o_tmpmemctx );
                           else
                                   free( _ca );
                         return rc;                          return rc;
                 }                  }
                 cav->cav_ptr = bv.bv_val;                  cav->cav_ptr = bv.bv_val;
Line 781  parse_comp_filter( Operation* op, Compon Line 1161  parse_comp_filter( Operation* op, Compon
                 break;                  break;
         }          }
   
         if ( tag != LDAP_COMP_FILTER_NOT )  
                 strip_cav_str( cav, "}");  
   
         if ( err != LDAP_SUCCESS && err != SLAPD_DISCONNECT ) {          if ( err != LDAP_SUCCESS && err != SLAPD_DISCONNECT ) {
                 *text = NULL;                  *text = "Component Filter Syntax Error";
                 f.cf_choice = SLAPD_FILTER_COMPUTED;                  return err;
                 f.cf_result = SLAPD_COMPARE_UNDEFINED;  
                 err = LDAP_SUCCESS;  
         }          }
   
           if ( tag != LDAP_COMP_FILTER_NOT )
                   strip_cav_str( cav, "}");
   
         if ( err == LDAP_SUCCESS ) {          if ( err == LDAP_SUCCESS ) {
                 *filt = op->o_tmpalloc( sizeof(f), op->o_tmpmemctx );                  if ( op ) {
                           *filt = op->o_tmpalloc( sizeof(f), op->o_tmpmemctx );
                   } else {
                           *filt = malloc( sizeof(f) );
                   }
                 **filt = f;                  **filt = f;
         }          }
   
Line 802  parse_comp_filter( Operation* op, Compon Line 1184  parse_comp_filter( Operation* op, Compon
 static int  static int
 test_comp_filter_and(  test_comp_filter_and(
         Syntax *syn,          Syntax *syn,
         Attribute *a,          ComponentSyntaxInfo *a,
         struct berval  *bv,  
         ComponentFilter *flist )          ComponentFilter *flist )
 {  {
         ComponentFilter *f;          ComponentFilter *f;
         int rtn = LDAP_COMPARE_TRUE;          int rtn = LDAP_COMPARE_TRUE;
   
         for ( f = flist ; f != NULL; f = f->cf_next ) {          for ( f = flist ; f != NULL; f = f->cf_next ) {
                 int rc = test_comp_filter( syn, a, bv, f );                  int rc = test_comp_filter( syn, a, f );
                 if ( rc == LDAP_COMPARE_FALSE ) {                  if ( rc == LDAP_COMPARE_FALSE ) {
                         rtn = rc;                          rtn = rc;
                         break;                          break;
Line 827  test_comp_filter_and( Line 1208  test_comp_filter_and(
 static int  static int
 test_comp_filter_or(  test_comp_filter_or(
         Syntax *syn,          Syntax *syn,
         Attribute *a,          ComponentSyntaxInfo *a,
         struct berval     *bv,  
         ComponentFilter *flist )          ComponentFilter *flist )
 {  {
         ComponentFilter *f;          ComponentFilter *f;
         int rtn = LDAP_COMPARE_TRUE;          int rtn = LDAP_COMPARE_TRUE;
   
         for ( f = flist ; f != NULL; f = f->cf_next ) {          for ( f = flist ; f != NULL; f = f->cf_next ) {
                 int rc = test_comp_filter( syn, a, bv, f );                  int rc = test_comp_filter( syn, a, f );
                 if ( rc == LDAP_COMPARE_TRUE ) {                  if ( rc == LDAP_COMPARE_TRUE ) {
                         rtn = rc;                          rtn = rc;
                         break;                          break;
Line 851  test_comp_filter_or( Line 1231  test_comp_filter_or(
   
 int  int
 csi_value_match( MatchingRule *mr, struct berval* bv_attr,  csi_value_match( MatchingRule *mr, struct berval* bv_attr,
                 struct berval* bv_assert )          struct berval* bv_assert )
 {  {
         int rc;          int rc;
         int match;          int match;
Line 859  csi_value_match( MatchingRule *mr, struc Line 1239  csi_value_match( MatchingRule *mr, struc
         assert( mr != NULL );          assert( mr != NULL );
         assert( !(mr->smr_usage & SLAP_MR_COMPONENT) );          assert( !(mr->smr_usage & SLAP_MR_COMPONENT) );
   
         if( !mr->smr_match ) {          if( !mr->smr_match ) return LDAP_INAPPROPRIATE_MATCHING;
                 return LDAP_INAPPROPRIATE_MATCHING;  
         }  
   
         rc = (mr->smr_match)( &match, 0, NULL /*ad->ad_type->sat_syntax*/,          rc = (mr->smr_match)( &match, 0, NULL /*ad->ad_type->sat_syntax*/,
                                 mr, bv_attr, bv_assert );                  mr, bv_attr, bv_assert );
         if ( rc == LDAP_SUCCESS )  
                 return match? LDAP_COMPARE_FALSE:LDAP_COMPARE_TRUE;          if ( rc != LDAP_SUCCESS ) return rc;
         else  
                 return rc;          return match ? LDAP_COMPARE_FALSE : LDAP_COMPARE_TRUE;
 }  }
   
 /*  /*
Line 877  csi_value_match( MatchingRule *mr, struc Line 1255  csi_value_match( MatchingRule *mr, struc
 static int  static int
 test_comp_filter_item(  test_comp_filter_item(
         Syntax *syn,          Syntax *syn,
         Attribute       *a,          ComponentSyntaxInfo *csi_attr,
         struct berval   *bv,  
         ComponentAssertion *ca )          ComponentAssertion *ca )
 {  {
         int rc, len;          int rc;
         ComponentSyntaxInfo* csi_attr, *csi_assert=NULL;  
         void *attr_nm, *assert_nm;          void *attr_nm, *assert_nm;
   
         if ( strcmp(ca->ca_ma_rule->smr_mrule.mr_oid,          if ( strcmp(ca->ca_ma_rule->smr_mrule.mr_oid,
                 OID_COMP_FILTER_MATCH ) == 0 && ca->ca_cf ) {                  OID_COMP_FILTER_MATCH ) == 0 && ca->ca_cf ) {
                 /* componentFilterMatch inside of componentFilterMatch */                  /* componentFilterMatch inside of componentFilterMatch */
                 rc = test_comp_filter( syn, a, bv, ca->ca_cf );                  rc = test_comp_filter( syn, csi_attr, ca->ca_cf );
                 return rc;                  return rc;
         }          }
   
         /* load attribute containg components */  
         if ( !a->a_comp_data && attr_converter && nibble_mem_allocator ) {  
                 a->a_comp_data = malloc( sizeof( ComponentData ) );  
                 /* Memory chunk pre-allocation for decoders */  
                 a->a_comp_data->cd_mem_op = (void*) nibble_mem_allocator ( 1024, 128 );  
                 a->a_comp_data->cd_tree = attr_converter (a, syn, bv);  
         }  
   
         if ( a->a_comp_data->cd_tree == NULL ) {  
                 free ( a->a_comp_data );  
                 return LDAP_PROTOCOL_ERROR;  
         }  
   
         /* Memory for storing will-be-extracted attribute values */          /* Memory for storing will-be-extracted attribute values */
         attr_nm = nibble_mem_allocator ( 256, 64 );          attr_nm = nibble_mem_allocator ( 1024*4 , 1024 );
         if ( !attr_nm )return LDAP_PROTOCOL_ERROR;          if ( !attr_nm ) return LDAP_PROTOCOL_ERROR;
         /* component reference initialization */  
         ca->ca_comp_ref->cr_curr = ca->ca_comp_ref->cr_list;  
         /* load component containg the referenced component */  
         csi_attr = (((ComponentSyntaxInfo*)a->a_comp_data->cd_tree)->csi_comp_desc->cd_extract_i)( attr_nm, ca->ca_comp_ref, a->a_comp_data->cd_tree );  
         if ( !csi_attr )  
                 return LDAP_PROTOCOL_ERROR;  
   
         /* Memory for storing component assertion values */          /* Memory for storing component assertion values */
         if( !ca->ca_comp_data.cd_mem_op ) {          if( !ca->ca_comp_data.cd_mem_op ) {
                 assert_nm = nibble_mem_allocator ( 256, 64 );                  assert_nm = nibble_mem_allocator ( 256, 64 );
                 if ( !assert_nm )                  if ( !assert_nm ) {
                           nibble_mem_free ( attr_nm );
                         return LDAP_PROTOCOL_ERROR;                          return LDAP_PROTOCOL_ERROR;
                   }
                 ca->ca_comp_data.cd_mem_op = assert_nm;                  ca->ca_comp_data.cd_mem_op = assert_nm;
         }  
         else {          } else {
                 assert_nm = ca->ca_comp_data.cd_mem_op;                  assert_nm = ca->ca_comp_data.cd_mem_op;
         }          }
         /* perform matching */  
         if ( ca->ca_comp_ref->cr_curr->ci_type == LDAP_COMPREF_ALL ) {          /* component reference initialization */
                 /*          if ( ca->ca_comp_ref ) {
                  * If <all> type component referenced is used                  ca->ca_comp_ref->cr_curr = ca->ca_comp_ref->cr_list;
                  * more than one component will be tested  
                  */  
                 if ( test_all_components )  
                         rc = test_all_components ( assert_nm, csi_attr, ca );  
                 else  
                         rc = LDAP_PROTOCOL_ERROR;  
         } else {  
                 /*  
                  * Exactly one component is referenced  
                  * Fast Path for matching for this case  
                  */  
                 if ( test_one_component )  
                         rc = test_one_component ( assert_nm, csi_attr, ca );  
                 else  
                         rc = LDAP_PROTOCOL_ERROR;  
         }          }
           rc = test_components( attr_nm, assert_nm, csi_attr, ca );
   
         /* free memory used for storing extracted attribute value */          /* free memory used for storing extracted attribute value */
         nibble_mem_free ( attr_nm );          nibble_mem_free ( attr_nm );
         return rc;          return rc;
Line 953  test_comp_filter_item( Line 1299  test_comp_filter_item(
 static int  static int
 test_comp_filter(  test_comp_filter(
     Syntax *syn,      Syntax *syn,
     Attribute   *a,      ComponentSyntaxInfo *a,
     struct berval *bv,  
     ComponentFilter *f )      ComponentFilter *f )
 {  {
         int     rc;          int     rc;
Line 967  test_comp_filter( Line 1312  test_comp_filter(
                 rc = f->cf_result;                  rc = f->cf_result;
                 break;                  break;
         case LDAP_COMP_FILTER_AND:          case LDAP_COMP_FILTER_AND:
                 rc = test_comp_filter_and( syn, a, bv, f->cf_and );                  rc = test_comp_filter_and( syn, a, f->cf_and );
                 break;                  break;
         case LDAP_COMP_FILTER_OR:          case LDAP_COMP_FILTER_OR:
                 rc = test_comp_filter_or( syn, a, bv, f->cf_or );                  rc = test_comp_filter_or( syn, a, f->cf_or );
                 break;                  break;
         case LDAP_COMP_FILTER_NOT:          case LDAP_COMP_FILTER_NOT:
                 rc = test_comp_filter( syn, a, bv, f->cf_not );                  rc = test_comp_filter( syn, a, f->cf_not );
   
                 switch ( rc ) {                  switch ( rc ) {
                 case LDAP_COMPARE_TRUE:                  case LDAP_COMPARE_TRUE:
Line 985  test_comp_filter( Line 1330  test_comp_filter(
                 }                  }
                 break;                  break;
         case LDAP_COMP_FILTER_ITEM:          case LDAP_COMP_FILTER_ITEM:
                 rc = test_comp_filter_item( syn, a, bv, f->cf_ca );                  rc = test_comp_filter_item( syn, a, f->cf_ca );
                 break;                  break;
         default:          default:
                 rc = LDAP_PROTOCOL_ERROR;                  rc = LDAP_PROTOCOL_ERROR;
Line 998  static void Line 1343  static void
 free_comp_filter_list( ComponentFilter* f )  free_comp_filter_list( ComponentFilter* f )
 {  {
         ComponentFilter* tmp;          ComponentFilter* tmp;
         for ( tmp = f ; tmp; tmp = tmp->cf_next );          for ( tmp = f; tmp; tmp = tmp->cf_next ) {
         {  
                 free_comp_filter( tmp );                  free_comp_filter( tmp );
         }          }
 }  }
Line 1007  free_comp_filter_list( ComponentFilter* Line 1351  free_comp_filter_list( ComponentFilter*
 static void  static void
 free_comp_filter( ComponentFilter* f )  free_comp_filter( ComponentFilter* f )
 {  {
           if ( !f ) {
                   Debug( LDAP_DEBUG_FILTER,
                           "free_comp_filter: Invalid filter so failed to release memory\n",
                           0, 0, 0 );
                   return;
           }
         switch ( f->cf_choice ) {          switch ( f->cf_choice ) {
         case LDAP_COMP_FILTER_AND:          case LDAP_COMP_FILTER_AND:
         case LDAP_COMP_FILTER_OR:          case LDAP_COMP_FILTER_OR:
                   free_comp_filter_list( f->cf_any );
                   break;
         case LDAP_COMP_FILTER_NOT:          case LDAP_COMP_FILTER_NOT:
                 free_comp_filter( f->cf_any );                  free_comp_filter( f->cf_any );
                 break;                  break;
   
         case LDAP_COMP_FILTER_ITEM:          case LDAP_COMP_FILTER_ITEM:
                 if ( nibble_mem_free && f->cf_ca->ca_comp_data.cd_mem_op )                  if ( nibble_mem_free && f->cf_ca->ca_comp_data.cd_mem_op ) {
                         nibble_mem_free( f->cf_ca->ca_comp_data.cd_mem_op );                          nibble_mem_free( f->cf_ca->ca_comp_data.cd_mem_op );
                   }
                 break;                  break;
   
         default:          default:
                 break;                  break;
         }          }
Line 1029  component_free( ComponentFilter *f ) { Line 1380  component_free( ComponentFilter *f ) {
         free_comp_filter( f );          free_comp_filter( f );
 }  }
   
   void
   free_ComponentData( Attribute *a ) {
           if ( a->a_comp_data->cd_mem_op )
                   component_destructor( a->a_comp_data->cd_mem_op );
           free ( a->a_comp_data );
           a->a_comp_data = NULL;
   }
 #endif  #endif

Removed from v.1.13  
changed lines
  Added in v.1.13.2.5


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