Staring AtsPIM implementation; Editorial changes in AtsAVM; Rename AtsPI and AtsSA (c4428ffa) · Commits · ITS - Intelligent Transport Systems / ITS Test Suite

ccsrc/EncDec/LibItsPim_Encdec.cc

0 → 100644

+255 −0

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

			#include "LibItsPim_EncdecDeclarations.hh"

			#include "pim_codec.hh"
			#include "loggers.hh"
			#include "uppertester_pim_codec.hh"

			namespace LibItsPim__EncdecDeclarations {

			/****************************************************
			* @desc External function to encode a PimReq type
			* @param value to encode
			* @return encoded value
			****************************************************/
			BITSTRING fx__enc__PimReq(const LibItsPim__TypesAndValues::PimReq &p_pimReq) {
			loggers::get_instance().log_msg(">>> fx__enc__PimReq: ", p_pimReq);

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

			return oct2bit(os);
			}

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

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

			pim_codec codec;
			MIM__PDU__Descriptions::MIM pim;
			OCTETSTRING is = bit2oct(b);

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

			return 0;
			}

			INTEGER fx__dec__PimInd(BITSTRING &b, LibItsPim__TypesAndValues::PimInd &p_pimInd) {
			loggers::get_instance().log(">>> fx__dec__PimInd");

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

			codec codec;
			PIM__PDU__Descriptions::PIM pim;
			OCTETSTRING is = bit2oct(b);

			// Calculate the size of the lower layers information
			int s = (LibItsPim__TypesAndValues::PimInd_gnNextHeader_raw_.fieldlength + LibItsPim__TypesAndValues::PimInd_gnHeaderType_raw_.fieldlength +
			LibItsPim__TypesAndValues::PimInd_gnHeaderSubtype_raw_.fieldlength + LibItsPim__TypesAndValues::PimInd_gnLifetime_raw_.fieldlength +
			LibItsPim__TypesAndValues::PimInd_gnTrafficClass_raw_.fieldlength + LibItsPim__TypesAndValues::PimInd_btpDestinationPort_raw_.fieldlength +
			LibItsPim__TypesAndValues::PimInd_btpInfo_raw_.fieldlength + LibItsPim__TypesAndValues::PimInd_ssp_raw_.fieldlength +
			LibItsPim__TypesAndValues::PimInd_its__aid_raw_.fieldlength) /
			8;
			// Decode MV message
			if (codec.decode(OCTETSTRING(is.lengthof() - s, static_cast<const uint8_t *>(is)), pim) == -1) {
			loggers::get_instance().warning("fx__dec__PimInd: -1 result code was returned");
			return -1;
			}
			p_pimInd.msgIn() = pim;
			// 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_MIM: ", decoding_buffer);
			// gnNextHeader
			if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsPim__TypesAndValues::PimInd_gnNextHeader_raw_.fieldlength / 8)) {
			p_pimInd.gnNextHeader().set_to_omit();
			} else {
			OCTETSTRING os;
			os.decode(LibItsPim__TypesAndValues::PimInd_gnNextHeader_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
			p_pimInd.gnNextHeader() = oct2int(os);
			}
			loggers::get_instance().log_msg("fx__dec_MIM: gnNextHeader=", p_pimInd.gnNextHeader());
			loggers::get_instance().log_to_hexa("fx__dec_MIM: ", decoding_buffer);
			// gnHeaderType
			if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsPim__TypesAndValues::PimInd_gnHeaderType_raw_.fieldlength / 8)) {
			p_pimInd.gnHeaderType().set_to_omit();
			} else {
			OCTETSTRING os;
			os.decode(LibItsPim__TypesAndValues::PimInd_gnHeaderType_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
			p_pimInd.gnHeaderType() = oct2int(os);
			}
			loggers::get_instance().log_msg("fx__dec_MIM: gnHeaderType=", p_pimInd.gnHeaderType());
			loggers::get_instance().log_to_hexa("fx__dec_MIM: ", decoding_buffer);
			// gnHeaderSubtype
			if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsPim__TypesAndValues::PimInd_gnHeaderSubtype_raw_.fieldlength / 8)) {
			p_pimInd.gnHeaderSubtype().set_to_omit();
			} else {
			OCTETSTRING os;
			os.decode(LibItsPim__TypesAndValues::PimInd_gnHeaderSubtype_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
			p_pimInd.gnHeaderSubtype() = oct2int(os);
			}
			loggers::get_instance().log_msg("fx__dec_MIM: gnHeaderSubtype=", p_pimInd.gnHeaderSubtype());
			loggers::get_instance().log_to_hexa("fx__dec_MIM: ", decoding_buffer);
			// gnLifetime
			if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsPim__TypesAndValues::PimInd_gnLifetime_raw_.fieldlength / 8)) {
			p_pimInd.gnLifetime().set_to_omit();
			} else {
			INTEGER i;
			i.decode(LibItsPim__TypesAndValues::PimInd_gnLifetime_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
			p_pimInd.gnLifetime() = i;
			}
			loggers::get_instance().log_msg("fx__dec_MIM: gnLifetime=", p_pimInd.gnLifetime());
			loggers::get_instance().log_to_hexa("fx__dec_MIM: ", decoding_buffer);
			// gnTrafficClass
			if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsPim__TypesAndValues::PimInd_gnTrafficClass_raw_.fieldlength / 8)) {
			p_pimInd.gnTrafficClass().set_to_omit();
			} else {
			OCTETSTRING os;
			os.decode(LibItsPim__TypesAndValues::PimInd_gnTrafficClass_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
			p_pimInd.gnTrafficClass() = oct2int(os);
			}
			loggers::get_instance().log_msg("fx__dec_MIM: gnTrafficClass=", p_pimInd.gnTrafficClass());
			loggers::get_instance().log_to_hexa("fx__dec_MIM: ", decoding_buffer);
			// btpDestinationPort
			if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsPim__TypesAndValues::PimInd_btpDestinationPort_raw_.fieldlength / 8)) {
			p_pimInd.btpDestinationPort().set_to_omit();
			} else {
			INTEGER i;
			i.decode(LibItsPim__TypesAndValues::PimInd_btpDestinationPort_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
			p_pimInd.btpDestinationPort() = i;
			}
			loggers::get_instance().log_msg("fx__dec_MIM: btpDestinationPort=", p_pimInd.btpDestinationPort());
			loggers::get_instance().log_to_hexa("fx__dec_MIM: ", decoding_buffer);
			// btpInfo
			if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsPim__TypesAndValues::PimInd_btpInfo_raw_.fieldlength / 8)) {
			p_pimInd.btpInfo().set_to_omit();
			} else {
			INTEGER i;
			i.decode(LibItsPim__TypesAndValues::PimInd_btpInfo_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
			p_pimInd.btpInfo() = i;
			}
			loggers::get_instance().log_msg("fx__dec_MIM: btpInfo=", p_pimInd.btpInfo());
			loggers::get_instance().log_to_hexa("fx__dec_MIM: ", decoding_buffer);
			// ssp
			if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsPim__TypesAndValues::PimInd_ssp_raw_.fieldlength / 8)) {
			p_pimInd.ssp().set_to_omit();
			} else {
			BITSTRING bs;
			bs.decode(LibItsPim__TypesAndValues::PimInd_ssp_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
			p_pimInd.ssp() = bs;
			}
			loggers::get_instance().log_msg("fx__dec_MIM: ssp=", p_pimInd.ssp());
			loggers::get_instance().log_to_hexa("fx__dec_MIM: ", decoding_buffer);
			// its__aid
			if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsPim__TypesAndValues::PimInd_its__aid_raw_.fieldlength / 8)) {
			p_pimInd.its__aid().set_to_omit();
			} else {
			INTEGER i;
			i.decode(LibItsPim__TypesAndValues::PimInd_its__aid_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
			p_pimInd.its__aid() = i;
			}
			loggers::get_instance().log_msg("fx__dec_MIM: its_aid=", p_pimInd.its__aid());
			loggers::get_instance().log_to_hexa("fx__dec_MIM: ", decoding_buffer);

			return 0;
			}

			BITSTRING fx__enc__MIM(const MIM__PDU__Descriptions::MIM &p_cam) {
			loggers::get_instance().log_msg(">>> fx__enc__MIM: ", p_cam);

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

			INTEGER fx__dec__MIM(BITSTRING &b, MIM__PDU__Descriptions::MIM &p) {
			loggers::get_instance().log(">>> fx__dec__MIM");
			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__MIM: -1 result code was returned");
			return -1;
			}

			return 0;
			}

			BITSTRING fx__enc__UtPimInitialize(const LibItsPim__TypesAndValues::UtPimInitialize &p_utPimInitialize) {
			loggers::get_instance().log_msg(">>> fx__enc__UtPimInitialize: ", p_utPimInitialize);

			uppertester_pim_codec codec;
			OCTETSTRING os;
			codec.encode(p_utPimInitialize, os);
			return oct2bit(os);
			}

			BITSTRING fx__enc__UtPimTrigger(const LibItsPim__TypesAndValues::UtPimTrigger &p_utPimTrigger) {
			loggers::get_instance().log_msg(">>> fx__enc__UtPimTrigger: ", p_utPimTrigger);

			uppertester_pim_codec codec;
			OCTETSTRING os;
			codec.encode(p_utPimTrigger, os);
			return oct2bit(os);
			}

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

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

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

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

			} // namespace LibItsPim__EncdecDeclarations

