Finalize PCAP,ETH, BTP & GN layers & codecs

Optimization and logs clean up should be done later

ccsrc/Framework/Codec.hh

 #ifndef CODEC_H
 #define CODEC_H
 
-#include "loggers.hh"
+#include "loggers.hh" // TODO To be removed
+#include "Params.hh"
 
 class OCTETSTRING;
 class CHARSTRING;
@@ -13,7 +14,7 @@ public:
   Codec() { loggers::get_instance().log("Codec::Codec"); };
   virtual ~Codec() { loggers::get_instance().log("Codec::~Codec"); };
   virtual int encode(const TPDUEnc& msg, OCTETSTRING& data) = 0;
-  virtual int decode(const OCTETSTRING& data, TPDUDec& msg) = 0;
+  virtual int decode(const OCTETSTRING& data, TPDUDec& msg, Params* param = NULL) = 0;
 };
 
 template<typename TPDU> class PERCodec

ccsrc/Framework/Params.hh

@@ -9,6 +9,9 @@ public:
   static const std::string& mac_dst;
   static const std::string& ssp;
   static const std::string& its_aid;
+  static const std::string& gn_payload;
+  static const std::string& btp_type;
+  static const std::string& btp_payload;
   static const std::vector<unsigned char>& mac_address;
   
   Params() : std::map<std::string, std::string>() {};

ccsrc/Framework/src/Params.cc

@@ -8,6 +8,9 @@ const std::string& Params::mac_src = std::string("mac_src");
 const std::string& Params::mac_dst = std::string("mac_dst");
 const std::string& Params::its_aid = std::string("its_aid");
 const std::string& Params::ssp = std::string("ssp");
+const std::string& Params::gn_payload = std::string("gn_payload");
+const std::string& Params::btp_type = std::string("btp_type");
+const std::string& Params::btp_payload = std::string("btp_payload");
 const std::vector<unsigned char>& Params::mac_address({0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF});
 
 void Params::convert(Params& p_param, const std::string p_parameters) {

ccsrc/Ports/LibIts_ports/BTP_ports/BtpPort.cc

@@ -52,9 +52,11 @@ namespace LibItsBtp__TestSystem {
     // Build layer stack
     std::map<std::string, std::string>::iterator it = _cfg_params.find(std::string("params"));
     if (it != _cfg_params.end()) {
-      //loggers::get_instance().log("BtpPort::user_map: %s", it->second.c_str());
+      loggers::get_instance().log("BtpPort::user_map: %s", it->second.c_str());
       _layer = LayerStackBuilder::GetInstance()->createLayerStack(it->second.c_str());
       dynamic_cast<BTPLayer *>(_layer)->addUpperPort(this);
+    } else {
+      loggers::get_instance().error("BtpPort::user_map: No layers defined in configuration file");
     }
   }
 

ccsrc/Ports/LibIts_ports/GN_ports/GeoNetworkingPort.cc

@@ -61,6 +61,8 @@ namespace LibItsGeoNetworking__TestSystem {
       //loggers::get_instance().log("GeoNetworkingPort::user_map: %s", it->second.c_str());
       _layer = LayerStackBuilder::GetInstance()->createLayerStack(it->second.c_str());
       dynamic_cast<GeoNetworkingLayer *>(_layer)->addUpperPort(this);
+    } else {
+      loggers::get_instance().error("GeoNetworkinggPort::user_map: No layers defined in configuration file");
     }
   }
 

ccsrc/Protocols/BTP/BTPCodec.cc

@@ -20,14 +20,6 @@ int BTPCodec::encode (const LibItsBtp__TypesAndValues::BtpPacket& msg, OCTETSTRI
 
   loggers::get_instance().log_msg("<<< BTPCodec::encode: data=", data);
   return 0;
-  /*
-
-  
-    TTCN_Buffer b;
-    p.header().encode(LibItsBtp__TypesAndValues::BtpHeader_descr_, b, TTCN_EncDec::CT_RAW);
-    b.get_string(data);
-
-    return 0;*/
 }
 
 int BTPCodec::encode_ (const Base_Type& type, const TTCN_Typedescriptor_t& field_descriptor, TTCN_Buffer& encoding_buffer)
@@ -71,19 +63,17 @@ int BTPCodec::encode_ (const Base_Type& type, const TTCN_Typedescriptor_t& field
   return 0;
 }
 
