Starting AtsSAEM imple (dba15e9b) · Commits · ITS - Intelligent Transport Systems / ITS Test Suite

ccsrc/EncDec/LibItsSaem_Encdec.cc

0 → 100644

+255 −0

Original line number	Original line	Diff line number	Diff line
			#include <memory>

			#include "LibItsSaem_EncdecDeclarations.hh"

			#include "saem_codec.hh"
			#include "loggers.hh"
			#include "uppertester_saem_codec.hh"

			namespace LibItsSaem__EncdecDeclarations {

			/****************************************************
			* @desc External function to encode a SaemReq type
			* @param value to encode
			* @return encoded value
			****************************************************/
			BITSTRING fx__enc__SaemReq(const LibItsSaem__TypesAndValues::SaemReq &p_saemReq) {
			loggers::get_instance().log_msg(">>> fx__enc__SaemReq: ", p_saemReq);

			saem_codec codec;
			OCTETSTRING os;
			if (codec.encode(p_saemReq.msgOut(), os) == -1) {
			loggers::get_instance().warning("fx__enc__SaemReq: -1 result code was returned");
			return int2bit(0, 1);
			}

			return oct2bit(os);
			}

			/****************************************************
			* @desc External function to decode a SaemReq type
			* @param value to encode
			* @return encoded value
			****************************************************/
			INTEGER fx__dec__SaemReq(BITSTRING &b, LibItsSaem__TypesAndValues::SaemReq &p) {
			loggers::get_instance().log(">>> fx__dec__SaemReq");

			// Sanity check
			if (b.lengthof() == 0) {
			return -1;
			}

			saem_codec codec;
			PIM__PDU__Descriptions::SAEM saem;
			OCTETSTRING is = bit2oct(b);

			if (codec.decode(is, saem) == -1) {
			loggers::get_instance().warning("fx__dec__MvmReq: -1 result code was returned");
			return -1;
			}
			p.msgOut() = saem;

			return 0;
			}

			INTEGER fx__dec__SaemInd(BITSTRING &b, LibItsSaem__TypesAndValues::SaemInd &p_saemInd) {
			loggers::get_instance().log(">>> fx__dec__SaemInd");

			// Sanity check
			if (b.lengthof() == 0) {
			return -1;
			}

			saem_codec codec;
			PIM__PDU__Descriptions::SAEM saem;
			OCTETSTRING is = bit2oct(b);

			// Calculate the size of the lower layers information
			int s = (LibItsSaem__TypesAndValues::SaemInd_gnNextHeader_raw_.fieldlength + LibItsSaem__TypesAndValues::SaemInd_gnHeaderType_raw_.fieldlength +
			LibItsSaem__TypesAndValues::SaemInd_gnHeaderSubtype_raw_.fieldlength + LibItsSaem__TypesAndValues::SaemInd_gnLifetime_raw_.fieldlength +
			LibItsSaem__TypesAndValues::SaemInd_gnTrafficClass_raw_.fieldlength + LibItsSaem__TypesAndValues::SaemInd_btpDestinationPort_raw_.fieldlength +
			LibItsSaem__TypesAndValues::SaemInd_btpInfo_raw_.fieldlength + LibItsSaem__TypesAndValues::SaemInd_ssp_raw_.fieldlength +
			LibItsSaem__TypesAndValues::SaemInd_its__aid_raw_.fieldlength) /
			8;
			// Decode MV message
			if (codec.decode(OCTETSTRING(is.lengthof() - s, static_cast<const uint8_t *>(is)), saem) == -1) {
			loggers::get_instance().warning("fx__dec__SaemInd: -1 result code was returned");
			return -1;
			}
			p_saemInd.msgIn() = saem;
			// Decode lower layer data
			TTCN_Buffer decoding_buffer(OCTETSTRING(s, static_cast<const uint8_t *>(is) + is.lengthof() - s));
			loggers::get_instance().log_to_hexa("fx__dec_PIM: ", decoding_buffer);
			// gnNextHeader
			if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSaem__TypesAndValues::SaemInd_gnNextHeader_raw_.fieldlength / 8)) {
			p_saemInd.gnNextHeader().set_to_omit();
			} else {
			OCTETSTRING os;
			os.decode(LibItsSaem__TypesAndValues::SaemInd_gnNextHeader_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
			p_saemInd.gnNextHeader() = oct2int(os);
			}
			loggers::get_instance().log_msg("fx__dec_PIM: gnNextHeader=", p_saemInd.gnNextHeader());
			loggers::get_instance().log_to_hexa("fx__dec_PIM: ", decoding_buffer);
			// gnHeaderType
			if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSaem__TypesAndValues::SaemInd_gnHeaderType_raw_.fieldlength / 8)) {
			p_saemInd.gnHeaderType().set_to_omit();
			} else {
			OCTETSTRING os;
			os.decode(LibItsSaem__TypesAndValues::SaemInd_gnHeaderType_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
			p_saemInd.gnHeaderType() = oct2int(os);
			}
			loggers::get_instance().log_msg("fx__dec_PIM: gnHeaderType=", p_saemInd.gnHeaderType());
			loggers::get_instance().log_to_hexa("fx__dec_PIM: ", decoding_buffer);
			// gnHeaderSubtype
			if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSaem__TypesAndValues::SaemInd_gnHeaderSubtype_raw_.fieldlength / 8)) {
			p_saemInd.gnHeaderSubtype().set_to_omit();
			} else {
			OCTETSTRING os;
			os.decode(LibItsSaem__TypesAndValues::SaemInd_gnHeaderSubtype_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
			p_saemInd.gnHeaderSubtype() = oct2int(os);
			}
			loggers::get_instance().log_msg("fx__dec_PIM: gnHeaderSubtype=", p_saemInd.gnHeaderSubtype());
			loggers::get_instance().log_to_hexa("fx__dec_PIM: ", decoding_buffer);
			// gnLifetime
			if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSaem__TypesAndValues::SaemInd_gnLifetime_raw_.fieldlength / 8)) {
			p_saemInd.gnLifetime().set_to_omit();
			} else {
			INTEGER i;
			i.decode(LibItsSaem__TypesAndValues::SaemInd_gnLifetime_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
			p_saemInd.gnLifetime() = i;
			}
			loggers::get_instance().log_msg("fx__dec_PIM: gnLifetime=", p_saemInd.gnLifetime());
			loggers::get_instance().log_to_hexa("fx__dec_PIM: ", decoding_buffer);
			// gnTrafficClass
			if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSaem__TypesAndValues::SaemInd_gnTrafficClass_raw_.fieldlength / 8)) {
			p_saemInd.gnTrafficClass().set_to_omit();
			} else {
			OCTETSTRING os;
			os.decode(LibItsSaem__TypesAndValues::SaemInd_gnTrafficClass_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
			p_saemInd.gnTrafficClass() = oct2int(os);
			}
			loggers::get_instance().log_msg("fx__dec_PIM: gnTrafficClass=", p_saemInd.gnTrafficClass());
			loggers::get_instance().log_to_hexa("fx__dec_PIM: ", decoding_buffer);
			// btpDestinationPort
			if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSaem__TypesAndValues::SaemInd_btpDestinationPort_raw_.fieldlength / 8)) {
			p_saemInd.btpDestinationPort().set_to_omit();
			} else {
			INTEGER i;
			i.decode(LibItsSaem__TypesAndValues::SaemInd_btpDestinationPort_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
			p_saemInd.btpDestinationPort() = i;
			}
			loggers::get_instance().log_msg("fx__dec_PIM: btpDestinationPort=", p_saemInd.btpDestinationPort());
			loggers::get_instance().log_to_hexa("fx__dec_PIM: ", decoding_buffer);
			// btpInfo
			if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSaem__TypesAndValues::SaemInd_btpInfo_raw_.fieldlength / 8)) {
			p_saemInd.btpInfo().set_to_omit();
			} else {
			INTEGER i;
			i.decode(LibItsSaem__TypesAndValues::SaemInd_btpInfo_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
			p_saemInd.btpInfo() = i;
			}
			loggers::get_instance().log_msg("fx__dec_PIM: btpInfo=", p_saemInd.btpInfo());
			loggers::get_instance().log_to_hexa("fx__dec_PIM: ", decoding_buffer);
			// ssp
			if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSaem__TypesAndValues::SaemInd_ssp_raw_.fieldlength / 8)) {
			p_saemInd.ssp().set_to_omit();
			} else {
			BITSTRING bs;
			bs.decode(LibItsSaem__TypesAndValues::SaemInd_ssp_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
			p_saemInd.ssp() = bs;
			}
			loggers::get_instance().log_msg("fx__dec_PIM: ssp=", p_saemInd.ssp());
			loggers::get_instance().log_to_hexa("fx__dec_PIM: ", decoding_buffer);
			// its__aid
			if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsSaem__TypesAndValues::SaemInd_its__aid_raw_.fieldlength / 8)) {
			p_saemInd.its__aid().set_to_omit();
			} else {
			INTEGER i;
			i.decode(LibItsSaem__TypesAndValues::SaemInd_its__aid_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
			p_saemInd.its__aid() = i;
			}
			loggers::get_instance().log_msg("fx__dec_PIM: its_aid=", p_saemInd.its__aid());
			loggers::get_instance().log_to_hexa("fx__dec_PIM: ", decoding_buffer);

			return 0;
			}

			BITSTRING fx__enc__PIM(const PIM__PDU__Descriptions::SAEM &p_cam) {
			loggers::get_instance().log_msg(">>> fx__enc__PIM: ", p_cam);

			saem_codec codec;
			OCTETSTRING os;
			codec.encode(p_cam, os);
			return oct2bit(os);
			}

			INTEGER fx__dec__PIM(BITSTRING &b, PIM__PDU__Descriptions::SAEM &p) {
			loggers::get_instance().log(">>> fx__dec__PIM");
			saem_codec codec;
			OCTETSTRING is = bit2oct(b);

			if (codec.decode(OCTETSTRING(is.lengthof(), static_cast<const uint8_t *>(is)), p) == -1) {
			loggers::get_instance().warning("fx__dec__PIM: -1 result code was returned");
			return -1;
			}

			return 0;
			}

			BITSTRING fx__enc__UtSaemInitialize(const LibItsSaem__TypesAndValues::UtSaemInitialize &p_utSaemInitialize) {
			loggers::get_instance().log_msg(">>> fx__enc__UtSaemInitialize: ", p_utSaemInitialize);

			uppertester_saem_codec codec;
			OCTETSTRING os;
			codec.encode(p_utSaemInitialize, os);
			return oct2bit(os);
			}

			BITSTRING fx__enc__UtSaemTrigger(const LibItsSaem__TypesAndValues::UtSaemTrigger &p_utSaemTrigger) {
			loggers::get_instance().log_msg(">>> fx__enc__UtSaemTrigger: ", p_utSaemTrigger);

			uppertester_saem_codec codec;
			OCTETSTRING os;
			codec.encode(p_utSaemTrigger, os);
			return oct2bit(os);
			}

			/****************************************************
			* @desc External function to decode a UtSaemResults type
			* @param value to encode
			* @return encoded value
			****************************************************/
			INTEGER fx__dec__UtSaemResults(BITSTRING &b, LibItsSaem__TypesAndValues::UtSaemResults &p) {
			loggers::get_instance().log(">>> fx__dec__UtSaemResults");

			uppertester_saem_codec codec;
			OCTETSTRING is = bit2oct(b);
			std::unique_ptr<Base_Type> ptr = codec.decode(is);
			if (ptr == nullptr) {
			loggers::get_instance().warning("fx__dec__UtSaemResults: -1 result code was returned");
			return -1;
			}
			p = static_cast<LibItsSaem__TypesAndValues::UtSaemResults &>(*ptr);
			return 0;
			}

			/****************************************************
			* @desc External function to decode a UtSaemEventInd type
			* @param value to encode
			* @return encoded value
			****************************************************/
			INTEGER fx__dec__UtSaemEventInd(BITSTRING &b, LibItsSaem__TypesAndValues::UtSaemEventInd &p) {
			loggers::get_instance().log(">>> fx__dec__UtSaemEventInd");

			uppertester_saem_codec codec;
			OCTETSTRING is = bit2oct(b);
			std::unique_ptr<Base_Type> ptr = codec.decode(is);
			if (ptr == nullptr) {
			loggers::get_instance().warning("fx__dec__UtSaemEventInd: -1 result code was returned");
			return -1;
			}
			p = static_cast<LibItsSaem__TypesAndValues::UtSaemEventInd &>(*ptr);
			return 0;
			}

			} // namespace LibItsSaem__EncdecDeclarations

