emane/v1.0.1/virtualtransport_8cc_source.html

 /*
  * Copyright (c) 2013-2016 - Adjacent Link LLC, Bridgewater, New Jersey
  * Copyright (c) 2008-2010 - DRS CenGen, LLC, Columbia, Maryland
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * * Redistributions of source code must retain the above copyright
  *   notice, this list of conditions and the following disclaimer.
  * * Redistributions in binary form must reproduce the above copyright
  *   notice, this list of conditions and the following disclaimer in
  *   the documentation and/or other materials provided with the
  *   distribution.
  * * Neither the name of DRS CenGen, LLC nor the names of its
  *   contributors may be used to endorse or promote products derived
  *   from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */

 #include "virtualtransport.h"

 #include "emane/downstreampacket.h"
 #include "emane/downstreamtransport.h"
 #include "emane/configureexception.h"
 #include "emane/startexception.h"

 #include "emane/utils/netutils.h"
 #include "emane/utils/threadutils.h"

 #include "emane/controls/serializedcontrolmessage.h"
 #include "emane/controls/flowcontrolcontrolmessage.h"

 #include "emane/controls/r2rineighbormetriccontrolmessage.h"
 #include "emane/controls/r2rineighbormetriccontrolmessageformatter.h"

 #include "emane/controls/r2riqueuemetriccontrolmessage.h"
 #include "emane/controls/r2riqueuemetriccontrolmessageformatter.h"

 #include "emane/controls/r2riselfmetriccontrolmessage.h"
 #include "emane/controls/r2riselfmetriccontrolmessageformatter.h"

 #include <sstream>

 namespace {
   const std::uint16_t DROP_CODE_WRITE_ERROR = 1;
   const std::uint16_t DROP_CODE_FRAME_ERROR = 2;

   EMANE::StatisticTableLabels STATISTIC_TABLE_LABELS {"Write Error",
                                                       "Frame Error"};
 }


 EMANE::Transports::Virtual::VirtualTransport::VirtualTransport(NEMId id,
                                                                PlatformServiceProvider * pPlatformService):
   EthernetTransport(id, pPlatformService),
   pTunTap_{},
   pBitPool_{},
   thread_{},
   bCanceled_{},
   flowControlClient_{*this},
   bFlowControlEnable_{},
   commonLayerStatistics_{STATISTIC_TABLE_LABELS}
 {}

 EMANE::Transports::Virtual::VirtualTransport::~VirtualTransport()
 {
   if(pTunTap_)
     {
       delete pTunTap_;

       pTunTap_ = nullptr;
     }

   if(pBitPool_)
     {
       delete pBitPool_;

       pBitPool_ = nullptr;
     }
 }

 void EMANE::Transports::Virtual::VirtualTransport::initialize(Registrar & registrar)
 {
   pTunTap_ = new TunTap{pPlatformService_};

   pBitPool_ = new Utils::BitPool{pPlatformService_, id_};

   auto & configRegistrar = registrar.configurationRegistrar();

   configRegistrar.registerNonNumeric<std::string>("device",
                                                   ConfigurationProperties::DEFAULT,
                                                   {"emane0"},
                                                   "Virtual device name.");


   configRegistrar.registerNonNumeric<std::string>("devicepath",
                                                   ConfigurationProperties::DEFAULT,
                                                   {NETWORK_DEVICE_PATH},
                                                   "Path to the tuntap device.");

   configRegistrar.registerNumeric<std::uint64_t>("bitrate",
                                                  ConfigurationProperties::DEFAULT,
                                                  {0},
                                                  "Transport bitrate in bps. This is the total allowable"
                                                  " throughput for the transport combined in both directions"
                                                  " (upstream and downstream). A value of 0 disables the"
                                                  " bitrate feature.");

   configRegistrar.registerNumeric<bool>("broadcastmodeenable",
                                         ConfigurationProperties::DEFAULT,
                                         {false},
                                         "Broadcast all packets to all NEMs.");


   configRegistrar.registerNumeric<bool>("arpcacheenable",
                                         ConfigurationProperties::DEFAULT,
                                         {true},
                                         "Enable ARP request/reply monitoring to map Ethernet address to NEM.");


   configRegistrar.registerNumeric<bool>("arpmodeenable",
                                         ConfigurationProperties::DEFAULT,
                                         {true},
                                         "Enable ARP on the virtual device.");

   configRegistrar.registerNumeric<bool>("flowcontrolenable",
                                         ConfigurationProperties::DEFAULT,
                                         {false},
                                         "Enables downstream traffic flow control with a corresponding flow"
                                         " control capable NEM layer.");

   configRegistrar.registerNonNumeric<INETAddr>("address",
                                                ConfigurationProperties::NONE,
                                                {},
                                                "IPv4 or IPv6 virutal device address.");

   configRegistrar.registerNonNumeric<INETAddr>("mask",
                                                ConfigurationProperties::NONE,
                                                {},
                                                "IPv4 or IPv6 virutal device addres network mask.");

   auto & statisticRegistrar = registrar.statisticRegistrar();

   commonLayerStatistics_.registerStatistics(statisticRegistrar);

 }


 void EMANE::Transports::Virtual::VirtualTransport::configure(const ConfigurationUpdate & update)
 {
   for(const auto & item : update)
     {
       if(item.first == "bitrate")
         {
           u64BitRate_ = item.second[0].asUINT64();

           LOGGER_STANDARD_LOGGING(pPlatformService_->logService(),
                                   INFO_LEVEL,
                                   "TRANSPORTI %03hu VirtualTransport::%s %s: %ju",
                                   id_,
                                   __func__,
                                   item.first.c_str(),
                                   u64BitRate_);
         }
       else if(item.first == "devicepath")
         {
           sDevicePath_ = item.second[0].asString();

           LOGGER_STANDARD_LOGGING(pPlatformService_->logService(),
                                   INFO_LEVEL,
                                   "TRANSPORTI %03hu VirtualTransport::%s %s: %s",
                                   id_,
                                   __func__,
                                   item.first.c_str(),
                                   sDevicePath_.c_str());
         }
       else if(item.first == "device")
         {
           sDeviceName_ = item.second[0].asString();

           LOGGER_STANDARD_LOGGING(pPlatformService_->logService(),
                                   INFO_LEVEL,
                                   "TRANSPORTI %03hu VirtualTransport::%s %s: %s",
                                   id_,
                                   __func__,
                                   item.first.c_str(),
                                   sDeviceName_.c_str());
         }
       else if(item.first == "mask")
         {
           mask_ =  item.second[0].asINETAddr();

           LOGGER_STANDARD_LOGGING(pPlatformService_->logService(),
                                   INFO_LEVEL,
                                   "TRANSPORTI %03hu VirtualTransport::%s %s: %s",
                                   id_,
                                   __func__,
                                   item.first.c_str(),
                                   mask_.str(false).c_str());
         }
       else if(item.first == "address")
         {
           address_ = item.second[0].asINETAddr();

           LOGGER_STANDARD_LOGGING(pPlatformService_->logService(),
                                   INFO_LEVEL,
                                   "TRANSPORTI %03hu VirtualTransport::%s %s: %s",
                                   id_,
                                   __func__,
                                   item.first.c_str(),
                                   address_.str(false).c_str());
         }
       else if(item.first == "arpmodeenable")
         {
           bARPMode_ = item.second[0].asBool();

           LOGGER_STANDARD_LOGGING(pPlatformService_->logService(),
                                   INFO_LEVEL,
                                   "TRANSPORTI %03hu VirtualTransport::%s %s: %d",
                                   id_,
                                   __func__,
                                   item.first.c_str(),
                                   bARPMode_);
         }
       else if(item.first == "broadcastmodeenable")
         {
           bBroadcastMode_ = item.second[0].asBool();

           LOGGER_STANDARD_LOGGING(pPlatformService_->logService(),
                                   INFO_LEVEL,
                                   "TRANSPORTI %03hu VirtualTransport::%s %s: %d",
                                   id_,
                                   __func__,
                                   item.first.c_str(),
                                   bBroadcastMode_);
         }
       else if(item.first == "arpcacheenable")
         {
           bArpCacheMode_ = item.second[0].asBool();

           LOGGER_STANDARD_LOGGING(pPlatformService_->logService(),
                                   INFO_LEVEL,
                                   "TRANSPORTI %03hu VirtualTransport::%s %s: %d",
                                   id_,
                                   __func__,
                                   item.first.c_str(),
                                   bArpCacheMode_);
         }
       else if(item.first == "flowcontrolenable")
         {
           bFlowControlEnable_ = item.second[0].asBool();

           LOGGER_STANDARD_LOGGING(pPlatformService_->logService(),
                                   INFO_LEVEL,
                                   "TRANSPORTI %03hu VirtualTransport::%s %s: %d",
                                   id_,
                                   __func__,
                                   item.first.c_str(),
                                   bFlowControlEnable_);
         }
       else
         {
           throw makeException<ConfigureException>("VirtualTransport: "
                                                   "Unexpected configuration item %s",
                                                   item.first.c_str());

         }
     }
 }


 void EMANE::Transports::Virtual::VirtualTransport::start()
 {
   if(pTunTap_->open(sDevicePath_.c_str(), sDeviceName_.c_str()) < 0)
     {
       std::stringstream ssDescription;
       ssDescription << "could not open tuntap device path "
                     << sDevicePath_
                     << " name "
                     << sDeviceName_
                     << std::ends;
       throw StartException(ssDescription.str());
     }

   if(pTunTap_->set_ethaddr (id_) < 0)
     {
       std::stringstream ssDescription;
       ssDescription << "could not set tuntap eth address "
                     << id_
                     << std::ends;
       throw StartException(ssDescription.str());
     }

   if(pTunTap_->activate(bARPMode_) < 0)
     {
       std::stringstream ssDescription;
       ssDescription << "could not activate tuntap arp mode "
                     << bARPMode_
                     << std::ends;
       throw StartException(ssDescription.str());
     }

   // was an interface address provided
   if(!address_.isAny())
     {
       // set tuntap address/mask
       if(pTunTap_->set_addr(address_, mask_) < 0)
         {
           std::stringstream ssDescription;
           ssDescription << "could not set tuntap address "
                         << address_.str();
           ssDescription << " mask "
                         << mask_.str()
                         << std::ends;
           throw StartException(ssDescription.str());
         }
     }

   bCanceled_ = false;

   pBitPool_->setMaxSize(u64BitRate_);

   // start tuntap read thread
   thread_ = std::thread{&VirtualTransport::readDevice,this};
 }

 void EMANE::Transports::Virtual::VirtualTransport::postStart()
 {
   if(bFlowControlEnable_)
     {
       flowControlClient_.start();

        LOGGER_VERBOSE_LOGGING(pPlatformService_->logService(),
                               DEBUG_LEVEL,
                               "TRANSPORTI %03hu VirtualTransport::%s sent a flow control"
                               " token request, a handshake response is required to process"
                               " packets",
                               id_,
                               __func__);

     }
 }

 void EMANE::Transports::Virtual::VirtualTransport::stop()
 {
   if(thread_.joinable())
     {
       if(bFlowControlEnable_)
         {
           flowControlClient_.stop();
         }

       bCanceled_ = true;

       ThreadUtils::cancel(thread_);

       thread_.join();
     }

   pTunTap_->deactivate();

   pTunTap_->close();
 }


 void EMANE::Transports::Virtual::VirtualTransport::destroy()
   throw()
 {}


 void EMANE::Transports::Virtual::VirtualTransport::processUpstreamPacket(UpstreamPacket & pkt,
                                                                          const ControlMessages & msgs)
 {
   const TimePoint beginTime{Clock::now()};

   // frame sanity check
   if(verifyFrame(pkt.get(), pkt.length()) < 0)
     {
       LOGGER_STANDARD_LOGGING(pPlatformService_->logService(),
                               ERROR_LEVEL,
                               "TRANSPORTI %03hu VirtualTransport::%s frame error",
                               id_,
                               __func__);
     }

   handleUpstreamControl(msgs);

   commonLayerStatistics_.processInbound(pkt);

   const PacketInfo & pktInfo{pkt.getPacketInfo()};

   const Utils::EtherHeader * pEtherHeader {reinterpret_cast<const Utils::EtherHeader*>(pkt.get())};

   // update arp cache
   updateArpCache(pEtherHeader, pktInfo.getSource());

   iovec iov;

   iov.iov_base = const_cast<char*>(reinterpret_cast<const char*>(pkt.get()));
   iov.iov_len  = pkt.length();

   if(pTunTap_->writev(&iov, 1) < 0)
     {
       LOGGER_STANDARD_LOGGING(pPlatformService_->logService(),
                               ERROR_LEVEL,
                               "TRANSPORTI %03hu VirtualTransport::%s %s",
                               id_,
                               __func__,
                               strerror(errno));

       commonLayerStatistics_.processOutbound(pkt,
                                              std::chrono::duration_cast<Microseconds>(Clock::now() - beginTime),
                                              DROP_CODE_WRITE_ERROR);
     }
   else
     {
       LOGGER_VERBOSE_LOGGING(pPlatformService_->logService(),
                              DEBUG_LEVEL,
                              "TRANSPORTI %03hu VirtualTransport::%s src %hu, dst %hu, dscp %hhu, length %zu",
                              id_,
                              __func__,
                              pktInfo.getSource(),
                              pktInfo.getDestination(),
                              pktInfo.getPriority(),
                              pkt.length());

       commonLayerStatistics_.processOutbound(pkt,
                                              std::chrono::duration_cast<Microseconds>(Clock::now() - beginTime));

       if(u64BitRate_)
         {
           // drain the bit pool
           const size_t sizePending = pBitPool_->get(pkt.length() * 8);

           // check for bitpool error
           if(sizePending != 0)
             {
               LOGGER_STANDARD_LOGGING(pPlatformService_->logService(),
                                       ERROR_LEVEL,
                                       "TRANSPORTI %03hu VirtualTransport::%s bitpool request error %zd of %zd",
                                       id_,
                                       __func__,
                                       sizePending,
                                       pkt.length() * 8);
             }
         }
     }
 }


 void EMANE::Transports::Virtual::VirtualTransport::processUpstreamControl(const ControlMessages & msgs)
 {
   handleUpstreamControl(msgs);
 }


 void EMANE::Transports::Virtual::VirtualTransport::handleUpstreamControl(const ControlMessages & msgs)
 {
   for(const auto & pMessage : msgs)
     {
       switch(pMessage->getId())
         {
           case Controls::FlowControlControlMessage::IDENTIFIER:
             {
               const auto pFlowControlControlMessage =
                 static_cast<const Controls::FlowControlControlMessage *>(pMessage);

               if(bFlowControlEnable_)
                 {
                   LOGGER_VERBOSE_LOGGING(pPlatformService_->logService(),
                                                  DEBUG_LEVEL,
                                                  "TRANSPORTI %03hu VirtualTransport::%s received a flow control"
                                                  " token update %hu tokens",
                                                  id_,
                                                  __func__,
                                                  pFlowControlControlMessage->getTokens());

                   flowControlClient_.processFlowControlMessage(pFlowControlControlMessage);
                 }
               else
                 {
                   LOGGER_STANDARD_LOGGING(pPlatformService_->logService(),
                                           ERROR_LEVEL,
                                           "TRANSPORTI %03hu VirtualTransport::%s received a flow control"
                                           " message but flow control is not enabled",
                                           id_,
                                           __func__);
                 }
             }
           break;

         case Controls::R2RINeighborMetricControlMessage::IDENTIFIER:
           {
              const auto pR2RINeighborMetricControlMessage =
                 static_cast<const Controls::R2RINeighborMetricControlMessage *>(pMessage);


             LOGGER_VERBOSE_LOGGING_FN_VARGS(pPlatformService_->logService(),
                                             DEBUG_LEVEL,
                                             Controls::R2RINeighborMetricControlMessageFormatter(pR2RINeighborMetricControlMessage),
                                             "TRANSPORTI %03hu VirtualTransport::%s R2RINeighborMetricControlMessage",
                                             id_,
                                             __func__);
           }
           break;

         case Controls::R2RIQueueMetricControlMessage::IDENTIFIER:
           {
             const auto pR2RIQueueMetricControlMessage =
               static_cast<const Controls::R2RIQueueMetricControlMessage *>(pMessage);

             LOGGER_VERBOSE_LOGGING_FN_VARGS(pPlatformService_->logService(),
                                             DEBUG_LEVEL,
                                             Controls::R2RIQueueMetricControlMessageFormatter(pR2RIQueueMetricControlMessage),
                                             "TRANSPORTI %03hu VirtualTransport::%s R2RIQueueMetricControlMessage",
                                             id_,
                                             __func__);
           }
           break;

         case Controls::R2RISelfMetricControlMessage::IDENTIFIER:
           {
             const auto pR2RISelfMetricControlMessage =
               static_cast<const Controls::R2RISelfMetricControlMessage *>(pMessage);

             LOGGER_VERBOSE_LOGGING_FN_VARGS(pPlatformService_->logService(),
                                             DEBUG_LEVEL,
                                             Controls::R2RISelfMetricControlMessageFormatter(pR2RISelfMetricControlMessage),
                                             "TRANSPORTI %03hu VirtualTransport::%s R2RISelfMetricControlMessage",
                                             id_,
                                             __func__);
           }
           break;


           case Controls::SerializedControlMessage::IDENTIFIER:
             {
               const auto pSerializedControlMessage =
                 static_cast<const Controls::SerializedControlMessage *>(pMessage);

               switch(pSerializedControlMessage->getSerializedId())
                 {
                   case Controls::FlowControlControlMessage::IDENTIFIER:
                     {
                       std::unique_ptr<Controls::FlowControlControlMessage>
                         pFlowControlControlMessage{
                         Controls::FlowControlControlMessage::create(
                                                                 pSerializedControlMessage->getSerialization())};

                       if(bFlowControlEnable_)
                         {
                           LOGGER_VERBOSE_LOGGING(pPlatformService_->logService(),
                                                  ERROR_LEVEL,
                                                  "TRANSPORTI %03hu VirtualTransport::%s received a flow control"
                                                  " token update %hu tokens",
                                                  id_,
                                                  __func__,
                                                  pFlowControlControlMessage->getTokens());

                             flowControlClient_.processFlowControlMessage(pFlowControlControlMessage.get());

                         }
                       else
                         {
                           LOGGER_STANDARD_LOGGING(pPlatformService_->logService(),
                                                   ERROR_LEVEL,
                                                   "TRANSPORTI %03hu VirtualTransport::%s received a flow control"
                                                   " message but flow control is not enabled",
                                                   id_,
                                                   __func__);
                         }
                     }
                   break;

                   case Controls::R2RINeighborMetricControlMessage::IDENTIFIER:
                     {
                       std::unique_ptr<Controls::R2RINeighborMetricControlMessage>
                         pR2RINeighborMetricControlMessage{
                         Controls::R2RINeighborMetricControlMessage::create(
                                                                 pSerializedControlMessage->getSerialization())};

                       LOGGER_VERBOSE_LOGGING_FN_VARGS(pPlatformService_->logService(),
                                                       DEBUG_LEVEL,
                                                       Controls::R2RINeighborMetricControlMessageFormatter(
                                                        pR2RINeighborMetricControlMessage.get()),
                                                       "TRANSPORTI %03hu VirtualTransport::%s",
                                                       id_,
                                                       __func__);
                     }
                   break;

                   case Controls::R2RIQueueMetricControlMessage::IDENTIFIER:
                     {
                       std::unique_ptr<Controls::R2RIQueueMetricControlMessage>
                         pR2RIQueueMetricControlMessage{
                         Controls::R2RIQueueMetricControlMessage::create(
                                                                 pSerializedControlMessage->getSerialization())};

                       LOGGER_VERBOSE_LOGGING_FN_VARGS(pPlatformService_->logService(),
                                                       DEBUG_LEVEL,
                                                       Controls::R2RIQueueMetricControlMessageFormatter(
                                                        pR2RIQueueMetricControlMessage.get()),
                                                       "TRANSPORTI %03hu VirtualTransport::%s",
                                                       id_,
                                                       __func__);
                     }
                   break;

                   case Controls::R2RISelfMetricControlMessage::IDENTIFIER:
                     {
                       std::unique_ptr<Controls::R2RISelfMetricControlMessage>
                         pR2RISelfMetricControlMessage{
                         Controls::R2RISelfMetricControlMessage::create(
                                                                 pSerializedControlMessage->getSerialization())};

                       LOGGER_VERBOSE_LOGGING_FN_VARGS(pPlatformService_->logService(),
                                                       DEBUG_LEVEL,
                                                       Controls::R2RISelfMetricControlMessageFormatter(
                                                        pR2RISelfMetricControlMessage.get()),
                                                       "TRANSPORTI %03hu VirtualTransport::%s",
                                                       id_,
                                                       __func__);
                     }
                   break;

                   default:
                      LOGGER_VERBOSE_LOGGING(pPlatformService_->logService(),
                                             DEBUG_LEVEL,
                                             "TRANSPORTI %03hu VirtualTransport::%s unknown serialized msg id %hu, ignore",
                                             id_,
                                             __func__,
                                             pSerializedControlMessage->getSerializedId());

                 }
             }
           break;

           default:
                LOGGER_VERBOSE_LOGGING(pPlatformService_->logService(),
                                       DEBUG_LEVEL,
                                       "TRANSPORTI %03hu VirtualTransport::%s unknown msg id %hu, ignore",
                                       id_,
                                       __func__,
                                       pMessage->getId());
       }
    }
 }


 void EMANE::Transports::Virtual::VirtualTransport::readDevice()
 {
   std::uint8_t buf[Utils::IP_MAX_PACKET];

   while(!bCanceled_)
     {
       ssize_t len{};

       memset(buf, 0x0, sizeof(buf));

       iovec iov;

       iov.iov_base = reinterpret_cast<char*>(buf);
       iov.iov_len  = sizeof(buf);

       // read from tuntap
       if((len = pTunTap_->readv(&iov, 1)) < 0)
         {
           LOGGER_STANDARD_LOGGING(pPlatformService_->logService(),
                                   ERROR_LEVEL,
                                   "TRANSPORTI %03hu VirtualTransport::%s %s",
                                   id_,
                                   __func__,
                                   strerror(errno));

           break;
         }
       else
         {
           const TimePoint beginTime{Clock::now()};

           // frame sanity check
           if(verifyFrame(buf, len) < 0)
             {
               LOGGER_STANDARD_LOGGING(pPlatformService_->logService(),
                                       ERROR_LEVEL,
                                       "TRANSPORTI %03hu VirtualTransport::%s frame error",
                                       id_,
                                       __func__);
             }
           else
             {
               // NEM destination
               NEMId nemDestination;

               // pkt tos/qos converted to dscp
               std::uint8_t dscp{};

               // get dst and dscp values
               if(parseFrame((const Utils::EtherHeader *)buf, nemDestination, dscp) < 0)
                 {
                   LOGGER_STANDARD_LOGGING(pPlatformService_->logService(),
                                           ERROR_LEVEL,
                                           "TRANSPORTI %03hu VirtualTransport::%s frame parse error",
                                           id_,
                                           __func__);
                 }
               else
                 {
                   LOGGER_VERBOSE_LOGGING(pPlatformService_->logService(),
                                          DEBUG_LEVEL,
                                          "TRANSPORTI %03hu VirtualTransport::%s src %hu, dst %hu, dscp %hhu, length %zd",
                                          id_,
                                          __func__,
                                          id_,
                                          nemDestination,
                                          dscp,
                                          len);

                   // create downstream packet with packet info
                   DownstreamPacket pkt(PacketInfo (id_, nemDestination, dscp,Clock::now()), buf, len);

                   commonLayerStatistics_.processInbound(pkt);

                   // check flow control
                   if(bFlowControlEnable_)
                     {
                       auto status = flowControlClient_.removeToken();

                       // block and wait for an available flow control token
                       if(!status.second)
                         {
                           LOGGER_VERBOSE_LOGGING(pPlatformService_->logService(),
                                                  ERROR_LEVEL,
                                                  "TRANSPORTI %03hu VirtualTransport::%s failed to remove token (tokens:%hu)",
                                                  id_,
                                                  __func__,
                                                  status.first);
                           // done
                           break;
                         }
                       else
                         {
                           LOGGER_VERBOSE_LOGGING(pPlatformService_->logService(),
                                                  DEBUG_LEVEL,
                                                  "TRANSPORTI %03hu VirtualTransport::%s removed token (tokens:%hu)",
                                                  id_,
                                                  __func__,
                                                  status.first);
                         }
                     }

                   commonLayerStatistics_.processOutbound(pkt,
                                                          std::chrono::duration_cast<Microseconds>(Clock::now() - beginTime));

                   // send to downstream transport
                   sendDownstreamPacket(pkt);

                   if(u64BitRate_)
                     {
                       // drain the bit pool
                       std::uint64_t sizePending {pBitPool_->get(len * 8)};

                       // check for bitpool error
                       if(sizePending > 0)
                         {
                           LOGGER_STANDARD_LOGGING(pPlatformService_->logService(),
                                                   ERROR_LEVEL,
                                                   "TRANSPORTI %03hu VirtualTransport::%s bitpool "
                                                   "request error %jd of %zd",
                                                   id_,
                                                   __func__,
                                                   sizePending,
                                                   len * 8);
                         }
                     }
                 }
             }
         }
     }
 }


 DECLARE_TRANSPORT(EMANE::Transports::Virtual::VirtualTransport);
