Finalyze AtsAVM (5a59d345) · Commits · ITS - Intelligent Transport Systems / ITS Test Suite

ccsrc/EncDec/LibItsAvm_Encdec.cc

0 → 100644

+443 −0

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

		#include "LibItsAvm_EncdecDeclarations.hh"

		#include "mvm_codec.hh"
		#include "mim_codec.hh"
		#include "loggers.hh"
		#include "uppertester_avm_codec.hh"

		namespace LibItsAvm__EncdecDeclarations {
		/****************************************************
		* @desc External function to encode a MvmReq type
		* @param value to encode
		* @return encoded value
		****************************************************/
		BITSTRING fx__enc__MvmReq(const LibItsAvm__TypesAndValues::MvmReq &p_mvmReq) {
		loggers::get_instance().log_msg(">>> fx__enc__MvmReq: ", p_mvmReq);

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

		return oct2bit(os);
		}

		/****************************************************
		* @desc External function to encode a MimReq type
		* @param value to encode
		* @return encoded value
		****************************************************/
		BITSTRING fx__enc__MimReq(const LibItsAvm__TypesAndValues::MimReq &p_mimReq) {
		loggers::get_instance().log_msg(">>> fx__enc__MimReq: ", p_mimReq);

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

		return oct2bit(os);
		}

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

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

		mvm_codec codec;
		MVM__PDU__Descriptions::MVM mvm;
		OCTETSTRING is = bit2oct(b);

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

		return 0;
		}

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

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

		mim_codec codec;
		MIM__PDU__Descriptions::MIM mim;
		OCTETSTRING is = bit2oct(b);

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

		return 0;
		}

		INTEGER fx__dec__MvmInd(BITSTRING &b, LibItsAvm__TypesAndValues::MvmInd &p_mvmInd) {
		loggers::get_instance().log(">>> fx__dec__MvmInd");

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

		mvm_codec codec;
		MVM__PDU__Descriptions::MVM mvm;
		OCTETSTRING is = bit2oct(b);

		// Calculate the size of the lower layers information
		int s = (LibItsAvm__TypesAndValues::MvmInd_gnNextHeader_raw_.fieldlength + LibItsAvm__TypesAndValues::MvmInd_gnHeaderType_raw_.fieldlength +
		LibItsAvm__TypesAndValues::MvmInd_gnHeaderSubtype_raw_.fieldlength + LibItsAvm__TypesAndValues::MvmInd_gnLifetime_raw_.fieldlength +
		LibItsAvm__TypesAndValues::MvmInd_gnTrafficClass_raw_.fieldlength + LibItsAvm__TypesAndValues::MvmInd_btpDestinationPort_raw_.fieldlength +
		LibItsAvm__TypesAndValues::MvmInd_btpInfo_raw_.fieldlength + LibItsAvm__TypesAndValues::MvmInd_ssp_raw_.fieldlength +
		LibItsAvm__TypesAndValues::MvmInd_its__aid_raw_.fieldlength) /
		8;
		// Decode MV message
		if (codec.decode(OCTETSTRING(is.lengthof() - s, static_cast<const uint8_t *>(is)), mvm) == -1) {
		loggers::get_instance().warning("fx__dec__MvmInd: -1 result code was returned");
		return -1;
		}
		p_mvmInd.msgIn() = mvm;
		// 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_MVM: ", decoding_buffer);
		// gnNextHeader
		if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsAvm__TypesAndValues::MvmInd_gnNextHeader_raw_.fieldlength / 8)) {
		p_mvmInd.gnNextHeader().set_to_omit();
		} else {
		OCTETSTRING os;
		os.decode(LibItsAvm__TypesAndValues::MvmInd_gnNextHeader_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
		p_mvmInd.gnNextHeader() = oct2int(os);
		}
		loggers::get_instance().log_msg("fx__dec_MVM: gnNextHeader=", p_mvmInd.gnNextHeader());
		loggers::get_instance().log_to_hexa("fx__dec_MVM: ", decoding_buffer);
		// gnHeaderType
		if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsAvm__TypesAndValues::MvmInd_gnHeaderType_raw_.fieldlength / 8)) {
		p_mvmInd.gnHeaderType().set_to_omit();
		} else {
		OCTETSTRING os;
		os.decode(LibItsAvm__TypesAndValues::MvmInd_gnHeaderType_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
		p_mvmInd.gnHeaderType() = oct2int(os);
		}
		loggers::get_instance().log_msg("fx__dec_MVM: gnHeaderType=", p_mvmInd.gnHeaderType());
		loggers::get_instance().log_to_hexa("fx__dec_MVM: ", decoding_buffer);
		// gnHeaderSubtype
		if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsAvm__TypesAndValues::MvmInd_gnHeaderSubtype_raw_.fieldlength / 8)) {
		p_mvmInd.gnHeaderSubtype().set_to_omit();
		} else {
		OCTETSTRING os;
		os.decode(LibItsAvm__TypesAndValues::MvmInd_gnHeaderSubtype_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
		p_mvmInd.gnHeaderSubtype() = oct2int(os);
		}
		loggers::get_instance().log_msg("fx__dec_MVM: gnHeaderSubtype=", p_mvmInd.gnHeaderSubtype());
		loggers::get_instance().log_to_hexa("fx__dec_MVM: ", decoding_buffer);
		// gnLifetime
		if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsAvm__TypesAndValues::MvmInd_gnLifetime_raw_.fieldlength / 8)) {
		p_mvmInd.gnLifetime().set_to_omit();
		} else {
		INTEGER i;
		i.decode(LibItsAvm__TypesAndValues::MvmInd_gnLifetime_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
		p_mvmInd.gnLifetime() = i;
		}
		loggers::get_instance().log_msg("fx__dec_MVM: gnLifetime=", p_mvmInd.gnLifetime());
		loggers::get_instance().log_to_hexa("fx__dec_MVM: ", decoding_buffer);
		// gnTrafficClass
		if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsAvm__TypesAndValues::MvmInd_gnTrafficClass_raw_.fieldlength / 8)) {
		p_mvmInd.gnTrafficClass().set_to_omit();
		} else {
		OCTETSTRING os;
		os.decode(LibItsAvm__TypesAndValues::MvmInd_gnTrafficClass_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
		p_mvmInd.gnTrafficClass() = oct2int(os);
		}
		loggers::get_instance().log_msg("fx__dec_MVM: gnTrafficClass=", p_mvmInd.gnTrafficClass());
		loggers::get_instance().log_to_hexa("fx__dec_MVM: ", decoding_buffer);
		// btpDestinationPort
		if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsAvm__TypesAndValues::MvmInd_btpDestinationPort_raw_.fieldlength / 8)) {
		p_mvmInd.btpDestinationPort().set_to_omit();
		} else {
		INTEGER i;
		i.decode(LibItsAvm__TypesAndValues::MvmInd_btpDestinationPort_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
		p_mvmInd.btpDestinationPort() = i;
		}
		loggers::get_instance().log_msg("fx__dec_MVM: btpDestinationPort=", p_mvmInd.btpDestinationPort());
		loggers::get_instance().log_to_hexa("fx__dec_MVM: ", decoding_buffer);
		// btpInfo
		if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsAvm__TypesAndValues::MvmInd_btpInfo_raw_.fieldlength / 8)) {
		p_mvmInd.btpInfo().set_to_omit();
		} else {
		INTEGER i;
		i.decode(LibItsAvm__TypesAndValues::MvmInd_btpInfo_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
		p_mvmInd.btpInfo() = i;
		}
		loggers::get_instance().log_msg("fx__dec_MVM: btpInfo=", p_mvmInd.btpInfo());
		loggers::get_instance().log_to_hexa("fx__dec_MVM: ", decoding_buffer);
		// ssp
		if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsAvm__TypesAndValues::MvmInd_ssp_raw_.fieldlength / 8)) {
		p_mvmInd.ssp().set_to_omit();
		} else {
		BITSTRING bs;
		bs.decode(LibItsAvm__TypesAndValues::MvmInd_ssp_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
		p_mvmInd.ssp() = bs;
		}
		loggers::get_instance().log_msg("fx__dec_MVM: ssp=", p_mvmInd.ssp());
		loggers::get_instance().log_to_hexa("fx__dec_MVM: ", decoding_buffer);
		// its__aid
		if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsAvm__TypesAndValues::MvmInd_its__aid_raw_.fieldlength / 8)) {
		p_mvmInd.its__aid().set_to_omit();
		} else {
		INTEGER i;
		i.decode(LibItsAvm__TypesAndValues::MvmInd_its__aid_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
		p_mvmInd.its__aid() = i;
		}
		loggers::get_instance().log_msg("fx__dec_MVM: its_aid=", p_mvmInd.its__aid());
		loggers::get_instance().log_to_hexa("fx__dec_MVM: ", decoding_buffer);

		return 0;
		}

		INTEGER fx__dec__MimInd(BITSTRING &b, LibItsAvm__TypesAndValues::MimInd &p_mimInd) {
		loggers::get_instance().log(">>> fx__dec__MimInd");

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

		mim_codec codec;
		MIM__PDU__Descriptions::MIM mim;
		OCTETSTRING is = bit2oct(b);

		// Calculate the size of the lower layers information
		int s = (LibItsAvm__TypesAndValues::MimInd_gnNextHeader_raw_.fieldlength + LibItsAvm__TypesAndValues::MimInd_gnHeaderType_raw_.fieldlength +
		LibItsAvm__TypesAndValues::MimInd_gnHeaderSubtype_raw_.fieldlength + LibItsAvm__TypesAndValues::MimInd_gnLifetime_raw_.fieldlength +
		LibItsAvm__TypesAndValues::MimInd_gnTrafficClass_raw_.fieldlength + LibItsAvm__TypesAndValues::MimInd_btpDestinationPort_raw_.fieldlength +
		LibItsAvm__TypesAndValues::MimInd_btpInfo_raw_.fieldlength + LibItsAvm__TypesAndValues::MimInd_ssp_raw_.fieldlength +
		LibItsAvm__TypesAndValues::MimInd_its__aid_raw_.fieldlength) /
		8;
		// Decode MV message
		if (codec.decode(OCTETSTRING(is.lengthof() - s, static_cast<const uint8_t *>(is)), mim) == -1) {
		loggers::get_instance().warning("fx__dec__MimInd: -1 result code was returned");
		return -1;
		}
		p_mimInd.msgIn() = mim;
		// 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>(LibItsAvm__TypesAndValues::MimInd_gnNextHeader_raw_.fieldlength / 8)) {
		p_mimInd.gnNextHeader().set_to_omit();
		} else {
		OCTETSTRING os;
		os.decode(LibItsAvm__TypesAndValues::MimInd_gnNextHeader_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
		p_mimInd.gnNextHeader() = oct2int(os);
		}
		loggers::get_instance().log_msg("fx__dec_MIM: gnNextHeader=", p_mimInd.gnNextHeader());
		loggers::get_instance().log_to_hexa("fx__dec_MIM: ", decoding_buffer);
		// gnHeaderType
		if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsAvm__TypesAndValues::MimInd_gnHeaderType_raw_.fieldlength / 8)) {
		p_mimInd.gnHeaderType().set_to_omit();
		} else {
		OCTETSTRING os;
		os.decode(LibItsAvm__TypesAndValues::MimInd_gnHeaderType_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
		p_mimInd.gnHeaderType() = oct2int(os);
		}
		loggers::get_instance().log_msg("fx__dec_MIM: gnHeaderType=", p_mimInd.gnHeaderType());
		loggers::get_instance().log_to_hexa("fx__dec_MIM: ", decoding_buffer);
		// gnHeaderSubtype
		if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsAvm__TypesAndValues::MimInd_gnHeaderSubtype_raw_.fieldlength / 8)) {
		p_mimInd.gnHeaderSubtype().set_to_omit();
		} else {
		OCTETSTRING os;
		os.decode(LibItsAvm__TypesAndValues::MimInd_gnHeaderSubtype_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
		p_mimInd.gnHeaderSubtype() = oct2int(os);
		}
		loggers::get_instance().log_msg("fx__dec_MIM: gnHeaderSubtype=", p_mimInd.gnHeaderSubtype());
		loggers::get_instance().log_to_hexa("fx__dec_MIM: ", decoding_buffer);
		// gnLifetime
		if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsAvm__TypesAndValues::MimInd_gnLifetime_raw_.fieldlength / 8)) {
		p_mimInd.gnLifetime().set_to_omit();
		} else {
		INTEGER i;
		i.decode(LibItsAvm__TypesAndValues::MimInd_gnLifetime_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
		p_mimInd.gnLifetime() = i;
		}
		loggers::get_instance().log_msg("fx__dec_MIM: gnLifetime=", p_mimInd.gnLifetime());
		loggers::get_instance().log_to_hexa("fx__dec_MIM: ", decoding_buffer);
		// gnTrafficClass
		if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsAvm__TypesAndValues::MimInd_gnTrafficClass_raw_.fieldlength / 8)) {
		p_mimInd.gnTrafficClass().set_to_omit();
		} else {
		OCTETSTRING os;
		os.decode(LibItsAvm__TypesAndValues::MimInd_gnTrafficClass_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
		p_mimInd.gnTrafficClass() = oct2int(os);
		}
		loggers::get_instance().log_msg("fx__dec_MIM: gnTrafficClass=", p_mimInd.gnTrafficClass());
		loggers::get_instance().log_to_hexa("fx__dec_MIM: ", decoding_buffer);
		// btpDestinationPort
		if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsAvm__TypesAndValues::MimInd_btpDestinationPort_raw_.fieldlength / 8)) {
		p_mimInd.btpDestinationPort().set_to_omit();
		} else {
		INTEGER i;
		i.decode(LibItsAvm__TypesAndValues::MimInd_btpDestinationPort_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
		p_mimInd.btpDestinationPort() = i;
		}
		loggers::get_instance().log_msg("fx__dec_MIM: btpDestinationPort=", p_mimInd.btpDestinationPort());
		loggers::get_instance().log_to_hexa("fx__dec_MIM: ", decoding_buffer);
		// btpInfo
		if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsAvm__TypesAndValues::MimInd_btpInfo_raw_.fieldlength / 8)) {
		p_mimInd.btpInfo().set_to_omit();
		} else {
		INTEGER i;
		i.decode(LibItsAvm__TypesAndValues::MimInd_btpInfo_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
		p_mimInd.btpInfo() = i;
		}
		loggers::get_instance().log_msg("fx__dec_MIM: btpInfo=", p_mimInd.btpInfo());
		loggers::get_instance().log_to_hexa("fx__dec_MIM: ", decoding_buffer);
		// ssp
		if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsAvm__TypesAndValues::MimInd_ssp_raw_.fieldlength / 8)) {
		p_mimInd.ssp().set_to_omit();
		} else {
		BITSTRING bs;
		bs.decode(LibItsAvm__TypesAndValues::MimInd_ssp_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
		p_mimInd.ssp() = bs;
		}
		loggers::get_instance().log_msg("fx__dec_MIM: ssp=", p_mimInd.ssp());
		loggers::get_instance().log_to_hexa("fx__dec_MIM: ", decoding_buffer);
		// its__aid
		if (decoding_buffer.get_read_len() < static_cast<size_t>(LibItsAvm__TypesAndValues::MimInd_its__aid_raw_.fieldlength / 8)) {
		p_mimInd.its__aid().set_to_omit();
		} else {
		INTEGER i;
		i.decode(LibItsAvm__TypesAndValues::MimInd_its__aid_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
		p_mimInd.its__aid() = i;
		}
		loggers::get_instance().log_msg("fx__dec_MIM: its_aid=", p_mimInd.its__aid());
		loggers::get_instance().log_to_hexa("fx__dec_MIM: ", decoding_buffer);

		return 0;
		}

		BITSTRING fx__enc__MVM(const MVM__PDU__Descriptions::MVM &p_cam) {
		loggers::get_instance().log_msg(">>> fx__enc__MVM: ", p_cam);

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

		INTEGER fx__dec__MVM(BITSTRING &b, MVM__PDU__Descriptions::MVM &p) {
		loggers::get_instance().log(">>> fx__dec__MVM");
		mvm_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__MVM: -1 result code was returned");
		return -1;
		}

		return 0;
		}

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

		mim_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");
		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__UtAvmInitialize(const LibItsAvm__TypesAndValues::UtAvmInitialize &p_utAvmInitialize) {
		loggers::get_instance().log_msg(">>> fx__enc__UtAvmInitialize: ", p_utAvmInitialize);

		uppertester_avm_codec codec;
		OCTETSTRING os;
		codec.encode(p_utAvmInitialize, os);
		return oct2bit(os);
		}

		BITSTRING fx__enc__UtAvmTrigger(const LibItsAvm__TypesAndValues::UtAvmTrigger &p_utAvmTrigger) {
		loggers::get_instance().log_msg(">>> fx__enc__UtAvmTrigger: ", p_utAvmTrigger);

		uppertester_avm_codec codec;
		OCTETSTRING os;
		codec.encode(p_utAvmTrigger, os);
		return oct2bit(os);
		}

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

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

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

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

		} // namespace LibItsAvm__EncdecDeclarations

