Attachment #1556 for bug #1609

View | Details | Raw Unified | Return to bug 1609
Collapse All | Expand All




  return none;
}

Ipv4Address DsrOptions::ReverseSearchNextTwoHop  (Ipv4Address ipv4Address, std::vector<Ipv4Address>& vec)
{
  NS_LOG_FUNCTION (this << ipv4Address);
  Ipv4Address nextTwoHop;
  NS_LOG_DEBUG ("The vector size " << vec.size ());
  NS_ASSERT (vec.size () > 2);
  for (std::vector<Ipv4Address>::reverse_iterator ri = vec.rbegin (); ri != vec.rend (); ++ri)
    {
      if (ipv4Address == (*ri))
        {
          nextTwoHop = *(ri + 2);
          return nextTwoHop;
        }
    }
  NS_FATAL_ERROR ("next hop address not found, route corrupted");
  Ipv4Address none = "0.0.0.0";
  return none;
}

void DsrOptions::PrintVector (std::vector<Ipv4Address>& vec)
{
  NS_LOG_FUNCTION (this);

bool DsrOptions::IfDuplicates (std::vector<Ipv4Address>& vec, std::vector<Ipv4Address>& vec2)
{
  NS_LOG_FUNCTION (this);
  NS_LOG_DEBUG ("The first vector ");
  PrintVector (vec);
  NS_LOG_DEBUG ("The second vector ");
  PrintVector (vec2);
  for (std::vector<Ipv4Address>::const_iterator i = vec.begin (); i != vec.end (); ++i)
    {
      for (std::vector<Ipv4Address>::const_iterator j = vec2.begin (); j != vec2.end (); ++j)

  return OPT_NUMBER;
}

uint8_t DsrOptionPad1::Process (Ptr<Packet> packet, Ptr<Packet> dsrP, Ipv4Address ipv4Address, Ipv4Address source, Ipv4Header const& ipv4Header, uint8_t protocol, bool& isPromisc, Ipv4Address promiscSource)
{
  NS_LOG_FUNCTION (this << packet << dsrP << ipv4Address << source << ipv4Header << (uint32_t)protocol << isPromisc);
  Ptr<Packet> p = packet->Copy ();

  return OPT_NUMBER;
}

uint8_t DsrOptionPadn::Process (Ptr<Packet> packet, Ptr<Packet> dsrP, Ipv4Address ipv4Address, Ipv4Address source, Ipv4Header const& ipv4Header, uint8_t protocol, bool& isPromisc, Ipv4Address promiscSource)
{
  NS_LOG_FUNCTION (this << packet << dsrP << ipv4Address << source << ipv4Header << (uint32_t)protocol << isPromisc);


  return OPT_NUMBER;
}

uint8_t DsrOptionRreq::Process (Ptr<Packet> packet, Ptr<Packet> dsrP, Ipv4Address ipv4Address, Ipv4Address source, Ipv4Header const& ipv4Header, uint8_t protocol, bool& isPromisc, Ipv4Address promiscSource)
{
  NS_LOG_FUNCTION (this << packet << dsrP << ipv4Address << source << ipv4Header << (uint32_t)protocol << isPromisc);
  // Fields from IP header

  Ptr<Node> node = GetNodeWithAddress (ipv4Address);
  Ptr<dsr::DsrRouting> dsr = node->GetObject<dsr::DsrRouting> ();

  Ptr<Packet> p = packet->Copy (); // Note: The packet here doesn't contain the fixed size dsr header
  /*
   * \brief Get the number of routers' address field before removing the header
   * \peek the packet and get the value

      m_dropTrace (packet); // call drop trace
      return 0;
    }
  // Check the rreq id for verifying the request id
  uint16_t requestId = rreq.GetId ();
  // The target address is where we want to send the data packets
  Ipv4Address targetAddress = rreq.GetTarget ();
  // Get the node list and source address from the route request header
  std::vector<Ipv4Address> mainVector = rreq.GetNodesAddresses ();
  std::vector<Ipv4Address> nodeList (mainVector);
  // Get the real source address of this request, it will be used when checking if we have received the save
  // route request before or not
  Ipv4Address sourceAddress = nodeList.front ();
  PrintVector (nodeList);
  /*
   * Construct the dsr routing header for later use
   */
  DsrRoutingHeader dsrRoutingHeader;
  dsrRoutingHeader.SetNextHeader (protocol);

  dsrRoutingHeader.SetSourceId (GetIDfromIP (source));
  dsrRoutingHeader.SetDestId (255);

  // check whether we have received this request or not, if not, it will save the request in the table for
  // later use, if not found, return false, and push the newly received source request entry in the cache

  bool dupRequest = dsr->FindSourceEntry (sourceAddress, targetAddress, requestId);
  /*
   * Before processing the route request, we need to check two things
   * 1. if this is the exact same request we have just received, ignore it
   * 2. if our address is already in the path list, ignore it
   * 3. otherwise process further
   */
  if (dupRequest)
    {
      NS_LOG_DEBUG ("We have received duplicate request");
      // We have received this same route reqeust before, not forwarding it now
      NS_LOG_LOGIC ("Duplicate request. Drop!");
      m_dropTrace (packet); // call drop trace
      return 0;
    }

  else if (CheckDuplicates (ipv4Address, nodeList))
    {
      /*
       * if the route contains the node address already, drop the request packet

    {
      // A node ignores all RREQs received from any node in its blacklist
      RouteCacheEntry toPrev;

      /*
       *  When the reverse route is created or updated, the following actions on the route are also carried out:
       *  3. the next hop in the routing table becomes the node from which the  RREQ was received


                  if (addRoute)
                    {
                      NS_LOG_LOGIC ("We have added the route and search send buffer for packet with destination " << dst);
                      /*
                       * Found a route the dst, construct the source route option header
                       */

  return OPT_NUMBER;
}

uint8_t DsrOptionRrep::Process (Ptr<Packet> packet, Ptr<Packet> dsrP, Ipv4Address ipv4Address, Ipv4Address source, Ipv4Header const& ipv4Header, uint8_t protocol, bool& isPromisc, Ipv4Address promiscSource)
{
  NS_LOG_FUNCTION (this << packet << dsrP << ipv4Address << source << ipv4Header << (uint32_t)protocol << isPromisc);


  return OPT_NUMBER;
}

uint8_t DsrOptionSR::Process (Ptr<Packet> packet, Ptr<Packet> dsrP, Ipv4Address ipv4Address, Ipv4Address source, Ipv4Header const& ipv4Header, uint8_t protocol, bool& isPromisc, Ipv4Address promiscSource)
{
  NS_LOG_FUNCTION (this << packet << dsrP << ipv4Address << source << ipv4Address << ipv4Header << (uint32_t)protocol << isPromisc);
  Ptr<Packet> p = packet->Copy ();

  // The route size saved in the source route
  std::vector<Ipv4Address> nodeList = sourceRoute.GetNodesAddress ();
  uint8_t segsLeft = sourceRoute.GetSegmentsLeft ();
  /// TODO remove this one later
  NS_LOG_DEBUG ("The segment left here " <<  (uint32_t) segsLeft);
  uint8_t salvage = sourceRoute.GetSalvage ();
  /*
   * Get the node from IP address and get the DSR extension object

   */
  Ipv4Address srcAddress = ipv4Header.GetSource ();
  Ipv4Address destAddress = ipv4Header.GetDestination ();

  // Get the node list destination
  Ipv4Address destination = nodeList.back ();
  /*

   */
  if (isPromisc)
    {
      NS_LOG_LOGIC ("We process promiscuous receipt data packet");
       * Get the node from Ip address and get the dsr routing object
       */
      Ptr<Node> node = GetNodeWithAddress (ipv4Address);
      Ptr<dsr::DsrRouting> dsr = node->GetObject<dsr::DsrRouting> ();
      bool findSame = dsr->FindSamePackets (packet, source, destination, segsLeft);

      if (findSame)
        {
          NS_LOG_DEBUG ("Received one passive acknowledgment for a successfully delivered packet");
        }
      if (ContainAddressAfter (ipv4Address, destAddress, nodeList))
        {
          NS_LOG_LOGIC ("Send back the gratuitous reply");
          dsr->SendGratuitousReply (source, srcAddress, nodeList, protocol);
        }

      uint16_t fragmentOffset = ipv4Header.GetFragmentOffset ();
      uint16_t identification = ipv4Header.GetIdentification ();

      /// TODO add the link ack over here

      if (destAddress != destination)
        {
          NS_LOG_DEBUG ("Process the promiscuously received packet");
          bool findPassive;
          int32_t nNodes = NodeList::GetNNodes ();
          for (int32_t i = 0; i < nNodes; ++i)
            {
              NS_LOG_DEBUG ("Working with node " << i);

              Ptr<Node> node = NodeList::GetNode (i);
              Ptr<dsr::DsrRouting> dsrNode = node->GetObject<dsr::DsrRouting> ();
              // The source and destination addresses here are the real source and destination for the packet
              findPassive = dsrNode->PassiveEntryCheck (packet, source, destination, segsLeft, fragmentOffset, identification, false);
              if (findPassive)
                {
                  break;
                }
            }

          if (findPassive)
            {
              NS_LOG_DEBUG ("We find one previously received passive entry");
              /*
               * Get the node from IP address and get the DSR extension object
               * the srcAddress would be the source address from ip header
               */
              PrintVector (nodeList);

              NS_LOG_DEBUG ("promisc source " << promiscSource);
              Ptr<Node> node = GetNodeWithAddress (promiscSource);
              Ptr<dsr::DsrRouting> dsrSrc = node->GetObject<dsr::DsrRouting> ();

              /// TODO need to think about this part
              /// TODO this is temporarily disabled to enable other
              dsrSrc->CancelPassiveTimer (packet, source, destination, segsLeft);
            }
          else
            {
              NS_LOG_DEBUG ("Saved the entry for further use");
              dsr->PassiveEntryCheck (packet, source, destination, segsLeft, fragmentOffset, identification, true);
            }
        }
      /// Safely terminate promiscuously received packet
      return 0;
    }
  else
    {

      p->CopyData (data, size);
      uint8_t optionType = 0;
      optionType = *(data);
      /// When the option type is 160, means there is ACK request header after the source route, we need
      /// to send back acknowledgment
      NS_LOG_DEBUG ("The option type over here " << (uint32_t)optionType);
      if (optionType == 160)
        {
          NS_LOG_LOGIC ("Remove the ack request header and add ack header to the packet");
          // Here we remove the ack packet to the previous hop
          DsrOptionAckReqHeader ackReq;
          p->RemoveHeader (ackReq);
          uint16_t ackId = ackReq.GetAckId ();
          NS_LOG_DEBUG ("The type value " << (uint32_t)ackReq.GetType ());
          /*
           * Send back acknowledgment packet to the earlier hop
           * If the node list is not empty, find the previous hop from the node list,
           * otherwise, use srcAddress
           */
          Ipv4Address ackAddress = srcAddress;
          if (!nodeList.empty ())
            {
                if (segsLeft > numberAddress) // The segmentsLeft field should not be larger than the total number of ip addresses
                  {
                    NS_LOG_LOGIC ("Malformed header. Drop!");
                    m_dropTrace (packet);
                    return 0;
                  }
                if (numberAddress - segsLeft - 2 < 0) // The index is invalid
                   {
                      NS_LOG_LOGIC ("Malformed header. Drop!");
                      m_dropTrace (packet);
                      return 0;
                   }
                   ackAddress = nodeList[numberAddress - segsLeft - 2];
            }
           m_ipv4Route = SetRoute (ackAddress, ipv4Address);
           NS_LOG_DEBUG ("Send back ACK to the earlier hop " << ackAddress << " from us " << ipv4Address);
           dsr->SendAck (ackId, ackAddress, source, destination, protocol, m_ipv4Route);
        }
      /*
       * After send back ACK, check if the segments left value has turned to 0 or not, if yes, update the route entry

  return OPT_NUMBER;
}

uint8_t DsrOptionRerr::Process (Ptr<Packet> packet, Ptr<Packet> dsrP, Ipv4Address ipv4Address, Ipv4Address source, Ipv4Header const& ipv4Header, uint8_t protocol, bool& isPromisc, Ipv4Address promiscSource)
{
  NS_LOG_FUNCTION (this << packet << dsrP << ipv4Address << source << ipv4Header << (uint32_t)protocol << isPromisc);
  Ptr<Packet> p = packet->Copy ();

      Ipv4Address unreachAddress = rerrUnreach.GetUnreachNode ();
      Ipv4Address errorSource = rerrUnreach.GetErrorSrc ();

      NS_LOG_DEBUG ("The error source is " <<  rerrUnreach.GetErrorDst () << "and the unreachable node is " << unreachAddress);
      /*
       * Get the serialized size of the rerr header
       */

  return OPT_NUMBER;
}

uint8_t DsrOptionAckReq::Process (Ptr<Packet> packet, Ptr<Packet> dsrP, Ipv4Address ipv4Address, Ipv4Address source, Ipv4Header const& ipv4Header, uint8_t protocol, bool& isPromisc, Ipv4Address promiscSource)
{
  NS_LOG_FUNCTION (this << packet << dsrP << ipv4Address << source << ipv4Header << (uint32_t)protocol << isPromisc);
  /*

  NS_LOG_DEBUG ("The next header value " << (uint32_t)protocol);

  Ipv4Address srcAddress = ipv4Header.GetSource ();
  SetRoute (srcAddress, ipv4Address);

  return ackReq.GetSerializedSize ();
}

  return OPT_NUMBER;
}

uint8_t DsrOptionAck::Process (Ptr<Packet> packet, Ptr<Packet> dsrP, Ipv4Address ipv4Address, Ipv4Address source, Ipv4Header const& ipv4Header, uint8_t protocol, bool& isPromisc, Ipv4Address promiscSource)
{
  NS_LOG_FUNCTION (this << packet << dsrP << ipv4Address << source << ipv4Header << (uint32_t)protocol << isPromisc);
  /*




   * \return the vector after the route cut
   */
  std::vector<Ipv4Address> CutRoute (Ipv4Address ipv4Address, std::vector<Ipv4Address> &nodeList);
  /**
   * \brief Set the route to use for data packets
   * \return the route
   * \used by the option headers when sending data/control packets

   * \return true if successfully reversed
   */
  bool ReverseRoutes  (std::vector<Ipv4Address>& vec);
  /**
   * \brief Search for the next hop in the route
   * \return the next hop address if found
   */
  Ipv4Address SearchNextHop (Ipv4Address ipv4Address, std::vector<Ipv4Address>& vec);
  /**
   * \brief Reverse search for the next hop in the route
   * \return the previous next hop address if found
   */
  Ipv4Address ReverseSearchNextHop (Ipv4Address ipv4Address, std::vector<Ipv4Address>& vec);
  /**
   * \brief Reverse search for the next two hop in the route
   * \return the previous next two hop address if found
   */
  Ipv4Address ReverseSearchNextTwoHop  (Ipv4Address ipv4Address, std::vector<Ipv4Address>& vec);
  /**
   * \brief Print out the elements in the route vector
   */
  void PrintVector (std::vector<Ipv4Address>& vec);

   * \return the route after route shorten
   */
  void RemoveDuplicates (std::vector<Ipv4Address>& vec);
  /**
   * \brief Schedule the intermediate node route request broadcast
   * \param the original packet
   * \param rrepHeader The rrep header
   * \param source address
   * \param destination address
   */
  void ScheduleReply (Ptr<Packet> &packet, std::vector<Ipv4Address> &nodeList, Ipv4Address &source, Ipv4Address &destination);
  /**
   * \brief Get the node id with Ipv4Address
   * \return the id of the node
   */
  uint32_t GetIDfromIP (Ipv4Address address);
  /**
   * \brief Get the node object with Ipv4Address
   * \return the object of the node
   */

   * \param isPromisc if the packet must be dropped
   * \return the processed size
   */
  virtual uint8_t Process (Ptr<Packet> packet, Ptr<Packet> dsrP, Ipv4Address ipv4Address, Ipv4Address source, Ipv4Header const& ipv4Header, uint8_t protocol, bool& isPromisc, Ipv4Address promiscSource) = 0;

protected:
  /**

   * \param isPromisc if the packet must be dropped
   * \return the processed size
   */
  virtual uint8_t Process (Ptr<Packet> packet, Ptr<Packet> dsrP, Ipv4Address ipv4Address, Ipv4Address source, Ipv4Header const& ipv4Header, uint8_t protocol, bool& isPromisc, Ipv4Address promiscSource);
};

/**

   * \param isPromisc if the packet must be dropped
   * \return the processed size
   */
  virtual uint8_t Process (Ptr<Packet> packet, Ptr<Packet> dsrP, Ipv4Address ipv4Address, Ipv4Address source, Ipv4Header const& ipv4Header, uint8_t protocol, bool& isPromisc, Ipv4Address promiscSource);
};

/**

   * \param isPromisc if the packet must be dropped
   * \return the processed size
   */
  virtual uint8_t Process (Ptr<Packet> packet, Ptr<Packet> dsrP, Ipv4Address ipv4Address, Ipv4Address source, Ipv4Header const& ipv4Header, uint8_t protocol, bool& isPromisc, Ipv4Address promiscSource);

private:
  /**

   * \param isPromisc if the packet must be dropped
   * \return the processed size
   */
  virtual uint8_t Process (Ptr<Packet> packet, Ptr<Packet> dsrP, Ipv4Address ipv4Address, Ipv4Address source, Ipv4Header const& ipv4Header, uint8_t protocol, bool& isPromisc, Ipv4Address promiscSource);

private:
  /**

   * \param isPromisc if the packet must be dropped
   * \return the processed size
   */
  virtual uint8_t Process (Ptr<Packet> packet, Ptr<Packet> dsrP, Ipv4Address ipv4Address, Ipv4Address source, Ipv4Header const& ipv4Header, uint8_t protocol, bool& isPromisc, Ipv4Address promiscSource);

private:
  /**

   * \param isPromisc if the packet must be dropped
   * \return the processed size
   */
  virtual uint8_t Process (Ptr<Packet> packet, Ptr<Packet> dsrP, Ipv4Address ipv4Address, Ipv4Address source, Ipv4Header const& ipv4Header, uint8_t protocol, bool& isPromisc, Ipv4Address promiscSource);
  /**
   * \brief Do Send error message
   *

   * \param isPromisc if the packet must be dropped
   * \return the processed size
   */
  virtual uint8_t Process (Ptr<Packet> packet, Ptr<Packet> dsrP, Ipv4Address ipv4Address, Ipv4Address source, Ipv4Header const& ipv4Header, uint8_t protocol, bool& isPromisc, Ipv4Address promiscSource);

private:
  /**

   * \param isPromisc if the packet must be dropped
   * \return the processed size
   */
  virtual uint8_t Process (Ptr<Packet> packet, Ptr<Packet> dsrP, Ipv4Address ipv4Address, Ipv4Address source, Ipv4Header const& ipv4Header, uint8_t protocol, bool& isPromisc, Ipv4Address promiscSource);

private:
  /**




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2011 Yufei Cheng
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Yufei Cheng   <yfcheng@ittc.ku.edu>
 *
 * James P.G. Sterbenz <jpgs@ittc.ku.edu>, director
 * ResiliNets Research Group  http://wiki.ittc.ku.edu/resilinets
 * Information and Telecommunication Technology Center (ITTC)
 * and Department of Electrical Engineering and Computer Science
 * The University of Kansas Lawrence, KS USA.
 *
 * Work supported in part by NSF FIND (Future Internet Design) Program
 * under grant CNS-0626918 (Postmodern Internet Architecture),
 * NSF grant CNS-1050226 (Multilayer Network Resilience Analysis and Experimentation on GENI),
 * US Department of Defense (DoD), and ITTC at The University of Kansas.
 */

#include "dsr-passive-buff.h"
#include <algorithm>
#include <functional>
#include "ns3/ipv4-route.h"
#include "ns3/socket.h"
#include "ns3/log.h"

NS_LOG_COMPONENT_DEFINE ("PassiveBuffer");

namespace ns3 {
namespace dsr {

NS_OBJECT_ENSURE_REGISTERED (PassiveBuffer);

TypeId PassiveBuffer::GetTypeId ()
{
  static TypeId tid = TypeId ("ns3::dsr::PassiveBuffer")
    .SetParent<Object> ()
    .AddConstructor<PassiveBuffer> ()
  ;
  return tid;
}

PassiveBuffer::PassiveBuffer ()
{
}

PassiveBuffer::~PassiveBuffer ()
{
}

uint32_t
PassiveBuffer::GetSize ()
{
  Purge ();
  return m_passiveBuffer.size ();
}

bool
PassiveBuffer::Enqueue (PassiveBuffEntry & entry)
{
  Purge ();
  for (std::vector<PassiveBuffEntry>::const_iterator i = m_passiveBuffer.begin (); i
       != m_passiveBuffer.end (); ++i)
    {
      NS_LOG_INFO ("packet id " << i->GetPacket ()->GetUid () << " " << entry.GetPacket ()->GetUid () << " source " << i->GetSource () << " " << entry.GetSource ()
                                     << " dst " << i->GetDestination () << " " << entry.GetDestination () << " identification " << i->GetIdentification () << " "
                                     << entry.GetIdentification () << " fragment " << i->GetFragmentOffset () << " " << entry.GetFragmentOffset ()
                                     << " segLeft " << i->GetSegsLeft () << " " << entry.GetSegsLeft ());

      if ((i->GetPacket ()->GetUid () == entry.GetPacket ()->GetUid ()) && (i->GetSource () == entry.GetSource ()) && (i->GetNextHop () == entry.GetNextHop ())
          && (i->GetDestination () == entry.GetDestination ()) && (i->GetIdentification () == entry.GetIdentification ()) && (i->GetFragmentOffset () == entry.GetFragmentOffset ())
          && (i->GetSegsLeft () == entry.GetSegsLeft () + 1))
        {
          return false;
        }
    }

  entry.SetExpireTime (m_passiveBufferTimeout);     // Initialize the send buffer timeout
  /*
   * Drop the most aged packet when buffer reaches to max
   */
  if (m_passiveBuffer.size () >= m_maxLen)
    {
      Drop (m_passiveBuffer.front (), "Drop the most aged packet");         // Drop the most aged packet
      m_passiveBuffer.erase (m_passiveBuffer.begin ());
    }
  // enqueue the entry
  m_passiveBuffer.push_back (entry);
  return true;
}

bool
PassiveBuffer::AllEqual (PassiveBuffEntry & entry)
{
  for (std::vector<PassiveBuffEntry>::iterator i = m_passiveBuffer.begin (); i
       != m_passiveBuffer.end (); ++i)
    {
      NS_LOG_INFO ("packet id " << i->GetPacket ()->GetUid () << " " << entry.GetPacket ()->GetUid () << " source " << i->GetSource () << " " << entry.GetSource ()
                                     << " dst " << i->GetDestination () << " " << entry.GetDestination () << " identification " << i->GetIdentification () << " "
                                     << entry.GetIdentification () << " fragment " << i->GetFragmentOffset () << " " << entry.GetFragmentOffset ()
                                     << " segLeft " << (uint32_t) i->GetSegsLeft () << " " << (uint32_t) entry.GetSegsLeft ());

      if ((i->GetPacket ()->GetUid () == entry.GetPacket ()->GetUid ()) && (i->GetSource () == entry.GetSource ()) && (i->GetNextHop () == entry.GetNextHop ())
          && (i->GetDestination () == entry.GetDestination ()) && (i->GetIdentification () == entry.GetIdentification ()) && (i->GetFragmentOffset () == entry.GetFragmentOffset ())
          && (i->GetSegsLeft () == entry.GetSegsLeft () + 1))
        {
          m_passiveBuffer.erase (i);   // Erase the same maintain buffer entry for the received packet
          return true;
        }
    }
  return false;
}

bool
PassiveBuffer::Dequeue (Ipv4Address dst, PassiveBuffEntry & entry)
{
  Purge ();
  /*
   * Dequeue the entry with destination address dst
   */
  for (std::vector<PassiveBuffEntry>::iterator i = m_passiveBuffer.begin (); i != m_passiveBuffer.end (); ++i)
    {
      if (i->GetDestination () == dst)
        {
          entry = *i;
          m_passiveBuffer.erase (i);
          NS_LOG_DEBUG ("Packet size while dequeuing " << entry.GetPacket ()->GetSize ());
          return true;
        }
    }
  return false;
}

bool
PassiveBuffer::Find (Ipv4Address dst)
{
  /*
   * Make sure if the send buffer contains entry with certain dst
   */
  for (std::vector<PassiveBuffEntry>::const_iterator i = m_passiveBuffer.begin (); i
       != m_passiveBuffer.end (); ++i)
    {
      if (i->GetDestination () == dst)
        {
          NS_LOG_DEBUG ("Found the packet");
          return true;
        }
    }
  return false;
}

struct IsExpired
{
  bool
  operator() (PassiveBuffEntry const & e) const
  {
    // NS_LOG_DEBUG("Expire time for packet in req queue: "<<e.GetExpireTime ());
    return (e.GetExpireTime () < Seconds (0));
  }
};

void
PassiveBuffer::Purge ()
{
  /*
   * Purge the buffer to eliminate expired entries
   */
  NS_LOG_DEBUG ("The passive buffer size " << m_passiveBuffer.size ());
  IsExpired pred;
  for (std::vector<PassiveBuffEntry>::iterator i = m_passiveBuffer.begin (); i
       != m_passiveBuffer.end (); ++i)
    {
      if (pred (*i))
        {
          NS_LOG_DEBUG ("Dropping Queue Packets");
          Drop (*i, "Drop out-dated packet ");
        }
    }
  m_passiveBuffer.erase (std::remove_if (m_passiveBuffer.begin (), m_passiveBuffer.end (), pred),
                       m_passiveBuffer.end ());
}

void
PassiveBuffer::Drop (PassiveBuffEntry en, std::string reason)
{
  NS_LOG_LOGIC (reason << en.GetPacket ()->GetUid () << " " << en.GetDestination ());
//  en.GetErrorCallback () (en.GetPacket (), en.GetDestination (),
//     Socket::ERROR_NOROUTETOHOST);
  return;
}

void
PassiveBuffer::DropLink (PassiveBuffEntry en, std::string reason)
{
  NS_LOG_LOGIC (reason << en.GetPacket ()->GetUid () << " " << en.GetSource () << " " << en.GetNextHop ());
//  en.GetErrorCallback () (en.GetPacket (), en.GetDestination (),
//     Socket::ERROR_NOROUTETOHOST);
  return;
}
}  // namespace dsr
}  // namespace ns3




/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2011 Yufei Cheng
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Yufei Cheng   <yfcheng@ittc.ku.edu>
 *
 * James P.G. Sterbenz <jpgs@ittc.ku.edu>, director
 * ResiliNets Research Group  http://wiki.ittc.ku.edu/resilinets
 * Information and Telecommunication Technology Center (ITTC)
 * and Department of Electrical Engineering and Computer Science
 * The University of Kansas Lawrence, KS USA.
 *
 * Work supported in part by NSF FIND (Future Internet Design) Program
 * under grant CNS-0626918 (Postmodern Internet Architecture),
 * NSF grant CNS-1050226 (Multilayer Network Resilience Analysis and Experimentation on GENI),
 * US Department of Defense (DoD), and ITTC at The University of Kansas.
 */

#ifndef DSR_PASSIVEBUFF_H
#define DSR_PASSIVEBUFF_H

#include <vector>
#include "ns3/ipv4-routing-protocol.h"
#include "ns3/simulator.h"

namespace ns3 {
namespace dsr {
/**
 * \ingroup dsr
 * \brief DSR Passive Buffer Entry
 */
class PassiveBuffEntry
{
public:
  // / c-tor
  PassiveBuffEntry (Ptr<const Packet> pa = 0, Ipv4Address d = Ipv4Address (), Ipv4Address s = Ipv4Address (),
                  Ipv4Address n = Ipv4Address (), uint16_t i = 0, uint16_t f = 0, uint8_t seg = 0, Time exp = Simulator::Now (),
                  uint8_t p = 0)
    : m_packet (pa),
      m_dst (d),
      m_source (s),
      m_nextHop (n),
      m_identification (i),
      m_fragmentOffset (f),
      m_segsLeft (seg),
      m_expire (exp + Simulator::Now ()),
      m_protocol (p)
  {
  }
  /**
   * Compare send buffer entries
   * \return true if equal
   */
  bool operator== (PassiveBuffEntry const & o) const
  {
    return ((m_packet == o.m_packet) && (m_source == o.m_source) && (m_nextHop == o.m_nextHop) && (m_dst == o.m_dst) && (m_expire == o.m_expire));
  }
  // /\name Fields
  // \{
  Ptr<const Packet> GetPacket () const
  {
    return m_packet;
  }
  void SetPacket (Ptr<const Packet> p)
  {
    m_packet = p;
  }
  Ipv4Address GetDestination () const
  {
    return m_dst;
  }
  void SetDestination (Ipv4Address d)
  {
    m_dst = d;
  }
  Ipv4Address GetSource () const
  {
    return m_source;
  }
  void SetSource (Ipv4Address s)
  {
    m_source = s;
  }
  Ipv4Address GetNextHop () const
  {
    return m_nextHop;
  }
  void SetNextHop (Ipv4Address n)
  {
    m_nextHop = n;
  }
  uint16_t GetIdentification () const
  {
    return m_identification;
  }
  void SetIdentification (uint16_t i)
  {
    m_identification = i;
  }
  uint16_t GetFragmentOffset () const
  {
    return m_fragmentOffset;
  }
  void SetFragmentOffset (uint16_t f)
  {
    m_fragmentOffset = f;
  }
  uint8_t GetSegsLeft () const
  {
    return m_segsLeft;
  }
  void SetSegsLeft (uint8_t seg)
  {
    m_segsLeft = seg;
  }
  void SetExpireTime (Time exp)
  {
    m_expire = exp + Simulator::Now ();
  }
  Time GetExpireTime () const
  {
    return m_expire - Simulator::Now ();
  }
  void SetProtocol (uint8_t p)
  {
    m_protocol = p;
  }
  uint8_t GetProtocol () const
  {
    return m_protocol;
  }
  // \}
private:
  // / Data packet
  Ptr<const Packet> m_packet;
  // / Destination address
  Ipv4Address m_dst;
  // / Source address
  Ipv4Address m_source;
  // / Nexthop address
  Ipv4Address m_nextHop;
  // /
  uint16_t m_identification;
  uint16_t m_fragmentOffset;
  uint8_t m_segsLeft;
  // / Expire time for queue entry
  Time m_expire;
  // / The protocol number
  uint8_t m_protocol;
};

/**
 * \ingroup dsr
 * \brief DSR passive buffer
 */
/************************************************************************************************************************/
class PassiveBuffer  : public Object
{
public:
  // / c-tor
  /**
   * \brief Get the type identificator.
   * \return type identificator
   */
  static TypeId GetTypeId ();
  /**
   * \brief Constructor.
   */
  PassiveBuffer ();
  /**
   * \brief Destructor.
   */
  virtual ~PassiveBuffer ();
  // / Push entry in queue, if there is no entry with the same packet and destination address in queue.
  bool Enqueue (PassiveBuffEntry & entry);
  // / Return first found (the earliest) entry for given destination
  bool Dequeue (Ipv4Address dst, PassiveBuffEntry & entry);
  // / Finds whether a packet with destination dst exists in the queue
  bool Find (Ipv4Address dst);
  // / Check if all the entries in passive buffer entry is all equal or not
  bool AllEqual (PassiveBuffEntry & entry);
  // / Number of entries
  uint32_t GetSize ();
  // /\name Fields
  // \{
  uint32_t GetMaxQueueLen () const
  {
    return m_maxLen;
  }
  void SetMaxQueueLen (uint32_t len)
  {
    m_maxLen = len;
  }
  Time GetPassiveBufferTimeout () const
  {
    return m_passiveBufferTimeout;
  }
  void SetPassiveBufferTimeout (Time t)
  {
    m_passiveBufferTimeout = t;
  }
  // \}

  std::vector<PassiveBuffEntry> & GetBuffer ()     /// TODO may need to remove this one here
  {
    return m_passiveBuffer;
  }

private:
  // / The send buffer to cache unsent packet
  std::vector<PassiveBuffEntry> m_passiveBuffer;
  // / Remove all expired entries
  void Purge ();
  // / Notify that packet is dropped from queue by timeout
  void Drop (PassiveBuffEntry en, std::string reason);
  // / Notify that packet is dropped from queue by timeout
  void DropLink (PassiveBuffEntry en, std::string reason);
  // / The maximum number of packets that we allow a routing protocol to buffer.
  uint32_t m_maxLen;
  // / The maximum period of time that a routing protocol is allowed to buffer a packet for, seconds.
  Time m_passiveBufferTimeout;
  // / Check if the send buffer entry is the same or not
  static bool LinkEqual (PassiveBuffEntry en, const std::vector<Ipv4Address> link)
  {
    return ((en.GetSource () == link[0]) && (en.GetNextHop () == link[1]));
  }
};
/*******************************************************************************************************************************/
} // namespace dsr
} // namespace ns3

#endif /* DSR_PASSIVEBUFF_H */

(-)ns3dev/src/dsr/model/dsr-routing.cc (-19 / +118 lines)

Lines 113-118 TypeId DsrRouting::GetTypeId ()	Link Here

113

                   MakePointerAccessor (&DsrRouting::SetRequestTable,

113

                   MakePointerAccessor (&DsrRouting::SetRequestTable,

114

                                        &DsrRouting::GetRequestTable),

114

                                        &DsrRouting::GetRequestTable),

115

                   MakePointerChecker<RreqTable> ())

115

                   MakePointerChecker<RreqTable> ())

116

    .AddAttribute ("PassiveBuffer", "The passive buffer to manage promisucously received passive ack.",

117

                   PointerValue (0),

118

                   MakePointerAccessor (&DsrRouting::SetPassiveBuffer,

119

                                        &DsrRouting::GetPassiveBuffer),

120

                   MakePointerChecker<PassiveBuffer> ())

116

    .AddAttribute ("MaxSendBuffLen","Maximum number of packets that can be stored in send buffer.",

121

    .AddAttribute ("MaxSendBuffLen","Maximum number of packets that can be stored in send buffer.",

117

                   UintegerValue (64),

122

                   UintegerValue (64),

118

                   MakeUintegerAccessor (&DsrRouting::m_maxSendBuffLen),

123

                   MakeUintegerAccessor (&DsrRouting::m_maxSendBuffLen),

Lines 154-162 TypeId DsrRouting::GetTypeId ()	Link Here

154

                   MakeUintegerAccessor (&DsrRouting::m_rreqRetries),

159

                   MakeUintegerAccessor (&DsrRouting::m_rreqRetries),

155

                   MakeUintegerChecker<uint32_t> ())

160

                   MakeUintegerChecker<uint32_t> ())

156

    .AddAttribute ("MaintenanceRetries","Maximum number of retransmissions for data packets from maintenance buffer.",

161

    .AddAttribute ("MaintenanceRetries","Maximum number of retransmissions for data packets from maintenance buffer.",

157

                   DoubleValue (2),

162

                   UintegerValue (2),

158

                   MakeDoubleAccessor (&DsrRouting::m_maxMaintRexmt),

163

                   MakeUintegerAccessor (&DsrRouting::m_maxMaintRexmt),

159

                   MakeDoubleChecker<uint32_t> ())

164

                   MakeUintegerChecker<uint32_t> ())

160

    .AddAttribute ("RequestTableSize","Maximum number of request entries in the request table.",

165

    .AddAttribute ("RequestTableSize","Maximum number of request entries in the request table.",

161

                   UintegerValue (64),

166

                   UintegerValue (64),

162

                   MakeUintegerAccessor (&DsrRouting::m_requestTableSize),

167

                   MakeUintegerAccessor (&DsrRouting::m_requestTableSize),

Lines 174-182 TypeId DsrRouting::GetTypeId ()	Link Here

174

                   MakeTimeAccessor (&DsrRouting::m_nonpropRequestTimeout),

179

                   MakeTimeAccessor (&DsrRouting::m_nonpropRequestTimeout),

175

                   MakeTimeChecker ())

180

                   MakeTimeChecker ())

176

    .AddAttribute ("DiscoveryHopLimit","The max discovery hop limit for route requests.",

181

    .AddAttribute ("DiscoveryHopLimit","The max discovery hop limit for route requests.",

177

                   DoubleValue (255),

182

                   UintegerValue (255),

178

                   MakeDoubleAccessor (&DsrRouting::m_discoveryHopLimit),

183

                   MakeUintegerAccessor (&DsrRouting::m_discoveryHopLimit),

179

                   MakeDoubleChecker<uint32_t> ())

184

                   MakeUintegerChecker<uint32_t> ())

180

    .AddAttribute ("MaxSalvageCount","The max salvage count for a single data packet.",

185

    .AddAttribute ("MaxSalvageCount","The max salvage count for a single data packet.",

181

                   UintegerValue (15),

186

                   UintegerValue (15),

182

                   MakeUintegerAccessor (&DsrRouting::m_maxSalvageCount),

187

                   MakeUintegerAccessor (&DsrRouting::m_maxSalvageCount),

Lines 353-358 void DsrRouting::Start ()	Link Here

353

  // The call back to handle link error and send error message to appropriate nodes

358

  // The call back to handle link error and send error message to appropriate nodes

354

  routeCache->SetCallback (MakeCallback (&DsrRouting::SendRerrWhenBreaksLinkToNextHop, this));

359

  routeCache->SetCallback (MakeCallback (&DsrRouting::SendRerrWhenBreaksLinkToNextHop, this));

355

  SetRouteCache (routeCache);

360

  SetRouteCache (routeCache);

361

// Set the passive buffer parameters using just the send buffer parameters

362

  Ptr<dsr::PassiveBuffer> passiveBuffer = CreateObject<dsr::PassiveBuffer> ();

363

  passiveBuffer->SetMaxQueueLen (m_maxSendBuffLen);

364

  passiveBuffer->SetPassiveBufferTimeout (m_sendBufferTimeout);

365

  SetPassiveBuffer (passiveBuffer);

356

366

357

  if (m_mainAddress == Ipv4Address ())

367

  if (m_mainAddress == Ipv4Address ())

358

368

Lines 486-491 DsrRouting::GetRequestTable () const	Link Here

486

  return m_rreqTable;

496

  return m_rreqTable;

487

497

488

498

499

void DsrRouting::SetPassiveBuffer (Ptr<dsr::PassiveBuffer> p)

500

501

  // / Set the request table to use

502

  m_passiveBuffer = p;

503

504

505

Ptr<dsr::PassiveBuffer>

506

DsrRouting::GetPassiveBuffer () const

507

508

  // / Get the request table to use

509

  return m_passiveBuffer;

510

511

489

bool DsrRouting::IsLinkCache ()

512

bool DsrRouting::IsLinkCache ()

490

513

491

  return m_routeCache->IsLinkCache ();

514

  return m_routeCache->IsLinkCache ();

Lines 526-531 bool DsrRouting::UpdateRouteEntry (Ipv4A	Link Here

526

  return m_routeCache->UpdateRouteEntry (dst);

549

  return m_routeCache->UpdateRouteEntry (dst);

527

550

528

551

552

bool DsrRouting::FindSourceEntry (Ipv4Address src, Ipv4Address dst, uint16_t id)

553

554

  return m_rreqTable->FindSourceEntry (src, dst, id);

555

556

529

Ipv4Address

557

Ipv4Address

530

DsrRouting::GetIPfromMAC (Mac48Address address)

558

DsrRouting::GetIPfromMAC (Mac48Address address)

531

559

Lines 704-710 void DsrRouting::SendRerrWhenBreaksLinkT	Link Here

704

          newPacket->RemoveHeader (sourceRoute);

732

          newPacket->RemoveHeader (sourceRoute);

705

          uint8_t salvage = sourceRoute.GetSalvage ();

733

          uint8_t salvage = sourceRoute.GetSalvage ();

706

734

707

          // TODO

708

          DsrOptionAckReqHeader ackReq;

735

          DsrOptionAckReqHeader ackReq;

709

          newPacket->RemoveHeader (ackReq);

736

          newPacket->RemoveHeader (ackReq);

710

/*

737

/*

Lines 1032-1051 bool DsrRouting::PromiscReceive (Ptr<Net	Link Here

1032

          optionType = *(data);

1059

          optionType = *(data);

1033

1060

1034

          Ptr<dsr::DsrOptions> dsrOption;

1061

          Ptr<dsr::DsrOptions> dsrOption;

1035

1062

          Ipv4Address promiscSource = GetIPfromMAC (Mac48Address::ConvertFrom (from));

1063

          Ipv4Address promiscDestination = GetIPfromMAC (Mac48Address::ConvertFrom (to));

1036

          if (optionType == 96)        // This is the source route option

1064

          if (optionType == 96)        // This is the source route option

1037

1065

1038

              dsrOption = GetOption (optionType);       // Get the relative DSR option and demux to the process function

1066

              dsrOption = GetOption (optionType);       // Get the relative DSR option and demux to the process function

1039

              NS_LOG_DEBUG (Simulator::Now ().GetSeconds () <<

1067

              NS_LOG_DEBUG (Simulator::Now ().GetSeconds () <<

1040

                            " DSR node " << m_mainAddress <<

1068

                            " DSR node " << m_mainAddress <<

1041

                            " overhearing packet PID: " << p->GetUid () <<

1069

                            " overhearing packet PID: " << p->GetUid () <<

1042

                            " from " << GetIPfromMAC (Mac48Address::ConvertFrom (from)) <<

1070

                            " from " << promiscSource <<

1043

                            " to " << GetIPfromMAC (Mac48Address::ConvertFrom (to)) <<

1071

                            " to " << promiscDestination <<

1044

                            " with source IP " << ipv4Header.GetSource () <<

1072

                            " with source IP " << ipv4Header.GetSource () <<

1045

                            " and destination IP " << ipv4Header.GetDestination () <<

1073

                            " and destination IP " << ipv4Header.GetDestination () <<

1046

                            " and packet : " << *dsrPacket);

1074

                            " and packet : " << *dsrPacket);

1047

              bool isPromisc = true;                     // Set the boolean value isPromisc as true

1075

              bool isPromisc = true;                     // Set the boolean value isPromisc as true

1048

              dsrOption->Process (p, dsrPacket, m_mainAddress, source, ipv4Header, nextHeader, isPromisc);

1076

1077

              dsrOption->Process (p, dsrPacket, m_mainAddress, source, ipv4Header, nextHeader, isPromisc, promiscSource);

1049

              return true;

1078

              return true;

1050

1079

1051

1080

Lines 1797-1802 DsrRouting::SendPacketFromBuffer (DsrOpt	Link Here

1797

1826

1798

1827

1799

bool

1828

bool

1829

DsrRouting::PassiveEntryCheck (Ptr<Packet> packet, Ipv4Address source, Ipv4Address destination, uint8_t segsLeft,

1830

                    uint16_t fragmentOffset, uint16_t identification, bool saveEntry)

1831

1832

  NS_LOG_FUNCTION (this << packet << source << destination << (uint32_t)segsLeft);

1833

1834

  Ptr<Packet> p = packet->Copy ();

1835

  // Here the segments left value need to plus one to check the earlier hop maintain buffer entry

1836

  PassiveBuffEntry newEntry;

1837

  newEntry.SetPacket (p);

1838

  newEntry.SetSource (source);

1839

  newEntry.SetDestination (destination);

1840

  newEntry.SetIdentification (identification);

1841

  newEntry.SetFragmentOffset (fragmentOffset);

1842

  newEntry.SetSegsLeft (segsLeft);  // We try to make sure the segments left is larger for 1

1843

1844

  NS_LOG_DEBUG ("The passive buffer size " << m_passiveBuffer->GetSize());

1845

1846

  if (m_passiveBuffer->AllEqual (newEntry) && (!saveEntry))

1847

1848

      // The PromiscEqual function will remove the maintain buffer entry if equal value found

1849

      // It only compares the source and destination address, ackId, and the segments left value

1850

      NS_LOG_DEBUG ("We get the all equal for passive buffer here");

1851

1852

      MaintainBuffEntry mbEntry;

1853

      mbEntry.SetPacket (p);

1854

      mbEntry.SetSrc (source);

1855

      mbEntry.SetDst (destination);

1856

      mbEntry.SetAckId (0);

1857

      mbEntry.SetSegsLeft (segsLeft + 1);

1858

1859

    /// TODO this needs to be done later

1860

      CancelPassivePacketTimer (mbEntry);

1861

      return true;

1862

1863

  if (saveEntry)

1864

1865

      /// Save this passive buffer entry for later check

1866

      m_passiveBuffer->Enqueue (newEntry);

1867

1868

  return false;

1869

1870

1871

bool

1872

DsrRouting::CancelPassiveTimer (Ptr<Packet> packet, Ipv4Address source, Ipv4Address destination,

1873

                                 uint8_t segsLeft)

1874

1875

  NS_LOG_FUNCTION (this << packet << source << destination << (uint32_t)segsLeft);

1876

1877

  NS_LOG_DEBUG ("Cancel the passive timer");

1878

1879

  Ptr<Packet> p = packet->Copy ();

1880

  // Here the segments left value need to plus one to check the earlier hop maintain buffer entry

1881

  MaintainBuffEntry newEntry;

1882

  newEntry.SetPacket (p);

1883

  newEntry.SetSrc (source);

1884

  newEntry.SetDst (destination);

1885

  newEntry.SetAckId (0);

1886

  newEntry.SetSegsLeft (segsLeft + 1);

1887

1888

  if (m_maintainBuffer.PromiscEqual (newEntry))

1889

1890

      // The PromiscEqual function will remove the maintain buffer entry if equal value found

1891

      // It only compares the source and destination address, ackId, and the segments left value

1892

      CancelPassivePacketTimer (newEntry);

1893

      return true;

1894

1895

  return false;

1896

1897

1898

bool

1800

DsrRouting::FindSamePackets (Ptr<Packet> packet, Ipv4Address source, Ipv4Address destination,

1899

DsrRouting::FindSamePackets (Ptr<Packet> packet, Ipv4Address source, Ipv4Address destination,

1801

                             uint8_t segsLeft)

1900

                             uint8_t segsLeft)

1802

1901

Lines 2632-2638 DsrRouting::ScheduleRreqRetry (Ptr<Packe	Link Here

2632

          NS_LOG_DEBUG ("The request delay time " << rreqDelay.GetSeconds ());

2731

          NS_LOG_DEBUG ("The request delay time " << rreqDelay.GetSeconds ());

2633

          m_addressReqTimer[dst].Schedule (rreqDelay);

2732

          m_addressReqTimer[dst].Schedule (rreqDelay);

2634

2733

2635

2636

2734

2637

2735

2638

2736

Lines 2956-2962 DsrRouting::Receive (Ptr<Packet> p,	Link Here

2956

  optionType = *(data);

3054

  optionType = *(data);

2957

  NS_LOG_LOGIC ("The option type value " << (uint32_t)optionType << " with packet size " << p->GetSize ());

3055

  NS_LOG_LOGIC ("The option type value " << (uint32_t)optionType << " with packet size " << p->GetSize ());

2958

  dsrOption = GetOption (optionType);       // Get the relative dsr option and demux to the process function

3056

  dsrOption = GetOption (optionType);       // Get the relative dsr option and demux to the process function

2959

3057

  // This promisc source is just set as empty, only the promisc received packet will have a promisc source value

3058

  Ipv4Address promiscSource;

2960

  if (optionType == 1)        // This is the request option

3059

  if (optionType == 1)        // This is the request option

2961

3060

2962

      BlackList *blackList = m_rreqTable->FindUnidirectional (src);

3061

      BlackList *blackList = m_rreqTable->FindUnidirectional (src);

Lines 2967-2973 DsrRouting::Receive (Ptr<Packet> p,	Link Here

2967

3066

2968

3067

2969

      dsrOption = GetOption (optionType);

3068

      dsrOption = GetOption (optionType);

2970

      optionLength = dsrOption->Process (p, packet, m_mainAddress, source, ip, protocol, isPromisc);

3069

      optionLength = dsrOption->Process (p, packet, m_mainAddress, source, ip, protocol, isPromisc, promiscSource);

2971

3070

2972

      if (optionLength == 0)

3071

      if (optionLength == 0)

2973

3072

Lines 2978-2984 DsrRouting::Receive (Ptr<Packet> p,	Link Here

2978

  else if (optionType == 2)

3077

  else if (optionType == 2)

2979

3078

2980

      dsrOption = GetOption (optionType);

3079

      dsrOption = GetOption (optionType);

2981

      optionLength = dsrOption->Process (p, packet, m_mainAddress, source, ip, protocol, isPromisc);

3080

      optionLength = dsrOption->Process (p, packet, m_mainAddress, source, ip, protocol, isPromisc, promiscSource);

2982

3081

2983

      if (optionLength == 0)

3082

      if (optionLength == 0)

2984

3083

Lines 2991-2997 DsrRouting::Receive (Ptr<Packet> p,	Link Here

2991

3090

2992

      NS_LOG_DEBUG ("This is the ack option");

3091

      NS_LOG_DEBUG ("This is the ack option");

2993

      dsrOption = GetOption (optionType);

3092

      dsrOption = GetOption (optionType);

2994

      optionLength = dsrOption->Process (p, packet, m_mainAddress, source, ip, protocol, isPromisc);

3093

      optionLength = dsrOption->Process (p, packet, m_mainAddress, source, ip, protocol, isPromisc, promiscSource);

2995

3094

2996

      if (optionLength == 0)

3095

      if (optionLength == 0)

2997

3096

Lines 3006-3012 DsrRouting::Receive (Ptr<Packet> p,	Link Here

3006

      NS_LOG_DEBUG ("The option type value " << (uint32_t)optionType);

3105

      NS_LOG_DEBUG ("The option type value " << (uint32_t)optionType);

3007

3106

3008

      dsrOption = GetOption (optionType);

3107

      dsrOption = GetOption (optionType);

3009

      optionLength = dsrOption->Process (p, packet, m_mainAddress, source, ip, protocol, isPromisc);

3108

      optionLength = dsrOption->Process (p, packet, m_mainAddress, source, ip, protocol, isPromisc, promiscSource);

3010

3109

3011

      if (optionLength == 0)

3110

      if (optionLength == 0)

3012

3111

Lines 3020-3026 DsrRouting::Receive (Ptr<Packet> p,	Link Here

3020

3119

3021

      NS_LOG_DEBUG ("This is the source route option " << (uint32_t)optionType);

3120

      NS_LOG_DEBUG ("This is the source route option " << (uint32_t)optionType);

3022

      dsrOption = GetOption (optionType);

3121

      dsrOption = GetOption (optionType);

3023

      optionLength = dsrOption->Process (p, packet, m_mainAddress, source, ip, protocol, isPromisc);

3122

      optionLength = dsrOption->Process (p, packet, m_mainAddress, source, ip, protocol, isPromisc, promiscSource);

3024

3123

3025

      segmentsLeft = *(data + 3);

3124

      segmentsLeft = *(data + 3);

3026

      NS_LOG_DEBUG ("The segments left in source route header " << (uint32_t)segmentsLeft);

3125

      NS_LOG_DEBUG ("The segments left in source route header " << (uint32_t)segmentsLeft);

(-)ns3dev/src/dsr/model/dsr-routing.h (-1 / +24 lines)

Lines 67-72	Link Here

#include "dsr-rcache.h"

#include "dsr-rcache.h"

#include "dsr-rreq-table.h"

#include "dsr-rreq-table.h"

#include "dsr-maintain-buff.h"

#include "dsr-maintain-buff.h"

#include "dsr-passive-buff.h"

#include "dsr-option-header.h"

#include "dsr-option-header.h"

#include "dsr-fs-header.h"

#include "dsr-fs-header.h"

#include "dsr-rsendbuff.h"

#include "dsr-rsendbuff.h"

Lines 141-146 public:	Link Here

141

    * \return the request table

142

    * \return the request table

142

*/

143

*/

143

  Ptr<dsr::RreqTable> GetRequestTable () const;

144

  Ptr<dsr::RreqTable> GetRequestTable () const;

145

/**

146

   * \brief Set the node.

147

   * \param the passive buffer to set

148

*/

149

  void SetPassiveBuffer (Ptr<dsr::PassiveBuffer> r);

150

/**

151

    * \brief Get the passive buffer

152

    * \return the passive buffer

153

*/

154

  Ptr<dsr::PassiveBuffer> GetPassiveBuffer () const;

144

155

145

  ///\functions used to direct to route cache

156

  ///\functions used to direct to route cache

146

  //\{

157

  //\{

Lines 151-156 public:	Link Here

151

  bool AddRoute (RouteCacheEntry & rt);

162

  bool AddRoute (RouteCacheEntry & rt);

152

  void DeleteAllRoutesIncludeLink (Ipv4Address errorSrc, Ipv4Address unreachNode, Ipv4Address node);

163

  void DeleteAllRoutesIncludeLink (Ipv4Address errorSrc, Ipv4Address unreachNode, Ipv4Address node);

153

  bool UpdateRouteEntry (Ipv4Address dst);

164

  bool UpdateRouteEntry (Ipv4Address dst);

165

  bool FindSourceEntry (Ipv4Address src, Ipv4Address dst, uint16_t id);

154

  //\}

166

  //\}

155

167

156

/**

168

/**

Lines 256-261 public:	Link Here

256

  void SendPacketFromBuffer (DsrOptionSRHeader const &sourceRoute,

268

  void SendPacketFromBuffer (DsrOptionSRHeader const &sourceRoute,

257

                             Ipv4Address nextHop,

269

                             Ipv4Address nextHop,

258

                             uint8_t protocol);

270

                             uint8_t protocol);

271

/**

272

   * \brief Find the same passive entry

273

*/

274

  bool PassiveEntryCheck (Ptr<Packet> packet, Ipv4Address source, Ipv4Address destination, uint8_t segsLeft,

275

                      uint16_t fragmentOffset, uint16_t identification, bool saveEntry);

276

/**

277

   * \brief Cancel the passive timer

278

*/

279

  bool CancelPassiveTimer (Ptr<Packet> packet, Ipv4Address source, Ipv4Address destination, uint8_t segsLeft);

259

/*

280

/*

260

   * \brief Find the similar entries in the maintenance buffer

281

   * \brief Find the similar entries in the maintenance buffer

261

*/

282

*/

Lines 616-621 private:	Link Here

616

637

617

  Ptr<dsr::RreqTable> m_rreqTable;        // / A "drop-front" queue used by the routing layer to cache route request sent.

638

  Ptr<dsr::RreqTable> m_rreqTable;        // / A "drop-front" queue used by the routing layer to cache route request sent.

618

639

640

  Ptr<dsr::PassiveBuffer> m_passiveBuffer;              ///< A "drop-front" queue used by the routing layer to cache route request sent.

641

619

  uint32_t m_numPriorityQueues;

642

  uint32_t m_numPriorityQueues;

620

643

621

  std::map<uint32_t, Ptr<dsr::DsrNetworkQueue> > m_priorityQueue;   // / priority queueus

644

  std::map<uint32_t, Ptr<dsr::DsrNetworkQueue> > m_priorityQueue;   // / priority queueus

Lines 627-633 private:	Link Here

627

  std::vector<Ipv4Address> m_addresses;   // / The bind ipv4 addresses with next hop, src, destination address in sequence

650

  std::vector<Ipv4Address> m_addresses;   // / The bind ipv4 addresses with next hop, src, destination address in sequence

628

651

629

  /// Provides uniform random variables.

652

  /// Provides uniform random variables.

630

  Ptr<UniformRandomVariable> m_uniformRandomVariable;

653

  Ptr<UniformRandomVariable> m_uniformRandomVariable;

631

};

654

};

632

}  /* namespace dsr */

655

}  /* namespace dsr */