EMANE::Transports::Virtual::TunTap
Definition: tuntap.h:70

EMANE::Transports::Virtual::VirtualTransport::VirtualTransport
VirtualTransport(NEMId id, PlatformServiceProvider *pPlatformService)
Definition: virtualtransport.cc:67

EMANE::Controls::SerializedControlMessage::IDENTIFIER
Definition: serializedcontrolmessage.h:109

EMANE::UpstreamPacket
A Packet class that allows upstream processing to strip layer headers as the packet travels up the st...
Definition: upstreampacket.h:51

EMANE::Transports::Virtual::TunTap::deactivate
int deactivate()
Definition: tuntap.cc:200

EMANE::Utils::BitPool
Implementation of a rate limiting bit pool.
Definition: bitpool.h:52

EMANE::Controls::R2RIQueueMetricControlMessage
R2RI Queue Metric Control Message is sent to an NEM&#39;s transport layer to convey information about MAC...
Definition: r2riqueuemetriccontrolmessage.h:58

EMANE::Registrar
The Registrar interface provides access to all of the emulator registrars.
Definition: registrar.h:50

EMANE::Controls::SerializedControlMessage
A Serialized Control Message is used to encapsulate Serializable control messages as they traverse pr...
Definition: serializedcontrolmessage.h:57

