Merge branch 'STF525' of https://forge.etsi.org/gitlab/ITS/ITS into STF525 (ff86b254) · Commits · ITS - Intelligent Transport Systems / ITS

ccsrc/Protocols/Commsignia/commsignia_layer.cc

+12 −1

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,6 +41,10 @@ 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();
		}

		@@ -48,6 +52,13 @@ 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);
		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);

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

+15 −8

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
		@@ -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

+3 −3

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;

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);

Admin message