GeoNetworking codecs ongoing (5f43df5b) · Commits · ITS - Intelligent Transport Systems / ITS

ccsrc/Protocols/GeoNetworking/GeoNetworkingCodec.cc

+149 −9

Original line number	Original line	Diff line number	Diff line
	#include <string>		#include <string>
	#include <typeinfo>		#include <typeinfo>

	#include "TTCN3.hh"		#//include <TTCN3.hh>

	#include "GeoNetworkingCodec.hh"		#include "GeoNetworkingCodec.hh"
	#include "loggers.hh"		#include "loggers.hh"

	#include "LibItsGeoNetworking_TypesAndValues.hh"		#include "LibItsGeoNetworking_TypesAndValues.hh"

			template <typename T_type> class OPTIONAL;
			class TTCN_EncDec;

	int GeoNetworkingCodec::encode (const LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu& msg, OCTETSTRING& data)		int GeoNetworkingCodec::encode (const LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu& msg, OCTETSTRING& data)
	{		{
	loggers::loggers::log_msg(">>> GeoNetworkingCodec::encode: ", (const Base_Type&)msg);		loggers::loggers::log_msg(">>> GeoNetworkingCodec::encode: ", (const Base_Type&)msg);
	TTCN_Buffer encoding_buffer;		TTCN_Buffer encoding_buffer;
	encode_(msg, LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu_descr_, encoding_buffer);		encode_(msg, LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu_descr_, encoding_buffer);
	data = OCTETSTRING(encoding_buffer.get_len(), encoding_buffer.get_data());		data = OCTETSTRING(encoding_buffer.get_len(), encoding_buffer.get_data());
			// Overwrite the payload length
			if (_ec.plLength_position != (unsigned int)-1) {
			loggers::loggers::log("GeoNetworkingCodec::encode: length=%d - plLength_position = %d - plLength = %d", data.lengthof(), _ec.plLength_position, _ec.plLength);
			unsigned char b[] = { (unsigned char)((_ec.plLength & 0x0000FF00) >> 8), (unsigned char)_ec.plLength };
			OCTETSTRING rpl(sizeof(b), b);
			data = replace(data, _ec.plLength_position, rpl.lengthof(), rpl);
			}

	return 0;		return 0;
	}		}

	int GeoNetworkingCodec::decode (const OCTETSTRING& data, LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu& msg)		int GeoNetworkingCodec::decode (const OCTETSTRING& data, LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu& msg)
	{		{
	loggers::loggers::log(">>> GeoNetworkingCodec::decode");		TTCN_Buffer decoding_buffer(data);
			loggers::loggers::log_to_hexa(">>> GeoNetworkingCodec::decode: decoding_buffer=", decoding_buffer);
			decode_(msg, LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu_descr_, decoding_buffer);
			loggers::loggers::log_msg("<<< GeoNetworkingCodec::decode: ", (const Base_Type&)msg);
			return 0;
			}

			int GeoNetworkingCodec::decode_ (Base_Type& type, const TTCN_Typedescriptor_t& field_descriptor, TTCN_Buffer& decoding_buffer)
			{
			loggers::loggers::log(">>> GeoNetworkingCodec::decode_: processing %s/%s", type.get_descriptor()->name, field_descriptor.name);

			if (dynamic_cast<Record_Type *>(&type) != NULL) {
			Record_Type& r = (Record_Type &)type;
			loggers::loggers::log("GeoNetworkingCodec::decode_: processing Record_Type %s", r.get_descriptor()->name);
			for(int i = 0; i < r.get_count(); i++) {
			loggers::loggers::log("GeoNetworkingCodec::decode_: processing %s/%s/%s", r.fld_name(i), r.fld_descr(i)->name, r.get_at(i)->get_descriptor()->name);
			// Base_Type b = ((Base_Type )(r.get_at(i)));
			// ((Base_Type )(r.get_at(i)))->decode_((const TTCN_Typedescriptor_t&)r.fld_descr(i), decoding_buffer, TTCN_EncDec::CT_RAW);
			if (decode_(((Base_Type )(r.get_at(i))), *(r.fld_descr(i)), decoding_buffer) == -1) {
			return -1;
			}
			} // End of 'for' statement
			} else if (std::string(type.get_descriptor()->name).compare("@LibItsGeoNetworking_TypesAndValues.ExtendedHeader") == 0) {
			if (_dc.next_header < 4) {
			LibItsGeoNetworking__TypesAndValues::ExtendedHeader extendedHeader;
			if (decode_extendedHeader(extendedHeader, decoding_buffer) == -1) {
			return -1;
			}
			type.set_value(extendedHeader.clone());
			} else {
			type.set_to_omit();
			}
			} else if (std::string(type.get_descriptor()->name).compare("@LibItsGeoNetworking_TypesAndValues.Payload") == 0) {
			if (_dc.plLength != 0) {
			const OPTIONAL<LibItsGeoNetworking__TypesAndValues::Payload> &v = dynamic_cast<const OPTIONAL<LibItsGeoNetworking__TypesAndValues::Payload> &>(type);
			loggers::loggers::log("GeoNetworkingCodec::decode_: Payload present: %d", v.is_present());
			// if (decode_(static_cast<LibItsGeoNetworking__TypesAndValues::Payload &>(*v.get_opt_value()), LibItsGeoNetworking__TypesAndValues::Payload_descr_, decoding_buffer) == -1) {
			// return -1;
			// }
			} else {
			type.set_to_omit();
			}
			} else if (std::string(type.get_descriptor()->name).compare("@LibItsGeoNetworking_TypesAndValues.DecodedPayload") == 0) {
			const OPTIONAL<LibItsGeoNetworking__TypesAndValues::DecodedPayload> &v = dynamic_cast<const OPTIONAL<LibItsGeoNetworking__TypesAndValues::DecodedPayload> &>(type);
			loggers::loggers::log("GeoNetworkingCodec::decode_: DecodedPayload present: %d", v.is_present());
			// TODO
			// if (decode_decodedPayload(static_cast<const LibItsGeoNetworking__TypesAndValues::DecodedPayload &>(*v.get_opt_value()), encoding_buffer) == -1) {
			// return -1;
			// }
			} else {
			loggers::loggers::log("GeoNetworkingCodec::decode_ (else): processing type %s/%s", type.get_descriptor()->name, field_descriptor.name);
			if (std::string(field_descriptor.name).compare("@LibItsGeoNetworking_TypesAndValues.CommonHeader.nextHeader") == 0) {
			// Store NextHeader field value and continue decoding
			_dc.next_header = (unsigned int)dynamic_cast<const Enum_Type &>(type).as_int();
			loggers::loggers::log("GeoNetworkingCodec::decode_: Storing next_header %d for %s", _dc.next_header, field_descriptor.name);
			} else if (std::string(field_descriptor.name).compare("@LibItsGeoNetworking_TypesAndValues.CommonHeader.plLength") == 0) {
			// Store playload length and continue decoding
			type.decode(field_descriptor, decoding_buffer, TTCN_EncDec::CT_RAW);
			_dc.plLength = dynamic_cast<const OCTETSTRING &>(type).lengthof();
			loggers::loggers::log("GeoNetworkingCodec::decode_: Storing position payload length: %d", _dc.plLength);
			} else if (std::string(field_descriptor.name).compare("@LibItsGeoNetworking_TypesAndValues.Payload.rawPayload") == 0) {
			// Store playload length and continue decoding
			_dc.plLength = dynamic_cast<const OCTETSTRING &>(type).lengthof();
			loggers::loggers::log("GeoNetworkingCodec::decode_: Storing payload length %d for %s", _dc.plLength, field_descriptor.name);
			} else {
			type.decode(field_descriptor, decoding_buffer, TTCN_EncDec::CT_RAW);
			}
			}

			loggers::loggers::log_msg("<<< GeoNetworkingCodec::decode_: ", type);
			loggers::loggers::log_to_hexa("<<< GeoNetworkingCodec::decode_: decoding_buffer=", decoding_buffer);

	return 0;		return 0;
	}		}

	@@ -65,15 +147,23 @@ int GeoNetworkingCodec::encode_ (const Base_Type& type, const TTCN_Typedescripto
	}		}
	} else {		} else {
	loggers::loggers::log("GeoNetworkingCodec::encode_ (else): processing type %s/%s", type.get_descriptor()->name, field_descriptor.name);		loggers::loggers::log("GeoNetworkingCodec::encode_ (else): processing type %s/%s", type.get_descriptor()->name, field_descriptor.name);
	if (std::string(field_descriptor.name).compare("@LibItsGeoNetworking_TypesAndValues.CommonHeader.plLength") == 0) {		if (std::string(field_descriptor.name).compare("@LibItsGeoNetworking_TypesAndValues.CommonHeader.nextHeader") == 0) {
			// Store NextHeader field value and continue encoding
			_ec.next_header = (unsigned int)dynamic_cast<const Enum_Type &>(type).as_int();
			loggers::loggers::log("GeoNetworkingCodec::encode_: Storing next_header %d for %s", _ec.next_header, field_descriptor.name);
			} else if (std::string(field_descriptor.name).compare("@LibItsGeoNetworking_TypesAndValues.CommonHeader.plLength") == 0) {
	// Store TTCN_Buffer position and continue encoding		// Store TTCN_Buffer position and continue encoding
	_plLength_position = encoding_buffer.get_pos_bit();		_ec.plLength_position = encoding_buffer.get_len();
	loggers::loggers::log("GeoNetworkingCodec::encode_: Storing position %d for %s", _plLength_position, field_descriptor.name);		loggers::loggers::log("GeoNetworkingCodec::encode_: Storing position %d for %s", _ec.plLength_position, field_descriptor.name);
			} else if (std::string(field_descriptor.name).compare("@LibItsGeoNetworking_TypesAndValues.Payload.rawPayload") == 0) {
			// Store playload length and continue encoding
			_ec.plLength = dynamic_cast<const OCTETSTRING &>(type).lengthof();
			loggers::loggers::log("GeoNetworkingCodec::encode_: Storing payload length %d for %s", _ec.plLength, field_descriptor.name);
	}		}
	type.encode(field_descriptor, encoding_buffer, TTCN_EncDec::CT_RAW);		type.encode(field_descriptor, encoding_buffer, TTCN_EncDec::CT_RAW);
	}		}
	loggers::loggers::log_to_hexa("GeoNetworkingCodec::encode_: encoding_buffer=", encoding_buffer);

			loggers::loggers::log_to_hexa("<<<GeoNetworkingCodec::encode_: encoding_buffer=", encoding_buffer);
	return 0;		return 0;
	}		}

	@@ -127,6 +217,56 @@ int GeoNetworkingCodec::encode_extendedHeader(const LibItsGeoNetworking__TypesAn
	return result;		return result;
	}		}

			int GeoNetworkingCodec::decode_extendedHeader(LibItsGeoNetworking__TypesAndValues::ExtendedHeader& u, TTCN_Buffer& decoding_buffer) {
			loggers::loggers::log(">>> GeoNetworkingCodec::decode_extendedHeader: processing %s", u.get_descriptor()->name);

			int result = -1;
			// switch (u.get_selection()) {
			// case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::UNBOUND_VALUE:
			// TTCN_error("GeoNetworkingCodec::decode_extendedHeader: Invalid selection in unbound union");
			// break;
			// case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_geoUnicastHeader:
			// loggers::loggers::log("GeoNetworkingCodec::decode_extendedHeader: processing type %s", u.geoUnicastHeader().get_descriptor()->name);
			// result = decode_(u.geoUnicastHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_geoUnicastHeader_descr_, encoding_buffer);
			// break;
			// case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_tsbHeader:
			// loggers::loggers::log("GeoNetworkingCodec::decode_extendedHeader: processing type %s", u.tsbHeader().get_descriptor()->name);
			// result = decode_(u.tsbHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_tsbHeader_descr_, encoding_buffer);
			// break;
			// case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_shbHeader:
			// loggers::loggers::log("GeoNetworkingCodec::decode_extendedHeader: processing type %s", u.shbHeader().get_descriptor()->name);
			// result = decode_(u.shbHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_shbHeader_descr_, encoding_buffer);
			// break;
			// case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_geoBroadcastHeader:
			// loggers::loggers::log("GeoNetworkingCodec::decode_extendedHeader: processing type %s", u.geoBroadcastHeader().get_descriptor()->name);
			// result = decode_(u.geoBroadcastHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_geoBroadcastHeader_descr_, encoding_buffer);
			// break;
			// case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_geoAnycastHeader:
			// loggers::loggers::log("GeoNetworkingCodec::decode_extendedHeader: processing type %s", u.geoAnycastHeader().get_descriptor()->name);
			// result = decode_(u.geoAnycastHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_geoAnycastHeader_descr_, encoding_buffer);
			// break;
			// case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_beaconHeader:
			// loggers::loggers::log("GeoNetworkingCodec::decode_extendedHeader: processing type %s", u.beaconHeader().get_descriptor()->name);
			// result = decode_(u.beaconHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_beaconHeader_descr_, encoding_buffer);
			// break;
			// case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_anyHeader:
			// loggers::loggers::log("GeoNetworkingCodec::decode_extendedHeader: processing type %s", u.anyHeader().get_descriptor()->name);
			// result = decode_(u.anyHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_anyHeader_descr_, encoding_buffer);
			// break;
			// case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_lsRequestHeader:
			// loggers::loggers::log("GeoNetworkingCodec::decode_extendedHeader: processing type %s", u.lsRequestHeader().get_descriptor()->name);
			// result = decode_(u.lsRequestHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_lsRequestHeader_descr_, encoding_buffer);
			// break;
			// case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_lsReplyHeader:
			// loggers::loggers::log("GeoNetworkingCodec::decode_extendedHeader: processing type %s", u.lsReplyHeader().get_descriptor()->name);
			// result = decode_(u.lsReplyHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_lsReplyHeader_descr_, encoding_buffer);
			// break;
			// default: TTCN_error("GeoNetworkingCodec::decode_extendedHeader: Invalid selection in union is_bound");
			// } // End of 'switch' statement

			return result;
			}

	int GeoNetworkingCodec::encode_decodedPayload(const LibItsGeoNetworking__TypesAndValues::DecodedPayload& u, TTCN_Buffer& encoding_buffer) {		int GeoNetworkingCodec::encode_decodedPayload(const LibItsGeoNetworking__TypesAndValues::DecodedPayload& u, TTCN_Buffer& encoding_buffer) {
	loggers::loggers::log(">>> GeoNetworkingCodec::encode_decodedPayload: processing %s", u.get_descriptor()->name);		loggers::loggers::log(">>> GeoNetworkingCodec::encode_decodedPayload: processing %s", u.get_descriptor()->name);

ccsrc/Protocols/GeoNetworking/GeoNetworkingCodec.hh

+36 −10

Original line number	Original line	Diff line number	Diff line
	@@ -2,25 +2,51 @@
	#define GNCODEC_H		#define GNCODEC_H
	#include "Codec.hh"		#include "Codec.hh"

			class Base_Type;
			class OCTETSTRING;
			class TTCN_Typedescriptor_t;
			class TTCN_Buffer;


	namespace LibItsGeoNetworking__TypesAndValues {		namespace LibItsGeoNetworking__TypesAndValues {
	class GeoNetworkingPdu;		class GeoNetworkingPdu;
	class ExtendedHeader;		class ExtendedHeader;
	class DecodedPayload;		class DecodedPayload;
	}		}

			struct Encoding_Context {
			unsigned char next_header; // FIXME Useless?
			unsigned int plLength_position;
			unsigned int plLength;

			Encoding_Context() { next_header = 0xff; plLength_position = -1; plLength = -1; }
			};

			struct Decoding_Context {
			unsigned char next_header; // FIXME Useless?
			unsigned int plLength;

			Decoding_Context() { next_header = 0xff; plLength = -1; }
			};

	class GeoNetworkingCodec : public Codec<LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu, LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu> {		class GeoNetworkingCodec : public Codec<LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu, LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu> {

	unsigned int _plLength_position;		Encoding_Context _ec;
			Decoding_Context _dc;

	int encode_ (const Base_Type& type, const TTCN_Typedescriptor_t& field_descriptor, TTCN_Buffer& encoding_buffer);		int encode_ (const Base_Type& type, const TTCN_Typedescriptor_t& field_descriptor, TTCN_Buffer& encoding_buffer);
	int encode_extendedHeader(const LibItsGeoNetworking__TypesAndValues::ExtendedHeader& u, TTCN_Buffer& encoding_buffer);		int encode_extendedHeader(const LibItsGeoNetworking__TypesAndValues::ExtendedHeader& u, TTCN_Buffer& encoding_buffer);
	int encode_decodedPayload(const LibItsGeoNetworking__TypesAndValues::DecodedPayload& u, TTCN_Buffer& encoding_buffer);		int encode_decodedPayload(const LibItsGeoNetworking__TypesAndValues::DecodedPayload& u, TTCN_Buffer& encoding_buffer);

			int decode_ (Base_Type& type, const TTCN_Typedescriptor_t& field_descriptor, TTCN_Buffer& decoding_buffer);
			int decode_extendedHeader(LibItsGeoNetworking__TypesAndValues::ExtendedHeader& u, TTCN_Buffer& decoding_buffer);


	public:		public:
	GeoNetworkingCodec() : _plLength_position(0) {};		GeoNetworkingCodec() : _ec(), _dc() {};

	virtual int encode (const LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu&, OCTETSTRING& data);		virtual int encode (const LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu& msg, OCTETSTRING& data);
	virtual int decode (const OCTETSTRING& data, LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu&);		virtual int decode (const OCTETSTRING& data, LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu& msg);
	};		};

	#endif		#endif

ccsrc/Protocols/GeoNetworking/GeoNetworkingLayer.cc

0 → 100644

+48 −0

Original line number	Original line	Diff line number	Diff line
			#include "GeoNetworkingLayer.hh"
			#include "GeoNetworkingTypes.hh"

			#include "loggers.hh"

			void GeoNetworkingLayer::sendMsg(const LibItsGeoNetworking__TestSystem::GeoNetworkingReq& p, const Params& params) {
			loggers::loggers::log(">>> GeoNetworkingLayer::sendMsg");
			const LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu & pdu = p.msgOut();
			OCTETSTRING data;
			_codec.encode(pdu, data);
			const unsigned char mac_address[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
			data += OCTETSTRING(sizeof(mac_address), static_cast<const unsigned char *>(mac_address));
			sendData(data, params);
			}

			void GeoNetworkingLayer::sendData(const OCTETSTRING& data, const Params& params) {
			sendToAllLayers(data, params);
			}

			void GeoNetworkingLayer::receiveData(const OCTETSTRING& data, const Params& info) {
			LibItsGeoNetworking__TestSystem::GeoNetworkingInd p;
			// _codec.decode(data, p);

			toAllUpperPorts(p, info);

			// if (p.payload().is_present()) {
			// toAllUpperLayers(p.payload()().rawPayload(), info);
			// }
			}

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

			GeoNetworkingFactory::GeoNetworkingFactory() {
			// register factory
			LayerStackBuilder::RegisterLayerFactory("GeoNetworking", this);
			}

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

			GeoNetworkingFactory GeoNetworkingFactory::_f;

ccsrc/Protocols/GeoNetworking/GeoNetworkingLayer.hh

0 → 100644

+23 −0

Original line number	Original line	Diff line number	Diff line
			#ifndef GEONETWORKING_LAYER_H
			#define GEONETWORKING_LAYER_H
			#include "Layer.hh"
			#include "GeoNetworkingCodec.hh"

			namespace LibItsGeoNetworking__TestSystem {
			class GeoNetworkingPort;
			class GeoNetworkingReq;
			}

			class GeoNetworkingLayer : public TLayer<LibItsGeoNetworking__TestSystem::GeoNetworkingPort> {
			GeoNetworkingCodec _codec;
			public:
			inline GeoNetworkingLayer():TLayer<LibItsGeoNetworking__TestSystem::GeoNetworkingPort>(){}
			virtual ~GeoNetworkingLayer(){}

			void sendMsg(const LibItsGeoNetworking__TestSystem::GeoNetworkingReq&, const Params& param);

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

			#endif

ccsrc/Protocols/GeoNetworking/GeoNetworking_Types.hh→ccsrc/Protocols/GeoNetworking/GeoNetworkingTypes.hh

+0 −0

File moved.

View file