EMANE::Transports::Virtual::TunTap::close
int close()
Definition: tuntap.cc:169

EMANE::Transports::Virtual::VirtualTransport::initialize
void initialize(Registrar &registrar) override
Definition: virtualtransport.cc:96

r2riselfmetriccontrolmessageformatter.h

EMANE::Registrar::configurationRegistrar
virtual ConfigurationRegistrar & configurationRegistrar()=0

EMANE::Transports::Virtual::VirtualTransport::stop
void stop() override
Definition: virtualtransport.cc:358

LOGGER_VERBOSE_LOGGING
#define LOGGER_VERBOSE_LOGGING(logger, level, fmt, args...)
Definition: logserviceprovider.h:160

EMANE::Transports::Ethernet::EthernetTransport::bArpCacheMode_
bool bArpCacheMode_
Definition: ethernettransport.h:76

EMANE::Registrar::statisticRegistrar
virtual StatisticRegistrar & statisticRegistrar()=0

EMANE::Utils::CommonLayerStatistics::processOutbound
void processOutbound(const UpstreamPacket &pkt, Microseconds delay, size_t dropCode={})
Definition: commonlayerstatistics.cc:763

EMANE::FlowControlClient::processFlowControlMessage
void processFlowControlMessage(const Controls::FlowControlControlMessage *pMsg)
Definition: flowcontrolclient.cc:153

