Add beaconing based on POSIX timer, alternatively based on fork (commented code) (2d3af265) · Commits · ITS - Intelligent Transport Systems / ITS

ccsrc/Framework/Params.hh

+3 −0

Original line number	Original line	Diff line number	Diff line
	@@ -7,6 +7,9 @@ class Params : public std::map<std::string, std::string> {
	public:		public:
	static const std::string& mac_src;		static const std::string& mac_src;
	static const std::string& mac_dst;		static const std::string& mac_dst;
			static const std::string& mac_bc;
			static const std::string& eth_type;
			static const std::string& beaconing;
	static const std::string& ssp;		static const std::string& ssp;
	static const std::string& its_aid;		static const std::string& its_aid;
	static const std::string& gn_payload;		static const std::string& gn_payload;

ccsrc/Framework/src/Params.cc

+3 −0

Original line number	Original line	Diff line number	Diff line
	@@ -6,6 +6,9 @@

	const std::string& Params::mac_src = std::string("mac_src");		const std::string& Params::mac_src = std::string("mac_src");
	const std::string& Params::mac_dst = std::string("mac_dst");		const std::string& Params::mac_dst = std::string("mac_dst");
			const std::string& Params::mac_bc = std::string("mac_bc");
			const std::string& Params::eth_type = std::string("eth_type");
			const std::string& Params::beaconing = std::string("beaconing");
	const std::string& Params::its_aid = std::string("its_aid");		const std::string& Params::its_aid = std::string("its_aid");
	const std::string& Params::ssp = std::string("ssp");		const std::string& Params::ssp = std::string("ssp");
	const std::string& Params::gn_payload = std::string("gn_payload");		const std::string& Params::gn_payload = std::string("gn_payload");

ccsrc/Protocols/ETH/EthernetLayer.cc

+17 −9

Original line number	Original line	Diff line number	Diff line
	@@ -16,24 +16,32 @@ void EthernetLayer::sendData(OCTETSTRING& data, Params& params) {
	loggers::get_instance().log_msg(">>> EthernetLayer::sendData: ", data);		loggers::get_instance().log_msg(">>> EthernetLayer::sendData: ", data);

	OCTETSTRING eth;		OCTETSTRING eth;
	Params::const_iterator it = params.find(Params::mac_dst); // Find in provided parameters		// Destination MAC address
			Params::const_iterator it = params.find(Params::mac_dst); // Find in provided parameters, params
	if (it != params.cend()) {		if (it != params.cend()) {
	eth = str2oct(CHARSTRING(it->second.c_str()));		eth = str2oct(CHARSTRING(it->second.c_str()));
	} else {		} else {
	it = _params.find(Params::mac_dst); // Find in layer parameters		it = _params.find(Params::mac_dst); // Find in layer parameters, _params
	if (it != _params.cend()) {		if (it != _params.cend()) {
	eth = str2oct(CHARSTRING(it->second.c_str()));		eth = str2oct(CHARSTRING(it->second.c_str()));
	} else {		} else {
	eth = str2oct(CHARSTRING(_params["mac_bc"].c_str()));		eth = str2oct(CHARSTRING(_params[Params::mac_bc].c_str()));
	}		}
	}		}
	it = _params.find(Params::mac_src); // Find in layer parameters		// Source MAC address
			it = params.find(Params::mac_src); // Find in provided parameters, params
			if (it != params.cend()) {
			eth += str2oct(CHARSTRING(it->second.c_str()));
			} else {
			it = _params.find(Params::mac_src); // Find in layer parameters, _params
	if (it != _params.cend()) {		if (it != _params.cend()) {
	eth += str2oct(CHARSTRING(it->second.c_str()));		eth += str2oct(CHARSTRING(it->second.c_str()));
	} else {		} else {
	eth += str2oct(CHARSTRING(_params["mac_bc"].c_str()));		const unsigned char null_mac[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
			eth += OCTETSTRING(sizeof(null_mac), static_cast<const unsigned char *>(null_mac));
			}
	}		}
	it = _params.find("eth_type"); // Find in layer parameters		it = _params.find(Params::eth_type); // Find in layer parameters
	if (it != params.cend()) {		if (it != params.cend()) {
	eth += str2oct(CHARSTRING(it->second.c_str()));		eth += str2oct(CHARSTRING(it->second.c_str()));
	} else {		} else {

ccsrc/Protocols/GeoNetworking/GeoNetworkingLayer.cc

+21 −76

Original line number	Original line	Diff line number	Diff line
	@@ -7,7 +7,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(NULL), _thread(NULL), _sendData(), _running(FALSE) {		GeoNetworkingLayer::GeoNetworkingLayer(const std::string & p_type, const std::string & param) : TLayer<LibItsGeoNetworking__TestSystem::GeoNetworkingPort>(p_type), _params(), _codec(), _beacon(NULL), _sendData() {
	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
	Params::convert(_params, param);		Params::convert(_params, param);
	@@ -33,17 +33,12 @@ GeoNetworkingLayer::GeoNetworkingLayer(const std::string & p_type, const std::st
	_params.insert(std::pair<std::string, std::string>(std::string("mac_bc"), "FFFFFFFFFFFF"));		_params.insert(std::pair<std::string, std::string>(std::string("mac_bc"), "FFFFFFFFFFFF"));
	}		}
	fill_beacon(latitude, longitude, ll_address);		fill_beacon(latitude, longitude, ll_address);
	// Prepare the static part of the TestSystem beacon		} // End of constructor
	it = _params.find("");
	if ((it != _params.cend()) && (it->second.compare("1") == 0)) {
	start_beaconing();
	}
	}

	GeoNetworkingLayer::~GeoNetworkingLayer() {		GeoNetworkingLayer::~GeoNetworkingLayer() {
	stop_beaconing();
	delete _beacon;		} // End of destructor
	}
	void GeoNetworkingLayer::sendMsg(const LibItsGeoNetworking__TestSystem::GeoNetworkingReq& p, Params& params) {		void GeoNetworkingLayer::sendMsg(const LibItsGeoNetworking__TestSystem::GeoNetworkingReq& p, Params& params) {
	loggers::get_instance().log(">>> GeoNetworkingLayer::sendMsg");		loggers::get_instance().log(">>> GeoNetworkingLayer::sendMsg");

	@@ -108,75 +103,25 @@ void GeoNetworkingLayer::receiveData(OCTETSTRING& data, Params& params) {
	toAllUpperPorts(p, params);		toAllUpperPorts(p, params);
	}		}

	void GeoNetworkingLayer::start_beaconing() {		void GeoNetworkingLayer::send_beacon() {
	loggers::get_instance().log(">>> GeoNetworkingLayer::start_beaconing");		loggers::get_instance().log(">>> GeoNetworkingLayer::send_beacon");
			ExtendedHeader* eh = static_cast<ExtendedHeader *>(_beacon->gnPacket().packet().extendedHeader().get_opt_value());
	// 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) {
	loggers::get_instance().error("GeoNetworkingLayer::start_beaconing: Failed to start beaconing thread");
	}
	// Wait for the thread
	while (_running == FALSE) {
	std::this_thread::sleep_for(std::chrono::milliseconds(100));
	}
	// Thread was started
	loggers::get_instance().log("<<< PcapLayer::PcapLayer");
	}

	void GeoNetworkingLayer::stop_beaconing() {
	loggers::get_instance().log(">>> GeoNetworkingLayer::stop_beaconing");
	if (_thread != NULL) {
	_running = FALSE;
	// Wait for the working thread to terminate
	_thread->join();
	loggers::get_instance().log("GeoNetworkingLayer::stop_beaconing: Thread were stops");
	_thread = NULL;
	}
	}

	void* GeoNetworkingLayer::run_beaconing(void* p_this) {
	loggers::get_instance().log(">>> GeoNetworkingLayer::run_beaconing");

	// Pointer the main object
	GeoNetworkingLayer& p = static_cast<GeoNetworkingLayer >(p_this);
	Params params(p._params);
	std::chrono::milliseconds expiry(1000); // Default is set to 1 second
	Params::const_iterator it = params.find("TsBeaconInterval");
	if (it != params.cend()) {
	expiry = std::chrono::milliseconds(std::stoul(it->second));
	}
	ExtendedHeader* eh = static_cast<ExtendedHeader *>(p._beacon->gnPacket().packet().extendedHeader().get_opt_value());
	if (eh == NULL) {		if (eh == NULL) {
	loggers::get_instance().error("GeoNetworkingLayer::run_beaconing: Wrong cast");		loggers::get_instance().error("GeoNetworkingLayer::send_beacon: Wrong cast");
	}		}
	GeoNetworkingCodec codec;
	// Start beaconing
	p._running = TRUE;
	std::this_thread::sleep_for(std::chrono::milliseconds(100));
	while (p._running == TRUE) { // Loop while _running flag is up
	// 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_tme() & its_time_mod()
	eh->beaconHeader().srcPosVector().timestamp__() = ms;		eh->beaconHeader().srcPosVector().timestamp__() = ms;
	// Encode message using TITAN because of payload in omited		// Encode message using TITAN because of payload in omited
	TTCN_Buffer encoding_buffer;		TTCN_Buffer encoding_buffer;
	p._beacon->encode(*(p._beacon->get_descriptor()), encoding_buffer, TTCN_EncDec::CT_RAW);		_beacon->encode(*(_beacon->get_descriptor()), encoding_buffer, TTCN_EncDec::CT_RAW);
	OCTETSTRING data(encoding_buffer.get_len(), encoding_buffer.get_data());		OCTETSTRING data(encoding_buffer.get_len(), encoding_buffer.get_data());
	// Send it		// Send it
	p.sendData(data, params);		Params params(_params);
	// Timer		sendData(data, params);
	ms = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count() + expiry.count();
	while ((p._running == TRUE) && (ms > std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count()));
	} // End of 'while' statement<

	loggers::get_instance().log("<<< GeoNetworkingLayer::run_beaconing");		loggers::get_instance().log("<<< GeoNetworkingLayer::send_beacon");
	return NULL;		} // End of send_beacon method
	}

	void GeoNetworkingLayer::fill_beacon(INTEGER& p_latitude, INTEGER& p_longitude, OCTETSTRING& p_ll_address)		void GeoNetworkingLayer::fill_beacon(INTEGER& p_latitude, INTEGER& p_longitude, OCTETSTRING& p_ll_address)
	{		{

ccsrc/Protocols/GeoNetworking/GeoNetworkingLayer.hh

+3 −8

Original line number	Original line	Diff line number	Diff line
	@@ -21,16 +21,12 @@ class GeoNetworkingLayer : public TLayer<LibItsGeoNetworking__TestSystem::GeoNet
	Params _params;		Params _params;
	GeoNetworkingCodec _codec;		GeoNetworkingCodec _codec;
	LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu* _beacon;		LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu* _beacon;
	std::thread* _thread;		std::mutex _sendData; // FIXME To be removed, useless
	std::mutex _sendData;
	bool _running;

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

	static void* run_beaconing(void* p_this);

	public:		public:
	GeoNetworkingLayer() : TLayer<LibItsGeoNetworking__TestSystem::GeoNetworkingPort>(), _params(), _codec(), _beacon(NULL), _thread(NULL), _sendData(), _running(FALSE) {};		GeoNetworkingLayer() : TLayer<LibItsGeoNetworking__TestSystem::GeoNetworkingPort>(), _params(), _codec(), _beacon(NULL), _sendData() {};
	GeoNetworkingLayer(const std::string& p_type, const std::string& param);		GeoNetworkingLayer(const std::string& p_type, const std::string& param);
	virtual ~GeoNetworkingLayer();		virtual ~GeoNetworkingLayer();

	@@ -39,8 +35,7 @@ public:
	virtual void sendData(OCTETSTRING& data, Params& params);		virtual void sendData(OCTETSTRING& data, Params& params);
	virtual void receiveData(OCTETSTRING& data, Params& params);		virtual void receiveData(OCTETSTRING& data, Params& params);

	void start_beaconing();		void send_beacon();
	void stop_beaconing();
	};		};

	#endif		#endif

Admin message