-int BTPCodec::decode (const OCTETSTRING& data, LibItsBtp__TypesAndValues::BtpPacket& msg)
+int BTPCodec::decode (const OCTETSTRING& data, LibItsBtp__TypesAndValues::BtpPacket& msg, Params* param)
 {
   TTCN_EncDec::clear_error();
   TTCN_Buffer decoding_buffer(data);
+  _param = param;
+  
   loggers::get_instance().log_to_hexa(">>> BTPCodec::decode: decoding_buffer=", decoding_buffer);
   decode_(msg, LibItsBtp__TypesAndValues::BtpPacket_descr_, decoding_buffer);
+  
   loggers::get_instance().log_msg("<<< BTPCodec::decode: ", (const Base_Type&)msg);
   return 0;
-
-  /*
-    TTCN_Buffer b(data);
-    p.header().decode(LibItsBtp__TypesAndValues::BtpHeader_descr_, b, TTCN_EncDec::CT_RAW);
-    return 0;*/
 }
 
 int BTPCodec::decode_ (Base_Type& type, const TTCN_Typedescriptor_t& field_descriptor, TTCN_Buffer& decoding_buffer)
@@ -102,15 +92,20 @@ int BTPCodec::decode_ (Base_Type& type, const TTCN_Typedescriptor_t& field_descr
   } else {
     loggers::get_instance().log("BTPCodec::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("@LibItsBtp_TypesAndValues.BtpPacket.payload") == 0) {
-      LibItsBtp__TypesAndValues::BtpPayload p;
-      decode_(p, LibItsBtp__TypesAndValues::BtpPayload_descr_, decoding_buffer);
-      loggers::get_instance().log_msg("BTPCodec::decode_: payload= ", p);
-      if (p.is_bound()) {
-	dynamic_cast<OPTIONAL<LibItsBtp__TypesAndValues::BtpPayload> &>(type) = OPTIONAL<LibItsBtp__TypesAndValues::BtpPayload>(p);
-	loggers::get_instance().log_msg("BTPCodec::decode_: Set OPTIONAL to ", type);
-      } else {
-	loggers::get_instance().log("BTPCodec::decode_: Set OPTIONAL to omit");
+      if (decoding_buffer.get_len() == decoding_buffer.get_pos()) { // No payload, set it to omit
+	loggers::get_instance().log("BTPCodec::decode_: Set OPTIONAL<BtpPayload> to omit");
 	dynamic_cast<OPTIONAL<LibItsBtp__TypesAndValues::BtpPayload> &>(type).set_to_omit();
+      } else {
+	LibItsBtp__TypesAndValues::BtpPayload p;
+	decode_(p, LibItsBtp__TypesAndValues::BtpPayload_descr_, decoding_buffer);
+	loggers::get_instance().log_msg("BTPCodec::decode_: payload= ", p);
+	if (p.is_bound()) {
+	  dynamic_cast<OPTIONAL<LibItsBtp__TypesAndValues::BtpPayload> &>(type) = OPTIONAL<LibItsBtp__TypesAndValues::BtpPayload>(p);
+	  loggers::get_instance().log_msg("BTPCodec::decode_: Set OPTIONAL to ", type);
+	} else {
+	  loggers::get_instance().log("BTPCodec::decode_: Set OPTIONAL to omit");
+	  dynamic_cast<OPTIONAL<LibItsBtp__TypesAndValues::BtpPayload> &>(type).set_to_omit();
+	}
       }
     } else if (std::string(field_descriptor.name).compare("@LibItsBtp_TypesAndValues.BtpPacket.header") == 0) {
       loggers::get_instance().log("BTPCodec::decode_: _type = %d", _type);
@@ -127,14 +122,12 @@ int BTPCodec::decode_ (Base_Type& type, const TTCN_Typedescriptor_t& field_descr
       dynamic_cast<OPTIONAL<LibItsBtp__TypesAndValues::DecodedBtpPayload> &>(type).set_to_omit();
     } else if (std::string(field_descriptor.name).compare("@LibItsBtp_TypesAndValues.BtpPayload.rawPayload") == 0) {
       // Decode BtpRawPayload data structure
-      OCTETSTRING s(decoding_buffer.get_len() - decoding_buffer.get_pos(), decoding_buffer.get_data() + decoding_buffer.get_pos());
-      loggers::get_instance().log_msg("BTPCodec::decode_: s=", s);
-      const unsigned char * p = static_cast<const unsigned char *>(s);
-      if (p == NULL) {
-	loggers::get_instance().warning("BTPCodec::encode_: Static cast error");
-	return -1;
+      OCTETSTRING os(decoding_buffer.get_len() - decoding_buffer.get_pos(), decoding_buffer.get_data() + decoding_buffer.get_pos());
+      loggers::get_instance().log_msg("BTPCodec::decode_: s=", os);
+      if (_param != NULL) {
+	(*_param)[Params::btp_payload] = std::string(static_cast<const char *>(oct2str(os)));
       }
-      dynamic_cast<OCTETSTRING &>(type) = s;
+      dynamic_cast<OCTETSTRING &>(type) = os;
     } else {
       type.decode(field_descriptor, decoding_buffer, TTCN_EncDec::CT_RAW);
     }

ccsrc/Protocols/BTP/BTPCodec.hh

@@ -2,7 +2,8 @@
 #define BTPCODEC_H
 
 #include "Codec.hh"
-#include "loggers.hh"
+#include "loggers.hh" // TODO To be removed
+#include "Params.hh"
 
 class Base_Type;
 class TTCN_Typedescriptor_t;
@@ -21,18 +22,20 @@ class BTPCodec: public Codec <
   LibItsBtp__TypesAndValues::BtpPacket,
   LibItsBtp__TypesAndValues::BtpPacket>
 {
+  Params* _param;
+  
   int encode_ (const Base_Type& type, const TTCN_Typedescriptor_t& field_descriptor, TTCN_Buffer& encoding_buffer);
 
   int decode_ (Base_Type& type, const TTCN_Typedescriptor_t& field_descriptor, TTCN_Buffer& decoding_buffer);
 
 public:
   enum BtpType { btpA, btpB };
-  BTPCodec() : Codec<LibItsBtp__TypesAndValues::BtpPacket, LibItsBtp__TypesAndValues::BtpPacket>() { _type = BTPCodec::btpA; loggers::get_instance().log("BTPCodec::BTPCodec(D) :%d ", _type); };
+  BTPCodec() : Codec<LibItsBtp__TypesAndValues::BtpPacket, LibItsBtp__TypesAndValues::BtpPacket>(), _param(NULL) { _type = BTPCodec::btpA; loggers::get_instance().log("BTPCodec::BTPCodec(D) :%d ", _type); };
   virtual ~BTPCodec() { loggers::get_instance().log("BTPCodec::~BTPCodec"); };
 
   void set_btp_type(const BTPCodec::BtpType p_BtpType);
   virtual int encode (const LibItsBtp__TypesAndValues::BtpPacket&, OCTETSTRING& data);
-  virtual int decode (const OCTETSTRING& data, LibItsBtp__TypesAndValues::BtpPacket&);
+  virtual int decode (const OCTETSTRING& data, LibItsBtp__TypesAndValues::BtpPacket&, Params* param = NULL);
 
 private:
   BtpType _type;

ccsrc/Protocols/BTP/BTPLayer.cc

@@ -31,9 +31,18 @@ void BTPLayer::receiveData(OCTETSTRING& data, Params& params)
   loggers::get_instance().log_msg(">>> BTPLayer::receiveData: ", data);
   // Decode the payload
   LibItsBtp__TestSystem::BtpInd p;
-  _codec.decode(data, p.msgIn());
+  _codec.decode(data, p.msgIn(), &params);
   
-  // Send it to the ports
+  // Pass the BTP raw payload to the upper layers if any
+  std::map<std::string, std::string>::const_iterator it = params.find(Params::btp_payload);
+  if (it != params.cend()) {
+    loggers::get_instance().log("BTPLayer::receiveData: btp_payload=%s", it->second.c_str());
+    OCTETSTRING os(str2oct(CHARSTRING(it->second.c_str())));
+    receiveToAllLayers(os, params);
+  } else {
+    loggers::get_instance().warning("BTPLayer::receiveData: No payload to pass to upper layers");
+  }
+  // Pass it to the ports if amy
   toAllUpperPorts(p, params);
 }
 

ccsrc/Protocols/GeoNetworking/GeoNetworkingCodec.cc

@@ -101,10 +101,12 @@ int GeoNetworkingCodec::encode_ (const Base_Type& type, const TTCN_Typedescripto
   return 0;
 }
 
-int GeoNetworkingCodec::decode (const OCTETSTRING& data, LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu& msg)
+int GeoNetworkingCodec::decode (const OCTETSTRING& data, LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu& msg, Params* param)
 {
   TTCN_EncDec::clear_error();
   TTCN_Buffer decoding_buffer(data);
+  _param = param;
+  
   loggers::get_instance().log_to_hexa(">>> GeoNetworkingCodec::decode: decoding_buffer=", decoding_buffer);
   decode_(msg, LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu_descr_, decoding_buffer);
   loggers::get_instance().log_msg("<<< GeoNetworkingCodec::decode: ", (const Base_Type&)msg);
@@ -148,13 +150,13 @@ int GeoNetworkingCodec::decode_ (Base_Type& type, const TTCN_Typedescriptor_t& f
       }
     } else if (std::string(field_descriptor.name).compare("@LibItsGeoNetworking_TypesAndValues.GnNonSecuredPacket.payload") == 0) {
       LibItsGeoNetworking__TypesAndValues::Payload p;
-      decode_(p, LibItsGeoNetworking__TypesAndValues::Payload_descr_, decoding_buffer);
+      decode_(p, *p.get_descriptor(), decoding_buffer);
       loggers::get_instance().log_msg("GeoNetworkingCodec::decode_: payload= ", p);
       if (p.is_bound()) {
 	dynamic_cast<OPTIONAL<LibItsGeoNetworking__TypesAndValues::Payload> &>(type) = OPTIONAL<LibItsGeoNetworking__TypesAndValues::Payload>(p);
-	loggers::get_instance().log_msg("GeoNetworkingCodec::decode_: Set OPTIONAL to ", type);
+	loggers::get_instance().log_msg("GeoNetworkingCodec::decode_: Set OPTIONAL<Payload> to ", type);
       } else {
-	loggers::get_instance().log("GeoNetworkingCodec::decode_: Set OPTIONAL to omit");
+	loggers::get_instance().log("GeoNetworkingCodec::decode_: Set OPTIONAL<Payload> to omit");
 	dynamic_cast<OPTIONAL<LibItsGeoNetworking__TypesAndValues::Payload> &>(type).set_to_omit();
       }
     } else if (std::string(field_descriptor.name).compare("@LibItsGeoNetworking_TypesAndValues.Payload.decodedPayload") == 0) {
@@ -168,15 +170,22 @@ int GeoNetworkingCodec::decode_ (Base_Type& type, const TTCN_Typedescriptor_t& f
 	loggers::get_instance().warning("GeoNetworkingCodec::encode_: Static cast error");
 	return -1;
       }
+      // Align the payload length with the specified plLenght value
       if (_dc.plLength != 0) {
 	if ((unsigned char)s.lengthof() <= _dc.plLength) {
 	  _dc.payload.assign(p, p + s.lengthof());
 	} else {
 	  _dc.payload.assign(p, p + _dc.plLength);
 	}
+      } else {
+	_dc.payload.clear();
       }
       loggers::get_instance().log("GeoNetworkingCodec::decode_: vector length=%d", _dc.payload.size());
-      dynamic_cast<OCTETSTRING &>(type) = OCTETSTRING(_dc.payload.size(), static_cast<const unsigned char *>(_dc.payload.data()));
+      OCTETSTRING os(_dc.payload.size(), static_cast<const unsigned char *>(_dc.payload.data()));
+      if (_param != NULL) {
+	(*_param)[Params::gn_payload] = std::string(static_cast<const char *>(oct2str(os)));
+      }
+      dynamic_cast<OCTETSTRING &>(type) = os;
     } else if (std::string(field_descriptor.name).compare("@LibItsGeoNetworking_TypesAndValues.CommonHeader.plLength") == 0) {
       // Decode plLength data structure
       type.decode(field_descriptor, decoding_buffer, TTCN_EncDec::CT_RAW);

ccsrc/Protocols/GeoNetworking/GeoNetworkingCodec.hh

@@ -4,7 +4,8 @@
 #include <vector>
 
 #include "Codec.hh"
-#include "loggers.hh"
+#include "Params.hh"
+#include "loggers.hh" // TODO To be removed
 
 class Base_Type;
 class TTCN_Typedescriptor_t;
@@ -46,6 +47,8 @@ class GeoNetworkingCodec : public Codec<LibItsGeoNetworking__TypesAndValues::Geo
 
   Encoding_Context _ec;
   Decoding_Context _dc;
+
+  Params* _param;
   
   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);
@@ -56,11 +59,11 @@ class GeoNetworkingCodec : public Codec<LibItsGeoNetworking__TypesAndValues::Geo
   int decode_extendedHeader(LibItsGeoNetworking__TypesAndValues::ExtendedHeader& u, TTCN_Buffer& decodin_buffer);
 
 public:
-  GeoNetworkingCodec() : Codec<LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu, LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu>(), _ec(), _dc() { loggers::get_instance().log("GeoNetworkingCodec::GeoNetworkingCodec(D) :%d ", _ec.next_header); };
+  GeoNetworkingCodec() : Codec<LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu, LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu>(), _ec(), _dc(), _param(NULL) { loggers::get_instance().log("GeoNetworkingCodec::GeoNetworkingCodec(D) :%d ", _ec.next_header); };
   virtual ~GeoNetworkingCodec() { loggers::get_instance().log("GeoNetworkingCodec::~GeoNetworkingCodec"); };
   
-  int encode (const LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu& msg, OCTETSTRING& data);
-  int decode (const OCTETSTRING& data, LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu& msg);
+  virtual int encode (const LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu& msg, OCTETSTRING& data);
+  virtual int decode (const OCTETSTRING& data, LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu& msg, Params* param = NULL);
 };
 
 #endif

ccsrc/Protocols/GeoNetworking/GeoNetworkingLayer.cc

@@ -32,12 +32,12 @@ void GeoNetworkingLayer::receiveData(OCTETSTRING& data, Params& params) {
   loggers::get_instance().log_msg(">>> GeoNetworkingLayer::receiveData: ", data);
   // Decode the payload
   LibItsGeoNetworking__TestSystem::GeoNetworkingInd p;
-  _codec.decode(data, p.msgIn());
+  _codec.decode(data, p.msgIn(), &params);
   // Add lower layers parameters
   // 1. Destination MAC address
   std::map<std::string, std::string>::const_iterator it = params.find(Params::mac_dst);
   if (it != params.cend()) {
-    loggers::get_instance().log("GeoNetworkingLayer::receiveData: dst=", it->second.c_str());
+    loggers::get_instance().log("GeoNetworkingLayer::receiveData: dst=%s", it->second.c_str());
     p.macDestinationAddress() = str2oct(CHARSTRING(it->second.c_str()));
   } else {
     p.macDestinationAddress() = OCTETSTRING(Params::mac_address.size(), Params::mac_address.data());
@@ -45,7 +45,7 @@ void GeoNetworkingLayer::receiveData(OCTETSTRING& data, Params& params) {
   // 2. ssp
   it = params.find(Params::ssp);
   if (it != params.cend()) {
-    loggers::get_instance().log("GeoNetworkingLayer::receiveData: ssp=", it->second.c_str());
+    loggers::get_instance().log("GeoNetworkingLayer::receiveData: ssp=%s", it->second.c_str());
     p.ssp() = str2bit(CHARSTRING(it->second.c_str()));
   } else {
     p.ssp().set_to_omit();
@@ -53,13 +53,22 @@ void GeoNetworkingLayer::receiveData(OCTETSTRING& data, Params& params) {
   // 3. its_aid
   it = params.find(Params::its_aid);
   if (it != params.cend()) {
-    loggers::get_instance().log("GeoNetworkingLayer::receiveData: its_aid=", it->second.c_str());
+    loggers::get_instance().log("GeoNetworkingLayer::receiveData: its_aid=%s", it->second.c_str());
     p.its__aid() = std::stoi(it->second.c_str());
   } else {
     p.its__aid().set_to_omit();
   }
   
-  // Send it to the ports
+  // Pass the GeoNetworking raw payload to the upper layers if any
+  it = params.find(Params::gn_payload);
+  if (it != params.cend()) {
+    loggers::get_instance().log("GeoNetworkingLayer::receiveData: gn_payload=%s", it->second.c_str());
+    OCTETSTRING os(str2oct(CHARSTRING(it->second.c_str())));
+    receiveToAllLayers(os, params);
+  } else {
+    loggers::get_instance().warning("GeoNetworkingLayer::receiveData: No payload to pass to upper layers");
+  }
+  // Pass it to the ports
   toAllUpperPorts(p, params);
 }