EMANE::Utils::IP_MAX_PACKET
const std::uint16_t IP_MAX_PACKET
Max ip packet len.
Definition: netutils.h:358

EMANE::Controls::R2RISelfMetricControlMessage::IDENTIFIER
Definition: r2riselfmetriccontrolmessage.h:144

EMANE::ControlMessages
std::list< const ControlMessage * > ControlMessages
Definition: controlmessage.h:77

EMANE::Controls::R2RINeighborMetricControlMessageFormatter
Callable formatter object for R2RINeighborMetricControlMessage instances.
Definition: r2rineighbormetriccontrolmessageformatter.h:48

EMANE::ConfigurationRegistrar::registerNonNumeric
void registerNonNumeric(const std::string &sName, const ConfigurationProperties &properties=ConfigurationProperties::NONE, const std::initializer_list< T > &values={}, const std::string &sUsage="", std::size_t minOccurs=1, std::size_t maxOccurs=1, const std::string &sRegexPattern={})
Definition: configurationregistrar.inl:68

EMANE::INFO_LEVEL
Definition: logserviceprovider.h:48

EMANE::Utils::BitPool::setMaxSize
void setMaxSize(std::uint64_t u64NewSize)
Definition: bitpool.inl:65

flowcontrolcontrolmessage.h