ccsrc/EncDec/module.mk

+5 −0

Original line number	Original line	Diff line number	Diff line
	@@ -87,3 +87,8 @@ sources += LibItsPim_Encdec.cc \
	LibItsBtp_Encdec.cc		LibItsBtp_Encdec.cc
	endif		endif

			ifeq (AtsSAEM, $(ATS))
			sources += LibItsSaem_Encdec.cc \
			LibItsBtp_Encdec.cc
			endif

ccsrc/Externals/module.mk

+4 −0

Original line number	Original line	Diff line number	Diff line
	@@ -56,6 +56,10 @@ ifeq (AtsPIM, $(ATS))
	sources += LibItsSecurity_externals.cc		sources += LibItsSecurity_externals.cc
	endif		endif

			ifeq (AtsSAEM, $(ATS))
			sources += LibItsSecurity_externals.cc
			endif

	ifeq (AtsRSUsSimulator, $(ATS))		ifeq (AtsRSUsSimulator, $(ATS))
	sources += LibItsPki_externals.cc LibItsSecurity_externals.cc AtsRSUsSimulator_externals.cc		sources += LibItsPki_externals.cc LibItsSecurity_externals.cc AtsRSUsSimulator_externals.cc
	endif		endif

ccsrc/Ports/LibIts_ports/AdapterControlPort.hh