ccsrc/EncDec/module.mk

+6 −0

Original line number	Diff line number	Diff line
		@@ -29,6 +29,7 @@ sources += \
		LibItsSremSsem_Encdec.cc \
		LibItsRtcmem_Encdec.cc \
		LibItsCps_Encdec.cc \
		LibItsAvm_Encdec.cc \
		LibItsVru_Encdec.cc \
		LibItsIvim_Encdec.cc \
		LibItsPki_Encdec.cc \
		@@ -76,3 +77,8 @@ sources += LibItsVru_Encdec.cc \
		LibItsBtp_Encdec.cc
		endif

		ifeq (AtsAVM, $(ATS))
		sources += LibItsAvm_Encdec.cc \
		LibItsBtp_Encdec.cc
		endif

ccsrc/Externals/module.mk

+5 −0

Original line number	Diff line number	Diff line
		@@ -48,6 +48,11 @@ ifeq (AtsBTP, $(ATS))
		sources += LibItsSecurity_externals.cc
		endif

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


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

ccsrc/Ports/LibIts_ports/AVM_ports/AdapterControlPort_AVM.cc

+2 −2

Original line number	Diff line number	Diff line
		@@ -4,7 +4,7 @@
		#include "registration.hh"

		#include "AdapterControlPort_AVM.hh"
		#include "cam_layer.hh"
		#include "avm_layer.hh"

		//=============================================================================
		namespace LibItsAvm__TestSystem {
		@@ -40,7 +40,7 @@ namespace LibItsAvm__TestSystem {
		loggers::get_instance().log_msg(">>> AdapterControlPort::outgoing_send: ", send_par);

		// Register this object for AdapterControlPort
		cam_layer *p = registration<cam_layer>::get_instance().get_item(std::string("AVM"));
		avm_layer *p = registration<avm_layer>::get_instance().get_item(std::string("AVM"));
		if (p != NULL) {
		loggers::get_instance().log("AdapterControlPort::outgoing_send: Got AVM layer %p", p);
		LibItsCommon__TypesAndValues::AdapterControlResults response;

ccsrc/Ports/LibIts_ports/AVM_ports/AvmPort.cc

+49 −31

File changed.

Preview size limit exceeded, changes collapsed.