AcControlPort changes validation (1e1ae582) · Commits · ITS - Intelligent Transport Systems / ITS

ccsrc/Framework/Layer.hh

+9 −2

Original line number	Diff line number	Diff line
		@@ -4,6 +4,7 @@
		#include <string>
		#include <map>
		#include <vector>
		#include <algorithm>

		#include "Params.hh"
		#include "loggers.hh"
		@@ -21,8 +22,14 @@ protected:
		public:
		Layer() : upperLayers(), lowerLayers(), type(std::string("")) { loggers::get_instance().log("Layer::Layer (D)"); };
		Layer(const std::string& p_type) : upperLayers(), lowerLayers(), type(std::string(p_type.begin(), p_type.end())) { loggers::get_instance().log("Layer::Layer"); };
		virtual ~Layer() { upperLayers.clear(); lowerLayers.clear(); };
		void deleteLayer() { };
		virtual ~Layer() {
		loggers::get_instance().log("Layer::~Layer");
		// Double linked list, only remove layers in lowerLayers from the lowest one
		std::for_each(lowerLayers.rbegin(), lowerLayers.rend(), [](Layer* it) { delete it; } );
		lowerLayers.clear();
		upperLayers.clear();
		};
		void deleteLayer() { loggers::get_instance().log("Layer::deleteLayer"); };
		public:
		inline void addUpperLayer(Layer* p_layer) {
		//loggers::get_instance().log(">>> Layer::addUpperLayer");

ccsrc/Framework/src/Asn1Recode.cc

+2 −1

Original line number	Diff line number	Diff line
		#include <asn1/asn_application.h>
		#include "../Codec.hh"

		#include "Codec.hh"

		extern "C" {
		static int asn1c_collect_encoded_data(const void buffer, size_t size, void application_specific_key)

ccsrc/Ports/LibIts_ports/GN_ports/AdapterControlPort_GN.partC

+10 −17

Original line number	Diff line number	Diff line
		@@ -76,37 +76,30 @@ namespace LibItsGeoNetworking__TestSystem {
		// Register this object for AdapterControlPort
		GeoNetworkingLayer* p = registration<GeoNetworkingLayer>::get_instance().get_item(std::string("GN"));
		if (p != NULL) {
		loggers::get_instance().log("AdapterControlPort::outgoing_send: Got layer %p", p);



		// TODO Use AcCodec to encode into ???
		/*TTCN_Buffer encoding_buffer;
		send_par.encode(*send_par.get_descriptor(), encoding_buffer, TTCN_EncDec::CT_RAW);
		loggers::get_instance().log_to_hexa("AdapterControlPort::outgoing_send: ", encoding_buffer);
		OCTETSTRING os(encoding_buffer.get_len(), encoding_buffer.get_data());
		OCTETSTRING result = p->trigger_ac_event(os, _params);*/



		loggers::get_instance().log("AdapterControlPort::outgoing_send: Got GN layer %p", p);
		LibItsGeoNetworking__TypesAndValues::AcGnResponse response;
		response.failure() = LibItsGeoNetworking__TypesAndValues::AcGnResponseFailure(BOOLEAN(false));
		if (send_par.ischosen(LibItsGeoNetworking__TypesAndValues::AcGnPrimitive::ALT_startBeaconing)) {
		loggers::get_instance().log("AdapterControlPort::outgoing_send: Start beaconing");
		p->start_beaconing();
		response.failure() = LibItsGeoNetworking__TypesAndValues::AcGnResponseFailure(BOOLEAN(false));
		p->start_beaconing(send_par.startBeaconing().beaconPacket());
		} else if (send_par.ischosen(LibItsGeoNetworking__TypesAndValues::AcGnPrimitive::ALT_stopBeaconing)) {
		loggers::get_instance().log("AdapterControlPort::outgoing_send: Stop beaconing");
		p->stop_beaconing();
		response.failure() = LibItsGeoNetworking__TypesAndValues::AcGnResponseFailure(BOOLEAN(false));
		} else if (send_par.ischosen(LibItsGeoNetworking__TypesAndValues::AcGnPrimitive::ALT_getLongPosVector)) {
		loggers::get_instance().log("AdapterControlPort::outgoing_send: Get LongPosVector");
		const LibItsGeoNetworking__TypesAndValues::LongPosVector* lpv = p->get_lpv(send_par.getLongPosVector().gnAddress());
		loggers::get_instance().log("AdapterControlPort::outgoing_send: Return value: %p", lpv);
		if (lpv == nullptr) {
		response.failure() = LibItsGeoNetworking__TypesAndValues::AcGnResponseFailure(BOOLEAN(false));
		response.failure() = LibItsGeoNetworking__TypesAndValues::AcGnResponseFailure(BOOLEAN(true));
		} else {
		response.getLongPosVector() = *lpv;
		}
		} else if (send_par.ischosen(LibItsGeoNetworking__TypesAndValues::AcGnPrimitive::ALT_startPassBeaconing)) {
		loggers::get_instance().log("AdapterControlPort::outgoing_send: Start pass beaconing");
		p->start_pass_beaconing(send_par.startPassBeaconing().beaconHeader());
		} else if (send_par.ischosen(LibItsGeoNetworking__TypesAndValues::AcGnPrimitive::ALT_stopPassBeaconing)) {
		loggers::get_instance().log("AdapterControlPort::outgoing_send: Stop pass beaconing");
		p->stop_pass_beaconing();
		} else {
		response.failure() = LibItsGeoNetworking__TypesAndValues::AcGnResponseFailure(BOOLEAN(true));
		}

ccsrc/Protocols/ETH/EthernetLayer.hh

+6 −6

Original line number	Diff line number	Diff line
		@@ -8,7 +8,7 @@ class EthernetLayer : public Layer {
		Params _params;
		public:
		EthernetLayer(const std::string & p_type, const std::string & param);
		virtual ~EthernetLayer() {}
		virtual ~EthernetLayer() {};

		virtual void sendData(OCTETSTRING& data, Params& params);
		virtual void receiveData(OCTETSTRING& data, Params& info);

ccsrc/Protocols/GeoNetworking/GeoNetworkingLayer.cc

+130 −88

Original line number	Diff line number	Diff line
		@@ -12,7 +12,7 @@

		using namespace LibItsGeoNetworking__TypesAndValues;

		GeoNetworkingLayer::GeoNetworkingLayer(const std::string & p_type, const std::string & param) : TLayer<LibItsGeoNetworking__TestSystem::GeoNetworkingPort>(p_type), _params(), _codec(), _beacon(NULL), _location_table(), _sendData(), _timerid{0}, _sev{0}, _its{0}, _freq_nanosecs(0), _mask{0}, _sa{0} {
		GeoNetworkingLayer::GeoNetworkingLayer(const std::string & p_type, const std::string & param) : TLayer<LibItsGeoNetworking__TestSystem::GeoNetworkingPort>(p_type), _params(), _codec(), _beacon(nullptr), _location_table(), _pass_beacon_table(), _sendData(), _timerid{0}, _sev{0}, _its{0}, _freq_nanosecs(0), _mask{0}, _sa{0} {
		loggers::get_instance().log(">>> GeoNetworkingLayer::GeoNetworkingLayer: %s, %s", to_string().c_str(), param.c_str());

		// Setup parameters
		@@ -42,18 +42,24 @@ GeoNetworkingLayer::GeoNetworkingLayer(const std::string & p_type, const std::st
		loggers::get_instance().log("GeoNetworkingLayer::GeoNetworkingLayer: register %s/%p", p_type.c_str(), this);
		registration<GeoNetworkingLayer>::get_instance().add_item(p_type, this);

		// Prepare beaconing operation
		fill_beacon(latitude, longitude, ll_address);
		Params::const_iterator i = _params.find(Params::beaconing);
		if ((i != _params.cend()) && (i->second.compare("1") == 0)) { // Immediate beaconing was requested
		// Prepare beaconing operation
		fill_beacon(latitude, longitude, ll_address);
		start_beaconing();
		}
		} // End of constructor

		GeoNetworkingLayer::~GeoNetworkingLayer() {
		loggers::get_instance().log(">>> GeoNetworkingLayer::~GeoNetworkingLayer");

		if (_timerid != 0) {
		timer_delete(_timerid);
		}

		if (_beacon != nullptr) {
		delete _beacon;
		}
		} // End of destructor

		void GeoNetworkingLayer::sendMsg(const LibItsGeoNetworking__TestSystem::GeoNetworkingReq& p, Params& params) {
		@@ -126,12 +132,20 @@ void GeoNetworkingLayer::receiveData(OCTETSTRING& data, Params& params) {
		}
		}

		// TODO Add beacon filter for StartPassBeaconing/Stop
		// By default incoming beacons are filtered by the test adapter
		if (htst.ischosen(LibItsGeoNetworking__TypesAndValues::HeaderTST::ALT_beaconHdr)) { // Discard beacon
		if (htst.ischosen(LibItsGeoNetworking__TypesAndValues::HeaderTST::ALT_beaconHdr)) {
		loggers::get_instance().log_msg("GeoNetworkingLayer::receiveData: Pass beaconing processing", htst);
		if (_pass_beacon_table.empty()) { // Discard beacon
		loggers::get_instance().log("GeoNetworkingLayer::receiveData: Pass beaconing table empty, skip it");
		return;
		} else { // TODO Add beacon filter for StartPassBeaconing/Stop
		if (!_pass_beacon_table.has_entry(sopv->gnAddr().mid())) { // Discard beacon
		loggers::get_instance().log_msg("GeoNetworkingLayer::receiveData: Not in pass beaconing table, skip it", *sopv);
		return;
		} // else, continue
		}
		} // TODO else security mode, becarfull to duplicate code
		} // else, continue
		} // TODO else security mode, becarefull to duplicate code

		// Add lower layers parameters
		// 1. Destination MAC address
		@@ -182,6 +196,7 @@ OCTETSTRING GeoNetworkingLayer::trigger_ac_event(OCTETSTRING& data, Params& para

		void GeoNetworkingLayer::start_beaconing() {
		loggers::get_instance().log(">>> GeoNetworkingLayer::start_beaconing");
		loggers::get_instance().log_msg("GeoNetworkingLayer::start_beaconing: _beacon=", *_beacon);

		// Establish handler for timer signal
		loggers::get_instance().log("GeoNetworkingLayer::start_beaconing: Establishing handler for signal %d\n", _signal_id);
		@@ -225,7 +240,19 @@ void GeoNetworkingLayer::start_beaconing() {
		if (sigprocmask(SIG_UNBLOCK, &_mask, NULL) == -1) {
		loggers::get_instance().error("GeoNetworkingLayer::start_beaconing: Sigprocmask failure: %d", errno);
		}
		} // End of start_beacon method
		} // End of start_beaconing method

		void GeoNetworkingLayer::start_beaconing(const LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu& p_beacon) {
		loggers::get_instance().log_msg(">>> GeoNetworkingLayer::start_beaconing", p_beacon);

		// Initialize the beacon
		if (_beacon != nullptr) {
		delete _beacon;
		}
		_beacon = new LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu(p_beacon);

		start_beaconing(); // TODO Refined adding a boolean return code
		} // End of start_beaconing method

		void GeoNetworkingLayer::stop_beaconing() {
		loggers::get_instance().log(">>> GeoNetworkingLayer::stop_beaconing");
		@@ -239,7 +266,7 @@ void GeoNetworkingLayer::stop_beaconing() {
		}
		timer_delete(_timerid);
		_timerid = 0;
		} // End of stop_beacon method
		} // End of stop_beaconing method

		void GeoNetworkingLayer::send_beacon() {
		loggers::get_instance().log(">>> GeoNetworkingLayer::send_beacon");
		@@ -263,6 +290,21 @@ void GeoNetworkingLayer::send_beacon() {
		//loggers::get_instance().log("<<< GeoNetworkingLayer::send_beacon");
		} // End of send_beacon method

		void GeoNetworkingLayer::start_pass_beaconing(const LibItsGeoNetworking__TypesAndValues::BeaconHeader& p_beacon) {
		loggers::get_instance().log_msg(">>> GeoNetworkingLayer::start_pass_beaconing", p_beacon);

		const LibItsGeoNetworking__TypesAndValues::LongPosVector& lpv = p_beacon.srcPosVector();
		if (!_pass_beacon_table.has_entry(lpv.gnAddr().mid())) {
		_pass_beacon_table.add_entry(lpv);
		} // TODO Refined adding a boolean return code
		} // End of start_pass_beaconing method

		void GeoNetworkingLayer::stop_pass_beaconing() {
		loggers::get_instance().log(">>> GeoNetworkingLayer::stop_pass_beaconing");

		_pass_beacon_table.reset();
		} // End of stop_pass_beaconing method

		const LongPosVector* GeoNetworkingLayer::get_lpv(const GN__Address& p_gn_address)
		{
		loggers::get_instance().log_msg(">>> GeoNetworkingLayer::get_lpv", p_gn_address);