Simplify Payload for GeoNetworking & BTP (13d63685) · Commits · ITS - Intelligent Transport Systems / ITS

ccsrc/Ports/LibIts_ports/GN_ports/GeoNetworkingPort.cc

+23 −0

Changes for ccsrc/Ports/LibIts_ports/GN_ports/GeoNetworkingPort.cc: 23 added lines, 0 removed lines.
Original line number	Diff line number	Diff line
		@@ -102,6 +102,29 @@ namespace LibItsGeoNetworking__TestSystem {

		void GeoNetworkingPort::receiveMsg (const LibItsGeoNetworking__TestSystem::GeoNetworkingInd& p_ind, const Params& p_params) {
		loggers::get_instance().log_msg(">>> GeoNetworkingPort::receive_msg: ", p_ind);
		// Sanity check
		if (!p_ind.is_bound()) {
		return;
		}

		// Update location table
		if (p_ind.msgIn().basicHeader().version() == 0) { // Non secured mode
		const LibItsGeoNetworking__TypesAndValues::GnNonSecuredPacket& p = p_ind.msgIn().gnPacket().packet();
		const LibItsGeoNetworking__TypesAndValues::HeaderTST& htst = p.commonHeader().headerTST();
		if (htst.ischosen(LibItsGeoNetworking__TypesAndValues::HeaderTST::ALT_lsHdr)) { // Location service
		const LibItsGeoNetworking__TypesAndValues::LsHeaderType& ls = htst.lsHdr();
		if (ls.headerSubType() == LibItsGeoNetworking__TypesAndValues::HeaderSubTypeLs::e__lsReply) { // Update the Test System Location Table
		const LibItsGeoNetworking__TypesAndValues::ExtendedHeader& ex = p.extendedHeader();
		if (ex.ischosen(LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_lsReplyHeader)) {
		const LibItsGeoNetworking__TypesAndValues::LongPosVector& sopv = ex.lsReplyHeader().srcPosVector();
		loggers::get_instance().user_msg("GeoNetworkingPort::receive_msg: Update LocationTable: ", sopv);
		// TODO Add a LocationTable class to manage it
		} // else, discard packet
		} // else, discard packet
		} // else, discard packet
		} // TODO else security mode

		// TODO Add beacon filter for StartPassBeaconing/Stop

		incoming_message(p_ind);
		}

ccsrc/Protocols/GeoNetworking/GeoNetworkingCodec.cc

+10 −10

Changes for ccsrc/Protocols/GeoNetworking/GeoNetworkingCodec.cc: 10 added lines, 10 removed lines.
Original line number	Diff line number	Diff line
		@@ -18,7 +18,7 @@ int GeoNetworkingCodec::encode (const LibItsGeoNetworking__TypesAndValues::GeoNe
		encode_(msg, *msg.get_descriptor(), encoding_buffer);
		data = OCTETSTRING(encoding_buffer.get_len(), encoding_buffer.get_data());
		// Overwrite the payload length
		if (_ec.length > (unsigned int)-1) {
		if (_ec.length != (unsigned int)-1) {
		loggers::get_instance().log("GeoNetworkingCodec::encode: length=%d - plLength_position = %d - plLength = %d", data.lengthof(), _ec.length_position, _ec.length);
		unsigned char b[] = { (unsigned char)((_ec.length & 0x0000FF00) >> 8), (unsigned char)_ec.length };
		OCTETSTRING rpl(sizeof(b), b);
		@@ -211,39 +211,39 @@ int GeoNetworkingCodec::encode_extendedHeader(const LibItsGeoNetworking__TypesAn
		break;
		case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_geoUnicastHeader:
		loggers::get_instance().log("GeoNetworkingCodec::encode_extendedHeader: processing type %s", u.geoUnicastHeader().get_descriptor()->name);
		result = encode_(u.geoUnicastHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_geoUnicastHeader_descr_, encoding_buffer);
		result = encode_(u.geoUnicastHeader(), *u.geoUnicastHeader().get_descriptor(), encoding_buffer);
		break;
		case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_tsbHeader:
		loggers::get_instance().log("GeoNetworkingCodec::encode_extendedHeader: processing type %s", u.tsbHeader().get_descriptor()->name);
		result = encode_(u.tsbHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_tsbHeader_descr_, encoding_buffer);
		result = encode_(u.tsbHeader(), *u.tsbHeader().get_descriptor(), encoding_buffer);
		break;
		case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_shbHeader:
		loggers::get_instance().log("GeoNetworkingCodec::encode_extendedHeader: processing type %s", u.shbHeader().get_descriptor()->name);
		result = encode_(u.shbHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_shbHeader_descr_, encoding_buffer);
		result = encode_(u.shbHeader(), *u.shbHeader().get_descriptor(), encoding_buffer);
		break;
		case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_geoBroadcastHeader:
		loggers::get_instance().log("GeoNetworkingCodec::encode_extendedHeader: processing type %s", u.geoBroadcastHeader().get_descriptor()->name);
		result = encode_(u.geoBroadcastHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_geoBroadcastHeader_descr_, encoding_buffer);
		result = encode_(u.geoBroadcastHeader(), *u.geoBroadcastHeader().get_descriptor(), encoding_buffer);
		break;
		case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_geoAnycastHeader:
		loggers::get_instance().log("GeoNetworkingCodec::encode_extendedHeader: processing type %s", u.geoAnycastHeader().get_descriptor()->name);
		result = encode_(u.geoAnycastHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_geoAnycastHeader_descr_, encoding_buffer);
		result = encode_(u.geoAnycastHeader(), *u.geoAnycastHeader().get_descriptor(), encoding_buffer);
		break;
		case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_beaconHeader:
		loggers::get_instance().log("GeoNetworkingCodec::encode_extendedHeader: processing type %s", u.beaconHeader().get_descriptor()->name);
		result = encode_(u.beaconHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_beaconHeader_descr_, encoding_buffer);
		result = encode_(u.beaconHeader(), *u.beaconHeader().get_descriptor(), encoding_buffer);
		break;
		case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_anyHeader:
		loggers::get_instance().log("GeoNetworkingCodec::encode_extendedHeader: processing type %s", u.anyHeader().get_descriptor()->name);
		result = encode_(u.anyHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_anyHeader_descr_, encoding_buffer);
		result = encode_(u.anyHeader(), *u.anyHeader().get_descriptor(), encoding_buffer);
		break;
		case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_lsRequestHeader:
		loggers::get_instance().log("GeoNetworkingCodec::encode_extendedHeader: processing type %s", u.lsRequestHeader().get_descriptor()->name);
		result = encode_(u.lsRequestHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_lsRequestHeader_descr_, encoding_buffer);
		result = encode_(u.lsRequestHeader(), *u.lsRequestHeader().get_descriptor(), encoding_buffer);
		break;
		case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_lsReplyHeader:
		loggers::get_instance().log("GeoNetworkingCodec::encode_extendedHeader: processing type %s", u.lsReplyHeader().get_descriptor()->name);
		result = encode_(u.lsReplyHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_lsReplyHeader_descr_, encoding_buffer);
		result = encode_(u.lsReplyHeader(), *u.lsReplyHeader().get_descriptor(), encoding_buffer);
		break;
		default: TTCN_error("GeoNetworkingCodec::encode_extendedHeader: Invalid selection in union is_bound");
		} // End of 'switch' statement

ccsrc/Protocols/GeoNetworking/GeoNetworkingLayer.cc

+72 −59

Changes for ccsrc/Protocols/GeoNetworking/GeoNetworkingLayer.cc: 72 added lines, 59 removed lines.
Original line number	Diff line number	Diff line
		@@ -32,66 +32,12 @@ GeoNetworkingLayer::GeoNetworkingLayer(const std::string & p_type, const std::st
		if (it == _params.cend()) {
		_params.insert(std::pair<std::string, std::string>(std::string("mac_bc"), "FFFFFFFFFFFF"));
		}
		fill_beacon(latitude, longitude, ll_address);
		// Prepare the static part of the TestSystem beacon
		// TODO Add a method
		_beacon = new GeoNetworkingPdu();
		HeaderTST h;
		h.beaconHdr() = BeaconHeaderType(
		HeaderType(HeaderType::e__beacon),
		0
		);
		ExtendedHeader eh;
		eh.beaconHeader() = BeaconHeader(
		LongPosVector(
		GN__Address(
		TypeOfAddress(TypeOfAddress::e__manual),
		StationType(StationType::e__roadSideUnit),
		33,
		ll_address
		),
		0,
		latitude,
		longitude,
		int2bit(0, 1),
		0,
		0
		)
		);
		_beacon->basicHeader() = BasicHeader(
		0,
		BasicNextHeader(
		BasicNextHeader::e__commonHeader
		),
		0,
		Lifetime(
		4,
		LtBase(LtBase::e__50ms)
		),
		5
		);
		_beacon->gnPacket().packet() = GnNonSecuredPacket(
		CommonHeader(
		NextHeader(
		NextHeader::e__any
		),
		0,
		h,
		TrafficClass(
		SCF(SCF::e__scfDisabled),
		ChannelOffload(ChannelOffload::e__choffDisabled),
		0
		),
		int2bit(0, 8),
		0,
		1,
		0
		),
		OPTIONAL<ExtendedHeader>(eh),
		OPTIONAL<GnRawPayload>()
		);
		_beacon->gnPacket().packet().payload().set_to_omit();
		_beacon->gnPacket().securedMsg().set_to_omit();
		// loggers::get_instance().log_msg("GeoNetworkingLayer::GeoNetworkingLayer: beacon value: ", *p._beacon);
		it = _params.find("");
		if ((it != _params.cend()) && (it->second.compare("1") == 0)) {
		start_beaconing();
		}
		}

		GeoNetworkingLayer::~GeoNetworkingLayer() {
		@@ -165,6 +111,11 @@ void GeoNetworkingLayer::receiveData(OCTETSTRING& data, Params& params) {
		void GeoNetworkingLayer::start_beaconing() {
		loggers::get_instance().log(">>> GeoNetworkingLayer::start_beaconing");

		// Sanity checks
		if (_thread != NULL) { // Already started
		return;
		}

		// Create the offline reader thread
		_thread = new std::thread(&GeoNetworkingLayer::run_beaconing, (void *)this);
		if (_thread == NULL) {
		@@ -227,6 +178,68 @@ void* GeoNetworkingLayer::run_beaconing(void* p_this) {
		return NULL;
		}

		void GeoNetworkingLayer::fill_beacon(INTEGER& p_latitude, INTEGER& p_longitude, OCTETSTRING& p_ll_address)
		{
		_beacon = new GeoNetworkingPdu();
		HeaderTST h;
		h.beaconHdr() = BeaconHeaderType(
		HeaderType(HeaderType::e__beacon),
		0
		);
		ExtendedHeader eh;
		eh.beaconHeader() = BeaconHeader(
		LongPosVector(
		GN__Address(
		TypeOfAddress(TypeOfAddress::e__manual),
		StationType(StationType::e__roadSideUnit),
		33,
		p_ll_address
		),
		0,
		p_latitude,
		p_longitude,
		int2bit(0, 1),
		0,
		0
		)
		);
		_beacon->basicHeader() = BasicHeader(
		0,
		BasicNextHeader(
		BasicNextHeader::e__commonHeader
		),
		0,
		Lifetime(
		4,
		LtBase(LtBase::e__50ms)
		),
		5
		);
		_beacon->gnPacket().packet() = GnNonSecuredPacket(
		CommonHeader(
		NextHeader(
		NextHeader::e__any
		),
		0,
		h,
		TrafficClass(
		SCF(SCF::e__scfDisabled),
		ChannelOffload(ChannelOffload::e__choffDisabled),
		0
		),
		int2bit(0, 8),
		0,
		1,
		0
		),
		OPTIONAL<ExtendedHeader>(eh),
		OPTIONAL<GnRawPayload>()
		);
		_beacon->gnPacket().packet().payload().set_to_omit();
		_beacon->gnPacket().securedMsg().set_to_omit();
		// loggers::get_instance().log_msg("GeoNetworkingLayer::GeoNetworkingLayer: beacon value: ", *p._beacon);
		}

		class GeoNetworkingFactory: public LayerFactory {
		static GeoNetworkingFactory _f;
		public:

ccsrc/Protocols/GeoNetworking/GeoNetworkingLayer.hh

+2 −0

Changes for ccsrc/Protocols/GeoNetworking/GeoNetworkingLayer.hh: 2 added lines, 0 removed lines.
Original line number	Diff line number	Diff line
		@@ -25,6 +25,8 @@ class GeoNetworkingLayer : public TLayer<LibItsGeoNetworking__TestSystem::GeoNet
		std::mutex _sendData;
		bool _running;

		void fill_beacon(INTEGER& p_latitude, INTEGER& p_longitude, OCTETSTRING& p_ll_address);

		static void* run_beaconing(void* p_this);

		public:

ccsrc/loggers/loggers.hh

+21 −0

Changes for ccsrc/loggers/loggers.hh: 21 added lines, 0 removed lines.
Original line number	Diff line number	Diff line
		@@ -40,6 +40,9 @@ public:
		inline void log_msg(const char *prompt, const Base_Type& type);
		inline void log(const char *fmt, ...);

		inline void user_msg(const char *prompt, const Base_Type& type);
		inline void user(const char *fmt, ...);

		inline void warning(const char *fmt, ...);
		inline void warning_msg(const char *prompt, const Base_Type& type);

		@@ -88,6 +91,24 @@ void loggers::log(const char *fmt, ...)
		TTCN_Logger::end_event();
		}

		void loggers::user_msg(const char *prompt, const Base_Type& type)
		{
		TTCN_Logger::begin_event(TTCN_Logger::USER_UNQUALIFIED);
		TTCN_Logger::log_event_str(prompt);
		type.log();
		TTCN_Logger::end_event();
		}

		void loggers::user(const char *fmt, ...)
		{
		TTCN_Logger::begin_event(TTCN_Logger::USER_UNQUALIFIED);
		va_list args;
		va_start(args, fmt);
		TTCN_Logger::log_event_va_list(fmt, args);
		va_end(args);
		TTCN_Logger::end_event();
		}

		void loggers::warning(const char *fmt, ...)
		{
		va_list args;