+6 −0

Original line number	Original line	Diff line number	Diff line
	@@ -40,6 +40,9 @@
	#ifdef LibItsPim__TestSystem_HH		#ifdef LibItsPim__TestSystem_HH
	#include "PIM_ports/AdapterControlPort_PIM.hh"		#include "PIM_ports/AdapterControlPort_PIM.hh"
	#endif		#endif
			#ifdef LibItsSaem__TestSystem_HH
			#include "SAEM_ports/AdapterControlPort_SAEM.hh"
			#endif
	//#ifdef LibItsPki__TestSystem_HH		//#ifdef LibItsPki__TestSystem_HH
	//#include "Pki_ports/AdapterControlPort_Pki.hh"		//#include "Pki_ports/AdapterControlPort_Pki.hh"
	//#endif		//#endif
	@@ -79,6 +82,9 @@
	#ifdef LibItsPim__TestSystem_HH		#ifdef LibItsPim__TestSystem_HH
	#include "AdapterControlPort_PIM.hh"		#include "AdapterControlPort_PIM.hh"
	#endif		#endif
			#ifdef LibItsSaem__TestSystem_HH
			#include "AdapterControlPort_SAEM.hh"
			#endif
	/*		/*
	#include "AdapterControlPort_Evcsn.partH"		#include "AdapterControlPort_Evcsn.partH"
	#include "AdapterControlPort_IVIM.partH"		#include "AdapterControlPort_IVIM.partH"

ccsrc/Ports/LibIts_ports/SAEM_ports/AdapterControlPort_SAEM.cc

0 → 100644

+70 −0

Original line number	Original line	Diff line number	Diff line
			#include <TTCN3.hh>

			#include "loggers.hh"
			#include "registration.hh"

			#include "AdapterControlPort_SAEM.hh"
			#include "saem_layer.hh"

			//=============================================================================
			namespace LibItsSaem__TestSystem {

			AdapterControlPort::AdapterControlPort(const char *par_port_name) : AdapterControlPort_BASE(par_port_name) {}

			AdapterControlPort::~AdapterControlPort() {}

			void AdapterControlPort::set_parameter(const char * /parameter_name/, const char * /parameter_value/) {}

			/*void AdapterControlPort::Handle_Fd_Event(int fd, boolean is_readable,
			boolean is_writable, boolean is_error) {}*/

			void AdapterControlPort::Handle_Fd_Event_Error(int /fd/) {}

			void AdapterControlPort::Handle_Fd_Event_Writable(int /fd/) {}

			void AdapterControlPort::Handle_Fd_Event_Readable(int /fd/) {}

			/void AdapterControlPort::Handle_Timeout(double time_since_last_call) {}/

			void AdapterControlPort::user_map(const char * /system_port/) {}

			void AdapterControlPort::user_unmap(const char * /system_port/) {}

			void AdapterControlPort::user_start() {}

			void AdapterControlPort::user_stop() {}

			void AdapterControlPort::outgoing_send(const LibItsCommon__TypesAndValues::AcGnssPrimitive & /send_par/) {}

			void AdapterControlPort::outgoing_send(const LibItsCommon__TypesAndValues::AcSecPrimitive &send_par) {
			loggers::get_instance().log_msg(">>> AdapterControlPort::outgoing_send: ", send_par);

			// Register this object for AdapterControlPort
			saem_layer *p = registration<saem_layer>::get_instance().get_item(std::string("SAEM"));
			if (p != NULL) {
			loggers::get_instance().log("AdapterControlPort::outgoing_send: Got SAEM layer %p", p);
			LibItsCommon__TypesAndValues::AdapterControlResults response;
			response.acSecResponse() = BOOLEAN(true);
			if (send_par.ischosen(LibItsCommon__TypesAndValues::AcSecPrimitive::ALT_acEnableSecurity)) {
			loggers::get_instance().log("AdapterControlPort::outgoing_send: Enable secured mode");
			std::string str(static_cast<const char *>(send_par.acEnableSecurity().certificateId()));
			if (p->enable_secured_mode(str, send_par.acEnableSecurity().enforceSecurity()) == -1) {
			response.acSecResponse() = BOOLEAN(false);
			}
			} else if (send_par.ischosen(LibItsCommon__TypesAndValues::AcSecPrimitive::ALT_acDisableSecurity)) {
			loggers::get_instance().log("AdapterControlPort::outgoing_send: Disable secured mode");
			if (p->disable_secured_mode() == -1) {
			response.acSecResponse() = BOOLEAN(false);
			}
			} else {
			response.acSecResponse() = BOOLEAN(false);
			}
			// Send response
			loggers::get_instance().log_msg("AdapterControlPort::outgoing_send: Send response: ", response);
			incoming_message(response);
			} else {
			loggers::get_instance().error("AdapterControlPort::outgoing_send: SAEM not registered");
			}
			}

			} // namespace LibItsSaem__TestSystem