Commit 836125d6 authored by Denis Filatov's avatar Denis Filatov
Browse files

Merge branch 'STF525' of https://forge.etsi.org/gitlab/ITS/ITS into STF525

parents 5950d341 17ac6b85

ccsrc/Protocols/Commsignia/commsignia_layer.cc

+56 −20
Original line number Diff line number Diff line
@@ -8,7 +8,7 @@ 


#include "converter.hh"



unsigned char commsignia_layer::_fixed_header[12] = { 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0x0D, 0x00, 0x00 };

unsigned char commsignia_layer::_fixed_header[10] = { 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0x0D };



commsignia_layer::commsignia_layer(const std::string & p_type, const std::string & param) : layer(p_type), _params(), _c2p_recv{0}, _802_11p_hdr{0}, _c2p_llc_hdr{0}, _mac_src(), _eth_type() {

  loggers::get_instance().log(">>> commsignia_layer::commsignia_layer: %s, %s", to_string().c_str(), param.c_str());
@@ -41,30 +41,41 @@ commsignia_layer::commsignia_layer(const std::string & p_type, const std::string 
  if (it == _params.cend()) {

    _params.insert(std::pair<std::string, std::string>(std::string("data_rate"), "12")); // 12 * 500Kbps = 6Mbps

  }

  it = _params.find(std::string("use_vpn"));

  if (it == _params.cend()) {

    _params.insert(std::pair<std::string, std::string>(std::string("use_vpn"), "0"));

  }

  //_params.log();

}



void commsignia_layer::send_data(OCTETSTRING& data, params& params) {

  loggers::get_instance().log_msg(">>> commsignia_layer::send_data: ", data);



  OCTETSTRING buffer(12, commsignia_layer::_fixed_header);

  OCTETSTRING buffer(10, commsignia_layer::_fixed_header);

  if (_params[std::string("use_vpn")].compare("1") == 0) {

    buffer += int2oct(1, 1); // Injection to software

  } else {

    buffer += int2oct(0, 1); // Injection to radio

  }

  buffer += int2oct(0, 1); // Fix

  loggers::get_instance().log_msg("commsignia_layer::send_data: buffer: ", buffer);

  buffer += int2oct(std::stoi(_params[params::interface_id]), 4);

  loggers::get_instance().log_msg("commsignia_layer::send_data: buffer: ", buffer);

  buffer += int2oct(std::stoi(_params[std::string("data_rate")]), 4);

  buffer += int2oct(std::stoi(_params[std::string("data_rate")]), 2);

  loggers::get_instance().log_msg("commsignia_layer::send_data: buffer: ", buffer);

  buffer += int2oct(7, 1); // MAC user priority

  buffer += int2oct(0x80000000 & std::stoi(_params[std::string("power_tx")]), 4); // Negative number

  loggers::get_instance().log_msg("commsignia_layer::send_data: buffer: ", buffer);

  buffer += int2oct(7, 1); // MAC user priority

  // Destination MAC address

  params::const_iterator it = params.find(params::mac_dst); // Find in provided parameters, params

  if (it != params.cend()) {

    buffer = str2oct(CHARSTRING(it->second.c_str()));

    buffer += str2oct(CHARSTRING(it->second.c_str()));

  } else {

    it = _params.find(params::mac_dst);

    if (it != _params.cend()) {

      buffer = str2oct(CHARSTRING(it->second.c_str()));

      buffer += str2oct(CHARSTRING(it->second.c_str()));

    } else {

      buffer = str2oct(CHARSTRING(_params[params::mac_bc].c_str()));

      buffer += str2oct(CHARSTRING(_params[params::mac_bc].c_str()));

    }

  }

  loggers::get_instance().log_msg("commsignia_layer::send_data: buffer: ", buffer);
@@ -72,9 +83,14 @@ void commsignia_layer::send_data(OCTETSTRING& data, params& params) { 
  it = params.find(params::mac_src); // Find in provided parameters, params

  if (it != params.cend()) {

    buffer += str2oct(CHARSTRING(it->second.c_str()));

  } else {

    it = _params.find(params::mac_src);

    if (it != _params.cend()) {

      buffer += str2oct(CHARSTRING(it->second.c_str()));

  } else {

      buffer += str2oct(CHARSTRING(_params[params::mac_src].c_str()));

    }

  }

  loggers::get_instance().log_msg("commsignia_layer::send_data: buffer: ", buffer);

  buffer += int2oct(0, 2); // Fixed

  loggers::get_instance().log_msg("commsignia_layer::send_data: buffer: ", buffer);
@@ -91,13 +107,22 @@ void commsignia_layer::receive_data(OCTETSTRING& data, params& params) { 
  

  const unsigned char* p = static_cast<const unsigned char *>(data);

  

  // Check the frame version

  if (*p != 0x12) {

    // Discard it, on;y use TX version

    return;

  }

    

  const commsignia_layer::c2p_s_v1_tx_t* r = (const commsignia_layer::c2p_s_v1_tx_t*)p;

  loggers::get_instance().log("commsignia_layer::receive_data: version=%02x", r->s_header.u8_ver_type);

  loggers::get_instance().log("commsignia_layer::receive_data: timestamp1=%08x", ntohl(r->s_header.u32_tst_sec));

  loggers::get_instance().log("commsignia_layer::receive_data: timestamp2=%08x", ntohl(r->s_header.u32_tst_msec));

  loggers::get_instance().log("commsignia_layer::receive_data: primary_channel=%08x", ntohl(r->u8_primary_channel));

  loggers::get_instance().log("commsignia_layer::receive_data: secondary_channel=%08x", ntohl(r->u8_secondary_channel));

  loggers::get_instance().log("commsignia_layer::receive_data: primary_channel=%08x", r->u8_primary_channel);

  loggers::get_instance().log("commsignia_layer::receive_data: secondary_channel=%08x", r->u8_secondary_channel);

  loggers::get_instance().log("commsignia_layer::receive_data: antenna=%02x", r->u8_antenna);

  loggers::get_instance().log("commsignia_layer::receive_data: speed=%d", ntohs(r->u16_speed));

  loggers::get_instance().log("commsignia_layer::receive_data: heading=%d", ntohs(r->u16_heading));

  loggers::get_instance().log("commsignia_layer::receive_data: txp=%02x", r->s8_txp);

  loggers::get_instance().log("commsignia_layer::receive_data: s8_tssi_ant_1=%d", r->s8_tssi_ant_1);

  loggers::get_instance().log("commsignia_layer::receive_data: s8_tssi_ant_2=%d", r->s8_tssi_ant_2);

  // Filtering on antenna index
@@ -105,10 +130,10 @@ void commsignia_layer::receive_data(OCTETSTRING& data, params& params) { 
  if (r->u8_antenna != std::stoi(_params[params::interface_id])) {

    // Discard packet

    loggers::get_instance().warning("commsignia_layer::receive_data: Discard packet due to wrong antenna id");

    return;

    // TODO return;

  } // else, continue



  const commsignia_layer::c2p_802_11p_hdr* h = (const commsignia_layer::c2p_802_11p_hdr*)(p + sizeof(commsignia_layer::c2p_s_v1_tx_t));

  const commsignia_layer::c2p_802_11p_hdr* h = (const commsignia_layer::c2p_802_11p_hdr*)(p + sizeof(commsignia_layer::c2p_s_v1_tx_t) - 1);

  loggers::get_instance().log("commsignia_layer::receive_data: frame_ctrl=%04x", ntohs(h->frame_ctrl));

  OCTETSTRING dst = OCTETSTRING(6, (const unsigned char*)&h->dst_addr);

  loggers::get_instance().log_msg("commsignia_layer::receive_data: dst: ", dst);
@@ -119,23 +144,30 @@ void commsignia_layer::receive_data(OCTETSTRING& data, params& params) { 
  if (!std::equal(_mac_src.cbegin(), _mac_src.cend(), static_cast<const unsigned char*>(src))) {

    // Discard packet

    loggers::get_instance().warning("commsignia_layer::receive_data: Discard packet due to wrong comparison");

    return;

    //TODO return;

  } // else, continue

  const commsignia_layer::c2p_llc_hdr* l;

  int length;

  if ((ntohs(h->frame_ctrl) & 0xf000) == 0x8000) {

    l = (const commsignia_layer::c2p_llc_hdr*)(p + sizeof(commsignia_layer::c2p_s_v1_tx_t) + sizeof(commsignia_layer::c2p_802_11p_hdr) + sizeof(commsignia_layer::c2p_qos_ctrl));

    length = sizeof(commsignia_layer::c2p_s_v1_tx_t) + sizeof(commsignia_layer::c2p_802_11p_hdr) + sizeof(commsignia_layer::c2p_qos_ctrl) + sizeof(commsignia_layer::c2p_llc_hdr);

    l = (const commsignia_layer::c2p_llc_hdr*)(p + sizeof(commsignia_layer::c2p_s_v1_tx_t) - 1 + sizeof(commsignia_layer::c2p_802_11p_hdr) + sizeof(commsignia_layer::c2p_qos_ctrl));

    length = sizeof(commsignia_layer::c2p_s_v1_tx_t) - 1 + sizeof(commsignia_layer::c2p_802_11p_hdr) + sizeof(commsignia_layer::c2p_qos_ctrl) + sizeof(commsignia_layer::c2p_llc_hdr);

  } else {

    l = (const commsignia_layer::c2p_llc_hdr*)(p + sizeof(commsignia_layer::c2p_s_v1_tx_t) + sizeof(commsignia_layer::c2p_802_11p_hdr));

    length = sizeof(commsignia_layer::c2p_s_v1_tx_t) + sizeof(commsignia_layer::c2p_802_11p_hdr) + sizeof(commsignia_layer::c2p_llc_hdr);

    l = (const commsignia_layer::c2p_llc_hdr*)(p + sizeof(commsignia_layer::c2p_s_v1_tx_t) - 1 + sizeof(commsignia_layer::c2p_802_11p_hdr));

    length = sizeof(commsignia_layer::c2p_s_v1_tx_t) - 1 + sizeof(commsignia_layer::c2p_802_11p_hdr) + sizeof(commsignia_layer::c2p_llc_hdr);

  }

  loggers::get_instance().log("commsignia_layer::receive_data: dsap=%02x", l->dsap);

  loggers::get_instance().log("commsignia_layer::receive_data: ssap=%02x", l->ssap);

  loggers::get_instance().log("commsignia_layer::receive_data: ssap=%02x", l->ctrl);

  loggers::get_instance().log("commsignia_layer::receive_data: type=%04x", l->type);





  

  length -= 4;

  





  // Check ether type

  if ((_eth_type[1] == (unsigned char)((l->type & 0xff00) >> 8)) && (_eth_type[0] == (unsigned char)(l->type & 0xff))) { // Warning: Network ordered bytes

  //if ((_eth_type[1] == (unsigned char)((l->type & 0xff00) >> 8)) && (_eth_type[0] == (unsigned char)(l->type & 0xff))) { // Warning: Network ordered bytes

    // Extract payload

    data = OCTETSTRING(data.lengthof() - length, length + static_cast<const unsigned char *>(data));

    //loggers::get_instance().log_msg("commsignia_layer::receive_data: payload for upper layer:", data);
@@ -147,7 +179,11 @@ void commsignia_layer::receive_data(OCTETSTRING& data, params& params) { 
    params[params::mac_src] = std::string(static_cast<const char *>(s));

    

    receive_to_all_layers(data, params);

  } // else, nothing to do

    /*} else {

    // Discard packet

    loggers::get_instance().warning("commsignia_layer::receive_data: Discard packet due to wrong ethernet type");

    //TODO return;

    }*/

}



commsignia_layer_factory commsignia_layer_factory::_f;

ccsrc/Protocols/Commsignia/commsignia_layer.hh

+1 −1
Original line number Diff line number Diff line
@@ -80,7 +80,7 @@ class commsignia_layer : public layer { 
  std::vector<unsigned char> _eth_type; //! Used to optimize filtering on ethernet type in \see commsignia_layer::receive_data method



  //! Fixed header for packet injection

  static unsigned char _fixed_header[12];

  static unsigned char _fixed_header[10];

  

public:

  //! \publicsection

ccsrc/Protocols/Http/http_codec.cc

+16 −9
Original line number Diff line number Diff line
@@ -208,6 +208,7 @@ int http_codec::encode_request(const LibItsHttp__TypesAndValues::Request& p_requ 
    p_encoding_buffer.put_cs("0");

    _ec.is_content_length_present = 0x00;

  }

  loggers::get_instance().log("http_codec::encode_request: Content-Length: %d - %x", _ec.length, _ec.is_content_length_present);

  p_encoding_buffer.put_cs("\r\n");



  // Add message body
@@ -215,7 +216,7 @@ int http_codec::encode_request(const LibItsHttp__TypesAndValues::Request& p_requ 
  if (_ec.is_content_length_present == 0x01) {

    loggers::get_instance().log_msg("http_codec::encode_request: Add body ", os);

    p_encoding_buffer.put_os(os);

    //FIXME For test With GEMALTO, comment to be removed, p_encoding_buffer.put_cs("\r\n");

    p_encoding_buffer.put_cs("\r\n");

  }



  loggers::get_instance().log_to_hexa("<<< http_codec::encode_request: ", p_encoding_buffer);
@@ -255,7 +256,8 @@ int http_codec::encode_response (const LibItsHttp__TypesAndValues::Response& p_r 
        if (v.size_of() > 0) {

          loggers::get_instance().log_msg("http_codec::encode_response: Processing value ", v[0]);

          if (std::string(static_cast<const char*>(header.header__name())).compare("Content-Type") == 0) { // Store it for HTTP body payload encoding

            int j = 1;

            loggers::get_instance().log("http_codec::encode_response: Storing Content-Type");

            int j = 0;

            while (j < v.size_of()) {

              content_type += v[j++];

            } // End of 'while' statement
@@ -265,7 +267,7 @@ int http_codec::encode_response (const LibItsHttp__TypesAndValues::Response& p_r 
          while (j < v.size_of()) {

                p_encoding_buffer.put_cs(", ");

                loggers::get_instance().log_msg("http_codec::encode_response: Processing value ", v[j]);

                p_encoding_buffer.put_cs(v[j]);

                p_encoding_buffer.put_cs(v[j++]);

                j += 1;

          } // End of 'while' statement

        }
@@ -287,30 +289,35 @@ int http_codec::encode_response (const LibItsHttp__TypesAndValues::Response& p_r 
      _ec.length = os.lengthof();

      _ec.is_content_length_present = 0x01;

    }

    loggers::get_instance().log("http_codec::encode_request: length=%d", _ec.length);

    loggers::get_instance().log("http_codec::encode_response: length=%d", _ec.length);

  } else {

    loggers::get_instance().log("http_codec::encode_request: HTTP body field not present");

    loggers::get_instance().log("http_codec::encode_response: HTTP body field not present");

    _ec.length = 0;

    _ec.is_content_length_present = 0x00;

  }



  // Encode Content-Length header

  p_encoding_buffer.put_cs("Content-Length: ");

  if (_ec.length != 0) {

    p_encoding_buffer.put_cs(int2str(_ec.length + 2/*Stand for the last CRLF*/));

    loggers::get_instance().log("http_codec::encode_request: Content-Length: %s", static_cast<const char*>(int2str(_ec.length + 2/*Stand for the last CRLF*/)));

    p_encoding_buffer.put_cs(static_cast<const char*>(int2str(_ec.length + 2/*Stand for the last CRLF*/)));

    _ec.is_content_length_present = 0x01;

  } else {

    p_encoding_buffer.put_cs("0");

    _ec.is_content_length_present = 0x00;

  }

  loggers::get_instance().log("http_codec::encode_response: Content-Length: %d - %x", _ec.length, _ec.is_content_length_present);

  loggers::get_instance().log("http_codec::encode_request: Content-Length: %d - %x", _ec.length, _ec.is_content_length_present);

  p_encoding_buffer.put_cs("\r\n");



  // Add message body

  p_encoding_buffer.put_cs("\r\n");

  if (_ec.length != 0) {

  if (_ec.is_content_length_present == 0x01) {

    loggers::get_instance().log_msg("http_codec::encode_request: Add body ", os);

    p_encoding_buffer.put_os(os);

    p_encoding_buffer.put_cs("\r\n");

  }

  

  loggers::get_instance().log_to_hexa("<<< http_codec::encode_response: ", p_encoding_buffer);

  return 0;

}

ccsrc/Protocols/Security/security_services.cc

+6 −4
Original line number Diff line number Diff line
@@ -156,12 +156,12 @@ int security_services::process_ieee_1609_dot2_signed_data(const IEEE1609dot2::Si 
      return -1;

    }

  } else {

    const OPTIONAL<INTEGER>& v = dynamic_cast<const OPTIONAL<INTEGER>& >(header_info.generationTime()); // in millisecond

    const OPTIONAL<INTEGER>& v = dynamic_cast<const OPTIONAL<INTEGER>& >(header_info.generationTime()); // in microsecond

    unsigned long long gt = ((INTEGER&)(*v.get_opt_value())).get_long_long_val();

    // Get current time timestamp

    unsigned long long us = base_time::get_instance().get_its_current_time_us(); // in millisecond

    unsigned long long us = base_time::get_instance().get_its_current_time_us(); // in microsecond

    loggers::get_instance().log("security_services::process_ieee_1609_dot2_signed_data: generation time check %ld / %ld, delta = %f", header_info.generationTime(), us, abs((double)gt - (double)us));

    if (abs((double)gt - (double)us) >= 5.0) { // TODO Use a params for generation_time_epsilon

    if (abs((double)gt - (double)us) >= 500000.0) { // TODO Use a params for generation_time_epsilon, 500ms differences

      loggers::get_instance().warning("security_services::process_ieee_1609_dot2_signed_data: Invalid generation time, discard it");

      if (p_verify) {

        return -1;
@@ -500,7 +500,7 @@ int security_services::sign_payload(const OCTETSTRING& p_unsecured_gn_payload, O 
  INTEGER i;

  i.set_long_long_val(us);

  header_info.generationTime() = OPTIONAL<INTEGER>(i);

  loggers::get_instance().log("security_services::sign_payload: Finame HeaderInfo timestamp: %ld", us);

  loggers::get_instance().log("security_services::sign_payload: Final HeaderInfo timestamp: %ld", us);

  // Check if a certificate shall be requested

  if (_unknown_certificate.lengthof() == 3) { // HashedId3

    IEEE1609dot2BaseTypes::SequenceOfHashedId3 s;
@@ -540,11 +540,13 @@ int security_services::sign_payload(const OCTETSTRING& p_unsecured_gn_payload, O 
      loggers::get_instance().warning("security_services:sign_payload: Failed to secure payload");

      return -1;

    }

    loggers::get_instance().log("security_services::sign_payload: cert= ", cert);

    IEEE1609dot2::SequenceOfCertificate sequenceOfCertificate;

    sequenceOfCertificate[0] = cert;

    signer.certificate() = sequenceOfCertificate;

    // Reset send certificate timer

    _last_generation_time = us;

    loggers::get_instance().log("security_services::sign_payload: Reset send certificate timer, signer= ", signer);

  } else {

    loggers::get_instance().log("security_services::sign_payload: Add digest");

    OCTETSTRING digest;

ccsrc/Protocols/UpperTester/uppertester_pki_codec.cc

+2 −70
Original line number Diff line number Diff line
@@ -46,6 +46,8 @@ int uppertester_pki_codec::encode (const LibItsPki__TypesAndValues::UtPkiTrigger 
    encoding_buffer.put_os(u.triggerEnrolmentRequest().privateKey()); // 32 bytes

    encoding_buffer.put_os(u.triggerEnrolmentRequest().compressedPublickey()); //33 bytes

    */

  } else if (u.ischosen(LibItsPki__TypesAndValues::UtPkiTrigger::ALT_triggerAuthorizationRequest)) {

    encoding_buffer.put_c(static_cast<const unsigned char>(uppertester_pki_codec::c_utPkiTriggerAuthorizationRequest));

  } else { // Error

    data = OCTETSTRING(0, nullptr);

    loggers::get_instance().warning("<<< uppertester_pki_codec::encode: Failed to encode UT message");
@@ -85,76 +87,6 @@ int uppertester_pki_codec::encode_ (const Base_Type& type, const TTCN_Typedescri 
    

    loggers::get_instance().log("uppertester_pki_codec::encode_ (else): processing type %s/%s", type.get_descriptor()->name, field_descriptor.name);

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

    /*if (

        (s.rfind(".shape") != string::npos) ||

        (s.rfind(".relevanceDistance") != string::npos) ||

        (s.rfind(".relevanceTrafficDirection") != string::npos)

        ) {

      encoding_buffer.put_c((unsigned char)static_cast<const Enum_Type&>(type).as_int());

    } else if (s.rfind(".payload") != string::npos) {

      const OCTETSTRING& os = static_cast<const OCTETSTRING&>(type);

      const unsigned char s[] = { (unsigned char)((os.lengthof() & 0x0000FF00) >> 8), (unsigned char)os.lengthof() };

      encoding_buffer.put_s(2, s);

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

        encoding_buffer.put_string(os);

      }

    } else if (s.rfind(".detectionTime") != string::npos) {

      unsigned long long llu = static_cast<const INTEGER&>(type).get_long_long_val();

      loggers::get_instance().log("uppertester_pki_codec::encode_ : detectionTime=%llu", llu);

      std::vector<unsigned char> v;

      for (int i = 0; i < 6; i++) {

        v.insert(v.begin(), static_cast<unsigned char>(llu));

        llu >>= 8;

      } // End of 'for' statement

      OCTETSTRING os(v.size(), v.data());

      loggers::get_instance().log_msg("uppertester_pki_codec::encode_: timeDetection=", os);

      encoding_buffer.put_string(os);

    } else if (

               (s.rfind(".validityDuration") != string::npos) ||

               (s.rfind(".repetitionDuration") != string::npos)

               ) {

      if (type.is_present()) {

        const OPTIONAL<INTEGER> &o = dynamic_cast<const OPTIONAL<INTEGER> &>(type);

        const INTEGER& i = static_cast<const INTEGER&>(*o.get_opt_value());

        loggers::get_instance().log_msg("uppertester_pki_codec::encode_: i=", i);

        encoding_buffer.put_string(int2oct(i, 3));

      }

    } else if (

               (s.rfind(".informationQuality") != string::npos) ||

               (s.rfind(".causeCode") != string::npos) ||

               (s.rfind(".subCauseCode") != string::npos)

               ) {

      const INTEGER& i = static_cast<const INTEGER&>(type);

      encoding_buffer.put_string(int2oct(i, 1));

    } else if (

               (s.rfind(".linkedCause") != string::npos) ||

               (s.rfind(".eventHistory") != string::npos)

               ) {

      // Skip them

    } else if (

               (s.rfind(".transmissionInterval") != string::npos) ||

               (s.rfind(".repetitionInterval") != string::npos)

               ) {

      if (type.is_present()) {

        const OPTIONAL<INTEGER> &o = dynamic_cast<const OPTIONAL<INTEGER> &>(type);

        const INTEGER& i = static_cast<const INTEGER&>(*o.get_opt_value());

        encoding_buffer.put_string(int2oct(i, 2));

      }

    } else if (s.rfind(".originatingStationID") != string::npos) {

      const INTEGER& i = static_cast<const INTEGER&>(type);

      encoding_buffer.put_string(int2oct(i, 4));

    } else if (s.rfind(".sequenceNumber") != string::npos) {

      const INTEGER& i = static_cast<const INTEGER&>(type);

      encoding_buffer.put_string(int2oct(i, 2));

    } else if (s.rfind(".AlacarteContainer") != string::npos) {

      const OPTIONAL<OCTETSTRING> &o = dynamic_cast<const OPTIONAL<OCTETSTRING> &>(type);

      const OCTETSTRING& os = static_cast<const OCTETSTRING&>(*o.get_opt_value());

      encoding_buffer.put_string(int2oct(os.lengthof(), 2));

      encoding_buffer.put_string(os);

    } else {

      loggers::get_instance().log("uppertester_pki_codec::encode_ (else): processing type %s/%s", type.get_descriptor()->name, field_descriptor.name);

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

      }*/

  }

  

  loggers::get_instance().log_to_hexa("<<<uppertester_pki_codec::encode_: encoding_buffer=", encoding_buffer);