Commit c31d5f7b authored by garciay's avatar garciay
Browse files

Bug fixed in certificate generation test suite 

Add support of v3 certificate loader
parent bd75f572

ccsrc/Externals/LibItsSecurity_externals.cc

+3 −3
Original line number Diff line number Diff line
@@ -945,7 +945,7 @@ namespace LibItsSecurity__Functions 
    return TRUE;

  }



  BOOLEAN fx__store__certificate(const CHARSTRING& p__cert__id, const OCTETSTRING& p__cert, const OCTETSTRING& p__private__key, const OCTETSTRING& p__public__key__x, const OCTETSTRING& p__public__key__y, const OCTETSTRING& p__public__key__compressed, const INTEGER& p__public__key__compressed__mode, const OCTETSTRING& p__hashid8, const OCTETSTRING& p__issuer, const OCTETSTRING_template& p__private__enc__key, const OCTETSTRING_template& p__public__enc__key__x, const OCTETSTRING_template& p__public__enc__key__y) {

  BOOLEAN fx__store__certificate(const CHARSTRING& p__cert__id, const OCTETSTRING& p__cert, const OCTETSTRING& p__private__key, const OCTETSTRING& p__public__key__x, const OCTETSTRING& p__public__key__y, const OCTETSTRING& p__public__key__compressed, const INTEGER& p__public__key__compressed__mode, const OCTETSTRING& p__hashid8, const OCTETSTRING& p__issuer, const OCTETSTRING_template& p__private__enc__key, const OCTETSTRING_template& p__public__enc__key__x, const OCTETSTRING_template& p__public__enc__key__y, const OCTETSTRING_template& p__public__enc__compressed__key, const INTEGER_template& p__public__enc__key__compressed__mode) {

    loggers::get_instance().log(">>> fx__store__certificate: '%s'", static_cast<const char*>(p__cert__id));



    int result;
@@ -953,9 +953,9 @@ namespace LibItsSecurity__Functions 
      const OCTETSTRING private_enc_key = p__private__enc__key.valueof();

      const OCTETSTRING public_enc_key_x = p__public__enc__key__x.valueof();

      const OCTETSTRING public_enc_key_y = p__public__enc__key__y.valueof();

      result = security_services::get_instance().store_certificate(p__cert__id, p__cert, p__private__key, p__public__key__x, p__public__key__y, p__public__key__compressed, p__public__key__compressed__mode, p__hashid8, p__issuer, private_enc_key, public_enc_key_x, public_enc_key_y);

      result = security_services::get_instance().store_certificate(p__cert__id, p__cert, p__private__key, p__public__key__x, p__public__key__y, p__public__key__compressed, p__public__key__compressed__mode, p__hashid8, p__issuer, p__private__enc__key.valueof(), p__public__enc__key__x.valueof(), p__public__enc__key__y.valueof(), p__public__enc__compressed__key.valueof(), p__public__enc__key__compressed__mode.valueof());

    } else {

      result = security_services::get_instance().store_certificate(p__cert__id, p__cert, p__private__key, p__public__key__x, p__public__key__y, p__public__key__compressed, p__public__key__compressed__mode, p__hashid8, p__issuer, OCTETSTRING(), OCTETSTRING(), OCTETSTRING());

      result = security_services::get_instance().store_certificate(p__cert__id, p__cert, p__private__key, p__public__key__x, p__public__key__y, p__public__key__compressed, p__public__key__compressed__mode, p__hashid8, p__issuer, OCTETSTRING(0, nullptr), OCTETSTRING(0, nullptr), OCTETSTRING(0, nullptr), OCTETSTRING(0, nullptr), INTEGER(-1));

    }

    

    return (result == 0);

ccsrc/Protocols/GeoNetworking/decoding_context.hh

0 → 100644
+36 −0
Original line number Diff line number Diff line 
#pragma once



#include <string>



class decoding_context {

  unsigned char _next_header;

  unsigned char _header_type;

  unsigned char _header_sub_type;

  unsigned char _traffic_class;

  unsigned int  _lifetime;

  unsigned int  _length;

  std::string   _payload;



public:

  explicit decoding_context() : _payload() { reset(); };

  ~decoding_context() { };

  inline void reset() { _next_header = 0xff; _header_type = 0xff; _header_sub_type = 0xff; _lifetime = 0; _length = -1; _payload.clear(); };



public:

  inline unsigned char get_next_header() { return _next_header; };

  inline void set_next_header(const unsigned char p_next_header) { _next_header = p_next_header; };

  inline unsigned char get_header_type() { return _header_type; };

  inline void set_header_type(const unsigned char p_header_type) { _header_type = p_header_type; };

  inline unsigned char get_header_sub_type() { return _header_sub_type; };

  inline void set_header_sub_type(const unsigned char p_header_sub_type) { _header_sub_type = p_header_sub_type; };

  inline unsigned char get_traffic_class() { return _traffic_class; };

  inline void set_traffic_class(const unsigned char p_traffic_class) { _traffic_class = p_traffic_class; };

  inline unsigned int get_lifetime() { return _lifetime; };

  inline void set_lifetime(const unsigned int p_lifetime) { _lifetime = p_lifetime; };

  inline unsigned int get_length() { return _length; };

  inline void set_length(const unsigned int p_length) { _length = p_length; };





  inline std::string& get_payload() { return _payload; };

  inline void set_payload(const std::string& p_payload) { _payload.assign(p_payload); };

}; // End of class decoding_context

ccsrc/Protocols/GeoNetworking/encoding_context.hh

0 → 100644
+27 −0
Original line number Diff line number Diff line 
#pragma once



#include <memory>



class encoding_context {

  unsigned char _basic_header;

  unsigned char _next_header;

  unsigned char _header_type;

  unsigned int  _length_position;

  unsigned int  _length;



public:

  explicit encoding_context() { reset(); }

  inline void reset() { _basic_header = 0xff; _next_header = 0xff; _header_type = 0xff; _length_position = -1; _length = -1; }



public:

  inline unsigned char get_basic_header() { return _basic_header; };

  inline void set_basic_header(const unsigned char p_basic_header) { _basic_header = p_basic_header; };

  inline unsigned char get_next_header() { return _next_header; };

  inline void set_next_header(const unsigned char p_next_header) { _next_header = p_next_header; };

  inline unsigned char get_header_type() { return _header_type; };

  inline void set_header_type(const unsigned char p_header_type) { _header_type = p_header_type; };

  inline unsigned int get_length_position() { return _length_position; };

  inline void set_length_position(const unsigned int p_length_position) { _length_position = p_length_position; };

  inline unsigned int get_length() { return _length; };

  inline void set_length(const unsigned int p_length) { _length = p_length; };

}; // End of class encoding_context

ccsrc/Protocols/GeoNetworking/geonetworking_codec.cc

+51 −66
Original line number Diff line number Diff line
@@ -23,12 +23,12 @@ int geonetworking_codec::encode (const LibItsGeoNetworking__TypesAndValues::GeoN 
  encode_(msg, *msg.get_descriptor(), encoding_buffer);

  data = OCTETSTRING(encoding_buffer.get_len(), encoding_buffer.get_data());

  // Overwrite the payload length

  if (_ec.length != (unsigned int)-1) {

    loggers::get_instance().log("geonetworking_codec::encode: length=%d - plLength_position = %d - plLength = %d", data.lengthof(), _ec.length_position, _ec.length);

    unsigned char b[] = { (unsigned char)((_ec.length & 0x0000FF00) >> 8), (unsigned char)_ec.length };

  if (_ec.get_length() != (unsigned int)-1) {

    loggers::get_instance().log("geonetworking_codec::encode: length=%d - plLength_position = %d - plLength = %d", data.lengthof(), _ec.get_length_position(), _ec.get_length());

    unsigned char b[] = { (unsigned char)((_ec.get_length() & 0x0000FF00) >> 8), (unsigned char)_ec.get_length() };

    OCTETSTRING rpl(sizeof(b), b);

    loggers::get_instance().log_msg("geonetworking_codec::encode: rpl=", rpl);

    data = replace(data, _ec.length_position, rpl.lengthof(), rpl);

    data = replace(data, _ec.get_length_position(), rpl.lengthof(), rpl);

    loggers::get_instance().log_msg("geonetworking_codec::encode: after replace: ", data);

  }

  loggers::get_instance().log_msg("geonetworking_codec::decode: After encoding: ", data);
@@ -46,12 +46,12 @@ int geonetworking_codec::encode (const LibItsGeoNetworking__TypesAndValues::GnNo 
  encode_(p_gnNonSecuredPacket, *p_gnNonSecuredPacket.get_descriptor(), encoding_buffer);

  data = OCTETSTRING(encoding_buffer.get_len(), encoding_buffer.get_data());

  // Overwrite the payload length

  if (_ec.length != (unsigned int)-1) {

    loggers::get_instance().log("geonetworking_codec::encode: length=%d - plLength_position = %d - plLength = %d", data.lengthof(), _ec.length_position, _ec.length);

    unsigned char b[] = { (unsigned char)((_ec.length & 0x0000FF00) >> 8), (unsigned char)_ec.length };

  if (_ec.get_length() != (unsigned int)-1) {

    loggers::get_instance().log("geonetworking_codec::encode: length=%d - plLength_position = %d - plLength = %d", data.lengthof(), _ec.get_length_position(), _ec.get_length());

    unsigned char b[] = { (unsigned char)((_ec.get_length() & 0x0000FF00) >> 8), (unsigned char)_ec.get_length() };

    OCTETSTRING rpl(sizeof(b), b);

    loggers::get_instance().log_msg("geonetworking_codec::encode: rpl=", rpl);

    data = replace(data, _ec.length_position, rpl.lengthof(), rpl);

    data = replace(data, _ec.get_length_position(), rpl.lengthof(), rpl);

    loggers::get_instance().log_msg("geonetworking_codec::encode: after replace: ", data);

  }

  loggers::get_instance().log_msg("geonetworking_codec::encode: After encoding: ", data);
@@ -71,7 +71,7 @@ int geonetworking_codec::encode_ (const Base_Type& type, const TTCN_Typedescript 
    for(int i = 0; i < r.get_count(); i++) {

      loggers::get_instance().log("geonetworking_codec::encode_: processing %s/%s/%s - %d (1 ==> use dynamic_cast<const OPTIONAL<...>) - %d", r.fld_name(i), r.fld_descr(i)->name, r.get_at(i)->get_descriptor()->name, r.get_at(i)->is_optional(), r.get_at(i)->is_present());

      if (r.get_at(i)->is_present()) {

        if ((_ec.basic_header == 0x02) && (std::string(r.fld_descr(i)->name).compare("@LibItsGeoNetworking_TypesAndValues.GeoNetworkingPacket.packet") == 0)) { // Encoding secured GeoNetworking packet, unsecured GN message was already encoded using encvalue

        if ((_ec.get_basic_header() == 0x02) && (std::string(r.fld_descr(i)->name).compare("@LibItsGeoNetworking_TypesAndValues.GeoNetworkingPacket.packet") == 0)) { // Encoding secured GeoNetworking packet, unsecured GN message was already encoded using encvalue

          loggers::get_instance().log("geonetworking_codec::encode_: Skip it");

          continue;

        }
@@ -100,8 +100,8 @@ int geonetworking_codec::encode_ (const Base_Type& type, const TTCN_Typedescript 
      }

      // Store playload length and continue encoding

      if (p.lengthof() != 0) {

        _ec.length = p.lengthof();

        loggers::get_instance().log("geonetworking_codec::encode_: Storing payload length %d for %s", _ec.length, p.get_descriptor()->name);

        _ec.set_length(p.lengthof());

        loggers::get_instance().log("geonetworking_codec::encode_: Storing payload length %d for %s", _ec.get_length(), p.get_descriptor()->name);

      }

    }

  } else if (std::string(field_descriptor.name).compare("@EtsiTs103097Module.EtsiTs103097Data") == 0) {
@@ -120,20 +120,20 @@ int geonetworking_codec::encode_ (const Base_Type& type, const TTCN_Typedescript 
    loggers::get_instance().log("geonetworking_codec::encode_ (else): processing type %s/%s", type.get_descriptor()->name, field_descriptor.name);

    if (std::string(field_descriptor.name).compare("@LibItsGeoNetworking_TypesAndValues.BasicHeader.nextHeader") == 0) {

      // Store NextHeader field value and continue encoding

      _ec.basic_header = (unsigned int)dynamic_cast<const Enum_Type &>(type).as_int();

      loggers::get_instance().log("geonetworking_codec::encode_: Storing basic_header %d for %s", _ec.next_header, field_descriptor.name);

      _ec.set_basic_header((unsigned int)dynamic_cast<const Enum_Type &>(type).as_int());

      loggers::get_instance().log("geonetworking_codec::encode_: Storing basic_header %d for %s", _ec.get_next_header(), field_descriptor.name);

    } else if (std::string(field_descriptor.name).compare("@LibItsGeoNetworking_TypesAndValues.CommonHeader.nextHeader") == 0) {

      // Store NextHeader field value and continue encoding

      _ec.next_header = (unsigned int)dynamic_cast<const Enum_Type &>(type).as_int();

      loggers::get_instance().log("geonetworking_codec::encode_: Storing next_header %d for %s", _ec.next_header, field_descriptor.name);

      _ec.set_next_header((unsigned int)dynamic_cast<const Enum_Type &>(type).as_int());

      loggers::get_instance().log("geonetworking_codec::encode_: Storing next_header %d for %s", _ec.get_next_header(), field_descriptor.name);

    } else if (std::string(field_descriptor.name).compare("@LibItsGeoNetworking_TypesAndValues.CommonHeader.headerType") == 0) {

      // Store HeaderType field value and continue encoding

      _ec.header_type = (unsigned int)dynamic_cast<const Enum_Type &>(type).as_int();

      loggers::get_instance().log("geonetworking_codec::encode_: Storing header_type %d for %s", _ec.header_type, field_descriptor.name);

      _ec.set_header_type((unsigned int)dynamic_cast<const Enum_Type &>(type).as_int());

      loggers::get_instance().log("geonetworking_codec::encode_: Storing header_type %d for %s", _ec.get_header_type(), field_descriptor.name);

    } else  if (std::string(field_descriptor.name).compare("@LibItsGeoNetworking_TypesAndValues.CommonHeader.plLength") == 0) {

      // Store TTCN_Buffer position and continue encoding

      _ec.length_position = encoding_buffer.get_len();

      loggers::get_instance().log("geonetworking_codec::encode_: Storing position %d for %s", _ec.length_position, field_descriptor.name);

      _ec.set_length_position(encoding_buffer.get_len());

      loggers::get_instance().log("geonetworking_codec::encode_: Storing position %d for %s", _ec.get_length_position(), field_descriptor.name);

    }

    type.encode(field_descriptor, encoding_buffer, TTCN_EncDec::CT_RAW);

  }
@@ -153,19 +153,15 @@ int geonetworking_codec::decode (const OCTETSTRING& data, LibItsGeoNetworking__T 
  

  loggers::get_instance().log_to_hexa(">>> geonetworking_codec::decode: decoding_buffer=", decoding_buffer);

  decode_(msg, *msg.get_descriptor(), decoding_buffer);

  loggers::get_instance().log("geonetworking_codec::decode: After decoding, payload: plLength=%d", _dc.length);

  loggers::get_instance().log("geonetworking_codec::decode: After decoding, payload: plLength=%d", _dc.get_length());

  // Set layer parameters

  if (_params != NULL) {

    (*_params)[params::gn_next_header] = std::string(static_cast<const char *>(oct2str(OCTETSTRING(1, &_dc.next_header))));

    (*_params)[params::gn_header_type] = std::string(static_cast<const char *>(oct2str(OCTETSTRING(1, &_dc.header_type))));

    (*_params)[params::gn_header_sub_type] = std::string(static_cast<const char *>(oct2str(OCTETSTRING(1, &_dc.header_sub_type))));

    (*_params)[params::gn_traffic_class] = std::string(static_cast<const char *>(oct2str(OCTETSTRING(1, &_dc.traffic_class))));

    (*_params)[params::gn_lifetime] = std::to_string(_dc.lifetime);

    if (_dc.payload != nullptr) {

      (*_params)[params::gn_payload] = _dc.payload;

      delete [] _dc.payload;

      _dc.payload = nullptr;

    }

    (*_params)[params::gn_next_header] = std::to_string((unsigned int)_dc.get_next_header());

    (*_params)[params::gn_header_type] = std::to_string((unsigned int)_dc.get_header_type());

    (*_params)[params::gn_header_sub_type] = std::to_string((unsigned int)_dc.get_header_sub_type());

    (*_params)[params::gn_traffic_class] = std::to_string((unsigned int)_dc.get_traffic_class());

    (*_params)[params::gn_lifetime] = std::to_string(_dc.get_lifetime());

    (*_params)[params::gn_payload] = _dc.get_payload();

    params->log();

  }
@@ -204,11 +200,11 @@ int geonetworking_codec::decode_ (Base_Type& type, const TTCN_Typedescriptor_t& 
        base = 100000;

        break;

      } // End of 'switch' statement

      _dc.lifetime = base * static_cast<unsigned int>(l.multiplier());

      //loggers::get_instance().log("geonetworking_codec::decode_: Lifetime calculus: %d - %s", _dc.lifetime, std::to_string(_dc.lifetime).c_str());

      _dc.set_lifetime(base * static_cast<unsigned int>(l.multiplier()));

      //loggers::get_instance().log("geonetworking_codec::decode_: Lifetime calculus: %d - %s", _dc.get_lifetime(), std::to_string(_dc.get_lifetime()).c_str());

    } else if (std::string(type.get_descriptor()->name).compare("@LibItsGeoNetworking_TypesAndValues.TrafficClass") == 0) {

      LibItsGeoNetworking__TypesAndValues::TrafficClass& t = static_cast<LibItsGeoNetworking__TypesAndValues::TrafficClass&>(r);

      _dc.traffic_class = (t.scf().as_int() << 7) | (t.channelOffload() << 6) | (t.tcId() & 0x3f); // ETSI EN 302 636-4-1 chapter 8.7.5

      _dc.set_traffic_class((t.scf().as_int() << 7) | (t.channelOffload() << 6) | (t.tcId() & 0x3f)); // ETSI EN 302 636-4-1 chapter 8.7.5

    }

  } else if (std::string(type.get_descriptor()->name).compare("@IEEE1609dot2.Ieee1609Dot2Data") == 0) {

    dynamic_cast<OPTIONAL<IEEE1609dot2::Ieee1609Dot2Data> &>(type).set_to_omit(); // TODO Add security support
@@ -218,7 +214,7 @@ int geonetworking_codec::decode_ (Base_Type& type, const TTCN_Typedescriptor_t& 
      // Decode NextHeader data structure

      type.decode(field_descriptor, decoding_buffer, TTCN_EncDec::CT_RAW);

      // Store NextHeader field value and continue decoding

      _dc.next_header = (unsigned int)dynamic_cast<const Enum_Type &>(type).as_int();

      _dc.set_next_header((unsigned int)dynamic_cast<const Enum_Type &>(type).as_int());

    } else if (std::string(field_descriptor.name).compare("@LibItsGeoNetworking_TypesAndValues.CommonHeader.headerTST") == 0) {

      decode_headerTST(static_cast<LibItsGeoNetworking__TypesAndValues::HeaderTST &>(type), decoding_buffer);

    } else if (std::string(field_descriptor.name).compare("@LibItsGeoNetworking_TypesAndValues.GnNonSecuredPacket.extendedHeader") == 0) {
@@ -243,31 +239,20 @@ int geonetworking_codec::decode_ (Base_Type& type, const TTCN_Typedescriptor_t& 
      }

      // Align the payload length with the specified plLenght value

      OCTETSTRING os;

      if (_dc.length != 0) {

        if ((unsigned char)s.lengthof() <= _dc.length) {

      if (_dc.get_length() != 0) {

        if ((unsigned char)s.lengthof() <= _dc.get_length()) {

          os = OCTETSTRING(s.lengthof(), p);

          CHARSTRING c(oct2str(os));

          _dc.payload = new char[c.lengthof() + 1];

          strcpy(_dc.payload, static_cast<const char*>(c));

          //_dc.payload = std::string(static_cast<const char *>(oct2str(os)));

          _dc.set_payload(static_cast<const char *>(oct2str(os)));

        } else {

          os = OCTETSTRING(_dc.length, p);

          CHARSTRING c(oct2str(os));

          _dc.payload = new char[c.lengthof() + 1];

          strcpy(_dc.payload, static_cast<const char*>(c));

          //_dc.payload = std::string(static_cast<const char *>(oct2str(os)));

          os = OCTETSTRING(_dc.get_length(), p);

          _dc.set_payload(static_cast<const char *>(oct2str(os)));

        }

      } else {

        os = s;

        if (_dc.payload != nullptr) {

          delete [] _dc.payload;

          _dc.payload = nullptr;

        }

        //_dc.payload.clear();

        _dc.set_payload("");

      }

      loggers::get_instance().log_msg("geonetworking_codec::decode_: Payload: os: ", os);

      //      loggers::get_instance().log("geonetworking_codec::decode_: Payload: '%s'", _dc.payload.c_str());

      loggers::get_instance().log("geonetworking_codec::decode_: Payload: '%s'", (_dc.payload != nullptr) ? _dc.payload : "(null)");

      loggers::get_instance().log("geonetworking_codec::decode_: Payload: '%s'", _dc.get_payload().c_str());

      if (os.lengthof() != 0) {

        dynamic_cast<OPTIONAL<LibItsGeoNetworking__TypesAndValues::GnRawPayload> &>(type) = OPTIONAL<LibItsGeoNetworking__TypesAndValues::GnRawPayload>(os);

        loggers::get_instance().log_msg("geonetworking_codec::decode_: Set OPTIONAL<GnRawPayload> to ", type);
@@ -279,7 +264,7 @@ int geonetworking_codec::decode_ (Base_Type& type, const TTCN_Typedescriptor_t& 
      // Decode plLength data structure

      type.decode(field_descriptor, decoding_buffer, TTCN_EncDec::CT_RAW);

      // Store playload length and continue decoding

      _dc.length = (unsigned int)static_cast<int>(dynamic_cast<const INTEGER &>(type));

      _dc.set_length((unsigned int)static_cast<int>(dynamic_cast<const INTEGER &>(type)));

    } else {

      type.decode(field_descriptor, decoding_buffer, TTCN_EncDec::CT_RAW);

    }
@@ -345,11 +330,11 @@ int geonetworking_codec::decode_headerTST(LibItsGeoNetworking__TypesAndValues::H 
  loggers::get_instance().log(">>> geonetworking_codec::decode_headerTST: processing %s", u.get_descriptor()->name);



  // Decode HeaderTST data structure

  _dc.header_type = *(decoding_buffer.get_data() + decoding_buffer.get_pos()) >> 4;

  _dc.header_sub_type = *(decoding_buffer.get_data() + decoding_buffer.get_pos()) & 0x0F;

  loggers::get_instance().log("geonetworking_codec::decode_: headerTST selectors: _dc.header_type = %d - _dc.header_sub_type = %d", _dc.header_type, _dc.header_sub_type);

  _dc.set_header_type(*(decoding_buffer.get_data() + decoding_buffer.get_pos()) >> 4);

  _dc.set_header_sub_type(*(decoding_buffer.get_data() + decoding_buffer.get_pos()) & 0x0F);

  loggers::get_instance().log("geonetworking_codec::decode_: headerTST selectors: _dc.header_type = %d - _dc.header_sub_type = %d", _dc.get_header_type(), _dc.get_header_sub_type());

  //LibItsGeoNetworking__TypesAndValues::HeaderTST & u = dynamic_cast<LibItsGeoNetworking__TypesAndValues::HeaderTST &>(u);

  switch (_dc.header_type) {

  switch (_dc.get_header_type()) {

  case LibItsGeoNetworking__TypesAndValues::HeaderType::e__geoUnicast:

    decode_(u.geoUnicastHdr(), *u.geoUnicastHdr().get_descriptor(), decoding_buffer);

    break;
@@ -375,7 +360,7 @@ int geonetworking_codec::decode_headerTST(LibItsGeoNetworking__TypesAndValues::H 
    decode_(u.saHdr(), *u.saHdr().get_descriptor(), decoding_buffer);

    break;

  default:

    TTCN_error("geonetworking_codec::decode_: Not processed, _dc.header_type = %d - _dc.header_sub_type = %d", _dc.header_type, _dc.header_sub_type);

    TTCN_error("geonetworking_codec::decode_: Not processed, _dc.header_type = %d - _dc.header_sub_type = %d", _dc.get_header_type(), _dc.get_header_sub_type());

  } // End of 'switch' statement



  return 0;
@@ -384,14 +369,14 @@ int geonetworking_codec::decode_headerTST(LibItsGeoNetworking__TypesAndValues::H 
int geonetworking_codec::decode_extendedHeader(LibItsGeoNetworking__TypesAndValues::ExtendedHeader& u, TTCN_Buffer& decoding_buffer) {

  loggers::get_instance().log(">>> geonetworking_codec::decode_extendedHeader: processing %s", u.get_descriptor()->name);



  switch (_dc.header_type) {

  switch (_dc.get_header_type()) {

  case LibItsGeoNetworking__TypesAndValues::HeaderType::e__geoUnicast:

    decode_(u.geoUnicastHeader(), *u.geoUnicastHeader().get_descriptor(), decoding_buffer);

    break;

  case LibItsGeoNetworking__TypesAndValues::HeaderType::e__topologicallyScopedBroadcast:

    if (_dc.header_sub_type == LibItsGeoNetworking__TypesAndValues::HeaderSubTypeTSB::e__multiHop) {

    if (_dc.get_header_sub_type() == LibItsGeoNetworking__TypesAndValues::HeaderSubTypeTSB::e__multiHop) {

      decode_(u.tsbHeader(), *u.tsbHeader().get_descriptor(), decoding_buffer);

    } else if (_dc.header_sub_type == LibItsGeoNetworking__TypesAndValues::HeaderSubTypeTSB::e__singleHop) {

    } else if (_dc.get_header_sub_type() == LibItsGeoNetworking__TypesAndValues::HeaderSubTypeTSB::e__singleHop) {

      decode_(u.shbHeader(), *u.shbHeader().get_descriptor(), decoding_buffer);

    } else {

      TTCN_error("geonetworking_codec::decode_headerTST: TSB subtype not processed");
@@ -407,9 +392,9 @@ int geonetworking_codec::decode_extendedHeader(LibItsGeoNetworking__TypesAndValu 
    decode_(u.beaconHeader(), *u.beaconHeader().get_descriptor(), decoding_buffer);

    break;

  case LibItsGeoNetworking__TypesAndValues::HeaderType::e__locationService:

    if (_dc.header_sub_type == LibItsGeoNetworking__TypesAndValues::HeaderSubTypeLs::e__lsRequest) {

    if (_dc.get_header_sub_type() == LibItsGeoNetworking__TypesAndValues::HeaderSubTypeLs::e__lsRequest) {

      decode_(u.lsRequestHeader(), *u.lsRequestHeader().get_descriptor(), decoding_buffer);

    } else if (_dc.header_sub_type == LibItsGeoNetworking__TypesAndValues::HeaderSubTypeLs::e__lsReply) {

    } else if (_dc.get_header_sub_type() == LibItsGeoNetworking__TypesAndValues::HeaderSubTypeLs::e__lsReply) {

      decode_(u.lsReplyHeader(), *u.lsReplyHeader().get_descriptor(), decoding_buffer);

    } else {

      TTCN_error("geonetworking_codec::decode_headerTST: Location service subtype not processed");
@@ -420,16 +405,16 @@ int geonetworking_codec::decode_extendedHeader(LibItsGeoNetworking__TypesAndValu 
    break;

  case LibItsGeoNetworking__TypesAndValues::HeaderType::e__serviceAnnouncement:

    // Check that Service Advertisment (ETSI TS 102 890-1) uses TSB

    if (_dc.header_sub_type == LibItsGeoNetworking__TypesAndValues::HeaderSubTypeSa::e__sa) {

    if (_dc.get_header_sub_type() == LibItsGeoNetworking__TypesAndValues::HeaderSubTypeSa::e__sa) {

      decode_(u.saHeader(), *u.saHeader().get_descriptor(), decoding_buffer);

    } else if (_dc.header_sub_type == LibItsGeoNetworking__TypesAndValues::HeaderSubTypeSa::e__saEos) {

    } else if (_dc.get_header_sub_type() == LibItsGeoNetworking__TypesAndValues::HeaderSubTypeSa::e__saEos) {

      decode_(u.saEosHeader(), *u.saEosHeader().get_descriptor(), decoding_buffer);

    } else {

      TTCN_error("geonetworking_codec::decode_headerTST: Service Advertisement subtype not processed");

    }

    break;

  default:

    TTCN_error("geonetworking_codec::decode_headerTST: Not processed, _dc.header_type = %d - _dc.header_sub_type = %d", _dc.header_type, _dc.header_sub_type);

    TTCN_error("geonetworking_codec::decode_headerTST: Not processed, _dc.header_type = %d - _dc.header_sub_type = %d", _dc.get_header_type(), _dc.get_header_sub_type());

  } // End of 'switch' statement



  return 0;

ccsrc/Protocols/GeoNetworking/geonetworking_codec.hh

+3 −27

File changed.

Preview size limit exceeded, changes collapsed.