ccsrc/EncDec/module.mk

+5 −0

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

			ifeq (AtsPIM, $(ATS))
			sources += LibItsPim_Encdec.cc \
			LibItsBtp_Encdec.cc
			endif

ccsrc/Externals/module.mk

+3 −0

Original line number	Original line	Diff line number	Diff line
	@@ -52,6 +52,9 @@ ifeq (AtsAVM, $(ATS))
	sources += LibItsSecurity_externals.cc		sources += LibItsSecurity_externals.cc
	endif		endif

			ifeq (AtsPIM, $(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

ccsrc/Ports/LibIts_ports/PIM_ports/AdapterControlPort_PIM.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_PIM.hh"
			#include "pim_layer.hh"

			//=============================================================================
			namespace LibItsPim__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
			pim_layer *p = registration<pim_layer>::get_instance().get_item(std::string("PIM"));
			if (p != NULL) {
			loggers::get_instance().log("AdapterControlPort::outgoing_send: Got PIM 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: PIM not registered");
			}
			}

			} // namespace LibItsPim__TestSystem

ccsrc/Ports/LibIts_ports/PIM_ports/AdapterControlPort_PIM.hh

0 → 100644

+36 −0

Original line number	Original line	Diff line number	Diff line
			#ifndef AdapterControlPort_PIM_HH
			#define AdapterControlPort_PIM_HH
			//=============================================================================
			#include "LibItsPim_TestSystem.hh"

			namespace LibItsPim__TestSystem {

			class AdapterControlPort : public AdapterControlPort_BASE {
			public:
			AdapterControlPort(const char *par_port_name = NULL);
			~AdapterControlPort();

			void set_parameter(const char parameter_name, const char parameter_value);

			private:
			/* void Handle_Fd_Event(int fd, boolean is_readable,
			boolean is_writable, boolean is_error); */
			void Handle_Fd_Event_Error(int fd);
			void Handle_Fd_Event_Writable(int fd);
			void Handle_Fd_Event_Readable(int fd);
			/* void Handle_Timeout(double time_since_last_call); */
			protected:
			void user_map(const char *system_port);
			void user_unmap(const char *system_port);

			void user_start();
			void user_stop();

			void outgoing_send(const LibItsCommon__TypesAndValues::AcGnssPrimitive &send_par);

			void outgoing_send(const LibItsCommon__TypesAndValues::AcSecPrimitive &send_par);
			};

			} // namespace LibItsPim__TestSystem

			#endif