Commit 84d345d9 authored by garciay's avatar garciay
Browse files

Layers ongoing

parent 180a0d5b
......@@ -23,7 +23,7 @@ INTEGER fx__dec__BtpPayload(BITSTRING& b, LibItsBtp__TypesAndValues::BtpPayload&
}
*/
BITSTRING fx__enc__BtpReq(LibItsBtp__TestSystem::BtpReq const&)
/*BITSTRING fx__enc__BtpReq(LibItsBtp__TestSystem::BtpReq const&)
{
return int2bit(0,8);
}
......@@ -31,7 +31,7 @@ BITSTRING fx__enc__BtpReq(LibItsBtp__TestSystem::BtpReq const&)
INTEGER fx__dec__BtpInd(BITSTRING&, LibItsBtp__TestSystem::BtpInd&)
{
return 0;
}
}*/
} //end namespace
......@@ -9,13 +9,13 @@ namespace LibItsDenm__EncdecDeclarations {
BITSTRING fx__enc__DenmReq(const LibItsDenm__TestSystem::DenmReq& p)
{
//set error behavior
TTCN_EncDec::set_error_behavior(TTCN_EncDec::ET_ALL,TTCN_EncDec::EB_WARNING);
// TTCN_EncDec::set_error_behavior(TTCN_EncDec::ET_ALL,TTCN_EncDec::EB_WARNING);
TTCN_Buffer TTCN_buf;
TTCN_buf.clear();
//encode message in BER (CER variant, but can be any)
p.msgOut().encode(DENM__PDU__Descriptions::DENM_descr_,TTCN_buf,TTCN_EncDec::CT_BER,BER_ENCODE_CER);
// p.msgOut().encode(DENM__PDU__Descriptions::DENM_descr_,TTCN_buf,TTCN_EncDec::CT_BER,BER_ENCODE_CER);
OCTETSTRING encodedData(TTCN_buf.get_len(), TTCN_buf.get_data());
......
#ifndef CODEC_H
#define CODEC_H
#include "loggers.hh"
class OCTETSTRING;
class CHARSTRING;
class BITSTRING;
template<typename TPDUEnc, typename TPDUDec> class Codec
{
public:
virtual int encode(const TPDUEnc& msg, OCTETSTRING& data) = 0;
virtual int decode(const OCTETSTRING& data, TPDUDec& msg) = 0;
Codec() { loggers::loggers::log("Codec::Codec"); };
virtual ~Codec() { loggers::loggers::log("Codec::~Codec"); };
virtual int encode(const TPDUEnc& msg, OCTETSTRING& data) = 0;
virtual int decode(const OCTETSTRING& data, TPDUDec& msg) = 0;
};
template<typename TPDU> class PERCodec
{
public:
virtual int encode(const TPDU& msg, BITSTRING& bits);
virtual int decode(const BITSTRING& bits, TPDU& msg);
virtual int encode(const TPDU& msg, BITSTRING& bits) {return -1;};
virtual int decode(const BITSTRING& bits, TPDU& msg) {return -1;};
};
#endif
#ifndef LAYER_HH
#define LAYER_HH
#include <string>
#include <map>
#include <vector>
......@@ -16,7 +17,8 @@ class Layer {
protected:
std::string type;
public:
Layer(const std::string& p_type) : upperLayers(), lowerLayers(), type(std::string(p_type.begin(), p_type.end())) {};
Layer() : upperLayers(), lowerLayers(), type(std::string("")) { loggers::loggers::log("Layer::Layer (D)"); };
Layer(const std::string& p_type) : upperLayers(), lowerLayers(), type(std::string(p_type.begin(), p_type.end())) { loggers::loggers::log("Layer::Layer"); };
virtual ~Layer() { upperLayers.clear(); lowerLayers.clear(); };
void deleteLayer() { };
public:
......@@ -32,24 +34,38 @@ public:
void removeUpperLayer(Layer* p_layer) { };
virtual void sendData(const OCTETSTRING& data, const Params& params) {};
virtual void receiveData(OCTETSTRING& data, Params& info) {};
virtual void receiveData(OCTETSTRING& data, Params& params) {};
inline const std::string& to_string() const { return type; };
protected:
inline void toAllLayers(std::vector<Layer*>&layers, OCTETSTRING& data, Params& info) {
inline void toAllLayers(std::vector<Layer*>&layers, OCTETSTRING& data, Params& params) {
//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);
p->receiveData(data, params); // FIXME BUG I
} // 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); }
};
//inline void toAllUpperLayers(OCTETSTRING& data, Params& params) { toAllLayers(upperLayers, data, params); } // TODO Useless??
//inline void toAllLowerLayers(OCTETSTRING& data, Params& params) { toAllLayers(lowerLayers, data, params); } // TODO Useless??
inline void receiveToAllLayers(OCTETSTRING& data, Params& params) {
//loggers::loggers::log_msg(">>> Layer::receiveToAllLayers: ", data);
loggers::loggers::log(">>> Layer::receiveToAllLayers: %d", upperLayers.size());
for (std::vector<Layer*>::const_iterator it = upperLayers.cbegin(); it != upperLayers.cend(); ++it) {
Layer * p = *it;
p->receiveData(data, params);
} // End of 'for' statement
};
inline void sendToAllLayers(OCTETSTRING& data, Params& params) {
//loggers::loggers::log_msg(">>> Layer::sendToAllLayers: ", data);
loggers::loggers::log(">>> Layer::sendToAllLayers: %d", lowerLayers.size());
for (std::vector<Layer*>::const_iterator it = lowerLayers.cbegin(); it != lowerLayers.cend(); ++it) {
Layer * p = *it;
p->sendData(data, params);
} // End of 'for' statement
};
}; // End of class Layer
template <typename TPort> class TLayer : public Layer {
......@@ -59,7 +75,8 @@ template <typename TPort> class TLayer : public Layer {
TPortList upperPorts;
public:
TLayer(const std::string& p_type) : Layer(p_type), upperPorts() {};
TLayer() : Layer(), upperPorts() { loggers::loggers::log("TLayer::TLayer (D)"); };
TLayer(const std::string& p_type) : Layer(p_type), upperPorts() { loggers::loggers::log("TLayer::TLayer"); };
void addUpperPort(TPort * p_port) { upperPorts.push_back(p_port); };
void removeUpperPort(TPort*);
......@@ -75,7 +92,7 @@ protected:
class LayerFactory {
public:
LayerFactory(){}
LayerFactory() {};
virtual Layer * createLayer(const std::string & type, const std::string & param) = 0;
};
......
......@@ -2,12 +2,15 @@
#include <map>
#include "loggers.hh"
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);
public:
Params() : std::map<std::string, std::string>() { loggers::loggers::log("Params::Params"); };
Params(const Params& p_params) : std::map<std::string, std::string>(p_params.begin(), p_params.end()) { loggers::loggers::log("Params::Params (1)"); };
virtual ~Params() {};
void log();
static void convert(Params& p_param, const std::string p_parameters);
};
......@@ -31,7 +31,8 @@ Layer* LayerStackBuilder::createLayerStack(const char* s)
{
loggers::loggers::log(">>> LayerStackBuilder::createLayerStack: %s", s);
Layer * up = NULL;
Layer * entry = NULL; // Initial layer (the first declared)
Layer * up = NULL; // Upper layer
// Parse str
try {
std::regex rgx ("(\\w+)(\\((.*?)\\))?(\\/|$)");
......@@ -53,14 +54,17 @@ Layer* LayerStackBuilder::createLayerStack(const char* s)
loggers::loggers::log("LayerStackBuilder::createLayerStack: Setup layers for %s", l->to_string().c_str());
l->addUpperLayer(up);
up = l;
if (entry == NULL) { // Set the first declared layer
entry = l;
}
up = l; // Build the linjed list of layers
} // End of 'for' statement
}
catch(const std::logic_error& e){
if(up){
if(up){ // FIXME To be reviewed
up->deleteLayer();
up = NULL;
}
}
return up;
return entry;
}
......@@ -4,9 +4,6 @@
#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
......
#include "BTPLayer.hh"
#include "BTPTypes.hh"
void BTPLayer::sendMsg(const LibItsBtp__TypesAndValues::BtpPacket& p, const Params& params){
void BTPLayer::sendMsg(LibItsBtp__TypesAndValues::BtpPacket& p, Params& params){
OCTETSTRING data;
_codec.encode(p, data);
sendData(data, params);
}
void BTPLayer::sendData(const OCTETSTRING& data, const Params& params){
void BTPLayer::sendData(OCTETSTRING& data, Params& params){
sendToAllLayers(data, params);
}
void BTPLayer::receiveData(const OCTETSTRING& data, const Params& info)
void BTPLayer::receiveData(OCTETSTRING& data, Params& info)
{
LibItsBtp__TypesAndValues::BtpPacket p;
_codec.decode(data, p);
toAllUpperPorts(p, info);
if(p.payload().is_present()) {
toAllUpperLayers(p.payload()().rawPayload(), info);
}
/*if(p.payload().is_present()) {
toAllUpperLayers(p.payload().rawPayload(), info);
}*/
}
class BTPFactory : public LayerFactory {
......@@ -35,8 +35,8 @@ BTPFactory::BTPFactory(){
LayerStackBuilder::RegisterLayerFactory("BTP", this);
}
Layer * BTPFactory::createLayer(const std::string & type, const std::string & param){
return new BTPLayer();
Layer * BTPFactory::createLayer(const std::string & p_type, const std::string & param){
return new BTPLayer(p_type);
}
BTPFactory BTPFactory::_f;
......@@ -14,13 +14,13 @@ namespace LibItsBtp__TestSystem {
class BTPLayer : public TLayer<LibItsBtp__TestSystem::BtpPort> {
BTPCodec _codec;
public:
inline BTPLayer():TLayer<LibItsBtp__TestSystem::BtpPort>(){}
virtual ~BTPLayer(){}
BTPLayer(const std::string& p_type) : TLayer<LibItsBtp__TestSystem::BtpPort>(p_type) {};
virtual ~BTPLayer() {};
void sendMsg(const LibItsBtp__TypesAndValues::BtpPacket&, const Params& param);
void sendMsg(LibItsBtp__TypesAndValues::BtpPacket&, 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
......@@ -34,7 +34,7 @@ void EthernetLayer::sendData(OCTETSTRING& data, Params& params) {
}
data = eth + data;
toAllLowerLayers(data, params);
sendToAllLayers(data, params);
}
void EthernetLayer::receiveData(OCTETSTRING& data, Params& params) {
......@@ -54,10 +54,10 @@ void EthernetLayer::receiveData(OCTETSTRING& data, Params& 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))));
params.insert(std::pair<std::string, std::string>(std::string("mac_src"), std::string(static_cast<const char *>(s))));
//loggers::loggers::log_msg("EthernetLayer::receiveData: payload for upper layer:", data);
toAllUpperLayers(data, params);
receiveToAllLayers(data, params);
}
class EthernetFactory: public LayerFactory {
......
......@@ -4,61 +4,64 @@
#include <vector>
#include "Codec.hh"
#include "loggers.hh"
class Base_Type;
class OCTETSTRING;
class TTCN_Typedescriptor_t;
class TTCN_Buffer;
namespace LibItsGeoNetworking__TypesAndValues {
class GeoNetworkingPdu;
class HeaderTST;
class ExtendedHeader;
class DecodedPayload;
class GeoNetworkingPdu;
class HeaderTST;
class ExtendedHeader;
class DecodedPayload;
};
namespace LibItsSecurity__TypesAndValues {
class SecuredMessage;
class SecuredMessage;
};
struct Encoding_Context {
unsigned char next_header; // FIXME Useless?
unsigned char header_type; // FIXME Useless?
unsigned int plLength_position;
unsigned int plLength;
unsigned char next_header;
unsigned char header_type;
unsigned int plLength_position;
unsigned int plLength;
Encoding_Context() { next_header = 0xff; header_type = 0xff; plLength_position = -1; plLength = -1; }
Encoding_Context() { next_header = 0xff; header_type = 0xff; plLength_position = -1; plLength = -1; }
};
//typedef struct Encoding_Context Encoding_Context;
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;
unsigned char next_header;
unsigned char header_type;
unsigned char header_sub_type;
unsigned int plLength;
std::vector<unsigned char> payload;
Decoding_Context() : payload() { next_header = 0xff; header_type = 0xff; header_sub_type = 0xff; plLength = -1; }
Decoding_Context() : payload{} { next_header = 0xff; header_type = 0xff; header_sub_type = 0xff; plLength = -1; }
};
//typedef struct Decoding_Context Decoding_Context;
class GeoNetworkingCodec : public Codec<LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu, LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu> {
Encoding_Context _ec;
Decoding_Context _dc;
Encoding_Context _ec;
Decoding_Context _dc;
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_decodedPayload(const LibItsGeoNetworking__TypesAndValues::DecodedPayload& u, 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_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_headerTST(LibItsGeoNetworking__TypesAndValues::HeaderTST& u, TTCN_Buffer& decoding_buffer);
int decode_extendedHeader(LibItsGeoNetworking__TypesAndValues::ExtendedHeader& u, TTCN_Buffer& decoding_buffer);
int decode_ (Base_Type& type, const TTCN_Typedescriptor_t& field_descriptor, TTCN_Buffer& decoding_buffer);
int decode_headerTST(LibItsGeoNetworking__TypesAndValues::HeaderTST& u, TTCN_Buffer& decoding_buffer);
int decode_extendedHeader(LibItsGeoNetworking__TypesAndValues::ExtendedHeader& u, TTCN_Buffer& decodin_buffer);
public:
GeoNetworkingCodec() : _ec(), _dc() {};
virtual int encode (const LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu& msg, OCTETSTRING& data);
virtual int decode (const OCTETSTRING& data, LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu& msg);
GeoNetworkingCodec() : Codec<LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu, LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu>(), _ec(), _dc() { loggers::loggers::log("GeoNetworkingCodec::GeoNetworkingCodec(D) :%d ", _ec.next_header); };
virtual ~GeoNetworkingCodec() { loggers::loggers::log("GeoNetworkingCodec::~GeoNetworkingCodec"); };
int encode (const LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu& msg, OCTETSTRING& data);
int decode (const OCTETSTRING& data, LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu& msg);
};
#endif
......@@ -3,37 +3,49 @@
#include "loggers.hh"
GeoNetworkingLayer::GeoNetworkingLayer(const std::string & p_type, const std::string & param) : TLayer<LibItsGeoNetworking__TestSystem::GeoNetworkingPort>(p_type), _codec(), _params() {
GeoNetworkingLayer::GeoNetworkingLayer(const std::string & p_type, const std::string & param) : TLayer<LibItsGeoNetworking__TestSystem::GeoNetworkingPort>(p_type), _params(), _codec() {
loggers::loggers::log(">>> GeoNetworkingLayer::GeoNetworkingLayer: %s, %s", to_string().c_str(), param.c_str());
// Setup parameters
Params::convert(_params, param);
_params.log();
//_params.log();
}
void GeoNetworkingLayer::sendMsg(const LibItsGeoNetworking__TestSystem::GeoNetworkingReq& p, const Params& params) {
loggers::loggers::log(">>> GeoNetworkingLayer::sendMsg");
OCTETSTRING data;
_codec.encode(p.msgOut(), data);
loggers::loggers::log_msg("GeoNetworkingLayer::sendMsg: After encoding: ", data);
Params par(params);
loggers::loggers::log("GeoNetworkingLayer::sendMsg: Before calling sendData");
par.log();
sendData(data, par);
}
void GeoNetworkingLayer::sendData(OCTETSTRING& data, Params& params) {
loggers::loggers::log(">>> GeoNetworkingLayer::sendData");
toAllLowerLayers(data, params);
sendToAllLayers(data, params);
}
void GeoNetworkingLayer::receiveData(OCTETSTRING& data, Params& info) {
void GeoNetworkingLayer::receiveData(OCTETSTRING& data, Params& params) {
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));
// 1. Destination MAC address
std::map<std::string, std::string>::const_iterator it = params.find("dst");
if (it != params.cend()) {
loggers::loggers::log("GeoNetworkingLayer::receiveData: dst=", it->second.c_str());
p.macDestinationAddress() = str2oct(CHARSTRING(it->second.c_str()));
} else {
const unsigned char mac_address[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; // TODO Declare it as a C++ constant
p.macDestinationAddress() = OCTETSTRING(sizeof(mac_address), static_cast<const unsigned char *>(mac_address));
}
p.ssp().set_to_omit();
// Its_Aid
p.its__aid().set_to_omit();
// Send it to the ports
toAllUpperPorts(p, info);
toAllUpperPorts(p, params);
}
class GeoNetworkingFactory: public LayerFactory {
......@@ -51,7 +63,7 @@ GeoNetworkingFactory::GeoNetworkingFactory() {
}
Layer * GeoNetworkingFactory::createLayer(const std::string & type, const std::string & param) {
return new GeoNetworkingLayer(type, param);
return new GeoNetworkingLayer(type, param);
}
GeoNetworkingFactory GeoNetworkingFactory::_f;
#ifndef GEONETWORKING_LAYER_H
#define GEONETWORKING_LAYER_H
#include "Layer.hh"
#include "GeoNetworkingCodec.hh"
namespace LibItsGeoNetworking__TestSystem {
class GeoNetworkingPort;
class GeoNetworkingReq;
class GeoNetworkingPort;
class GeoNetworkingReq;
class GeoNetworkingInd;
}
class GeoNetworkingLayer : public TLayer<LibItsGeoNetworking__TestSystem::GeoNetworkingPort> {
GeoNetworkingCodec _codec;
Params _params;
public:
Params _params;
GeoNetworkingCodec _codec;
public:
GeoNetworkingLayer() : _params(), _codec() {};
GeoNetworkingLayer(const std::string & p_type, const std::string & param);
virtual ~GeoNetworkingLayer() {};
void sendMsg(const LibItsGeoNetworking__TestSystem::GeoNetworkingReq&, const Params& param);
virtual void sendData(OCTETSTRING& data, Params& params);
virtual void receiveData(OCTETSTRING& data, Params& info);
void sendMsg(const LibItsGeoNetworking__TestSystem::GeoNetworkingReq&, const Params& param);
virtual void sendData(OCTETSTRING& data, Params& params);
virtual void receiveData(OCTETSTRING& data, Params& params);
};
#endif
......@@ -94,6 +94,7 @@ PcapLayer::PcapLayer(const std::string & p_type, const std::string & param) : La
while (_running == FALSE) {
std::this_thread::sleep_for(std::chrono::seconds(1));
}
// Thread was started
loggers::loggers::log("<<< PcapLayer::PcapLayer");
}
} // End of ctor
......@@ -119,6 +120,7 @@ void * PcapLayer::run(void *p_this) {
PcapLayer& p = *static_cast<PcapLayer *>(p_this);
p._running = TRUE;
p._resume = TRUE;
sleep(1);
while (p._running) {
if (p._resume == TRUE) {
write(p._fd[1], "\n", 1);
......@@ -144,10 +146,10 @@ void PcapLayer::sendData(OCTETSTRING& data, Params& params) {
}
void PcapLayer::receiveData(OCTETSTRING& data, Params& params) {
loggers::loggers::log(">>> PcapLayer::receiveData: Received %d bytes", data.lengthof());
//loggers::loggers::log_to_hexa("Packet dump", data);
//loggers::loggers::log(">>> PcapLayer::receiveData: Received %d bytes", data.lengthof());
loggers::loggers::log_to_hexa("Packet dump", data);
// Pass the packet to the upper layers
toAllUpperLayers(data, params);
receiveToAllLayers(data, params);
}
void PcapLayer::Handle_Fd_Event_Readable(int fd) {
......@@ -164,7 +166,9 @@ void PcapLayer::Handle_Fd_Event_Readable(int fd) {
params.insert(std::pair<std::string, std::string>(std::string("timestamp"), std::to_string(pkt_header->ts.tv_usec)));
// Process the packet at this layer
OCTETSTRING os(pkt_header->caplen, pkt_data);
this->receiveData(os, params);
//loggers::loggers::log_to_hexa("PcapLayer::Handle_Fd_Event_Readable: ", os);
// TODO Case of caplen != len !!!
this->receiveData(os, params); // TODO Check execution time for decoding operation
}
} // else, skip the packet
// Specific to offline mode
......
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