633

}  /* namespace ns3 */

656

}  /* namespace ns3 */




    m_rreqDstMap.find (dst);
  if (i == m_rreqDstMap.end ())
    {
      NS_LOG_LOGIC ("The request table entry for " << dst << " not found");
      /*
       * Drop the most aged packet when buffer reaches to max
       */
      if (m_rreqDstMap.size () >= m_requestTableSize)
        {
          RemoveLeastExpire (m_rreqDstMap);
          NS_LOG_INFO ("The request table size after erase " << (uint32_t)m_rreqDstMap.size ());
        }
      RreqTableEntry rreqTableEntry;
      rreqTableEntry.m_reqNo = 1;

    }
  else
    {
      NS_LOG_LOGIC ("Find the request table entry for  " << dst << ", increment the request count");
      Ipv4Address dst = i->first;
      RreqTableEntry rreqTableEntry = i->second;
      rreqTableEntry.m_reqNo = rreqTableEntry.m_reqNo + 1;
      rreqTableEntry.m_reqNo = (rreqTableEntry.m_reqNo + 1);
      rreqTableEntry.m_expire = Simulator::Now ();
      m_rreqDstMap [dst] = rreqTableEntry;
    }

RreqTable::RemoveRreqEntry (Ipv4Address dst)
{
  NS_LOG_FUNCTION (this << dst);
  NS_LOG_DEBUG ("Remove rreq entry with index dst");
  std::map<Ipv4Address, RreqTableEntry >::const_iterator i =
    m_rreqDstMap.find (dst);
  if (i == m_rreqDstMap.end ())
    {
      NS_LOG_LOGIC ("The request table entry not found");
    }
  else
    {

    m_rreqDstMap.find (dst);
  if (i == m_rreqDstMap.end ())
    {
      NS_LOG_LOGIC ("Request table entry not found");
      return 0;
    }
  else
    {
      RreqTableEntry rreqTableEntry = i->second;
      NS_LOG_DEBUG ("Find the request count for " << dst << " " << rreqTableEntry.m_reqNo);
      return rreqTableEntry.m_reqNo;
    }
}

// ----------------------------------------------------------------------------------------------------------
/*
 * This part takes care of the route request ID initialized from a specific source to one destination
 * Essentially a counter
 */
uint32_t
RreqTable::CheckUniqueRreqId (Ipv4Address dst)
{
  NS_LOG_LOGIC ("The size of id cache " << m_rreqIdCache.size ());
  std::map<Ipv4Address, uint32_t>::const_iterator i =
    m_rreqIdCache.find (dst);
  if (i == m_rreqIdCache.end ())
    {
      NS_LOG_LOGIC ("No Request id for " << dst << " found, initialize it to 0");
      m_rreqIdCache[dst] = 0;
      return 0;
    }

          rreqId++;
          m_rreqIdCache[dst] = rreqId;
        }
      NS_LOG_INFO ("The Request id for " << dst << " is " << rreqId);
      return rreqId;
    }
}

}

