Skip to content
GitLab
Commit 9babe5b2 authored by garciay's avatar garciay
Browse files

GeoNetworking codecs & Layers ongoing

parent 19b549ff
Hide whitespace changes
Inline Side-by-side
ccsrc/Framework/src/LayerFactory.cc
View file @ 9babe5b2
......@@ -9,11 +9,12 @@ LayerStackBuilder * LayerStackBuilder::_instance = NULL;
// static functions
LayerStackBuilder * LayerStackBuilder::GetInstance()
{
return _instance ? _instance : _instance=new LayerStackBuilder();
return _instance ? _instance : _instance = new LayerStackBuilder();
}
void LayerStackBuilder::RegisterLayerFactory(const std::string & type, LayerFactory * f)
{
LayerStackBuilder::GetInstance()->registerLayerFactory(type, f);
LayerStackBuilder::GetInstance()->registerLayerFactory(type, f);
}
// member functions
......@@ -23,42 +24,49 @@ LayerStackBuilder::LayerStackBuilder()
void LayerStackBuilder::registerLayerFactory(const std::string & type, LayerFactory * f)
{
_fs[type] = f;
_fs[type] = f;
}
Layer* LayerStackBuilder::createLayerStack(const char* s)
{
loggers::loggers::log(">>> LayerStackBuilder::createLayerStack: %s", s);
Layer * up = NULL;
//parse str
std::regex rgx ("(\\w+)(\\((.*?)\\))?(\\/|$)");
std::smatch m;
std::string str = s;
try {
while(std::regex_search(str, m, rgx)) {
std::string mname = m[1];
loggers::loggers::log("LayerStackBuilder::createLayerStack: mname=%s", mname);
LayerFactoryMap::iterator it =_fs.find(mname);
if(it == _fs.end()){
throw (std::logic_error(mname + ": Unknown layer type"));
}
// TODO: parse parameters
loggers::loggers::log("LayerStackBuilder::createLayerStack: Create layer %s", it->first);
Layer * l = it->second->createLayer(mname, m[3]);
if(NULL == l){
throw (std::logic_error(mname + ": Layer creation error"));
}
Layer * up = NULL;
// Parse str
try {
std::regex rgx ("(\\w+)(\\((.*?)\\))?(\\/|$)");
std::string str = s;
std::sregex_iterator begin(str.cbegin(), str.cend(), rgx);
std::sregex_iterator end = std::sregex_iterator();
for (std::sregex_iterator it = begin; it != end; ++it) {
std::smatch m = *it;
loggers::loggers::log("LayerStackBuilder::createLayerStack: %d - %s - %s - %s - %s", m.size(), m[0].str().c_str(), m[1].str().c_str(), m[2].str().c_str(), m[3].str().c_str());
std::string mname = m[1].str();
if (mname.find_first_of('/') != std::string::npos) {
mname.replace(mname.find_first_of('/'), 1, "");
}
LayerFactoryMap::iterator i =_fs.find(mname);
if (i == _fs.end()) {
loggers::loggers::error("LayerStackBuilder::createLayerStack: %s: Unknown layer type", mname.c_str());
throw (std::logic_error(mname + ": Unknown layer type"));
}
// TODO: parse parameters
loggers::loggers::log("LayerStackBuilder::createLayerStack: Create layer %s", i->first.c_str());
Layer * l = i->second->createLayer(mname, m[3]);
if(NULL == l){
loggers::loggers::error("LayerStackBuilder::createLayerStack: %s: Layer creation error", mname.c_str());
throw (std::logic_error(mname + ": Layer creation error"));
}
l->addUpperLayer(up);
up = l;
}
}
catch(const std::logic_error& e){
if(up){
up->deleteLayer();
up = NULL;
}
}
return up;
l->addUpperLayer(up);
up = l;
}
}
catch(const std::logic_error& e){
if(up){
up->deleteLayer();
up = NULL;
}
}
return up;
}
ccsrc/Ports/LibIts_ports/GN_ports/GeoNetworkingPort.cc
View file @ 9babe5b2
......@@ -52,10 +52,10 @@ void GeoNetworkingPort::Handle_Fd_Event_Readable(int /*fd*/)
void GeoNetworkingPort::user_map(const char * system_port)
{
loggers::loggers::log("GeoNetworkingPort::user_map: %s", system_port);
//if (strcmp(parameter_name, "geoNetworkingPort") == 0);
// _layer = LayerStackBuilder::GetInstance()->createLayerStack("ETH(src_addr=00:00:00:00:00:00,FF:FF:FF:FF:Fsrc_addr=00:00:00:00:00:00,FF:FF:FF:FF:F)");
//}
std::map<std::string, std::string>::iterator it = _params.find(std::string("params"));
if (it != _params.end()) {
_layer = LayerStackBuilder::GetInstance()->createLayerStack(it->second.c_str());
}
}
void GeoNetworkingPort::user_unmap(const char * /*system_port*/)
......
ccsrc/Protocols/ETH/EthernetLayer.cc 0 → 100644
View file @ 9babe5b2
#include "EthernetLayer.hh"
#include "loggers.hh"
EthernetLayer::EthernetLayer(const std::string & type, const std::string & param) : EthernetLayer() {
loggers::loggers::log(">>> EthernetLayer::EthernetLayer: %s, %s", type.c_str(), param.c_str());
// Setup parameters
}
void EthernetLayer::sendData(const OCTETSTRING& data, const Params& params) {
}
void EthernetLayer::receiveData(const OCTETSTRING& data, const Params& info) {
}
class EthernetFactory: public LayerFactory {
static EthernetFactory _f;
public:
EthernetFactory();
virtual Layer * createLayer(const std::string & type,
const std::string & param);
};
EthernetFactory::EthernetFactory() {
// register factory
loggers::loggers::log(">>> EthernetFactory::EthernetFactory");
LayerStackBuilder::RegisterLayerFactory("ETH", this);
}
Layer * EthernetFactory::createLayer(const std::string & type, const std::string & param) {
return new EthernetLayer(type, param);
}
EthernetFactory EthernetFactory::_f;
ccsrc/Protocols/ETH/EthernetLayer.hh 0 → 100644
View file @ 9babe5b2
#ifndef ETHERNET_FINAL_LAYER_H
#define ETHERNET_FINAL_LAYER_H
#include "Layer.hh"
class EthernetLayer : public Layer {
public:
inline EthernetLayer() : Layer() {}
EthernetLayer(const std::string & type, const std::string & param);
virtual ~EthernetLayer() {}
virtual void sendData(const OCTETSTRING& data, const Params& params);
virtual void receiveData(const OCTETSTRING& data, const Params& info);
};
#endif
ccsrc/Protocols/GeoNetworking/GeoNetworkingCodec.cc
View file @ 9babe5b2
......@@ -50,54 +50,95 @@ int GeoNetworkingCodec::decode_ (Base_Type& type, const TTCN_Typedescriptor_t& f
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);
loggers::loggers::log("GeoNetworkingCodec::decode_ (else): processing type %s/%s - optional:%d", type.get_descriptor()->name, field_descriptor.name, type.is_optional());
if (std::string(field_descriptor.name).compare("@LibItsGeoNetworking_TypesAndValues.CommonHeader.nextHeader") == 0) {
// Decode NextHeader data strcuture
// Decode NextHeader data structure
type.decode(field_descriptor, decoding_buffer, TTCN_EncDec::CT_RAW);
// 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.headerTST") == 0) {
// Decode HeaderTST data structure
type.decode(field_descriptor, decoding_buffer, TTCN_EncDec::CT_RAW);
// Store HeaderTST field value and continue decoding
// const LibItsGeoNetworking__TypesAndValues::HeaderTST & h = dynamic_cast<const LibItsGeoNetworking__TypesAndValues::HeaderTST &>(type);
// switch (h.get_selection()) {
// case LibItsGeoNetworking__TypesAndValues::HeaderTST::ALT_anyHdr:
// _dc.header_type = (unsigned int)dynamic_cast<const Enum_Type &>(*h.anyHdr().get_at(0)).as_int();
// _dc.header_sub_type = (unsigned int)static_cast<int>(dynamic_cast<const INTEGER &>(*h.anyHdr().get_at(1)));
// break;
// case LibItsGeoNetworking__TypesAndValues::HeaderTST::ALT_beaconHdr:
// _dc.header_type = (unsigned int)dynamic_cast<const Enum_Type &>(*h.beaconHdr().get_at(0)).as_int();
// _dc.header_sub_type = (unsigned int)static_cast<int>(dynamic_cast<const INTEGER &>(*h.beaconHdr().get_at(1)));
// break;
// case LibItsGeoNetworking__TypesAndValues::HeaderTST::ALT_geoUnicastHdr:
// _dc.header_type = (unsigned int)dynamic_cast<const Enum_Type &>(*h.geoUnicastHdr().get_at(0)).as_int();
// _dc.header_sub_type = (unsigned int)static_cast<int>(dynamic_cast<const INTEGER &>(*h.geoUnicastHdr().get_at(1)));
// break;
// case LibItsGeoNetworking__TypesAndValues::HeaderTST::ALT_geoAnycastHdr:
// _dc.header_type = (unsigned int)dynamic_cast<const Enum_Type &>(*h.geoAnycastHdr().get_at(0)).as_int();
// _dc.header_sub_type = (unsigned int)static_cast<int>(dynamic_cast<const INTEGER &>(*h.geoAnycastHdr().get_at(1)));
// break;
// case LibItsGeoNetworking__TypesAndValues::HeaderTST::ALT_geoBroadcastHdr:
// _dc.header_type = (unsigned int)dynamic_cast<const Enum_Type &>(*h.geoBroadcastHdr().get_at(0)).as_int();
// _dc.header_sub_type = (unsigned int)static_cast<int>(dynamic_cast<const INTEGER &>(*h.geoBroadcastHdr().get_at(1)));
// break;
// case LibItsGeoNetworking__TypesAndValues::HeaderTST::ALT_tsbHdr:
// _dc.header_type = (unsigned int)dynamic_cast<const Enum_Type &>(*h.tsbHdr().get_at(0)).as_int();
// _dc.header_sub_type = (unsigned int)static_cast<int>(dynamic_cast<const INTEGER &>(*h.tsbHdr().get_at(1)));
// break;
// case LibItsGeoNetworking__TypesAndValues::HeaderTST::ALT_lsHdr:
// _dc.header_type = (unsigned int)dynamic_cast<const Enum_Type &>(*h.lsHdr().get_at(0)).as_int();
// _dc.header_sub_type = (unsigned int)static_cast<int>(dynamic_cast<const INTEGER &>(*h.lsHdr().get_at(1)));
// break;
// case LibItsGeoNetworking__TypesAndValues::HeaderTST::ALT_saHdr:
// _dc.header_type = (unsigned int)dynamic_cast<const Enum_Type &>(*h.saHdr().get_at(0)).as_int();
// _dc.header_sub_type = (unsigned int)static_cast<int>(dynamic_cast<const INTEGER &>(*h.saHdr().get_at(1)));
// break;
// default: TTCN_error("GeoNetworkingCodec::decode_: Invalid selection in union is_bound");
// } // End of 'switch' statement
} else if (std::string(field_descriptor.name).compare("@LibItsGeoNetworking_TypesAndValues.CommonHeader.plLength") == 0) {
// Decode plLength data strcuture
// Decode plLength data structure
type.decode(field_descriptor, decoding_buffer, TTCN_EncDec::CT_RAW);
// Store playload length and continue decoding
_dc.plLength = (unsigned int)static_cast<int>(dynamic_cast<const INTEGER &>(type));
// loggers::loggers::log("GeoNetworkingCodec::decode_: Storing position payload length: %d", _dc.plLength);
} else if (std::string(field_descriptor.name).compare("@LibItsGeoNetworking_TypesAndValues.GnNonSecuredPacket.extendedHeader") == 0) {
// Decode ExtendedHeader data structure
LibItsGeoNetworking__TypesAndValues::ExtendedHeader e;
e.decode(LibItsGeoNetworking__TypesAndValues::ExtendedHeader_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
if (e.is_bound()) {
// OPTIONAL<LibItsGeoNetworking__TypesAndValues::ExtendedHeader> o(e);
// loggers::loggers::log_msg("GeoNetworkingCodec::decode_: o = ", o);
dynamic_cast<OPTIONAL<LibItsGeoNetworking__TypesAndValues::ExtendedHeader> &>(type) = OPTIONAL<LibItsGeoNetworking__TypesAndValues::ExtendedHeader>(e);
loggers::loggers::log_msg("GeoNetworkingCodec::decode_: Set OPTIONAL to ", type);
} else {
loggers::loggers::log("GeoNetworkingCodec::decode_: Set OPTIONAL to omit");
dynamic_cast<OPTIONAL<LibItsGeoNetworking__TypesAndValues::ExtendedHeader> &>(type).set_to_omit();
}
} else if (std::string(type.get_descriptor()->name).compare("@LibItsGeoNetworking_TypesAndValues.GnNonSecuredPacket.payload") == 0) {
LibItsGeoNetworking__TypesAndValues::Payload p;
p.decode(LibItsGeoNetworking__TypesAndValues::Payload_descr_, decoding_buffer, TTCN_EncDec::CT_RAW);
loggers::loggers::log_msg("GeoNetworkingCodec::decode_: payload= ", p);
if (p.is_bound()) {
// OPTIONAL<LibItsGeoNetworking__TypesAndValues::ExtendedHeader> o(e);
// loggers::loggers::log_msg("GeoNetworkingCodec::decode_: o = ", o);
dynamic_cast<OPTIONAL<LibItsGeoNetworking__TypesAndValues::Payload> &>(type) = OPTIONAL<LibItsGeoNetworking__TypesAndValues::Payload>(p);
loggers::loggers::log_msg("GeoNetworkingCodec::decode_: Set OPTIONAL to ", type);
} else {
loggers::loggers::log("GeoNetworkingCodec::decode_: Set OPTIONAL to omit");
dynamic_cast<OPTIONAL<LibItsGeoNetworking__TypesAndValues::Payload> &>(type).set_to_omit();
}
} else if (std::string(type.get_descriptor()->name).compare("@LibItsGeoNetworking_TypesAndValues.decodedPayload") == 0) {
dynamic_cast<OPTIONAL<LibItsGeoNetworking__TypesAndValues::DecodedPayload> &>(type).set_to_omit();
} else if (std::string(field_descriptor.name).compare("@LibItsGeoNetworking_TypesAndValues.Payload.rawPayload") == 0) {
// Decode RawPayload data strcuture
// Decode RawPayload data structure
type.decode(field_descriptor, decoding_buffer, TTCN_EncDec::CT_RAW);
// Store it
const OCTETSTRING& s = dynamic_cast<const OCTETSTRING &>(type);
const unsigned char * p = static_cast<const unsigned char *>(s);
if (s.lengthof() <= _dc.plLength) {
if ((unsigned char)s.lengthof() <= _dc.plLength) {
_dc.payload.assign(p, p + s.lengthof());
} else {
_dc.payload.assign(p, p + _dc.plLength);
......@@ -159,7 +200,11 @@ int GeoNetworkingCodec::encode_ (const Base_Type& type, const TTCN_Typedescripto
// 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) {
} else if (std::string(field_descriptor.name).compare("@LibItsGeoNetworking_TypesAndValues.CommonHeader.headerType") == 0) {
// Store HeaderType field value and continue encoding
_ec.header_type = (unsigned int)dynamic_cast<const Enum_Type &>(type).as_int();
loggers::loggers::log("GeoNetworkingCodec::encode_: Storing header_type %d for %s", _ec.header_type, field_descriptor.name);
} else if (std::string(field_descriptor.name).compare("@LibItsGeoNetworking_TypesAndValues.CommonHeader.plLength") == 0) {
// Store TTCN_Buffer position and continue encoding
_ec.plLength_position = encoding_buffer.get_len();
loggers::loggers::log("GeoNetworkingCodec::encode_: Storing position %d for %s", _ec.plLength_position, field_descriptor.name);
......@@ -229,47 +274,53 @@ int GeoNetworkingCodec::decode_extendedHeader(LibItsGeoNetworking__TypesAndValue
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:
// size_t bitpos;
// _dc.header_type = (*decoding_buffer.get_read_data(&bitpos) & (1 << LibItsGeoNetworking__TypesAndValues::HeaderType_raw_::HeaderType_raw_.fieldlength)) >> LibItsGeoNetworking__TypesAndValues::HeaderType_raw_::HeaderType_raw_.fieldlength;
// switch (_dc.header_type) {
//
//// = 0, = 1, = 2, = 3, = 4, = 5, e__locationService = 6, e__serviceAnnouncement = 7, e__reserved = 8, UNKNOWN_VALUE = 9, UNBOUND_VALUE = 10
//
// case LibItsGeoNetworking__TypesAndValues::HeaderType::e__geoUnicast:
// 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);
// result = decode_(u.geoUnicastHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_geoUnicastHeader_descr_, decoding_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);
// case LibItsGeoNetworking__TypesAndValues::HeaderType::e__topologicallyScopedBroadcast:
// _dc.header_sub_type = (*decoding_buffer.get_read_data(&bitpos) & (1 << LibItsGeoNetworking__TypesAndValues::HeaderSubTypeTSB_raw_.fieldlength)) >> LibItsGeoNetworking__TypesAndValues::HeaderSubTypeTSB_raw_.fieldlength;
// if (header_sub_type == 0) {
// loggers::loggers::log("GeoNetworkingCodec::decode_extendedHeader: processing type %s", u.shbHeader().get_descriptor()->name);
// result = decode_(u.shbHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_shbHeader_descr_, decoding_buffer);
// } else {
// loggers::loggers::log("GeoNetworkingCodec::decode_extendedHeader: processing type %s", u.tsbHeader().get_descriptor()->name);
// result = decode_(u.tsbHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_tsbHeader_descr_, decoding_buffer);
// }
// break;
// case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_geoBroadcastHeader:
// case LibItsGeoNetworking__TypesAndValues::HeaderType::e__geoBroadcast:
// 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);
// result = decode_(u.geoBroadcastHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_geoBroadcastHeader_descr_, decoding_buffer);
// break;
// case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_geoAnycastHeader:
// case LibItsGeoNetworking__TypesAndValues::HeaderType::e__geoAnycast:
// 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);
// result = decode_(u.geoAnycastHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_geoAnycastHeader_descr_, decoding_buffer);
// break;
// case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_beaconHeader:
// case LibItsGeoNetworking__TypesAndValues::HeaderType::e__beacon:
// 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);
// result = decode_(u.beaconHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_beaconHeader_descr_, decoding_buffer);
// break;
// case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_anyHeader:
// case LibItsGeoNetworking__TypesAndValues::HeaderType::e__any:
// 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);
// result = decode_(u.anyHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_anyHeader_descr_, decoding_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);
// case LibItsGeoNetworking__TypesAndValues::HeaderType::e__locationService:
// _dc.header_sub_type = (*decoding_buffer.get_read_data(&bitpos) & (1 << LibItsGeoNetworking__TypesAndValues::HeaderSubTypeLs_raw_.fieldlength)) >> LibItsGeoNetworking__TypesAndValues::HeaderSubTypeLs_raw_.fieldlength;
// if (header_sub_type == 0) {
// loggers::loggers::log("GeoNetworkingCodec::decode_extendedHeader: processing type %s", u.lsRequestHeader().get_descriptor()->name);
// result = decode_(u.lsRequestHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_lsRequestHeader_descr_, decoding_buffer);
// } else {
// loggers::loggers::log("GeoNetworkingCodec::decode_extendedHeader: processing type %s", u.lsReplyHeader().get_descriptor()->name);
// result = decode_(u.lsReplyHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_lsReplyHeader_descr_, decoding_buffer);
// }
// break;
// default: TTCN_error("GeoNetworkingCodec::decode_extendedHeader: Invalid selection in union is_bound");
// default: TTCN_error("GeoNetworkingCodec::decode_extendedHeader: Invalid selection in union");
// } // End of 'switch' statement
return result;
......
ccsrc/Protocols/GeoNetworking/GeoNetworkingCodec.hh
View file @ 9babe5b2
......@@ -19,18 +19,21 @@ namespace LibItsGeoNetworking__TypesAndValues {
struct Encoding_Context {
unsigned char next_header; // FIXME Useless?
unsigned char header_type; // FIXME Useless?
unsigned int plLength_position;
unsigned int plLength;
Encoding_Context() { next_header = 0xff; plLength_position = -1; plLength = -1; }
Encoding_Context() { next_header = 0xff; header_type = 0xff; plLength_position = -1; plLength = -1; }
};
struct Decoding_Context {
unsigned char next_header; // FIXME Useless?
unsigned char header_type; // FIXME Useless?
unsigned char header_sub_type; // FIXME Useless?
unsigned int plLength;
std::vector<unsigned char> payload;
Decoding_Context() : payload() { next_header = 0xff; plLength = -1; }
Decoding_Context() : payload() { next_header = 0xff; header_type = 0xff; header_sub_type = 0xff; plLength = -1; }
};
class GeoNetworkingCodec : public Codec<LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu, LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu> {
......
ccsrc/Protocols/GeoNetworking/GeoNetworkingLayer.cc
View file @ 9babe5b2
......@@ -3,6 +3,11 @@
#include "loggers.hh"
GeoNetworkingLayer::GeoNetworkingLayer(const std::string & type, const std::string & param) : GeoNetworkingLayer() {
loggers::loggers::log(">>> GeoNetworkingLayer::GeoNetworkingLayer: %s, %s", type.c_str(), param.c_str());
}
void GeoNetworkingLayer::sendMsg(const LibItsGeoNetworking__TestSystem::GeoNetworkingReq& p, const Params& params) {
loggers::loggers::log(">>> GeoNetworkingLayer::sendMsg");
const LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu & pdu = p.msgOut();
......@@ -38,11 +43,12 @@ public:
GeoNetworkingFactory::GeoNetworkingFactory() {
// register factory
LayerStackBuilder::RegisterLayerFactory("GeoNetworking", this);
loggers::loggers::log(">>> GeoNetworkingFactory::GeoNetworkingFactory");
LayerStackBuilder::RegisterLayerFactory("GN", this);
}
Layer * GeoNetworkingFactory::createLayer(const std::string & type, const std::string & param) {
return new GeoNetworkingLayer();
return new GeoNetworkingLayer(type, param);
}
GeoNetworkingFactory GeoNetworkingFactory::_f;
ccsrc/Protocols/GeoNetworking/GeoNetworkingLayer.hh
View file @ 9babe5b2
......@@ -11,7 +11,8 @@ namespace LibItsGeoNetworking__TestSystem {
class GeoNetworkingLayer : public TLayer<LibItsGeoNetworking__TestSystem::GeoNetworkingPort> {
GeoNetworkingCodec _codec;
public:
inline GeoNetworkingLayer():TLayer<LibItsGeoNetworking__TestSystem::GeoNetworkingPort>(){}
inline GeoNetworkingLayer():TLayer<LibItsGeoNetworking__TestSystem::GeoNetworkingPort>() {}
GeoNetworkingLayer(const std::string & type, const std::string & param);
virtual ~GeoNetworkingLayer(){}
void sendMsg(const LibItsGeoNetworking__TestSystem::GeoNetworkingReq&, const Params& param);
......
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment