Add beaconing based on POSIX timer, alternatively based on fork (commented code)

ccsrc/Framework/Params.hh

@@ -7,6 +7,9 @@ class Params : public std::map<std::string, std::string> {
 public:
   static const std::string& mac_src;
   static const std::string& mac_dst;
+  static const std::string& mac_bc;
+  static const std::string& eth_type;
+  static const std::string& beaconing;
   static const std::string& ssp;
   static const std::string& its_aid;
   static const std::string& gn_payload;

ccsrc/Framework/src/Params.cc

@@ -6,6 +6,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::mac_bc = std::string("mac_bc");
+const std::string& Params::eth_type = std::string("eth_type");
+const std::string& Params::beaconing = std::string("beaconing");
 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");

ccsrc/Protocols/ETH/EthernetLayer.cc

@@ -14,30 +14,38 @@ EthernetLayer::EthernetLayer(const std::string & p_type, const std::string & par
 
 void EthernetLayer::sendData(OCTETSTRING& data, Params& params) {
   loggers::get_instance().log_msg(">>> EthernetLayer::sendData: ", data);
-  
+
   OCTETSTRING eth;
-  Params::const_iterator it = params.find(Params::mac_dst); // Find in provided parameters
+  // Destination MAC address
+  Params::const_iterator it = params.find(Params::mac_dst); // Find in provided parameters, params
   if (it != params.cend()) {
     eth = str2oct(CHARSTRING(it->second.c_str()));    
   } else {
-    it = _params.find(Params::mac_dst); // Find in layer parameters
+    it = _params.find(Params::mac_dst); // Find in layer parameters, _params
     if (it != _params.cend()) {
       eth = str2oct(CHARSTRING(it->second.c_str()));    
     } else {
-      eth = str2oct(CHARSTRING(_params["mac_bc"].c_str()));
+      eth = str2oct(CHARSTRING(_params[Params::mac_bc].c_str()));
     }
   }
-  it = _params.find(Params::mac_src); // Find in layer parameters
-  if (it != _params.cend()) {
+  // Source MAC address
+  it = params.find(Params::mac_src); // Find in provided parameters, params
+  if (it != params.cend()) {
     eth += str2oct(CHARSTRING(it->second.c_str()));    
   } else {
-    eth += str2oct(CHARSTRING(_params["mac_bc"].c_str()));
+    it = _params.find(Params::mac_src); // Find in layer parameters, _params
+    if (it != _params.cend()) {
+      eth += str2oct(CHARSTRING(it->second.c_str()));    
+    } else {
+      const unsigned char null_mac[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+      eth += OCTETSTRING(sizeof(null_mac), static_cast<const unsigned char *>(null_mac));
+    }
   }
-  it = _params.find("eth_type"); // Find in layer parameters
+  it = _params.find(Params::eth_type); // Find in layer parameters
   if (it != params.cend()) {
     eth += str2oct(CHARSTRING(it->second.c_str()));        
   } else {
-    const unsigned char proto[] = {0x89, 0x47};
+    const unsigned char proto[] = { 0x89, 0x47 };
     eth += OCTETSTRING(sizeof(proto), static_cast<const unsigned char *>(proto));
   }
   

ccsrc/Protocols/GeoNetworking/GeoNetworkingLayer.cc

@@ -7,7 +7,7 @@
 
 using namespace LibItsGeoNetworking__TypesAndValues;
 
-GeoNetworkingLayer::GeoNetworkingLayer(const std::string & p_type, const std::string & param) : TLayer<LibItsGeoNetworking__TestSystem::GeoNetworkingPort>(p_type), _params(), _codec(), _beacon(NULL), _thread(NULL), _sendData(), _running(FALSE) {
+GeoNetworkingLayer::GeoNetworkingLayer(const std::string & p_type, const std::string & param) : TLayer<LibItsGeoNetworking__TestSystem::GeoNetworkingPort>(p_type), _params(), _codec(), _beacon(NULL), _sendData() {
   loggers::get_instance().log(">>> GeoNetworkingLayer::GeoNetworkingLayer: %s, %s", to_string().c_str(), param.c_str());
   // Setup parameters
   Params::convert(_params, param);
@@ -33,17 +33,12 @@ GeoNetworkingLayer::GeoNetworkingLayer(const std::string & p_type, const std::st
     _params.insert(std::pair<std::string, std::string>(std::string("mac_bc"), "FFFFFFFFFFFF"));
   }
   fill_beacon(latitude, longitude, ll_address);
-  // Prepare the static part of the TestSystem beacon
-  it = _params.find("");
-  if ((it != _params.cend()) && (it->second.compare("1") == 0)) {
-    start_beaconing();
-  }
-}
+} // End of constructor
 
 GeoNetworkingLayer::~GeoNetworkingLayer() {
-  stop_beaconing();
-  delete _beacon;
-}
+
+} // End of destructor
+
 void GeoNetworkingLayer::sendMsg(const LibItsGeoNetworking__TestSystem::GeoNetworkingReq& p, Params& params) {
   loggers::get_instance().log(">>> GeoNetworkingLayer::sendMsg");
 
@@ -108,75 +103,25 @@ void GeoNetworkingLayer::receiveData(OCTETSTRING& data, Params& params) {
   toAllUpperPorts(p, params);
 }
 
-void GeoNetworkingLayer::start_beaconing() {
-  loggers::get_instance().log(">>> GeoNetworkingLayer::start_beaconing");
-
-  // Sanity checks
-  if (_thread != NULL) { // Already started
-    return;
-  }
-
-  // Create the offline reader thread
-  _thread = new std::thread(&GeoNetworkingLayer::run_beaconing, (void *)this);
-  if (_thread == NULL) {
-    loggers::get_instance().error("GeoNetworkingLayer::start_beaconing: Failed to start beaconing thread");
-  }
-  // Wait for the thread
-  while (_running == FALSE) {
-    std::this_thread::sleep_for(std::chrono::milliseconds(100));
-  }
-  // Thread was started
-  loggers::get_instance().log("<<< PcapLayer::PcapLayer");    
-}
-
-void GeoNetworkingLayer::stop_beaconing() {
-  loggers::get_instance().log(">>> GeoNetworkingLayer::stop_beaconing");
-  if (_thread != NULL) {
-    _running = FALSE;
-    // Wait for the working thread to terminate
-    _thread->join();
-    loggers::get_instance().log("GeoNetworkingLayer::stop_beaconing: Thread were stops");
-    _thread = NULL;
-  }
-}
-
-void* GeoNetworkingLayer::run_beaconing(void* p_this) {
-  loggers::get_instance().log(">>> GeoNetworkingLayer::run_beaconing");
-
-  // Pointer the main object
-  GeoNetworkingLayer& p = *static_cast<GeoNetworkingLayer *>(p_this);
-  Params params(p._params);
-  std::chrono::milliseconds expiry(1000); // Default is set to 1 second
-  Params::const_iterator it = params.find("TsBeaconInterval");
-  if (it != params.cend()) {
-    expiry = std::chrono::milliseconds(std::stoul(it->second));
-  }
-  ExtendedHeader* eh = static_cast<ExtendedHeader *>(p._beacon->gnPacket().packet().extendedHeader().get_opt_value());
+void GeoNetworkingLayer::send_beacon() {
+  loggers::get_instance().log(">>> GeoNetworkingLayer::send_beacon");
+  ExtendedHeader* eh = static_cast<ExtendedHeader *>(_beacon->gnPacket().packet().extendedHeader().get_opt_value());
   if (eh == NULL) {
-    loggers::get_instance().error("GeoNetworkingLayer::run_beaconing: Wrong cast");
+    loggers::get_instance().error("GeoNetworkingLayer::send_beacon: Wrong cast");
   }
-  GeoNetworkingCodec codec;
-  // Start beaconing
-  p._running = TRUE;
-  std::this_thread::sleep_for(std::chrono::milliseconds(100));
-  while (p._running == TRUE) { // Loop while _running flag is up
-    // Update timestamp
-    unsigned long long ms = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count() - 1072911600000L; // TODO Add method such as its_tme() & its_time_mod()
-    eh->beaconHeader().srcPosVector().timestamp__() = ms;
-    // Encode message using TITAN because of payload in omited
-    TTCN_Buffer encoding_buffer;
-    p._beacon->encode(*(p._beacon->get_descriptor()), encoding_buffer, TTCN_EncDec::CT_RAW);
-    OCTETSTRING data(encoding_buffer.get_len(), encoding_buffer.get_data());
-    // Send it
-    p.sendData(data, params);
-    // Timer
-    ms = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count() + expiry.count();
-    while ((p._running == TRUE) && (ms > std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count()));
-  } // End of 'while' statement<
+  // Update timestamp
+  unsigned long long ms = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count() - 1072911600000L; // TODO Add method such as its_tme() & its_time_mod()
+  eh->beaconHeader().srcPosVector().timestamp__() = ms;
+  // Encode message using TITAN because of payload in omited
+  TTCN_Buffer encoding_buffer;
+  _beacon->encode(*(_beacon->get_descriptor()), encoding_buffer, TTCN_EncDec::CT_RAW);
+  OCTETSTRING data(encoding_buffer.get_len(), encoding_buffer.get_data());
+  // Send it
+  Params params(_params);
+  sendData(data, params);
   
-  loggers::get_instance().log("<<< GeoNetworkingLayer::run_beaconing");
-  return NULL;
-}
+  loggers::get_instance().log("<<< GeoNetworkingLayer::send_beacon");
+} // End of send_beacon method
 
 void GeoNetworkingLayer::fill_beacon(INTEGER& p_latitude, INTEGER& p_longitude, OCTETSTRING& p_ll_address)
 {

ccsrc/Protocols/GeoNetworking/GeoNetworkingLayer.hh

@@ -21,16 +21,12 @@ class GeoNetworkingLayer : public TLayer<LibItsGeoNetworking__TestSystem::GeoNet
   Params _params;
   GeoNetworkingCodec _codec;
   LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu* _beacon;
-  std::thread* _thread;
-  std::mutex _sendData;
-  bool _running;
+  std::mutex _sendData; // FIXME To be removed, useless
 
   void fill_beacon(INTEGER& p_latitude, INTEGER& p_longitude, OCTETSTRING& p_ll_address);
   
-  static void* run_beaconing(void* p_this);
-
 public:
-  GeoNetworkingLayer() : TLayer<LibItsGeoNetworking__TestSystem::GeoNetworkingPort>(), _params(), _codec(), _beacon(NULL), _thread(NULL), _sendData(), _running(FALSE) {};
+  GeoNetworkingLayer() : TLayer<LibItsGeoNetworking__TestSystem::GeoNetworkingPort>(), _params(), _codec(), _beacon(NULL), _sendData() {};
   GeoNetworkingLayer(const std::string& p_type, const std::string& param);
   virtual ~GeoNetworkingLayer();
   
@@ -39,8 +35,7 @@ public:
   virtual void sendData(OCTETSTRING& data, Params& params);
   virtual void receiveData(OCTETSTRING& data, Params& params);
 
-  void start_beaconing();
-  void stop_beaconing();
+  void send_beacon();
 };
 
 #endif

ccsrc/Protocols/GeoNetworking/Makefile

@@ -4,12 +4,12 @@ PROJECT      = its-framework
 DEBUG        = yes
 testdir      = tests
 srcdir       = .
-ccflags      += -O0 -ggdb -std=c++11 -DTITAN_RUNTIME_2
+ccflags      += -O0 -ggdb -std=c++11 -DTITAN_RUNTIME_2 -DWIN32
 
 alibs        = $(PROJECT)
 
 sources       := ../../Framework/src/LayerFactory.cc GeoNetworkingCodec.cc GeoNetworkingLayer.cc
 headers       := Codec.hh Layer.hh GeoNetworkingTypes.hh GeoNetworkingCodec.hh  GeoNetworkingLayer.hh
-includes      := . .. ../../Framework ../../loggers ../../../../bin
+includes      := . .. ../../Framework ../../loggers ../../../../bin $(TTCN3_DIR)/include
 
 include ../../common.mk

ccsrc/Protocols/Pcap/PcapLayer.cc

@@ -180,7 +180,7 @@ void* PcapLayer::run(void* p_this) {
 }
 
 void PcapLayer::sendData(OCTETSTRING& data, Params& params) {
-  //loggers::get_instance().log_msg(">>> PcapLayer::sendData: ", data);
+  loggers::get_instance().log_msg(">>> PcapLayer::sendData: ", data);
 
   if (_pcap_h != -1) { // Check if offline mode is used
     if (pcap_sendpacket(_device, static_cast<const unsigned char *>(data), data.lengthof()) == -1) {