Skip to content
GitLab
Commit 125923b9 authored by garciay's avatar garciay
Browse files

Layers ongoing

parent c649d32a
Hide whitespace changes
Inline Side-by-side
ccsrc/Framework/Layer.hh
View file @ 125923b9
......@@ -8,34 +8,47 @@
#include "loggers.hh"
class OCTETSTRING;
class CHARSTRING;
class Layer {
std::vector<Layer*> upperLayers;
std::vector<Layer*> lowerLayers;
public:
Layer(){}
virtual ~Layer() {};
void deleteLayer() {};
public:
void addUpperLayer(Layer*) {};
void removeUpperLayer(Layer*) {};
virtual void sendData(const OCTETSTRING& data, const Params& params) {};
virtual void receiveData(const OCTETSTRING& data, const Params& info) {};
protected:
inline void toAllLayers(std::vector<Layer*>&layers, const OCTETSTRING& data, const Params& info) {
// loggers::loggers::log_msg(">>> Layer::toAllLayer: ", data);
loggers::loggers::log(">>> Layer::toAllLayer: %d", layers.size());
for (std::vector<Layer*>::const_iterator it = layers.cbegin(); it != layers.cend(); ++it) {
Layer * p = *it;
p->receiveData(data, info);
} // End of 'for' statement
protected:
std::string type;
public:
Layer(const std::string& p_type) : upperLayers(), lowerLayers(), type(std::string(p_type.begin(), p_type.end())) {};
virtual ~Layer() { upperLayers.clear(); lowerLayers.clear(); };
void deleteLayer() { };
public:
inline void addUpperLayer(Layer* p_layer) {
//loggers::loggers::log(">>> Layer::addUpperLayer");
if (p_layer != NULL) {
loggers::loggers::log("Layer::addUpperLayer: %s is upper layer of %s", p_layer->to_string().c_str(), to_string().c_str());
upperLayers.push_back(p_layer);
loggers::loggers::log(" Layer::addUpperLayer: %s is loweer layer of %s", to_string().c_str(), p_layer->to_string().c_str());
p_layer->lowerLayers.push_back(this);
};
inline void toAllUpperLayers(const OCTETSTRING& data, const Params& info) { toAllLayers(upperLayers, data, info); }
inline void toAllLowerLayers(const OCTETSTRING& data, const Params& info) { toAllLayers(upperLayers, data, info); }
inline void receiveToAllLayers(const OCTETSTRING& data, const Params& info) { toAllLayers(upperLayers, data, info); }
inline void sendToAllLayers(const OCTETSTRING& data, const Params& info) { toAllLayers(lowerLayers, data, info); }
};
void removeUpperLayer(Layer* p_layer) { };
virtual void sendData(const OCTETSTRING& data, const Params& params) {};
virtual void receiveData(OCTETSTRING& data, Params& info) {};
inline const std::string& to_string() const { return type; };
protected:
inline void toAllLayers(std::vector<Layer*>&layers, OCTETSTRING& data, Params& info) {
//loggers::loggers::log_msg(">>> Layer::toAllLayer: ", data);
loggers::loggers::log(">>> Layer::toAllLayer: %d", layers.size());
for (std::vector<Layer*>::const_iterator it = layers.cbegin(); it != layers.cend(); ++it) {
Layer * p = *it;
p->receiveData(data, info);
} // End of 'for' statement
};
inline void toAllUpperLayers(OCTETSTRING& data, Params& info) { toAllLayers(upperLayers, data, info); }
inline void toAllLowerLayers(OCTETSTRING& data, Params& info) { toAllLayers(lowerLayers, data, info); }
inline void receiveToAllLayers(OCTETSTRING& data, Params& info) { toAllLayers(upperLayers, data, info); }
inline void sendToAllLayers(OCTETSTRING& data, Params& info) { toAllLayers(lowerLayers, data, info); }
};
......@@ -45,40 +58,41 @@ template <typename TPort> class TLayer : public Layer {
TPortList upperPorts;
public:
TLayer(){}
void addUpperPort(TPort*);
void removeUpperPort(TPort*);
protected:
template <typename TMessage> void toAllUpperPorts(const TMessage& m, const Params& param) {
for(TPortListIterator it=upperPorts.begin(); it<upperPorts.end(); ++it){
(*it)->receiveMsg(m, param);
}
public:
TLayer(const std::string& p_type) : Layer(p_type), upperPorts() {};
void addUpperPort(TPort * p_port) { upperPorts.push_back(p_port); };
void removeUpperPort(TPort*);
protected:
template <typename TMessage> void toAllUpperPorts(const TMessage& m, const Params& param) {
loggers::loggers::log(">>> TLayer::toAllUpperPorts: %d", upperPorts.size());
for(TPortListIterator it=upperPorts.begin(); it<upperPorts.end(); ++it){
(*it)->receiveMsg(m, param);
}
}
};
class LayerFactory {
public:
LayerFactory(){}
virtual Layer * createLayer(const std::string & type, const std::string & param) = 0;
public:
LayerFactory(){}
virtual Layer * createLayer(const std::string & type, const std::string & param) = 0;
};
class LayerStackBuilder {
typedef std::map<std::string, LayerFactory*> LayerFactoryMap;
static LayerStackBuilder * _instance;
std::map<std::string, LayerFactory*> _fs;
private:
LayerStackBuilder(); // can not be created manually
public:
static LayerStackBuilder * GetInstance();
static void RegisterLayerFactory(const std::string & type, LayerFactory * f);
public:
void registerLayerFactory(const std::string & type, LayerFactory * f);
Layer* createLayerStack(const char*);
typedef std::map<std::string, LayerFactory*> LayerFactoryMap;
static LayerStackBuilder * _instance;
std::map<std::string, LayerFactory*> _fs;
private:
LayerStackBuilder(); // can not be created manually
public:
static LayerStackBuilder * GetInstance();
static void RegisterLayerFactory(const std::string & type, LayerFactory * f);
public:
void registerLayerFactory(const std::string & type, LayerFactory * f);
Layer* createLayerStack(const char*);
};
#endif
ccsrc/Framework/Params.hh
View file @ 125923b9
......@@ -2,11 +2,10 @@
#include <map>
//typedef std::map<std::string, std::string> Params;
class Params : public std::map<std::string, std::string> {
public:
Params() : std::map<std::string, std::string>() {};
Params(const Params& p_params);
virtual ~Params() {};
void log();
static void convert(Params& p_param, const std::string p_parameters);
......
ccsrc/Framework/src/LayerFactory.cc
View file @ 125923b9
......@@ -14,7 +14,7 @@ LayerStackBuilder * LayerStackBuilder::GetInstance()
void LayerStackBuilder::RegisterLayerFactory(const std::string & type, LayerFactory * f)
{
LayerStackBuilder::GetInstance()->registerLayerFactory(type, f);
LayerStackBuilder::GetInstance()->registerLayerFactory(type, f);
}
// member functions
......@@ -24,46 +24,43 @@ 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);
loggers::loggers::log(">>> LayerStackBuilder::createLayerStack: %s", s);
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();
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"));
}
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());
LayerFactoryMap::iterator i =_fs.find(m[1].str());
if (i == _fs.end()) {
loggers::loggers::error("LayerStackBuilder::createLayerStack: %s: Unknown layer type", m[1].str().c_str());
}
loggers::loggers::log("LayerStackBuilder::createLayerStack: Create layer %s, %s", m[1].str().c_str(), m[3].str().c_str());
Layer * l = i->second->createLayer(m[1].str(), m[3].str());
if (NULL == l) {
loggers::loggers::error("LayerStackBuilder::createLayerStack: %s: Layer creation error", m[1].str().c_str());
}
l->addUpperLayer(up);
up = l;
} // End of 'for' statement
loggers::loggers::log("LayerStackBuilder::createLayerStack: Setup layers for %s", l->to_string().c_str());
l->addUpperLayer(up);
up = l;
} // End of 'for' statement
}
catch(const std::logic_error& e){
if(up){
up->deleteLayer();
up = NULL;
}
catch(const std::logic_error& e){
if(up){
up->deleteLayer();
up = NULL;
}
}
return up;
}
return up;
}
ccsrc/Framework/src/Params.cc
View file @ 125923b9
......@@ -4,6 +4,9 @@
#include "Params.hh"
#include "loggers.hh"
Params::Params(const Params& p_params) : std::map<std::string, std::string>(p_params.begin(), p_params.end()) {
}
void Params::convert(Params& p_param, const std::string p_parameters) {
//loggers::loggers::log(">>> Params::convert: '%s'", p_parameters.c_str());
// Sanity checks
......
ccsrc/Protocols/ETH/EthernetLayer.cc
View file @ 125923b9
#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
Params::convert(_params, param);
_params.log();
EthernetLayer::EthernetLayer(const std::string & p_type, const std::string & param) : Layer(p_type), _params() {
loggers::loggers::log(">>> EthernetLayer::EthernetLayer: %s, %s", to_string().c_str(), param.c_str());
// Setup parameters
Params::convert(_params, param);
//_params.log();
}
void EthernetLayer::sendData(const OCTETSTRING& data, const Params& params) {
loggers::loggers::log_msg(">>> EthernetLayer::sendData: ", data);
void EthernetLayer::sendData(OCTETSTRING& data, Params& params) {
loggers::loggers::log_msg(">>> EthernetLayer::sendData: ", data);
OCTETSTRING eth;
std::map<std::string, std::string>::const_iterator it = params.find("mac_dst");
if (it != params.cend()) {
eth += str2oct(CHARSTRING(it->second.c_str()));
} else {
const unsigned char mac_address[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
eth += OCTETSTRING(sizeof(mac_address), static_cast<const unsigned char *>(mac_address));
}
it = params.find("mac_src");
if (it != params.cend()) {
eth += str2oct(CHARSTRING(it->second.c_str()));
} else {
const unsigned char mac_address[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0xFF};
eth += OCTETSTRING(sizeof(mac_address), static_cast<const unsigned char *>(mac_address));
}
it = params.find("eth_type");
if (it != params.cend()) {
eth += str2oct(CHARSTRING(it->second.c_str()));
} else {
const unsigned char proto[] = {0x47, 0x89};
eth += OCTETSTRING(sizeof(proto), static_cast<const unsigned char *>(proto));
}
data = eth + data;
toAllLowerLayers(data, params);
}
void EthernetLayer::receiveData(const OCTETSTRING& data, const Params& info) {
loggers::loggers::log_msg(">>> EthernetLayer::receiveData: ", data);
// Extract dest MAC Address
OCTETSTRING dst = data << 6;
loggers::loggers::log_msg("EthernetLayer::receiveData: dst: ", dst);
// Extract source MAC Address
OCTETSTRING src = data << 6;
loggers::loggers::log_msg("EthernetLayer::receiveData: src: ", src);
// Extract ethertype
OCTETSTRING type = data << 2;
loggers::loggers::log_msg("EthernetLayer::receiveData: type: ", type);
// Update params
loggers::loggers::log_msg("<<< EthernetLayer::receiveData: ", data);
void EthernetLayer::receiveData(OCTETSTRING& data, Params& params) {
loggers::loggers::log_msg(">>> EthernetLayer::receiveData: ", data);
// Extract dest MAC Address
OCTETSTRING dst = OCTETSTRING(6, static_cast<const unsigned char *>(data));
//loggers::loggers::log_msg("EthernetLayer::receiveData: dst: ", dst);
// Extract source MAC Address
OCTETSTRING src = OCTETSTRING(6, 6 + static_cast<const unsigned char *>(data));
//loggers::loggers::log_msg("EthernetLayer::receiveData: src: ", src);
// Extract ethertype
OCTETSTRING proto = OCTETSTRING(2, 2 + static_cast<const unsigned char *>(data));
//loggers::loggers::log_msg("EthernetLayer::receiveData: proto: ", proto);
data = OCTETSTRING(data.lengthof() - 14, 14 + static_cast<const unsigned char *>(data));
// Update params
CHARSTRING s = oct2str(dst);
params.insert(std::pair<std::string, std::string>(std::string("mac_dst"), std::string(static_cast<const char *>(s))));
s = oct2str(src);
params.insert(std::pair<std::string, std::string>(std::string("mac_src2"), std::string(static_cast<const char *>(s))));
//loggers::loggers::log_msg("EthernetLayer::receiveData: payload for upper layer:", data);
toAllUpperLayers(data, params);
}
class EthernetFactory: public LayerFactory {
static EthernetFactory _f;
static EthernetFactory _f;
public:
EthernetFactory();
virtual Layer * createLayer(const std::string & type,
const std::string & param);
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);
// 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);
return new EthernetLayer(type, param);
}
EthernetFactory EthernetFactory::_f;
ccsrc/Protocols/ETH/EthernetLayer.hh
View file @ 125923b9
......@@ -7,12 +7,11 @@
class EthernetLayer : public Layer {
Params _params;
public:
inline EthernetLayer() : Layer(), _params() {}
EthernetLayer(const std::string & type, const std::string & param);
EthernetLayer(const std::string & p_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);
virtual void sendData(OCTETSTRING& data, Params& params);
virtual void receiveData(OCTETSTRING& data, Params& info);
};
#endif
ccsrc/Protocols/GeoNetworking/GeoNetworkingCodec.cc
View file @ 125923b9
......@@ -262,33 +262,30 @@ int GeoNetworkingCodec::decode_headerTST(LibItsGeoNetworking__TypesAndValues::He
loggers::loggers::log("GeoNetworkingCodec::decode_: headerTST selectors: _dc.header_type = %d - _dc.header_sub_type = %d", _dc.header_type, _dc.header_sub_type);
//LibItsGeoNetworking__TypesAndValues::HeaderTST & u = dynamic_cast<LibItsGeoNetworking__TypesAndValues::HeaderTST &>(u);
switch (_dc.header_type) {
case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_geoUnicastHeader:
case LibItsGeoNetworking__TypesAndValues::HeaderType::e__geoUnicast:
u.geoUnicastHdr().decode(*u.geoUnicastHdr().get_descriptor(), decoding_buffer, TTCN_EncDec::CT_RAW);
break;
case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_tsbHeader:
case LibItsGeoNetworking__TypesAndValues::HeaderType::e__topologicallyScopedBroadcast:
u.tsbHdr().decode(*u.tsbHdr().get_descriptor(), decoding_buffer, TTCN_EncDec::CT_RAW);
break;
case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_shbHeader:
u.tsbHdr().decode(*u.tsbHdr().get_descriptor(), decoding_buffer, TTCN_EncDec::CT_RAW);
break;
case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_geoBroadcastHeader:
case LibItsGeoNetworking__TypesAndValues::HeaderType::e__geoBroadcast:
u.geoBroadcastHdr().decode(*u.geoBroadcastHdr().get_descriptor(), decoding_buffer, TTCN_EncDec::CT_RAW);
break;
case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_geoAnycastHeader:
case LibItsGeoNetworking__TypesAndValues::HeaderType::e__geoAnycast:
u.geoAnycastHdr().decode(*u.geoAnycastHdr().get_descriptor(), decoding_buffer, TTCN_EncDec::CT_RAW);
break;
case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_beaconHeader:
case LibItsGeoNetworking__TypesAndValues::HeaderType::e__beacon:
u.beaconHdr().decode(*u.beaconHdr().get_descriptor(), decoding_buffer, TTCN_EncDec::CT_RAW);
break;
case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_lsRequestHeader:
case LibItsGeoNetworking__TypesAndValues::HeaderType::e__locationService:
u.lsHdr().decode(*u.lsHdr().get_descriptor(), decoding_buffer, TTCN_EncDec::CT_RAW);
break;
case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_lsReplyHeader:
u.lsHdr().decode(*u.lsHdr().get_descriptor(), decoding_buffer, TTCN_EncDec::CT_RAW);
break;
case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_anyHeader:
case LibItsGeoNetworking__TypesAndValues::HeaderType::e__any:
u.anyHdr().decode(*u.anyHdr().get_descriptor(), decoding_buffer, TTCN_EncDec::CT_RAW);
break;
case LibItsGeoNetworking__TypesAndValues::HeaderType::e__serviceAnnouncement:
u.saHdr().decode(*u.saHdr().get_descriptor(), decoding_buffer, TTCN_EncDec::CT_RAW);
break;
default:
TTCN_error("GeoNetworkingCodec::decode_: Not processed, _dc.header_type = %d - _dc.header_sub_type = %d", _dc.header_type, _dc.header_sub_type);
} // End of 'switch' statement
......@@ -300,33 +297,48 @@ int GeoNetworkingCodec::decode_extendedHeader(LibItsGeoNetworking__TypesAndValue
loggers::loggers::log(">>> GeoNetworkingCodec::decode_extendedHeader: processing %s", u.get_descriptor()->name);
switch (_dc.header_type) {
case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_geoUnicastHeader:
case LibItsGeoNetworking__TypesAndValues::HeaderType::e__geoUnicast:
u.geoUnicastHeader().decode(*u.geoUnicastHeader().get_descriptor(), decoding_buffer, TTCN_EncDec::CT_RAW);
break;
case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_tsbHeader:
case LibItsGeoNetworking__TypesAndValues::HeaderType::e__topologicallyScopedBroadcast:
if (_dc.header_sub_type == LibItsGeoNetworking__TypesAndValues::HeaderSubTypeTSB::e__multiHop) {
u.tsbHeader().decode(*u.tsbHeader().get_descriptor(), decoding_buffer, TTCN_EncDec::CT_RAW);
break;
case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_shbHeader:
} else if (_dc.header_sub_type == LibItsGeoNetworking__TypesAndValues::HeaderSubTypeTSB::e__singleHop) {
u.shbHeader().decode(*u.shbHeader().get_descriptor(), decoding_buffer, TTCN_EncDec::CT_RAW);
break;
case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_geoBroadcastHeader:
} else {
TTCN_error("GeoNetworkingCodec::decode_headerTST: TSB subtype not processed");
}
break;
case LibItsGeoNetworking__TypesAndValues::HeaderType::e__geoBroadcast:
u.geoBroadcastHeader().decode(*u.geoBroadcastHeader().get_descriptor(), decoding_buffer, TTCN_EncDec::CT_RAW);
break;
case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_geoAnycastHeader:
case LibItsGeoNetworking__TypesAndValues::HeaderType::e__geoAnycast:
u.geoAnycastHeader().decode(*u.geoAnycastHeader().get_descriptor(), decoding_buffer, TTCN_EncDec::CT_RAW);
break;
case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_beaconHeader:
case LibItsGeoNetworking__TypesAndValues::HeaderType::e__beacon:
u.beaconHeader().decode(*u.beaconHeader().get_descriptor(), decoding_buffer, TTCN_EncDec::CT_RAW);
break;
case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_lsRequestHeader:
case LibItsGeoNetworking__TypesAndValues::HeaderType::e__locationService:
if (_dc.header_sub_type == LibItsGeoNetworking__TypesAndValues::HeaderSubTypeLs::e__lsRequest) {
u.lsRequestHeader().decode(*u.lsRequestHeader().get_descriptor(), decoding_buffer, TTCN_EncDec::CT_RAW);
break;
case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_lsReplyHeader:
} else if (_dc.header_type == LibItsGeoNetworking__TypesAndValues::HeaderSubTypeLs::e__lsReply) {
u.lsReplyHeader().decode(*u.lsReplyHeader().get_descriptor(), decoding_buffer, TTCN_EncDec::CT_RAW);
break;
case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_anyHeader:
} else {
TTCN_error("GeoNetworkingCodec::decode_headerTST: Location service subtype not processed");
}
break;
case LibItsGeoNetworking__TypesAndValues::HeaderType::e__any:
u.anyHeader().decode(*u.anyHeader().get_descriptor(), decoding_buffer, TTCN_EncDec::CT_RAW);
break;
case LibItsGeoNetworking__TypesAndValues::HeaderType::e__serviceAnnouncement:
/*if (_dc.header_sub_type == LibItsGeoNetworking__TypesAndValues::HeaderSubTypeSa::e__sa) {
u.saHeader().decode(*u.saHeader().get_descriptor(), decoding_buffer, TTCN_EncDec::CT_RAW);
} else if (_dc.header_type == LibItsGeoNetworking__TypesAndValues::HeaderSubTypeSa::e__saEos) {
u.saEosHeader().decode(*u.lsReplyHeader().get_descriptor(), decoding_buffer, TTCN_EncDec::CT_RAW);
} else {*/
TTCN_error("GeoNetworkingCodec::decode_headerTST: Service Advertisement subtype not processed");
//}
break;
default:
TTCN_error("GeoNetworkingCodec::decode_headerTST: Not processed, _dc.header_type = %d - _dc.header_sub_type = %d", _dc.header_type, _dc.header_sub_type);
} // End of 'switch' statement
......
ccsrc/Protocols/GeoNetworking/GeoNetworkingLayer.cc
View file @ 125923b9
......@@ -3,36 +3,37 @@
#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());
GeoNetworkingLayer::GeoNetworkingLayer(const std::string & p_type, const std::string & param) : TLayer<LibItsGeoNetworking__TestSystem::GeoNetworkingPort>(p_type), _codec(), _params() {
loggers::loggers::log(">>> GeoNetworkingLayer::GeoNetworkingLayer: %s, %s", to_string().c_str(), param.c_str());
// Setup parameters
Params::convert(_params, param);
_params.log();
}
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);
loggers::loggers::log(">>> GeoNetworkingLayer::sendMsg");
OCTETSTRING data;
_codec.encode(p.msgOut(), data);
Params par(params);
sendData(data, par);
}
void GeoNetworkingLayer::sendData(const OCTETSTRING& data, const Params& params) {
sendToAllLayers(data, params);
void GeoNetworkingLayer::sendData(OCTETSTRING& data, Params& params) {
loggers::loggers::log(">>> GeoNetworkingLayer::sendData");
toAllLowerLayers(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);
// }
void GeoNetworkingLayer::receiveData(OCTETSTRING& data, Params& info) {
loggers::loggers::log_msg(">>> GeoNetworkingLayer::receiveData: ", data);
// Decode the payload
LibItsGeoNetworking__TestSystem::GeoNetworkingInd p;
_codec.decode(data, p.msgIn());
// Add lower layers parameters
// TODO
// const unsigned char mac_address[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
//data += OCTETSTRING(sizeof(mac_address), static_cast<const unsigned char *>(mac_address));
// Send it to the ports
toAllUpperPorts(p, info);
}
class GeoNetworkingFactory: public LayerFactory {
......
ccsrc/Protocols/GeoNetworking/GeoNetworkingLayer.hh
View file @ 125923b9
......@@ -9,17 +9,16 @@ namespace LibItsGeoNetworking__TestSystem {
}
class GeoNetworkingLayer : public TLayer<LibItsGeoNetworking__TestSystem::GeoNetworkingPort> {
GeoNetworkingCodec _codec;
GeoNetworkingCodec _codec;
Params _params;
public:
inline GeoNetworkingLayer() : TLayer<LibItsGeoNetworking__TestSystem::GeoNetworkingPort>(), _codec(), _params() {}
GeoNetworkingLayer(const std::string & type, const std::string & param);
virtual ~GeoNetworkingLayer(){}
GeoNetworkingLayer(const std::string & p_type, const std::string & param);
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);
virtual void sendData(OCTETSTRING& data, Params& params);
virtual void receiveData(OCTETSTRING& data, Params& info);
};
#endif
ccsrc/Protocols/Pcap/PcapLayer.cc
View file @ 125923b9
......@@ -10,11 +10,12 @@
#include "PcapLayer.hh"