// ----------------------------------------------------------------------------------------------------------
/*
 * This part takes care of black list which can save unidirectional link information
 */


                                IsExpired ()), m_blackList.end ());
}

bool
RreqTable::FindSourceEntry (Ipv4Address src, Ipv4Address dst, uint16_t id)
{
  NS_LOG_FUNCTION (this << src << dst << id);
  ReceivedRreqEntry rreqEntry;
  rreqEntry.SetDestination (dst);
  rreqEntry.SetIdentification (id);
  std::list<ReceivedRreqEntry> receivedRreqEntryList;
  /*
   * this function will return false if the entry is not found, true if duplicate entry find
   */
  std::map<Ipv4Address, std::list<ReceivedRreqEntry> >::const_iterator i = m_sourceRreqMap.find (src);
  if (i == m_sourceRreqMap.end ())
    {
      NS_LOG_LOGIC ("The source request table entry for " << src << " not found");

      receivedRreqEntryList.clear ();  /// Clear the received source request entry
      receivedRreqEntryList.push_back (rreqEntry);

      m_sourceRreqMap [src] = receivedRreqEntryList;
      return false;
    }
  else
    {
      NS_LOG_LOGIC ("Find the request table entry for  " << src << ", check if it is exact duplicate");
      /*
       * Drop the most aged packet when buffer reaches to max
       */
      receivedRreqEntryList = i->second;
      if (receivedRreqEntryList.size () >= m_requestIdSize)
        {
          receivedRreqEntryList.pop_front ();
        }
      Ipv4Address src = i->first;
      // We loop the receive rreq entry to find duplicate
      for (std::list<ReceivedRreqEntry>::const_iterator j = receivedRreqEntryList.begin (); j != receivedRreqEntryList.end (); ++j)
        {
          ReceivedRreqEntry newEntry = *j;
          if (*j == rreqEntry)          /// Check if we have found one duplication entry or not
            {
              return true;
            }
        }
      /// if this entry is not found, we need to save the entry in the cache, and then return false for the check
      receivedRreqEntryList.push_back (rreqEntry);
      m_sourceRreqMap [src] = receivedRreqEntryList;
      return false;
    }
}

} // namespace dsr
} // namespace ns3




  {
  }
};
/**
 * The route request table entries
 */
