Unify CAM/DENM codec code (5c1bf1ea) · Commits · ITS - Intelligent Transport Systems / ITS

ccsrc/Framework/Params.hh

+3 −0

Original line number	Original line	Diff line number	Diff line
	@@ -30,6 +30,9 @@ public:
	static const std::string& expiry;		static const std::string& expiry;

	static const std::string& packetize; /** Indicate to the lower layer to build packet */		static const std::string& packetize; /** Indicate to the lower layer to build packet */
			static const std::string& distanceA;
			static const std::string& distanceB;
			static const std::string& angle;

	Params() : std::map<std::string, std::string>() {};		Params() : std::map<std::string, std::string>() {};
	Params(const Params& p_params) : std::map<std::string, std::string>(p_params.begin(), p_params.end()) {};		Params(const Params& p_params) : std::map<std::string, std::string>(p_params.begin(), p_params.end()) {};

ccsrc/Framework/src/Params.cc

+3 −0

Original line number	Original line	Diff line number	Diff line
	@@ -29,6 +29,9 @@ const std::string& Params::ll_address = std::string("ll_address");
	const std::string& Params::expiry = std::string("expiry");		const std::string& Params::expiry = std::string("expiry");

	const std::string& Params::packetize = std::string("packetize");		const std::string& Params::packetize = std::string("packetize");
			const std::string& Params::distanceA = std::string("distanceA");
			const std::string& Params::distanceB = std::string("distanceB");
			const std::string& Params::angle = std::string("angle");

	void Params::convert(Params& p_param, const std::string p_parameters) {		void Params::convert(Params& p_param, const std::string p_parameters) {
	// Sanity checks		// Sanity checks

ccsrc/Protocols/CAM/CAMLayer.cc

+7 −5

Original line number	Original line	Diff line number	Diff line
	@@ -10,18 +10,20 @@ CAMLayer::CAMLayer(const std::string & p_type, const std::string & param) : TLay
	}		}

	void CAMLayer::sendMsg(const LibItsCam__TestSystem::CamReq& p, Params& params){		void CAMLayer::sendMsg(const LibItsCam__TestSystem::CamReq& p, Params& params){
	loggers::get_instance().log(">>> CAMLayer::sendMsg");		loggers::get_instance().log_msg(">>> CAMLayer::sendMsg: ", p);

	// Encode CAM PDU		// Encode CAM PDU
	OCTETSTRING data;		OCTETSTRING data;
	_codec.encode(p.msgOut(), data);		if (_codec.encode(p.msgOut(), data) == -1) {
			loggers::get_instance().warning("CAMLayer::sendMsg: Encodeing failure");
			return;
			}
	// Update parameters		// Update parameters
	Params pars(params);		params.insert(std::pair<std::string, std::string>(
	pars.insert(std::pair<std::string, std::string>(
	Params::packetize,		Params::packetize,
	std::string("")		std::string("")
	));		));
	sendData(data, pars);		sendData(data, params);
	}		}

	void CAMLayer::sendData(OCTETSTRING& data, Params& params) {		void CAMLayer::sendData(OCTETSTRING& data, Params& params) {

ccsrc/Protocols/DENM/DENMLayer.cc

+6 −4

Original line number	Original line	Diff line number	Diff line
	@@ -10,14 +10,16 @@ DENMLayer::DENMLayer(const std::string & p_type, const std::string & param) : TL
	}		}

	void DENMLayer::sendMsg(const LibItsDenm__TestSystem::DenmReq& p, Params& params){		void DENMLayer::sendMsg(const LibItsDenm__TestSystem::DenmReq& p, Params& params){
	loggers::get_instance().log(">>> DENMLayer::sendMsg");		loggers::get_instance().log_msg(">>> DENMLayer::sendMsg: ", p);

	// Encode DENM PDU		// Encode DENM PDU
	OCTETSTRING data;		OCTETSTRING data;
	_codec.encode(p.msgOut(), data);		if (_codec.encode(p.msgOut(), data) == -1) {
			loggers::get_instance().warning("DENMLayer::sendMsg: Encodeing failure");
			return;
			}
	// Update parameters		// Update parameters
	Params pars(params);		params.insert(std::pair<std::string, std::string>(
	pars.insert(std::pair<std::string, std::string>(
	Params::packetize,		Params::packetize,
	std::string("")		std::string("")
	));		));

ccsrc/Protocols/GeoNetworking/GeoNetworkingLayer.cc

+121 −34

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

	using namespace LibItsGeoNetworking__TypesAndValues;		using namespace LibItsGeoNetworking__TypesAndValues;

	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} {		GeoNetworkingLayer::GeoNetworkingLayer(const std::string & p_type, const std::string & param) : TLayer<LibItsGeoNetworking__TestSystem::GeoNetworkingPort>(p_type), _params(), _codec(), _beacon(nullptr), _packet(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());		loggers::get_instance().log(">>> GeoNetworkingLayer::GeoNetworkingLayer: %s, %s", to_string().c_str(), param.c_str());

	// Setup parameters		// Setup parameters
	@@ -33,6 +33,21 @@ GeoNetworkingLayer::GeoNetworkingLayer(const std::string & p_type, const std::st
	if (it != _params.cend()) {		if (it != _params.cend()) {
	ll_address = str2oct(CHARSTRING(it->second.c_str()));		ll_address = str2oct(CHARSTRING(it->second.c_str()));
	}		}
			INTEGER distanceA = 1000; // 1km
			it = _params.find(Params::distanceA);
			if (it != _params.cend()) {
			distanceA = str2int(CHARSTRING(it->second.c_str()));
			}
			INTEGER distanceB = 1000; // 1Km
			it = _params.find(Params::distanceB);
			if (it != _params.cend()) {
			distanceB = str2int(CHARSTRING(it->second.c_str()));
			}
			INTEGER angle = 0;
			it = _params.find(Params::angle);
			if (it != _params.cend()) {
			angle = str2int(CHARSTRING(it->second.c_str()));
			}
	// Add broadcast address if needed		// Add broadcast address if needed
	it = _params.find("mac_bc");		it = _params.find("mac_bc");
	if (it == _params.cend()) {		if (it == _params.cend()) {
	@@ -48,6 +63,8 @@ GeoNetworkingLayer::GeoNetworkingLayer(const std::string & p_type, const std::st
	fill_beacon(latitude, longitude, ll_address);		fill_beacon(latitude, longitude, ll_address);
	start_beaconing();		start_beaconing();
	}		}

			fill_packet(latitude, longitude, ll_address, latitude, longitude, distanceA, distanceB, angle);// TODO Check if GeoBroadcastArea lat/lon are identical to lat/lon of the Test System
	} // End of constructor		} // End of constructor

	GeoNetworkingLayer::~GeoNetworkingLayer() {		GeoNetworkingLayer::~GeoNetworkingLayer() {
	@@ -60,6 +77,9 @@ GeoNetworkingLayer::~GeoNetworkingLayer() {
	if (_beacon != nullptr) {		if (_beacon != nullptr) {
	delete _beacon;		delete _beacon;
	}		}
			if (_packet != nullptr) {
			delete _packet;
			}
	} // End of destructor		} // End of destructor

	void GeoNetworkingLayer::sendMsg(const LibItsGeoNetworking__TestSystem::GeoNetworkingReq& p, Params& params) {		void GeoNetworkingLayer::sendMsg(const LibItsGeoNetworking__TestSystem::GeoNetworkingReq& p, Params& params) {
	@@ -77,39 +97,36 @@ void GeoNetworkingLayer::sendData(OCTETSTRING& data, Params& params) {

	// TODO Take into account the Security		// TODO Take into account the Security
	Params::const_iterator it = params.find(Params::packetize);		Params::const_iterator it = params.find(Params::packetize);
	/*if (it != params.cend()) {		if (it != params.cend()) { // Need to build a GN packet
	LibItsGeoNetworking__TypesAndValues::GeoNetworkingPacket gnp;		params.log();
	if (_params[Params::btp_type].compare("btpA") == 0) {		ExtendedHeader* eh = static_cast<ExtendedHeader *>(_packet->gnPacket().packet().extendedHeader().get_opt_value());
	header.btpAHeader() = LibItsGeoNetworking__TypesAndValues::GeoNetworkingAHeader(		if (eh == NULL) {
	std::stoi(_params[Params::btp_destination_port]),		loggers::get_instance().error("GeoNetworkingLayer::sendData: Wrong cast");
	std::stoi(_params[Params::btp_info])		return;
	);
	} else {
	header.btpBHeader() = LibItsGeoNetworking__TypesAndValues::GeoNetworkingBHeader(
	std::stoi(_params[Params::btp_destination_port]),
	std::stoi(_params[Params::btp_info])
	);
	}		}
	LibItsGeoNetworking__TypesAndValues::GeoNetworkingPacket p(		// Update NextHeader
	LibItsGeoNetworking__TypesAndValues::BasicHeader(		it = params.find(Params::btp_type);
	1,		if ((it != params.cend()) && (it->second.compare("btpB") == 0)) {
	LibItsGeoNetworking__TypesAndValues::BasicNextHeader(LibItsGeoNetworking__TypesAndValues::BasicNextHeader::e__commonHeader), // TODO Take into acount the Security		_packet->gnPacket().packet().commonHeader().nextHeader() = NextHeader::e__btpB;
	0,		} else { // Default btp is btpA
	LibItsGeoNetworking__TypesAndValues::Lifetime(		_packet->gnPacket().packet().commonHeader().nextHeader() = NextHeader::e__btpA;
	LibItsGeoNetworking__TypesAndValues::Ltbase(LibItsGeoNetworking__TypesAndValues::Ltbase::e__50ms),		}
	std::stoi(_params[Params::expity]) / 50		// Update sequence number
	),		eh->geoBroadcastHeader().seqNumber() = 1 + eh->geoBroadcastHeader().seqNumber();
	10		// Update payload
	),		_packet->gnPacket().packet().commonHeader().plLength() = data.lengthof();
	LibItsGeoNetworking__TypesAndValues::GeoNetworkingPacket(gnp)		_packet->gnPacket().packet().payload() = OPTIONAL<OCTETSTRING>(data);
	);		// Update timestamp
	loggers::get_instance().log_msg("GeoNetworkingLayer::sendData: ", p);		unsigned long long ms = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count() - 1072911600000L; // TODO Add method such as its_tme() & its_time_mod()
			eh->geoBroadcastHeader().srcPosVector().timestamp__().set_long_long_val(static_cast<unsigned int>(ms));

			loggers::get_instance().log_msg("GeoNetworkingLayer::sendData: ", *_packet);

	// Encode GeoNetworking PDU		// Encode GeoNetworking PDU
	OCTETSTRING os;		OCTETSTRING os;
	_codec.encode(p, os);		_codec.encode(*_packet, os);
	data = os;		data = os;
	}*/		}

	// TODO To be removed		// TODO To be removed
	while (_sendData.try_lock() == FALSE) {		while (_sendData.try_lock() == FALSE) {
	@@ -235,7 +252,7 @@ OCTETSTRING GeoNetworkingLayer::trigger_ac_event(OCTETSTRING& data, Params& para

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

	// Establish handler for timer signal		// Establish handler for timer signal
	loggers::get_instance().log("GeoNetworkingLayer::start_beaconing: Establishing handler for signal %d\n", _signal_id);		loggers::get_instance().log("GeoNetworkingLayer::start_beaconing: Establishing handler for signal %d\n", _signal_id);
	@@ -315,7 +332,7 @@ void GeoNetworkingLayer::send_beacon() {
	loggers::get_instance().error("GeoNetworkingLayer::send_beacon: Wrong cast");		loggers::get_instance().error("GeoNetworkingLayer::send_beacon: Wrong cast");
	}		}
	// Update timestamp		// Update timestamp
	unsigned long long ms = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count() - 1072911600000L; // TODO Add method such as its_tme() & its_time_mod()		unsigned long long ms = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count() - 1072911600000L; // TODO Add method such as its_time() & its_time_mod()
	eh->beaconHeader().srcPosVector().timestamp__().set_long_long_val(static_cast<unsigned int>(ms));		eh->beaconHeader().srcPosVector().timestamp__().set_long_long_val(static_cast<unsigned int>(ms));
	//loggers::get_instance().log_msg("GeoNetworkingLayer::send_beacon: ", *_beacon);		//loggers::get_instance().log_msg("GeoNetworkingLayer::send_beacon: ", *_beacon);
	// Encode message using TITAN because of payload in omited		// Encode message using TITAN because of payload in omited
	@@ -367,8 +384,8 @@ void GeoNetworkingLayer::fill_beacon(INTEGER& p_latitude, INTEGER& p_longitude,
	eh.beaconHeader() = BeaconHeader(		eh.beaconHeader() = BeaconHeader(
	LongPosVector(		LongPosVector(
	GN__Address(		GN__Address(
	TypeOfAddress(TypeOfAddress::e__manual),		TypeOfAddress(TypeOfAddress::e__manual), // TODO Use Params
	StationType(StationType::e__roadSideUnit),		StationType(StationType::e__roadSideUnit), // TODO Use Params
	33,		33,
	p_ll_address		p_ll_address
	),		),
	@@ -414,9 +431,79 @@ void GeoNetworkingLayer::fill_beacon(INTEGER& p_latitude, INTEGER& p_longitude,
	);		);
	_beacon->gnPacket().packet().payload().set_to_omit();		_beacon->gnPacket().packet().payload().set_to_omit();
	_beacon->gnPacket().securedMsg().set_to_omit();		_beacon->gnPacket().securedMsg().set_to_omit();
	// loggers::get_instance().log_msg("GeoNetworkingLayer::GeoNetworkingLayer: beacon value: ", *p._beacon);		//loggers::get_instance().log_msg("GeoNetworkingLayer::fill_beacon: beacon value: ", *_beacon);
	} // End of fill_beacon method		} // End of fill_beacon method

			void GeoNetworkingLayer::fill_packet(const INTEGER& p_latitude, const INTEGER& p_longitude, const OCTETSTRING& p_ll_address, const INTEGER& p_geoAreaPosLatitude, const INTEGER& p_geoAreaPosLongitude, const INTEGER& p_distanceA, const INTEGER& p_distanceB, const INTEGER& p_angle)
			{
			_packet = new GeoNetworkingPdu();
			HeaderTST h;
			h.geoBroadcastHdr() = GeoBroadcastHeaderType(
			HeaderType(HeaderType::e__geoBroadcast),
			HeaderSubTypeGeoBroadcast(HeaderSubTypeGeoBroadcast::e__geoBroadcastElip)
			);
			ExtendedHeader eh;
			eh.geoBroadcastHeader() = GeoAnycastHeader( // GeoBradcastHeader is identical as GeoAnycastHeader
			0,
			0,
			LongPosVector(
			GN__Address(
			TypeOfAddress(TypeOfAddress::e__manual), // TODO Use Params
			StationType(StationType::e__passengerCar), // TODO Use Params
			33,
			p_ll_address
			),
			0,
			p_latitude,
			p_longitude,
			int2bit(1, 1), // PAI
			0,
			0
			),
			p_geoAreaPosLatitude,
			p_geoAreaPosLongitude,
			p_distanceA,
			p_distanceB,
			p_angle,
			0
			);
			_packet->basicHeader() = BasicHeader(
			0,
			BasicNextHeader(
			BasicNextHeader::e__commonHeader
			),
			0,
			Lifetime(
			4,
			LtBase(LtBase::e__50ms)
			),
			5
			);
			_packet->gnPacket().packet() = GnNonSecuredPacket(
			CommonHeader(
			NextHeader(
			NextHeader::e__btpA
			),
			0,
			h,
			TrafficClass(
			SCF(SCF::e__scfDisabled),
			ChannelOffload(ChannelOffload::e__choffDisabled),
			0
			),
			int2bit(128, 8), // Mobile stationnary flag set
			0,
			5,
			0
			),
			OPTIONAL<ExtendedHeader>(eh),
			OPTIONAL<GnRawPayload>()
			);
			_packet->gnPacket().packet().payload().set_to_omit();
			_packet->gnPacket().securedMsg().set_to_omit();
			//loggers::get_instance().log_msg("GeoNetworkingLayer::fill_packet: packet value: ", *_packet);
			} // End of fill_packet method

	void GeoNetworkingLayer::timer_irq_sigalrm_handler(int p_signal, siginfo_t p_signal_info, void p_uc) {		void GeoNetworkingLayer::timer_irq_sigalrm_handler(int p_signal, siginfo_t p_signal_info, void p_uc) {
	//loggers::get_instance().log(">>> GeoNetworkingLayer::timer_irq_sigalrm_handler: Caught signal %d", p_signal);		//loggers::get_instance().log(">>> GeoNetworkingLayer::timer_irq_sigalrm_handler: Caught signal %d", p_signal);

Admin message