EMANE::Transports::Ethernet::EthernetTransport::parseFrame
virtual int parseFrame(const Utils::EtherHeader *pEthHeader, EMANE::NEMId &dst, std::uint8_t &dscp)
Definition: ethernettransport.cc:166

EMANE::Transports::Virtual::VirtualTransport::start
void start() override
Definition: virtualtransport.cc:286

EMANE::Transports::Virtual::TunTap::activate
int activate(bool)
Definition: tuntap.cc:185

EMANE::PlatformServiceProvider
The PlatformServiceProvider interface provides access to emulator services.
Definition: platformserviceprovider.h:55

threadutils.h

EMANE::Controls::FlowControlControlMessage::create
static FlowControlControlMessage * create(const Serialization &serialization)
Definition: flowcontrolcontrolmessage.cc:94

EMANE::Utils::CommonLayerStatistics::registerStatistics
void registerStatistics(StatisticRegistrar &statisticRegistrar)
Definition: commonlayerstatistics.cc:751

EMANE::Transports::Virtual::VirtualTransport::~VirtualTransport
~VirtualTransport()
Definition: virtualtransport.cc:79

virtualtransport.h

EMANE::Transports::Virtual::TunTap::writev
int writev(const struct iovec *, size_t)
Definition: tuntap.cc:429