struct RreqTableEntry

  Time m_expire;
};
/*
 * The request entry for intermediate nodes to check if they have received this request or not
 * This is used to control the duplication request from being processed
 */
class ReceivedRreqEntry
{
public:
  // / c-tor
  ReceivedRreqEntry (Ipv4Address d = Ipv4Address (), uint16_t i = 0)
    : m_destination (d),
      m_identification (i)
  {
  }
  /**
   * Compare send buffer entries
   * \return true if equal
   */
  bool operator== (ReceivedRreqEntry const & o) const
  {
    return ((m_destination == o.m_destination) && (m_identification == o.m_identification)
           );
  }
  // /\name Fields
  // \{
  Ipv4Address GetDestination () const
  {
    return m_destination;
  }
  void SetDestination (Ipv4Address d)
  {
    m_destination = d;
  }
  Ipv4Address GetSource () const
  {
    return m_source;
  }
  void SetSource (Ipv4Address s)
  {
    m_source = s;
  }
  uint16_t GetIdentification () const
  {
    return m_identification;
  }
  void SetIdentification (uint16_t i)
  {
    m_identification = i;
  }
  void SetExpireTime (Time exp)
  {
    m_expire = exp + Simulator::Now ();
  }
  Time GetExpireTime () const
  {
    return m_expire - Simulator::Now ();
  }
  // \}
private:
    Ipv4Address m_destination;
    Ipv4Address m_source;
    uint16_t m_identification;
    Time m_expire;
};

