Layers ongoing

ccsrc/EncDec/LibItsBtp_Encdec.cc

@@ -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
 

ccsrc/EncDec/LibItsDenm_Encdec.cc

@@ -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());

ccsrc/Framework/Codec.hh

 #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

ccsrc/Framework/Layer.hh

 #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;
 };
 

ccsrc/Framework/Params.hh

@@ -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);
 };
 

ccsrc/Framework/src/LayerFactory.cc

@@ -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;
 }

ccsrc/Framework/src/Params.cc

@@ -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

ccsrc/Protocols/BTP/BTPLayer.cc

 #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;

ccsrc/Protocols/BTP/BTPLayer.hh

@@ -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

ccsrc/Protocols/ETH/EthernetLayer.cc

@@ -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 {

ccsrc/Protocols/GeoNetworking/GeoNetworkingCodec.hh

@@ -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

ccsrc/Protocols/GeoNetworking/GeoNetworkingLayer.cc

@@ -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;

ccsrc/Protocols/GeoNetworking/GeoNetworkingLayer.hh

 #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

ccsrc/Protocols/Pcap/PcapLayer.cc

@@ -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