EMANE::PacketInfo
Store source, destination, creation time and priority information for a packet.
Definition: packetinfo.h:50

configureexception.h

EMANE::INETAddr::isAny
bool isAny() const
Definition: inetaddr.cc:389

NETWORK_DEVICE_PATH
#define NETWORK_DEVICE_PATH
Definition: tuntap.h:51

r2riqueuemetriccontrolmessage.h

EMANE::Controls::R2RISelfMetricControlMessageFormatter
Callable formatter object for R2RISelfMetricControlMessage instances.
Definition: r2riselfmetriccontrolmessageformatter.h:48

downstreampacket.h

EMANE::ConfigurationProperties::NONE

EMANE::Controls::R2RIQueueMetricControlMessageFormatter
Callable formatter object for R2RIQueueMetricControlMessage instances.
Definition: r2riqueuemetriccontrolmessageformatter.h:48

EMANE::INETAddr
Definition: inetaddr.h:43

LOGGER_VERBOSE_LOGGING_FN_VARGS
#define LOGGER_VERBOSE_LOGGING_FN_VARGS(logger, level, fn, fmt, args...)
Definition: logserviceprovider.h:187

EMANE::Controls::FlowControlControlMessage::IDENTIFIER
Definition: flowcontrolcontrolmessage.h:124