/**
 * \ingroup dsr
 * \brief maintain list of RreqTable entry

  void RemoveRreqEntry (Ipv4Address dst);
  // / Get the request count number for one destination address
  uint32_t GetRreqCnt (Ipv4Address dst);

  //----------------------------------------------------------------------------------------------------------
  /**
   * The following code generates new request id for each destination
   */
  // / Check for duplicate ids and save new entries if the id is not present in the table
  uint32_t CheckUniqueRreqId (Ipv4Address dst);
  // / Get the request id size
  uint32_t GetRreqSize ();

  // ---------------------------------------------------------------------------------------------------------
  /**
   * set the unidirectional entry as QUESTIONABLE state
   */
  void Invalidate ();

  bool MarkLinkAsUnidirectional (Ipv4Address neighbor, Time blacklistTimeout);
  // / Remove all expired black list entries
  void PurgeNeighbor ();
  // ----------------------------------------------------------------------------------------------------------
  /**
   * Find the source request entry in the route request queue, return false if not found
   * \param src the source address we just received the source request
   * \param dst the destination address the request is targeted at
   * \param id the identification number for this request
   */
  bool FindSourceEntry (Ipv4Address src, Ipv4Address dst, uint16_t id);

private:

  Timer m_ntimer;
  // / The max # of requests to retransmit
  uint32_t MaxRequestRexmt;
  // / The max request period among requests

  // / The state of the unidirectional link
  LinkStates m_linkStates;
  // / Map of entries
  std::list<ReceivedRreqEntry> m_sourceRequests;
  // / The id cache to ensure all the ids are unique, it is used when sending out route request
  std::map<Ipv4Address, uint32_t> m_rreqIdCache;
  // / The cache to save route request table entries indexed with destination address
  std::map<Ipv4Address, RreqTableEntry > m_rreqDstMap;
  // / The cache to ensure all the route request from unique source
  std::map<Ipv4Address, std::list<ReceivedRreqEntry> > m_sourceRreqMap;

  // / The Black list
  std::vector<BlackList> m_blackList;
  // / Check if the entry is expired or not




        'model/dsr-fs-header.cc',
        'model/dsr-option-header.cc',
        'model/dsr-maintain-buff.cc',
        'model/dsr-passive-buff.cc',
        'model/dsr-rsendbuff.cc',
        'model/dsr-rcache.cc',
        'model/dsr-rreq-table.cc',
        'model/dsr-gratuitous-reply-table.cc',
        'model/dsr-errorbuff.cc',
        'model/dsr-network-queue.cc',
        'helper/dsr-helper.cc',
        'helper/dsr-main-helper.cc',
        ]

        'model/dsr-fs-header.h',
        'model/dsr-option-header.h',
        'model/dsr-maintain-buff.h',
        'model/dsr-passive-buff.h',
        'model/dsr-rsendbuff.h',
        'model/dsr-rcache.h',
        'model/dsr-rreq-table.h',
        'model/dsr-gratuitous-reply-table.h',
        'model/dsr-errorbuff.h',
        'model/dsr-network-queue.h',
        'helper/dsr-helper.h',
        'helper/dsr-main-helper.h',
        ]

Return to bug 1609