Layers ongoing (2fae064f) · Commits · ITS - Intelligent Transport Systems / ITS

ccsrc/Ports/LibIts_ports/GN_ports/GeoNetworkingPort.cc

+1 −1

Original line number	Diff line number	Diff line
		@@ -68,7 +68,7 @@ namespace LibItsGeoNetworking__TestSystem {
		loggers::get_instance().error("GeoNetworkingPort::user_map: No layers defined in configuration file");
		}

		static_cast<GeoNetworkingLayer *>(_layer)->start_beaconing();
		//static_cast<GeoNetworkingLayer *>(_layer)->start_beaconing();
		}

		void GeoNetworkingPort::user_unmap(const char * system_port)

ccsrc/Ports/LibIts_ports/GN_ports/UpperTesterPort_GN.partC

+41 −8

Original line number	Diff line number	Diff line
		#include "UpperTesterLayer.hh"
		#include "loggers.hh"

		//=============================================================================
		namespace LibItsGeoNetworking__TestSystem {

		UpperTesterPort::UpperTesterPort(const char *par_port_name)
		: UpperTesterPort_BASE(par_port_name)
		: UpperTesterPort_BASE(par_port_name), _cfg_params(), _layer_params(), _layer(NULL), _time_key("UpperTesterPort::outgoing_send")
		{
		loggers::get_instance().log("UpperTesterPort::UpperTesterPort");

		}

		UpperTesterPort::~UpperTesterPort()
		{

		if (_layer != NULL) {
		delete _layer;
		}
		}

		void UpperTesterPort::set_parameter(const char * /parameter_name/,
		const char * /parameter_value/)
		void UpperTesterPort::set_parameter(const char * parameter_name, const char * parameter_value)
		{

		loggers::get_instance().log("UpperTesterPort::set_parameter: %s=%s", parameter_name, parameter_value);
		_cfg_params.insert(std::pair<std::string, std::string>(std::string(parameter_name), std::string(parameter_value)));
		_cfg_params.log();
		}

		/*void UpperTesterPort::Handle_Fd_Event(int fd, boolean is_readable,
		@@ -38,14 +45,31 @@ void UpperTesterPort::Handle_Fd_Event_Readable(int /fd/)

		/void UpperTesterPort::Handle_Timeout(double time_since_last_call) {}/

		void UpperTesterPort::user_map(const char * /system_port/)
		void UpperTesterPort::user_map(const char * system_port)
		{
		loggers::get_instance().log(">>> UpperTesterPort::user_map: %s", system_port);
		// Build layer stack
		Params::iterator it = _cfg_params.find(std::string("params"));
		if (it != _cfg_params.end()) {
		loggers::get_instance().log("UpperTesterPort::user_map: %s", it->second.c_str());
		_layer = LayerStackBuilder::GetInstance()->createLayerStack(it->second.c_str());
		if (static_cast<UpperTesterLayer *>(_layer) == NULL) {
		loggers::get_instance().error("UpperTesterPort::user_map: Invalid stack configuration: %s", it->second.c_str());
		}
		static_cast<UpperTesterLayer *>(_layer)->addUpperPort(this);
		} else {
		loggers::get_instance().error("UpperTesterPort::user_map: No layers defined in configuration file");
		}

		}

		void UpperTesterPort::user_unmap(const char * /system_port/)
		void UpperTesterPort::user_unmap(const char * system_port)
		{

		loggers::get_instance().log(">>> UpperTesterPort::user_unmap: %s", system_port);
		if (_layer != NULL) {
		delete _layer;
		_layer = NULL;
		}
		}

		void UpperTesterPort::user_start()
		@@ -78,4 +102,13 @@ void UpperTesterPort::outgoing_send(const LibItsGeoNetworking__TypesAndValues::U

		}

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

		}

		} /* end of namespace */

ccsrc/Ports/LibIts_ports/GN_ports/UpperTesterPort_GN.partH

+10 −0

Original line number	Diff line number	Diff line
		#include "Layer.hh"
		#include "Params.hh"

		//=============================================================================
		#include "LibItsGeoNetworking_TestSystem.hh"
		namespace LibItsGeoNetworking__TestSystem {

		class UpperTesterPort : public UpperTesterPort_BASE {
		Params _cfg_params;
		Params _layer_params;
		Layer * _layer;
		std::string _time_key;

		public:
		UpperTesterPort(const char *par_port_name = NULL);
		~UpperTesterPort();
		@@ -10,6 +18,8 @@ public:
		void set_parameter(const char *parameter_name,
		const char *parameter_value);

		void receiveMsg (const Base_Type&, const Params&);

		private:
		/* void Handle_Fd_Event(int fd, boolean is_readable,
		boolean is_writable, boolean is_error); */

ccsrc/Protocols/Pcap/PcapLayer.cc

+8 −2

Original line number	Diff line number	Diff line
		@@ -72,10 +72,16 @@ PcapLayer::PcapLayer(const std::string& p_type, const std::string& param) : Laye
		}
		}
		// Setup filter
		std::string filter(" not ether src " + _params[Params::mac_src]);
		std::string filter = "";
		if (!_params[Params::mac_src].empty()) {
		filter = " not ether src " + _params[Params::mac_src];
		}
		it = _params.find(std::string("filter"));
		if ((it != _params.end()) && !it->second.empty()) {
		filter += " and " + _params["filter"];
		if (!filter.empty()) {
		filter += " and ";
		}
		filter += _params["filter"];
		} // else nothing to do
		// Skip our own MAC address
		loggers::get_instance().log("PcapLayer::PcapLayer: Filter: %s", filter.c_str());

ccsrc/Protocols/UDP/UdpLayer.cc

0 → 100644

+117 −0

Original line number	Diff line number	Diff line
		#include "UdpLayer.hh"
		#include "loggers.hh"

		UdpLayer::UdpLayer(const std::string & p_type, const std::string & param) : Layer(p_type), _params() {
		loggers::get_instance().log(">>> UdpLayer::UdpLayer: %s, %s", to_string().c_str(), param.c_str());
		// Setup parameters
		Params::convert(_params, param);
		Params::const_iterator it = _params.find("src_ip");
		if (it == _params.cend()) {
		_params.insert(std::pair<std::string, std::string>(std::string("src_ip"), "127.0.0.1"));
		}
		it = _params.find("src_port");
		if (it == _params.cend()) {
		_params.insert(std::pair<std::string, std::string>(std::string("src_port"), "12345"));
		}
		it = _params.find("dst_ip");
		if (it == _params.cend()) {
		_params.insert(std::pair<std::string, std::string>(std::string("dst_ip"), "127.0.0.1"));
		}
		it = _params.find("dst_port");
		if (it == _params.cend()) {
		_params.insert(std::pair<std::string, std::string>(std::string("dst_port"), "12346"));
		}

		//_params.log();
		}

		void UdpLayer::sendData(OCTETSTRING& data, Params& params) {
		loggers::get_instance().log_msg(">>> UdpLayer::sendData: ", data);

		// Create IP/UDP packet
		unsigned int len = sizeof(struct iphdr) + sizeof(struct udphdr) + data.lengthof();
		unsigned char *buffer = new unsigned char[len];
		// Set ip header
		_iphdr = (struct iphdr *)buffer;
		_daddr.sin_family = AF_INET;
		_saddr.sin_family = AF_INET;
		Params::const_iterator it = _params.find("dst_port");
		_daddr.sin_port = htons(std::strtoul(it->second.c_str(), NULL, 10));
		it = _params.find("src_port");
		_saddr.sin_port = htons(std::strtoul(it->second.c_str(), NULL, 10));
		it = _params.find("dst_ip");
		inet_pton(AF_INET, it->second.c_str(), (struct in_addr *)&_daddr.sin_addr.s_addr);
		it = _params.find("src_ip");
		inet_pton(AF_INET, it->second.c_str(), (struct in_addr *)&_saddr.sin_addr.s_addr);
		_iphdr->ihl = 5;
		_iphdr->version = 4;
		_iphdr->tos = 0x0;
		_iphdr->id = 0;
		_iphdr->frag_off = htons(0x4000); /* Don't fragment */
		_iphdr->ttl = 64;
		_iphdr->tot_len = htons(sizeof(struct iphdr) + sizeof(struct udphdr) + data.lengthof());
		_iphdr->protocol = IPPROTO_UDP;
		_iphdr->saddr = _saddr.sin_addr.s_addr;
		_iphdr->daddr = _daddr.sin_addr.s_addr;
		_iphdr->check = 0;
		_iphdr->check = inetCsum((const void *)_iphdr, sizeof(struct iphdr));// The checksum should be calculated over the entire header with the checksum field set to 0, so that's what we do
		// Set udp header
		_udphdr = (struct udphdr *)(buffer + sizeof(struct iphdr));
		_udphdr->source = _saddr.sin_port;
		_udphdr->dest = _daddr.sin_port;
		_udphdr->len = htons(sizeof(struct udphdr) + data.lengthof());
		_udphdr->check = 0;
		// Set payload
		unsigned char *payload = buffer + sizeof(struct iphdr) + sizeof(struct udphdr);
		memcpy(payload, static_cast<const unsigned char *>(data), data.lengthof());
		// Send data lower layers
		OCTETSTRING udp(len, buffer);
		sendToAllLayers(udp, params);
		// Free buffer
		delete [] buffer;
		}

		void UdpLayer::receiveData(OCTETSTRING& data, Params& params) {
		loggers::get_instance().log_msg(">>> UdpLayer::receiveData: ", data);

		// Decode UDP packet
		receiveToAllLayers(data, params);
		}

		unsigned short UdpLayer::inetCsum(const void *buf, size_t hdr_len) {
		unsigned long sum = 0;
		const unsigned short *ip1;

		ip1 = (const unsigned short *) buf;
		while (hdr_len > 1)
		{
		sum += *ip1++;
		if (sum & 0x80000000)
		sum = (sum & 0xFFFF) + (sum >> 16);
		hdr_len -= 2;
		}

		while (sum >> 16)
		sum = (sum & 0xFFFF) + (sum >> 16);

		return(~sum);
		}
		class UdpFactory: public LayerFactory {
		static UdpFactory _f;
		public:
		UdpFactory();
		virtual Layer * createLayer(const std::string & type,
		const std::string & param);
		};

		UdpFactory::UdpFactory() {
		// register factory
		loggers::get_instance().log(">>> UdpFactory::UdpFactory");
		LayerStackBuilder::RegisterLayerFactory("UDP", this);
		}

		Layer * UdpFactory::createLayer(const std::string & type, const std::string & param) {
		return new UdpLayer(type, param);
		}

		UdpFactory UdpFactory::_f;