EMANE::StatisticTableLabels
std::vector< std::string > StatisticTableLabels
Definition: statistictablepublisher.h:44

EMANE::UpstreamPacket::getPacketInfo
const PacketInfo & getPacketInfo() const
Definition: upstreampacket.cc:188

EMANE::DownstreamPacket
Specialized packet the allows downstream processing to add layer specific headers as the packet trave...
Definition: downstreampacket.h:55

EMANE::INETAddr::str
std::string str(bool bWithPort=true) const
Definition: inetaddr.cc:409

EMANE::FlowControlClient::stop
void stop()
Definition: flowcontrolclient.cc:140

EMANE::Transports::Ethernet::EthernetTransport::bBroadcastMode_
bool bBroadcastMode_
Definition: ethernettransport.h:75

EMANE::ThreadUtils::cancel
int cancel(std::thread &thread)
Definition: threadutils.h:65

EMANE::FlowControlClient::start
void start()
Definition: flowcontrolclient.cc:134

EMANE::Utils::BitPool::get
std::uint64_t get(std::uint64_t u64Request, bool bFullFill=true)
Definition: bitpool.inl:97

EMANE::NEMLayer::id_
NEMId id_
Definition: nemlayer.h:81

EMANE::Transports::Virtual::VirtualTransport::processUpstreamPacket
void processUpstreamPacket(UpstreamPacket &pkt, const ControlMessages &msgs)
Definition: virtualtransport.cc:385

r2riselfmetriccontrolmessage.h

EMANE::NEMId
std::uint16_t NEMId
Definition: types.h:52

EMANE::Controls::R2RISelfMetricControlMessage::create
static R2RISelfMetricControlMessage * create(const Serialization &serialization)
Definition: r2riselfmetriccontrolmessage.cc:134

EMANE::Controls::FlowControlControlMessage
Flow Control Control Messages are sent between a MAC layer and a transport in order to communicate da...
Definition: flowcontrolcontrolmessage.h:58

