Add Commsignia support for RX

ccsrc/Protocols/Commsignia/CommsigniaLayer.cc

+#include <arpa/inet.h>
+
 #include "CommsigniaLayerFactory.hh"
 
 #include "loggers.hh"
 
-CommsigniaLayer::CommsigniaLayer(const std::string & p_type, const std::string & param) : Layer(p_type), _params() {
+CommsigniaLayer::CommsigniaLayer(const std::string & p_type, const std::string & param) : Layer(p_type), _params(), _c2p_recv{0}, _802_11p_hdr{0}, _c2p_llc_hdr{0} {
   loggers::get_instance().log(">>> CommsigniaLayer::CommsigniaLayer: %s, %s", to_string().c_str(), param.c_str());
+  
   // Setup parameters
   Params::convert(_params, param);
   Params::const_iterator it = _params.find("mac_bc");
   if (it == _params.cend()) {
     _params.insert(std::pair<std::string, std::string>(std::string("mac_bc"), "FFFFFFFFFFFF"));
   }
+  it = _params.find(Params::eth_type);
+  if (it == _params.cend()) {
+    _params.insert(std::pair<std::string, std::string>(std::string("eth_type"), "8947"));
+  }
   //_params.log();
 }
 
@@ -20,7 +27,43 @@ void CommsigniaLayer::sendData(OCTETSTRING& data, Params& params) {
 
 void CommsigniaLayer::receiveData(OCTETSTRING& data, Params& params) {
   loggers::get_instance().log_msg(">>> CommsigniaLayer::receiveData: ", data);
-
+  
+  const unsigned char* p = static_cast<const unsigned char *>(data);
+  const CommsigniaLayer::c2p_recv* r = (const CommsigniaLayer::c2p_recv*)p;
+  //loggers::get_instance().log("CommsigniaLayer::receiveData: version=%02x", r->version);
+  //loggers::get_instance().log("CommsigniaLayer::receiveData: timestamp1=%08x", ntohl(r->timestamp_sec));
+  //loggers::get_instance().log("CommsigniaLayer::receiveData: timestamp2=%08x", ntohl(r->timestamp_msec));
+  //loggers::get_instance().log("CommsigniaLayer::receiveData: rssi_ant1=%02x", r->rssi_ant1);
+  //loggers::get_instance().log("CommsigniaLayer::receiveData: rssi_ant2=%02x", r->rssi_ant2);
+  //loggers::get_instance().log("CommsigniaLayer::receiveData: noise_ant1=%02x", r->noise_ant1);
+  //loggers::get_instance().log("CommsigniaLayer::receiveData: noise_ant2=%02x", r->noise_ant2);
+  const CommsigniaLayer::c2p_802_11p_hdr* h = (const CommsigniaLayer::c2p_802_11p_hdr*)(p + sizeof(CommsigniaLayer::c2p_recv));
+  loggers::get_instance().log("CommsigniaLayer::receiveData: frame_ctrl=%04x", h->frame_ctrl);
+  OCTETSTRING dst = OCTETSTRING(6, (const unsigned char*)&h->dst_addr);
+  //loggers::get_instance().log_msg("CommsigniaLayer::receiveData: dst: ", dst);
+  OCTETSTRING src = OCTETSTRING(6, (const unsigned char*)&h->src_addr);
+  //loggers::get_instance().log_msg("CommsigniaLayer::receiveData: src: ", src);
+  const CommsigniaLayer::c2p_llc_hdr* l = (const CommsigniaLayer::c2p_llc_hdr*)(p + sizeof(CommsigniaLayer::c2p_recv) + sizeof(CommsigniaLayer::c2p_802_11p_hdr));
+  //loggers::get_instance().log("CommsigniaLayer::receiveData: dsap=%02x", l->dsap);
+  //loggers::get_instance().log("CommsigniaLayer::receiveData: ssap=%02x", l->ssap);
+  //loggers::get_instance().log("CommsigniaLayer::receiveData: type=%04x", ntohs(l->type));
+  // Check ether type
+  OCTETSTRING et = str2oct(_params[Params::eth_type].c_str());
+  loggers::get_instance().log_msg("CommsigniaLayer::receiveData: ether type convert: ", et);
+  if ((et[0].get_octet() == (unsigned char)((l->type & 0xff00) >> 8)) && (et[1].get_octet() == (unsigned char)(l->type & 0xff))) { // Warning: Network ordered bytes
+    // Extract payload
+    int length = sizeof(CommsigniaLayer::c2p_recv) + sizeof(CommsigniaLayer::c2p_802_11p_hdr) + sizeof(CommsigniaLayer::c2p_llc_hdr);
+    data = OCTETSTRING(data.lengthof() - length, length + static_cast<const unsigned char *>(data));
+    loggers::get_instance().log_msg("CommsigniaLayer::receiveData: payload for upper layer:", data);
+    
+    // Update params
+    CHARSTRING s = oct2str(dst);
+    params[Params::mac_dst] = std::string(static_cast<const char *>(s));
+    s = oct2str(src);
+    params[Params::mac_src] = std::string(static_cast<const char *>(s));
+    
+    receiveToAllLayers(data, params);
+  } // else, nothing to do
 }
 
 CommsigniaLayerFactory CommsigniaLayerFactory::_f;

ccsrc/Protocols/Commsignia/CommsigniaLayer.hh

@@ -4,11 +4,57 @@
 #include "Params.hh"
 
 class CommsigniaLayer : public Layer {
+  static constexpr unsigned char LL_ADDR_LENGTH = 6;
+  static constexpr unsigned char LL_ORG_CODE_LENGTH = 3;
+  
+  typedef struct {
+    unsigned char version;
+    unsigned int timestamp_sec;
+    unsigned int timestamp_msec;
+    unsigned char primary_channel;
+    unsigned char secondary_channel;
+    unsigned char used_iface;
+    unsigned char data_rate;
+    unsigned char antenna;
+    unsigned int latitude;
+    unsigned int longitude;
+    unsigned short speed;
+    unsigned short heading;
+    unsigned char rssi_ant1;
+    unsigned char rssi_ant2;
+    unsigned char noise_ant1;
+    unsigned char noise_ant2;
+    unsigned short cbr_ant1;
+    unsigned short cbr_ant2;
+  } __attribute__((__packed__)) c2p_recv;
+
+  typedef struct {
+    unsigned short frame_ctrl;
+    unsigned short duration;
+    unsigned char dst_addr[CommsigniaLayer::LL_ADDR_LENGTH];
+    unsigned char src_addr[CommsigniaLayer::LL_ADDR_LENGTH];
+    unsigned char bss_id[CommsigniaLayer::LL_ADDR_LENGTH];
+    unsigned short fragment_seq_num;
+    unsigned short qos_ctrl;
+  } __attribute__((__packed__)) c2p_802_11p_hdr;
+
+  typedef struct {
+    unsigned char dsap;
+    unsigned char ssap;
+    unsigned char ctrl;
+    unsigned char org_code[CommsigniaLayer::LL_ORG_CODE_LENGTH];
+    unsigned short type;
+  } __attribute__((__packed__)) c2p_llc_hdr;
+
   Params _params;
+
+  c2p_recv _c2p_recv;
+  c2p_802_11p_hdr _802_11p_hdr;
+  c2p_llc_hdr _c2p_llc_hdr;
 public:
   CommsigniaLayer(const std::string & p_type, const std::string & param);
   virtual ~CommsigniaLayer() {};
 
   virtual void sendData(OCTETSTRING& data, Params& params);
   virtual void receiveData(OCTETSTRING& data, Params& info);
-};
+}; // End of class CommsigniaLayer

ccsrc/Protocols/UDP/UdpLayer.cc

@@ -91,9 +91,9 @@ void UdpLayer::receiveData(OCTETSTRING& data, Params& params) {
 
   // Decode UDP packet
   const unsigned char* buffer = static_cast<const unsigned char *>(data);
-  _iphdr = (struct iphdr *)buffer;
-  _udphdr = (struct udphdr *)(buffer + sizeof(struct iphdr));
-  loggers::get_instance().log("UdpLayer::receiveData: src_port = %d, payload length = %d", ntohs(_udphdr->source), ntohs(_udphdr->len) - sizeof(struct udphdr));
+  _iphdr = (struct iphdr*)buffer;
+  _udphdr = (struct udphdr*)(buffer + sizeof(struct iphdr));
+  loggers::get_instance().log("UdpLayer::receiveData: src_port = %d, payload length = %d", ntohs(_udphdr->source), ntohs(_udphdr->len));
   // TODO To be refined
   data = OCTETSTRING(ntohs(_udphdr->len) - sizeof(struct udphdr), (unsigned char*)(buffer + sizeof(struct iphdr) + sizeof(struct udphdr)));
   loggers::get_instance().log_msg("UdpLayer::receiveData: message payload", data);

ccsrc/Protocols/UDP/UdpLayer.hh

-#ifndef UDP_FINAL_LAYER_H
-#define UDP_FINAL_LAYER_H
+#ifndef UDP_LAYER_H
+#define UDP_LAYER_H
 
 #include <arpa/inet.h>
 #include <linux/ip.h>