EMANE::DEBUG_LEVEL
Definition: logserviceprovider.h:49

DECLARE_TRANSPORT
DECLARE_TRANSPORT(EMANE::Transports::Virtual::VirtualTransport)

startexception.h

EMANE::Transports::Virtual::TunTap::set_ethaddr
int set_ethaddr(const Utils::EtherAddr &)
Definition: tuntap.cc:380

EMANE::PlatformServiceUser::pPlatformService_
PlatformServiceProvider * pPlatformService_
Definition: platformserviceuser.h:64

EMANE::Transports::Virtual::TunTap::readv
int readv(struct iovec *, size_t)
Definition: tuntap.cc:451

EMANE::Controls::R2RINeighborMetricControlMessage
R2RI Neighbor Metric Control Message is sent to an NEM&#39;s transport layer to convey information about ...
Definition: r2rineighbormetriccontrolmessage.h:59

netutils.h

r2rineighbormetriccontrolmessageformatter.h

r2riqueuemetriccontrolmessageformatter.h

EMANE::UpstreamPacket::get
const void * get() const
Definition: upstreampacket.cc:176

EMANE::PlatformServiceProvider::logService
virtual LogServiceProvider & logService()=0

serializedcontrolmessage.h

EMANE::StartException
Component start exception is used to indicate an exception during transition to the start state...
Definition: startexception.h:47

EMANE::Transports::Ethernet::EthernetTransport::verifyFrame
virtual int verifyFrame(const void *buf, size_t len)
Definition: ethernettransport.cc:50

EMANE::ConfigurationUpdate
std::vector< ConfigurationNameAnyValues > ConfigurationUpdate
Definition: configurationupdate.h:82

EMANE::Controls::R2RINeighborMetricControlMessage::create
static R2RINeighborMetricControlMessage * create(const Serialization &serialization)
Definition: r2rineighbormetriccontrolmessage.cc:121

EMANE::FlowControlClient::removeToken
std::pair< std::uint16_t, bool > removeToken()
Definition: flowcontrolclient.cc:147

EMANE::Controls::R2RIQueueMetricControlMessage::IDENTIFIER
Definition: r2riqueuemetriccontrolmessage.h:125

EMANE::ConfigurationProperties::DEFAULT

EMANE::Transports::Virtual::TunTap::set_addr
int set_addr(const INETAddr &, const INETAddr &)
Definition: tuntap.cc:207

EMANE::Transports::Virtual::VirtualTransport::postStart
void postStart() override
Definition: virtualtransport.cc:341

EMANE::Transports::Virtual::VirtualTransport::configure
void configure(const ConfigurationUpdate &update) override
Definition: virtualtransport.cc:163

EMANE::Controls::R2RISelfMetricControlMessage
R2RI Self Metric Control Message is sent to an NEM&#39;s transport layer to specify the parameters necess...
Definition: r2riselfmetriccontrolmessage.h:59

EMANE::TimePoint
Clock::time_point TimePoint
Definition: types.h:50

EMANE::Transports::Virtual::VirtualTransport::destroy
void destroy() override
Definition: virtualtransport.cc:380

EMANE::Controls::R2RINeighborMetricControlMessage::IDENTIFIER
Definition: r2rineighbormetriccontrolmessage.h:128

LOGGER_STANDARD_LOGGING
#define LOGGER_STANDARD_LOGGING(logger, level, fmt, args...)
Definition: logserviceprovider.h:199

EMANE::Utils::EtherHeader
Definition of the ethernet frame header.
Definition: netutils.h:434

EMANE::UpstreamTransport::sendDownstreamPacket
void sendDownstreamPacket(DownstreamPacket &pkt, const ControlMessages &msgs=empty)
Definition: upstreamtransport.inl:37

EMANE::ERROR_LEVEL
Definition: logserviceprovider.h:47

EMANE::Transports::Ethernet::EthernetTransport::updateArpCache
void updateArpCache(const Utils::EtherHeader *pEthHeader, EMANE::NEMId nemId)
Definition: ethernettransport.cc:294

downstreamtransport.h

EMANE::Utils::CommonLayerStatistics::processInbound
void processInbound(const UpstreamPacket &pkt)
Definition: commonlayerstatistics.cc:757

EMANE::UpstreamPacket::length
size_t length() const
Definition: upstreampacket.cc:182

r2rineighbormetriccontrolmessage.h

EMANE::Controls::R2RIQueueMetricControlMessage::create
static R2RIQueueMetricControlMessage * create(const Serialization &serialization)
Definition: r2riqueuemetriccontrolmessage.cc:108

EMANE::Transports::Virtual::TunTap::open
int open(const char *, const char *)
Definition: tuntap.cc:79

EMANE::Transports::Virtual::VirtualTransport
Virtual Device EMANE Transport.
Definition: virtualtransport.h:62

EMANE::Transports::Virtual::VirtualTransport::processUpstreamControl
void processUpstreamControl(const ControlMessages &msgs)
Definition: virtualtransport.cc:465