Attachment #2213 for bug #2246

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

(-)a/src/dsr/examples/dsr.cc (-2 / +2 lines)

Lines 66-74	Link Here

  LogComponentEnable ("DsrFsHeader", LOG_LEVEL_ALL);

  LogComponentEnable ("DsrFsHeader", LOG_LEVEL_ALL);

  LogComponentEnable ("DsrGraReplyTable", LOG_LEVEL_ALL);

  LogComponentEnable ("DsrGraReplyTable", LOG_LEVEL_ALL);

  LogComponentEnable ("DsrSendBuffer", LOG_LEVEL_ALL);

  LogComponentEnable ("DsrSendBuffer", LOG_LEVEL_ALL);

  LogComponentEnable ("RouteCache", LOG_LEVEL_ALL);

  LogComponentEnable ("DsrRouteCache", LOG_LEVEL_ALL);

  LogComponentEnable ("DsrMaintainBuffer", LOG_LEVEL_ALL);

  LogComponentEnable ("DsrMaintainBuffer", LOG_LEVEL_ALL);

  LogComponentEnable ("RreqTable", LOG_LEVEL_ALL);

  LogComponentEnable ("DsrRreqTable", LOG_LEVEL_ALL);

  LogComponentEnable ("DsrErrorBuffer", LOG_LEVEL_ALL);

  LogComponentEnable ("DsrErrorBuffer", LOG_LEVEL_ALL);

  LogComponentEnable ("DsrNetworkQueue", LOG_LEVEL_ALL);

  LogComponentEnable ("DsrNetworkQueue", LOG_LEVEL_ALL);

#endif

#endif




namespace dsr {

uint32_t
DsrErrorBuffer::GetSize ()
{
  Purge ();
  return m_errorBuffer.size ();
}

bool
DsrErrorBuffer::Enqueue (DsrErrorBuffEntry & entry)
{
  Purge ();
  for (std::vector<DsrErrorBuffEntry>::const_iterator i = m_errorBuffer.begin (); i
       != m_errorBuffer.end (); ++i)
    {
      NS_LOG_INFO ("packet id " << i->GetPacket ()->GetUid () << " " << entry.GetPacket ()->GetUid () << " source " << i->GetSource () << " " << entry.GetSource ()

}

void
DsrErrorBuffer::DropPacketForErrLink (Ipv4Address source, Ipv4Address nextHop)
{
  NS_LOG_FUNCTION (this << source << nextHop);
  Purge ();

  /*
   * Drop the packet with the error link source----------nextHop
   */
  for (std::vector<DsrErrorBuffEntry>::iterator i = m_errorBuffer.begin (); i
       != m_errorBuffer.end (); ++i)
    {
      if (LinkEqual (*i, link))

        }
    }
  m_errorBuffer.erase (std::remove_if (m_errorBuffer.begin (), m_errorBuffer.end (),
                                       std::bind2nd (std::ptr_fun (DsrErrorBuffer::LinkEqual), link)), m_errorBuffer.end ());
}

bool
DsrErrorBuffer::Dequeue (Ipv4Address dst, DsrErrorBuffEntry & entry)
{
  Purge ();
  /*
   * Dequeue the entry with destination address dst
   */
  for (std::vector<DsrErrorBuffEntry>::iterator i = m_errorBuffer.begin (); i != m_errorBuffer.end (); ++i)
    {
      if (i->GetDestination () == dst)
        {

}

bool
DsrErrorBuffer::Find (Ipv4Address dst)
{
  /*
   * Make sure if the send buffer contains entry with certain dst
   */
  for (std::vector<DsrErrorBuffEntry>::const_iterator i = m_errorBuffer.begin (); i
       != m_errorBuffer.end (); ++i)
    {
      if (i->GetDestination () == dst)

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

};

void
DsrErrorBuffer::Purge ()
{
  /*
   * Purge the buffer to eliminate expired entries
   */
  NS_LOG_DEBUG ("The error buffer size " << m_errorBuffer.size ());
  IsExpired pred;
  for (std::vector<DsrErrorBuffEntry>::iterator i = m_errorBuffer.begin (); i
       != m_errorBuffer.end (); ++i)
    {
      if (pred (*i))

}

void
DsrErrorBuffer::Drop (DsrErrorBuffEntry en, std::string reason)
{
  NS_LOG_LOGIC (reason << en.GetPacket ()->GetUid () << " " << en.GetDestination ());
//  en.GetErrorCallback () (en.GetPacket (), en.GetDestination (),

}

void
DsrErrorBuffer::DropLink (DsrErrorBuffEntry en, std::string reason)
{
  NS_LOG_LOGIC (reason << en.GetPacket ()->GetUid () << " " << en.GetSource () << " " << en.GetNextHop ());
//  en.GetErrorCallback () (en.GetPacket (), en.GetDestination (),




 * \ingroup dsr
 * \brief DSR Error Buffer Entry
 */
class DsrErrorBuffEntry
{
public:
  /**
   * Create an DsrErrorBuffEntry with the given parameters.
   *
   * \param pa packet
   * \param d IPv4 address of the destination

   * \param exp expiration time
   * \param p protocol number
   */
  DsrErrorBuffEntry (Ptr<const Packet> pa = 0, Ipv4Address d = Ipv4Address (), Ipv4Address s = Ipv4Address (),
                  Ipv4Address n = Ipv4Address (), Time exp = Simulator::Now (), uint8_t p = 0)
    : m_packet (pa),
      m_dst (d),

  }
  /**
   * Compare send buffer entries
   * \param o another DsrErrorBuffEntry
   * \return true if equal
   */
  bool operator== (DsrErrorBuffEntry 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));
  }

 * \brief DSR error buffer
 */
/************************************************************************************************************************/
class DsrErrorBuffer
{
public:
  /**
   * Default constructor
   */
  DsrErrorBuffer ()
  {
  }
  /// Push entry in queue, if there is no entry with the same packet and destination address in queue.
  bool Enqueue (DsrErrorBuffEntry & entry);
  /// Return first found (the earliest) entry for given destination
  bool Dequeue (Ipv4Address dst, DsrErrorBuffEntry & entry);
  /// Remove all packets with the error link
  void DropPacketForErrLink (Ipv4Address source, Ipv4Address nextHop);
  /// Finds whether a packet with destination dst exists in the queue

    m_errorBufferTimeout = t;
  }

  std::vector<DsrErrorBuffEntry> & GetBuffer ()
  {
    return m_errorBuffer;
  }

private:
  /// The send buffer to cache unsent packet
  std::vector<DsrErrorBuffEntry> m_errorBuffer;
  /// Remove all expired entries
  void Purge ();
  /// Notify that packet is dropped from queue by timeout
  void Drop (DsrErrorBuffEntry en, std::string reason);
  /// Notify that packet is dropped from queue by timeout
  void DropLink (DsrErrorBuffEntry 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_errorBufferTimeout;
  /// Check if the send buffer entry is the same or not
  static bool LinkEqual (DsrErrorBuffEntry en, const std::vector<Ipv4Address> link)
  {
    return ((en.GetSource () == link[0]) && (en.GetNextHop () == link[1]));
  }




  
namespace dsr {

NS_OBJECT_ENSURE_REGISTERED (DsrGraReply);

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

DsrGraReply::DsrGraReply ()
{
}

DsrGraReply::~DsrGraReply ()
{
  NS_LOG_FUNCTION_NOARGS ();
}

bool
DsrGraReply::FindAndUpdate (Ipv4Address replyTo, Ipv4Address replyFrom, Time gratReplyHoldoff)
{
  Purge ();  // purge the gratuitous reply table
  for (std::vector<GraReplyEntry>::iterator i = m_graReply.begin ();

}

bool
DsrGraReply::AddEntry (GraReplyEntry & graTableEntry)
{
  m_graReply.push_back (graTableEntry);
  return true;
}

void
DsrGraReply::Purge ()
{
  /*
   * Purge the expired gratuitous reply entries




 * \ingroup dsr
 * \brief maintain the gratuitous reply
 */
class DsrGraReply  : public Object
{
public:

  static TypeId GetTypeId ();

  DsrGraReply ();
  virtual ~DsrGraReply ();

  /// Set the gratuitous reply table size
  void SetGraTableSize (uint32_t g)




namespace dsr {

uint32_t
DsrMaintainBuffer::GetSize ()
{
  Purge ();
  return m_maintainBuffer.size ();
}

bool
DsrMaintainBuffer::Enqueue (DsrMaintainBuffEntry & entry)
{
  Purge ();
  for (std::vector<DsrMaintainBuffEntry>::const_iterator i = m_maintainBuffer.begin (); i
       != m_maintainBuffer.end (); ++i)
    {
//      NS_LOG_INFO ("nexthop " << i->GetNextHop () << " " << entry.GetNextHop () << " our add " << i->GetOurAdd () << " " << entry.GetOurAdd ()

}

void
DsrMaintainBuffer::DropPacketWithNextHop (Ipv4Address nextHop)
{
  NS_LOG_FUNCTION (this << nextHop);
  Purge ();
  NS_LOG_INFO ("Drop Packet With next hop " << nextHop);
  m_maintainBuffer.erase (std::remove_if (m_maintainBuffer.begin (), m_maintainBuffer.end (),
                                          std::bind2nd (std::ptr_fun (DsrMaintainBuffer::IsEqual), nextHop)), m_maintainBuffer.end ());
}

bool
DsrMaintainBuffer::Dequeue (Ipv4Address nextHop, DsrMaintainBuffEntry & entry)
{
  Purge ();
  for (std::vector<DsrMaintainBuffEntry>::iterator i = m_maintainBuffer.begin (); i != m_maintainBuffer.end (); ++i)
    {
      if (i->GetNextHop () == nextHop)
        {

}

bool
DsrMaintainBuffer::Find (Ipv4Address nextHop)
{
  for (std::vector<DsrMaintainBuffEntry>::const_iterator i = m_maintainBuffer.begin (); i
       != m_maintainBuffer.end (); ++i)
    {
      if (i->GetNextHop () == nextHop)

}

bool
DsrMaintainBuffer::AllEqual (DsrMaintainBuffEntry & entry)
{
  for (std::vector<DsrMaintainBuffEntry>::iterator i = m_maintainBuffer.begin (); i
       != m_maintainBuffer.end (); ++i)
    {
//      NS_LOG_DEBUG ("nexthop " << i->GetNextHop () << " " << entry.GetNextHop () << " our address " << i->GetOurAdd () << " " << entry.GetOurAdd ()

}

bool
DsrMaintainBuffer::NetworkEqual (DsrMaintainBuffEntry & entry)
{
  for (std::vector<DsrMaintainBuffEntry>::iterator i = m_maintainBuffer.begin (); i
       != m_maintainBuffer.end (); ++i)
    {
//      NS_LOG_DEBUG ("nexthop " << i->GetNextHop () << " " << entry.GetNextHop () << " our address " << i->GetOurAdd () << " " << entry.GetOurAdd ()

}

bool
DsrMaintainBuffer::PromiscEqual (DsrMaintainBuffEntry & entry)
{
  NS_LOG_DEBUG ("The maintenance buffer size " << m_maintainBuffer.size ());
  for (std::vector<DsrMaintainBuffEntry>::iterator i = m_maintainBuffer.begin (); i
       != m_maintainBuffer.end (); ++i)
    {
//      NS_LOG_DEBUG ("src " << i->GetSrc () << " " << entry.GetSrc () << " dst " << i->GetDst () << " " << entry.GetDst ()

}

bool
DsrMaintainBuffer::LinkEqual (DsrMaintainBuffEntry & entry)
{
  NS_LOG_DEBUG ("The maintenance buffer size " << m_maintainBuffer.size ());
  for (std::vector<DsrMaintainBuffEntry>::iterator i = m_maintainBuffer.begin (); i
       != m_maintainBuffer.end (); ++i)
    {
//      NS_LOG_DEBUG ("src " << i->GetSrc () << " " << entry.GetSrc () << " dst " << i->GetDst () << " " << entry.GetDst ()

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

};

void
DsrMaintainBuffer::Purge ()
{
  NS_LOG_DEBUG ("Purging Maintenance Buffer");
  IsExpired pred;




 * \ingroup dsr
 * \brief DSR Maintain Buffer Entry
 */
class DsrMaintainBuffEntry
{
public:
  /**
   * Construct a DsrMaintainBuffEntry with the given parameters
   *
   * \param pa packet
   * \param us our IPv4 address

   * \param segs number of segments left
   * \param exp expiration time
   */
  DsrMaintainBuffEntry (Ptr<const Packet> pa = 0, Ipv4Address us = Ipv4Address (),
                     Ipv4Address n = Ipv4Address (), Ipv4Address s = Ipv4Address (), Ipv4Address dst = Ipv4Address (),
                     uint16_t ackId = 0, uint8_t segs = 0, Time exp = Simulator::Now ())
    : m_packet (pa),

 * \brief DSR maintain buffer
 */
/************************************************************************************************************************/
class DsrMaintainBuffer
{
public:
  /**
   * Default constructor
   */
  DsrMaintainBuffer ()
  {
  }
  /// Push entry in queue, if there is no entry with the same packet and destination address in queue.
  bool Enqueue (DsrMaintainBuffEntry & entry);
  /// Return first found (the earliest) entry for given destination
  bool Dequeue (Ipv4Address dst, DsrMaintainBuffEntry & entry);
  /// Remove all packets with destination IP address dst
  void DropPacketWithNextHop (Ipv4Address nextHop);
  /// Finds whether a packet with destination dst exists in the queue

    m_maintainBufferTimeout = t;
  }
  /// Verify if all the elements in the maintainence buffer entry is the same
  bool AllEqual (DsrMaintainBuffEntry & entry);
  /// Verify if the maintain buffer entry is the same in every field for link ack
  bool LinkEqual (DsrMaintainBuffEntry & entry);
  /// Verify if the maintain buffer entry is the same in every field for network ack
  bool NetworkEqual (DsrMaintainBuffEntry & entry);
  /// Verify if the maintain buffer entry is the same in every field for promiscuous ack
  bool PromiscEqual (DsrMaintainBuffEntry & entry);

private:
  /// The vector of maintain buffer entries
  std::vector<DsrMaintainBuffEntry> m_maintainBuffer;
  std::vector<NetworkKey> m_allNetworkKey;
  /// Remove all expired entries
  void Purge ();

  /// The maximum period of time that a routing protocol is allowed to buffer a packet for, seconds.
  Time m_maintainBufferTimeout;
  /// Verify if the maintain buffer is equal or not
  static bool IsEqual (DsrMaintainBuffEntry en, const Ipv4Address nextHop)
  {
    return (en.GetNextHop () == nextHop);
  }




  else
    {
      // A node ignores all RREQs received from any node in its blacklist
      DsrRouteCacheEntry toPrev;
      bool isRouteInCache = dsr->LookupRoute (targetAddress,
                                              toPrev);
      DsrRouteCacheEntry::IP_VECTOR ip = toPrev.GetVector (); // The route from our own route cache to dst
      PrintVector (ip);
      std::vector<Ipv4Address> saveRoute (nodeList);
      PrintVector (saveRoute);

              bool addRoute = false;
              if (numberAddress > 0)
                {
                  DsrRouteCacheEntry toSource (/*IP_VECTOR=*/ m_finalRoute, /*dst=*/
                                                           dst, /*expire time=*/ ActiveRouteTimeout);
                  if (dsr->IsLinkCache ())
                    {

                  NS_LOG_DEBUG ("This is the route save in route cache");
                  PrintVector (saveRoute);

                  DsrRouteCacheEntry toSource (/*IP_VECTOR=*/ saveRoute, /*dst=*/ dst, /*expire time=*/ ActiveRouteTimeout);
                  NS_ASSERT (saveRoute.front () == ipv4Address);
                  // Add the route entry in the route cache
                  if (dsr->IsLinkCache ())

       * The route looks like:
       * \\ "srcAddress" + "intermediate node address" + "targetAddress"
       */
      DsrRouteCacheEntry toDestination (/*IP_VECTOR=*/ nodeList, /*dst=*/ dst, /*expire time=*/ ActiveRouteTimeout);
      NS_ASSERT (nodeList.front () == ipv4Address);
      bool addRoute = false;
      if (dsr->IsLinkCache ())

        {
          Ipv4Address dst = cutRoute.back ();
          NS_LOG_DEBUG ("The route destination after cut " << dst);
          DsrRouteCacheEntry toDestination (/*IP_VECTOR=*/ cutRoute, /*dst=*/ dst, /*expire time=*/ ActiveRouteTimeout);
          NS_ASSERT (cutRoute.front () == ipv4Address);
          bool addRoute = false;
          if (dsr->IsLinkCache ())




  /**
   * \brief The route request table.
   */
  Ptr<dsr::DsrRreqTable> m_rreqTable;
  /**
   * \brief The route cache table.
   */
  Ptr<dsr::DsrRouteCache> m_routeCache;
  /**
   * \brief The ipv4 route.
   */

  /**
   * \brief The route cache.
   */
  Ptr<dsr::DsrRouteCache> m_routeCache;
  /**
   * \brief The ipv4.
   */

  /**
   * \brief The route cache.
   */
  Ptr<dsr::DsrRouteCache> m_routeCache;
  /**
   * \brief The ip layer 3.
   */

  /**
   * \brief The route cache.
   */
  Ptr<dsr::DsrRouteCache> m_routeCache;
  /**
   * \brief The ipv4 layer 3.
   */

  /**
   * \brief The route cache.
   */
  Ptr<dsr::DsrRouteCache> m_routeCache;
  /**
   * \brief The ipv4 layer 3.
   */

  /**
   * \brief The route cache.
   */
  Ptr<dsr::DsrRouteCache> m_routeCache;
  /**
   * \brief The ipv4 layer 3.
   */





namespace ns3 {

NS_LOG_COMPONENT_DEFINE ("DsrPassiveBuffer");
  
namespace dsr {

NS_OBJECT_ENSURE_REGISTERED (DsrPassiveBuffer);

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

DsrPassiveBuffer::DsrPassiveBuffer ()
{
}

DsrPassiveBuffer::~DsrPassiveBuffer ()
{
}

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

bool
DsrPassiveBuffer::Enqueue (DsrPassiveBuffEntry & entry)
{
  Purge ();
  for (std::vector<DsrPassiveBuffEntry>::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 ()

}

bool
DsrPassiveBuffer::AllEqual (DsrPassiveBuffEntry & entry)
{
  for (std::vector<DsrPassiveBuffEntry>::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 ()

}

bool
DsrPassiveBuffer::Dequeue (Ipv4Address dst, DsrPassiveBuffEntry & entry)
{
  Purge ();
  /*
   * Dequeue the entry with destination address dst
   */
  for (std::vector<DsrPassiveBuffEntry>::iterator i = m_passiveBuffer.begin (); i != m_passiveBuffer.end (); ++i)
    {
      if (i->GetDestination () == dst)
        {

}

bool
DsrPassiveBuffer::Find (Ipv4Address dst)
{
  /*
   * Make sure if the send buffer contains entry with certain dst
   */
  for (std::vector<DsrPassiveBuffEntry>::const_iterator i = m_passiveBuffer.begin (); i
       != m_passiveBuffer.end (); ++i)
    {
      if (i->GetDestination () == dst)

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

};

void
DsrPassiveBuffer::Purge ()
{
  /*
   * Purge the buffer to eliminate expired entries
   */
  NS_LOG_DEBUG ("The passive buffer size " << m_passiveBuffer.size ());
  IsExpired pred;
  for (std::vector<DsrPassiveBuffEntry>::iterator i = m_passiveBuffer.begin (); i
       != m_passiveBuffer.end (); ++i)
    {
      if (pred (*i))

}

void
DsrPassiveBuffer::Drop (DsrPassiveBuffEntry en, std::string reason)
{
  NS_LOG_LOGIC (reason << en.GetPacket ()->GetUid () << " " << en.GetDestination ());
//  en.GetErrorCallback () (en.GetPacket (), en.GetDestination (),

}

void
DsrPassiveBuffer::DropLink (DsrPassiveBuffEntry en, std::string reason)
{
  NS_LOG_LOGIC (reason << en.GetPacket ()->GetUid () << " " << en.GetSource () << " " << en.GetNextHop ());
//  en.GetErrorCallback () (en.GetPacket (), en.GetDestination (),




 * \ingroup dsr
 * \brief DSR Passive Buffer Entry
 */
class DsrPassiveBuffEntry
{
public:
  /**
   * Construct a DsrPassiveBuffEntry with the given parameters
   *
   * \param pa packet
   * \param d IPv4 address of the destination

   * \param exp expiration time
   * \param p protocol number
   */
  DsrPassiveBuffEntry (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),

   * Compare send buffer entries
   * \return true if equal
   */
  bool operator== (DsrPassiveBuffEntry 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));
  }

 * \brief DSR passive buffer
 */
/************************************************************************************************************************/
class DsrPassiveBuffer  : public Object
{
public:

  static TypeId GetTypeId ();

  DsrPassiveBuffer ();
  virtual ~DsrPassiveBuffer ();

  /// Push entry in queue, if there is no entry with the same packet and destination address in queue.
  bool Enqueue (DsrPassiveBuffEntry & entry);
  /// Return first found (the earliest) entry for given destination
  bool Dequeue (Ipv4Address dst, DsrPassiveBuffEntry & 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 (DsrPassiveBuffEntry & entry);
  /// Number of entries
  uint32_t GetSize ();



private:
  /// The send buffer to cache unsent packet
  std::vector<DsrPassiveBuffEntry> m_passiveBuffer;
  /// Remove all expired entries
  void Purge ();
  /// Notify that packet is dropped from queue by timeout
  void Drop (DsrPassiveBuffEntry en, std::string reason);
  /// Notify that packet is dropped from queue by timeout
  void DropLink (DsrPassiveBuffEntry 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 (DsrPassiveBuffEntry en, const std::vector<Ipv4Address> link)
  {
    return ((en.GetSource () == link[0]) && (en.GetNextHop () == link[1]));
  }





namespace ns3 {

NS_LOG_COMPONENT_DEFINE ("DsrRouteCache");
  
namespace dsr {

bool CompareRoutesBoth (const DsrRouteCacheEntry &a, const DsrRouteCacheEntry &b)
{
  // compare based on both with hop count considered priority
  return (a.GetVector ().size () < b.GetVector ().size ())

  ;
}

bool CompareRoutesHops (const DsrRouteCacheEntry &a, const DsrRouteCacheEntry &b)
{
  // compare based on hops
  return a.GetVector ().size () < b.GetVector ().size ();
}

bool CompareRoutesExpire (const DsrRouteCacheEntry &a, const DsrRouteCacheEntry &b)
{
  // compare based on expire time
  return a.GetExpireTime () > b.GetExpireTime ();

  NS_LOG_DEBUG (m_low << "----" << m_high);
}

DsrNodeStab::DsrNodeStab (Time nodeStab)
  : m_nodeStability (nodeStab + Simulator::Now ())
{
}

DsrNodeStab::~DsrNodeStab ()
{
}

DsrLinkStab::DsrLinkStab (Time linkStab)
  : m_linkStability (linkStab + Simulator::Now ())
{
}

DsrLinkStab::~DsrLinkStab ()
{
}

void DsrLinkStab::Print ( ) const
{
  NS_LOG_LOGIC ("LifeTime: " << GetLinkStability ().GetSeconds ());
}

typedef std::list<DsrRouteCacheEntry>::value_type route_pair;

DsrRouteCacheEntry::DsrRouteCacheEntry (IP_VECTOR const  & ip, Ipv4Address dst, Time exp)
  : m_ackTimer (Timer::CANCEL_ON_DESTROY),
    m_dst (dst),
    m_path (ip),

{
}

DsrRouteCacheEntry::~DsrRouteCacheEntry ()
{
}

void
DsrRouteCacheEntry::Invalidate (Time badLinkLifetime)
{
  m_reqCount = 0;
  m_expire = badLinkLifetime + Simulator::Now ();
}

void
DsrRouteCacheEntry::Print (std::ostream & os) const
{
  os << m_dst << "\t" << (m_expire - Simulator::Now ()).GetSeconds ()
     << "\t";
}

NS_OBJECT_ENSURE_REGISTERED (DsrRouteCache);

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

DsrRouteCache::DsrRouteCache ()
  : m_vector (0),
    m_maxEntriesEachDst (3),
    m_isLinkCache (false),

   * The timer to set layer 2 notification, not fully supported by ns3 yet
   */
  m_ntimer.SetDelay (m_delay);
  m_ntimer.SetFunction (&DsrRouteCache::PurgeMac, this);
  m_txErrorCallback = MakeCallback (&DsrRouteCache::ProcessTxError, this);
}

DsrRouteCache::~DsrRouteCache ()
{
  NS_LOG_FUNCTION_NOARGS ();
  // clear the route cache when done

}

void
DsrRouteCache::RemoveLastEntry (std::list<DsrRouteCacheEntry> & rtVector)
{
  NS_LOG_FUNCTION (this);
  // Release the last entry of route list

}

bool
DsrRouteCache::UpdateRouteEntry (Ipv4Address dst)
{
  NS_LOG_FUNCTION (this << dst);
  std::map<Ipv4Address, std::list<DsrRouteCacheEntry> >::const_iterator i =
    m_sortedRoutes.find (dst);
  if (i == m_sortedRoutes.end ())
    {

    }
  else
    {
      std::list<DsrRouteCacheEntry> rtVector = i->second;
      DsrRouteCacheEntry successEntry = rtVector.front ();
      successEntry.SetExpireTime (RouteCacheTimeout);
      rtVector.pop_front ();
      rtVector.push_back (successEntry);

      /*
       * Save the new route cache along with the destination address in map
       */
      std::pair<std::map<Ipv4Address, std::list<DsrRouteCacheEntry> >::iterator, bool> result =
        m_sortedRoutes.insert (std::make_pair (dst, rtVector));
      return result.second;
    }

}

bool
DsrRouteCache::LookupRoute (Ipv4Address id, DsrRouteCacheEntry & rt)
{
  NS_LOG_FUNCTION (this << id);
  if (IsLinkCache ())

          NS_LOG_LOGIC ("Route to " << id << " not found; m_sortedRoutes is empty");
          return false;
        }
      std::map<Ipv4Address, std::list<DsrRouteCacheEntry> >::const_iterator i = m_sortedRoutes.find (id);
      if (i == m_sortedRoutes.end ())
        {
          NS_LOG_LOGIC ("No Direct Route to " << id << " found");
          for (std::map<Ipv4Address, std::list<DsrRouteCacheEntry> >::const_iterator j =
                 m_sortedRoutes.begin (); j != m_sortedRoutes.end (); ++j)
            {
              std::list<DsrRouteCacheEntry> rtVector = j->second; // The route cache vector linked with destination address
              /*
               * Loop through the possibly multiple routes within the route vector
               */
              for (std::list<DsrRouteCacheEntry>::const_iterator k = rtVector.begin (); k != rtVector.end (); ++k)
                {
                  // return the first route in the route vector
                  DsrRouteCacheEntry::IP_VECTOR routeVector = k->GetVector ();
                  DsrRouteCacheEntry::IP_VECTOR changeVector;

                  for (DsrRouteCacheEntry::IP_VECTOR::iterator l = routeVector.begin (); l != routeVector.end (); ++l)
                    {
                      if (*l != id)
                        {

                   */
                  if ((changeVector.size () < routeVector.size ())  && (changeVector.size () > 1))
                    {
                      DsrRouteCacheEntry changeEntry; // Create the route entry
                      changeEntry.SetVector (changeVector);
                      changeEntry.SetDestination (id);
                      // Use the expire time from original route entry
                      changeEntry.SetExpireTime (k->GetExpireTime ());
                      // We need to add new route entry here
                      std::list<DsrRouteCacheEntry> newVector;
                      newVector.push_back (changeEntry);
                      newVector.sort (CompareRoutesExpire);  // sort the route vector first
                      m_sortedRoutes[id] = newVector;   // Only get the first sub route and add it in route cache

            }
        }
      NS_LOG_INFO ("Here we check the route cache again after updated the sub routes");
      std::map<Ipv4Address, std::list<DsrRouteCacheEntry> >::const_iterator m = m_sortedRoutes.find (id);
      if (m == m_sortedRoutes.end ())
        {
          NS_LOG_LOGIC ("No updated route till last time");

      /*
       * We have a direct route to the destination address
       */
      std::list<DsrRouteCacheEntry> rtVector = m->second;
      rt = rtVector.front ();  // use the first entry in the route vector
      NS_LOG_LOGIC ("Route to " << id << " with route size " << rtVector.size ());
      return true;

}

void
DsrRouteCache::SetCacheType (std::string type)
{
  NS_LOG_FUNCTION (this << type);
  if (type == std::string ("LinkCache"))

}

bool
DsrRouteCache::IsLinkCache ()
{
  NS_LOG_FUNCTION (this);
  return m_isLinkCache;
}

void
DsrRouteCache::RebuildBestRouteTable (Ipv4Address source)
{
  NS_LOG_FUNCTION (this << source);
  /**

               */
              else if (d[k->first] == d[tempip] + k->second)
                {
                  std::map<Link, DsrLinkStab>::iterator oldlink = m_linkCache.find (Link (k->first, pre[k->first]));
                  std::map<Link, DsrLinkStab>::iterator newlink = m_linkCache.find (Link (k->first, tempip));
                  if (oldlink != m_linkCache.end () && newlink != m_linkCache.end ())
                    {
                      if (oldlink->second.GetLinkStability () < newlink->second.GetLinkStability ())

  for (std::map<Ipv4Address, Ipv4Address>::iterator i = pre.begin (); i != pre.end (); ++i)
    {
      // loop for all vertexes
      DsrRouteCacheEntry::IP_VECTOR route;
      Ipv4Address iptemp = i->first;

      if (!i->second.IsBroadcast () && iptemp != source)

            }
          route.push_back (source);
          // Reverse the route
          DsrRouteCacheEntry::IP_VECTOR reverseroute;
          for (DsrRouteCacheEntry::IP_VECTOR::reverse_iterator j = route.rbegin (); j != route.rend (); ++j)
            {
              reverseroute.push_back (*j);
            }

}

bool
DsrRouteCache::LookupRoute_Link (Ipv4Address id, DsrRouteCacheEntry & rt)
{
  NS_LOG_FUNCTION (this << id);
  /// We need to purge the link node cache
  PurgeLinkNode ();
  std::map<Ipv4Address, DsrRouteCacheEntry::IP_VECTOR>::const_iterator i = m_bestRoutesTable_link.find (id);
  if (i == m_bestRoutesTable_link.end ())
    {
      NS_LOG_INFO ("No route find to " << id);

          return false;
        }

      DsrRouteCacheEntry newEntry; // Create the route entry
      newEntry.SetVector (i->second);
      newEntry.SetDestination (id);
      newEntry.SetExpireTime (RouteCacheTimeout);

}

void
DsrRouteCache::PurgeLinkNode ()
{
  NS_LOG_FUNCTION (this);
  for (std::map<Link, DsrLinkStab>::iterator i = m_linkCache.begin (); i != m_linkCache.end (); )
    {
      NS_LOG_DEBUG ("The link stability " << i->second.GetLinkStability ().GetSeconds ());
      std::map<Link, DsrLinkStab>::iterator itmp = i;
      if (i->second.GetLinkStability () <= Seconds (0))
        {
          ++i;

        }
    }
  /// may need to remove them after verify
  for (std::map<Ipv4Address, DsrNodeStab>::iterator i = m_nodeCache.begin (); i != m_nodeCache.end (); )
    {
      NS_LOG_DEBUG ("The node stability " << i->second.GetNodeStability ().GetSeconds ());
      std::map<Ipv4Address, DsrNodeStab>::iterator itmp = i;
      if (i->second.GetNodeStability () <= Seconds (0))
        {
          ++i;

}

void
DsrRouteCache::UpdateNetGraph ()
{
  NS_LOG_FUNCTION (this);
  m_netGraph.clear ();
  for (std::map<Link, DsrLinkStab>::iterator i = m_linkCache.begin (); i != m_linkCache.end (); ++i)
    {
      // Here the weight is set as 1
      /// \todo May need to set different weight for different link here later

}

bool
DsrRouteCache::IncStability (Ipv4Address node)
{
  NS_LOG_FUNCTION (this << node);
  std::map<Ipv4Address, DsrNodeStab>::const_iterator i = m_nodeCache.find (node);
  if (i == m_nodeCache.end ())
    {
      NS_LOG_INFO ("The initial stability " << m_initStability.GetSeconds ());
      DsrNodeStab ns (m_initStability);
      m_nodeCache[node] = ns;
      return false;
    }

      /// \todo get rid of the debug here
      NS_LOG_INFO ("The node stability " << i->second.GetNodeStability ().GetSeconds ());
      NS_LOG_INFO ("The stability here " << Time (i->second.GetNodeStability () * m_stabilityIncrFactor).GetSeconds ());
      DsrNodeStab ns (Time (i->second.GetNodeStability () * m_stabilityIncrFactor));
      m_nodeCache[node] = ns;
      return true;
    }

}

bool
DsrRouteCache::DecStability (Ipv4Address node)
{
  NS_LOG_FUNCTION (this << node);
  std::map<Ipv4Address, DsrNodeStab>::const_iterator i = m_nodeCache.find (node);
  if (i == m_nodeCache.end ())
    {
      DsrNodeStab ns (m_initStability);
      m_nodeCache[node] = ns;
      return false;
    }

      /// \todo remove it here
      NS_LOG_INFO ("The stability here " << i->second.GetNodeStability ().GetSeconds ());
      NS_LOG_INFO ("The stability here " << Time (i->second.GetNodeStability () / m_stabilityDecrFactor).GetSeconds ());
      DsrNodeStab ns (Time (i->second.GetNodeStability () / m_stabilityDecrFactor));
      m_nodeCache[node] = ns;
      return true;
    }

}

bool
DsrRouteCache::AddRoute_Link (DsrRouteCacheEntry::IP_VECTOR nodelist, Ipv4Address source)
{
  NS_LOG_FUNCTION (this << source);
  NS_LOG_LOGIC ("Use Link Cache");

  PurgeLinkNode ();
  for (uint32_t i = 0; i < nodelist.size () - 1; i++)
    {
      DsrNodeStab ns;                /// This is the node stability
      ns.SetNodeStability (m_initStability);

      if (m_nodeCache.find (nodelist[i]) == m_nodeCache.end ())

          m_nodeCache[nodelist[i + 1]] = ns;
        }
      Link link (nodelist[i], nodelist[i + 1]);         /// Link represent the one link for the route
      DsrLinkStab stab;                /// Link stability
      stab.SetLinkStability (m_initStability);
      /// Set the link stability as the smallest node stability
      if (m_nodeCache[nodelist[i]].GetNodeStability () < m_nodeCache[nodelist[i + 1]].GetNodeStability ())

}

void
DsrRouteCache::UseExtends (DsrRouteCacheEntry::IP_VECTOR rt)
{
  NS_LOG_FUNCTION (this);
  /// Purge the link node cache first

      NS_LOG_INFO ("The route is too short");
      return;
    }
  for (DsrRouteCacheEntry::IP_VECTOR::iterator i = rt.begin (); i != rt.end () - 1; ++i)
    {
      Link link (*i, *(i + 1));
      if (m_linkCache.find (link) != m_linkCache.end ())

        }
    }
  /// Increase the stability of the node cache
  for (DsrRouteCacheEntry::IP_VECTOR::iterator i = rt.begin (); i != rt.end (); ++i)
    {
      if (m_nodeCache.find (*i) != m_nodeCache.end ())
        {

}

bool
DsrRouteCache::AddRoute (DsrRouteCacheEntry & rt)
{
  NS_LOG_FUNCTION (this);
  Purge ();
  std::list<DsrRouteCacheEntry> rtVector;   // Declare the route cache entry vector
  Ipv4Address dst = rt.GetDestination ();
  std::vector<Ipv4Address> route = rt.GetVector ();

  NS_LOG_DEBUG ("The route destination we have " << dst);
  std::map<Ipv4Address, std::list<DsrRouteCacheEntry> >::const_iterator i =
    m_sortedRoutes.find (dst);

  if (i == m_sortedRoutes.end ())

      /**
       * Save the new route cache along with the destination address in map
       */
      std::pair<std::map<Ipv4Address, std::list<DsrRouteCacheEntry> >::iterator, bool> result =
        m_sortedRoutes.insert (std::make_pair (dst, rtVector));
      return result.second;
    }

              /**
               * Save the new route cache along with the destination address in map
               */
              std::pair<std::map<Ipv4Address, std::list<DsrRouteCacheEntry> >::iterator, bool> result =
                m_sortedRoutes.insert (std::make_pair (dst, rtVector));
              return result.second;
            }

  return false;
}

bool DsrRouteCache::FindSameRoute (DsrRouteCacheEntry & rt, std::list<DsrRouteCacheEntry> & rtVector)
{
  NS_LOG_FUNCTION (this);
  for (std::list<DsrRouteCacheEntry>::iterator i = rtVector.begin (); i != rtVector.end (); ++i)
    {
      // return the first route in the route vector
      DsrRouteCacheEntry::IP_VECTOR routeVector = i->GetVector ();
      DsrRouteCacheEntry::IP_VECTOR newVector = rt.GetVector ();

      if (routeVector == newVector)
        {

          /*
           * Save the new route cache along with the destination address in map
           */
          std::pair<std::map<Ipv4Address, std::list<DsrRouteCacheEntry> >::iterator, bool> result =
            m_sortedRoutes.insert (std::make_pair (rt.GetDestination (), rtVector));
          return result.second;
        }

}

bool
DsrRouteCache::DeleteRoute (Ipv4Address dst)
{
  NS_LOG_FUNCTION (this << dst);
  Purge (); // purge the route cache first to remove timeout entries

}

void
DsrRouteCache::DeleteAllRoutesIncludeLink (Ipv4Address errorSrc, Ipv4Address unreachNode, Ipv4Address node)
{
  NS_LOG_FUNCTION (this << errorSrc << unreachNode << node);
  if (IsLinkCache ())

      m_linkCache.erase (link2);
      NS_LOG_DEBUG ("The link cache size " << m_linkCache.size());

      std::map<Ipv4Address, DsrNodeStab>::iterator i = m_nodeCache.find (errorSrc);
      if (i == m_nodeCache.end ())
        {
          NS_LOG_LOGIC ("Update the node stability unsuccessfully");

      /*
       * Loop all the routes saved in the route cache
       */
      for (std::map<Ipv4Address, std::list<DsrRouteCacheEntry> >::iterator j =
             m_sortedRoutes.begin (); j != m_sortedRoutes.end (); )
        {
          std::map<Ipv4Address, std::list<DsrRouteCacheEntry> >::iterator jtmp = j;
          Ipv4Address address = j->first;
          std::list<DsrRouteCacheEntry> rtVector = j->second;
          /*
           * Loop all the routes for a single destination
           */
          for (std::list<DsrRouteCacheEntry>::iterator k = rtVector.begin (); k != rtVector.end (); )
            {
              // return the first route in the route vector
              DsrRouteCacheEntry::IP_VECTOR routeVector = k->GetVector ();
              DsrRouteCacheEntry::IP_VECTOR changeVector;
              /*
               * Loop the ip addresses within a single route entry
               */
              for (DsrRouteCacheEntry::IP_VECTOR::iterator i = routeVector.begin (); i != routeVector.end (); ++i)
                {
                  if (*i != errorSrc)
                    {

                       * Remove the route first
                       */
                      k = rtVector.erase (k);
                      DsrRouteCacheEntry changeEntry;
                      changeEntry.SetVector (changeVector);
                      Ipv4Address destination = changeVector.back ();
                      NS_LOG_DEBUG ("The destination of the newly formed route " << destination << " and the size of the route " << changeVector.size ());

}

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

}

void
DsrRouteCache::PrintRouteVector (std::list<DsrRouteCacheEntry> route)
{
  NS_LOG_FUNCTION (this);
  for (std::list<DsrRouteCacheEntry>::iterator i = route.begin (); i != route.end (); i++)
    {
      std::vector<Ipv4Address> path = i->GetVector ();
      NS_LOG_INFO ("Route NO. ");

}

void
DsrRouteCache::Purge ()
{
  NS_LOG_FUNCTION (this);
  //Trying to purge the route cache

      NS_LOG_DEBUG ("The route cache is empty");
      return;
    }
  for (std::map<Ipv4Address, std::list<DsrRouteCacheEntry> >::iterator i =
         m_sortedRoutes.begin (); i != m_sortedRoutes.end (); )
    {
      // Loop of route cache entry with the route size
      std::map<Ipv4Address, std::list<DsrRouteCacheEntry> >::iterator itmp = i;
      /*
       * The route cache entry vector
       */
      Ipv4Address dst = i->first;
      std::list<DsrRouteCacheEntry> rtVector = i->second;
      NS_LOG_DEBUG ("The route vector size of 1 " << dst << " " << rtVector.size ());
      if (rtVector.size ())
        {
          for (std::list<DsrRouteCacheEntry>::iterator j = rtVector.begin (); j != rtVector.end (); )
            {
              NS_LOG_DEBUG ("The expire time of every entry with expire time " << j->GetExpireTime ());
              /*

}

void
DsrRouteCache::Print (std::ostream &os)
{
  NS_LOG_FUNCTION (this);
  Purge ();
  os << "\nDSR Route Cache\n"
     << "Destination\tGateway\t\tInterface\tFlag\tExpire\tHops\n";
  for (std::list<DsrRouteCacheEntry>::const_iterator i =
         m_routeEntryVector.begin (); i != m_routeEntryVector.end (); ++i)
    {
      i->Print (os);

 * This part of code maintains an Acknowledgment id cache for next hop and remove duplicate ids
 */
uint16_t
DsrRouteCache::CheckUniqueAckId (Ipv4Address nextHop)
{
  NS_LOG_FUNCTION (this);
  std::map<Ipv4Address, uint16_t>::const_iterator i =

}

uint16_t
DsrRouteCache::GetAckSize ()
{
  return m_ackIdCache.size ();
}

 * This part maintains a neighbor list to handle unidirectional links and link-layer acks
 */
bool
DsrRouteCache::IsNeighbor (Ipv4Address addr)
{
  NS_LOG_FUNCTION (this);
  PurgeMac ();  // purge the mac cache

}

Time
DsrRouteCache::GetExpireTime (Ipv4Address addr)
{
  NS_LOG_FUNCTION (this);
  PurgeMac ();

}

void
DsrRouteCache::UpdateNeighbor (std::vector<Ipv4Address> nodeList, Time expire)
{
  NS_LOG_FUNCTION (this);
  for (std::vector<Neighbor>::iterator i = m_nb.begin (); i != m_nb.end (); ++i)

}

void
DsrRouteCache::AddNeighbor (std::vector<Ipv4Address> nodeList, Ipv4Address ownAddress, Time expire)
{
  NS_LOG_LOGIC ("Add neighbor number " << nodeList.size ());
  for (std::vector<Ipv4Address>::iterator j = nodeList.begin (); j != nodeList.end ();)


struct CloseNeighbor
{
  bool operator() (const DsrRouteCache::Neighbor & nb) const
  {
    return ((nb.m_expireTime < Simulator::Now ()) || nb.close);
  }
};

void
DsrRouteCache::PurgeMac ()
{
  if (m_nb.empty ())
    {

}

void
DsrRouteCache::ScheduleTimer ()
{
  m_ntimer.Cancel ();
  m_ntimer.Schedule ();
}

void
DsrRouteCache::AddArpCache (Ptr<ArpCache> a)
{
  m_arp.push_back (a);
}

void
DsrRouteCache::DelArpCache (Ptr<ArpCache> a)
{
  m_arp.erase (std::remove (m_arp.begin (), m_arp.end (), a), m_arp.end ());
}

Mac48Address
DsrRouteCache::LookupMacAddress (Ipv4Address addr)
{
  Mac48Address hwaddr;
  for (std::vector<Ptr<ArpCache> >::const_iterator i = m_arp.begin ();

}

void
DsrRouteCache::ProcessTxError (WifiMacHeader const & hdr)
{
  Mac48Address addr = hdr.GetAddr1 ();





  void Print () const;
};

class DsrLinkStab
{
public:
  /**
   * \brief Constructor
   */
  DsrLinkStab (Time linkStab = Simulator::Now ());
  /**
   * \brief Destructor
   */
  virtual ~DsrLinkStab ();

  /**
   * \brief set/get the link stability

  Time m_linkStability;
};

class DsrNodeStab
{
public:

  DsrNodeStab (Time nodeStab = Simulator::Now ());
  virtual ~DsrNodeStab ();

  void SetNodeStability (Time nodeStab)
  {

  Time m_nodeStability;
};

class DsrRouteCacheEntry
{
public:
  typedef std::vector<Ipv4Address> IP_VECTOR;                ///< Define the vector to hold Ip address
  typedef std::vector<Ipv4Address>::iterator Iterator;       ///< Define the iterator

  DsrRouteCacheEntry (IP_VECTOR const  & ip = IP_VECTOR (), Ipv4Address dst = Ipv4Address (), Time exp = Simulator::Now ());
  virtual ~DsrRouteCacheEntry ();

  /// Mark entry as "down" (i.e. disable it)
  void Invalidate (Time badLinkLifetime);

   * \brief Compare the route cache entry
   * \return true if equal
   */
  bool operator== (DsrRouteCacheEntry const & o) const
  {
    if (m_path.size () != o.m_path.size ())
      {

 * \brief DSR route request queue
 * Since DSR is an on demand routing we queue requests while looking for route.
 */
class DsrRouteCache : public Object
{
public:

  static TypeId GetTypeId ();

  DsrRouteCache ();
  virtual ~DsrRouteCache ();

  /**
   * \brief Remove the aged route cache entries when the route cache is full
   */
  void RemoveLastEntry (std::list<DsrRouteCacheEntry> & rtVector);
  /**
   * \brief Define the vector of route entries.
   */
  typedef std::list<DsrRouteCacheEntry::IP_VECTOR> routeVector;

  // Fields
  bool GetSubRoute () const

   * \param rt route cache entry
   * \return true in success
   */
  bool AddRoute (DsrRouteCacheEntry & rt);
  /**
   * \brief Lookup route cache entry with destination address dst
   * \param id destination address
   * \param rt entry with destination address id, if exists
   * \return true on success
   */
  bool LookupRoute (Ipv4Address id, DsrRouteCacheEntry & rt);
  /**
   * \brief Print the route vector elements
   * \param vec the route vector

   * \brief Print all the route vector elements from the route list
   * \param route the route list
   */
  void PrintRouteVector (std::list<DsrRouteCacheEntry> route);
  /**
   * \brief Find the same route in the route cache
   * \param rt entry with destination address dst, if exists
   * \param rtVector the route vector
   */
  bool FindSameRoute (DsrRouteCacheEntry & rt, std::list<DsrRouteCacheEntry> & rtVector);
  /**
   * \brief Delete the route with certain destination address
   * \param dst the destination address of the routes that should be deleted

  }

private:
  DsrRouteCache & operator= (DsrRouteCache const &);
  DsrRouteCacheEntry::IP_VECTOR m_vector;               ///< The route vector to save the ip addresses for intermediate nodes.
  uint32_t m_maxCacheLen;                               ///< The maximum number of packets that we allow a routing protocol to buffer.
  Time     RouteCacheTimeout;                           ///< The maximum period of time that dsr is allowed to for an unused route.
  Time     m_badLinkLifetime;                           ///< The time for which the neighboring node is put into the blacklist.

  /**
   * Define the route cache data structure
   */
  typedef std::list<DsrRouteCacheEntry> routeEntryVector;

  std::map<Ipv4Address, routeEntryVector> m_sortedRoutes;       ///< Map the ipv4Address to route entry vector


   */
  std::map<Ipv4Address, std::map<Ipv4Address, uint32_t> > m_netGraph;

  std::map<Ipv4Address, DsrRouteCacheEntry::IP_VECTOR> m_bestRoutesTable_link;     ///< for link route cache
  std::map<Link, DsrLinkStab> m_linkCache;                                         ///< The data structure to store link info
  std::map<Ipv4Address, DsrNodeStab> m_nodeCache;                                  ///< The data structure to store node info
  /**
   * \brief used by LookupRoute when LinkCache
   * \param id the ip address we are looking for
   * \param rt the route cache entry to store the found one
   */
  bool LookupRoute_Link (Ipv4Address id, DsrRouteCacheEntry & rt);
  /**
   * \brief increase the stability of the node
   * \param node the ip address of the node we want to increase stability

   */
  void SetCacheType (std::string type);
  bool IsLinkCache ();
  bool AddRoute_Link (DsrRouteCacheEntry::IP_VECTOR nodelist, Ipv4Address node);
  /**
   *  \brief USE MAXWEIGHT TO REPRESENT MAX; USE BROADCAST ADDRESS TO REPRESENT NULL PRECEEDING ADDRESS
   *  \param source The source address the routes based on

   * amount of time since that link was last used. When a link is used in a route chosen for a packet originated or
   * salvaged by this node, the link's lifetime is set to be at least UseExtends into the future
   */
  void UseExtends (DsrRouteCacheEntry::IP_VECTOR rt);
  /**
   *  \brief Update the Net Graph for the link and node cache has changed
   */




                   PointerValue (0),
                   MakePointerAccessor (&DsrRouting::SetRouteCache,
                                        &DsrRouting::GetRouteCache),
                   MakePointerChecker<DsrRouteCache> ())
    .AddAttribute ("RreqTable",
                   "The request table to manage route requests.",
                   PointerValue (0),
                   MakePointerAccessor (&DsrRouting::SetRequestTable,
                                        &DsrRouting::GetRequestTable),
                   MakePointerChecker<DsrRreqTable> ())
    .AddAttribute ("PassiveBuffer",
                   "The passive buffer to manage "
                   "promisucously received passive ack.",
                   PointerValue (0),
                   MakePointerAccessor (&DsrRouting::SetPassiveBuffer,
                                        &DsrRouting::GetPassiveBuffer),
                   MakePointerChecker<DsrPassiveBuffer> ())
    .AddAttribute ("MaxSendBuffLen",
                   "Maximum number of packets that can be stored "
                   "in send buffer.",

      std::pair<std::map<uint32_t, Ptr<dsr::DsrNetworkQueue> >::iterator, bool> result_i = m_priorityQueue.insert (std::make_pair (i, queue_i));
      NS_ASSERT_MSG (result_i.second, "Error in creating queues");
    }
  Ptr<dsr::DsrRreqTable> rreqTable = CreateObject<dsr::DsrRreqTable> ();
  // Set the initial hop limit
  rreqTable->SetInitHopLimit (m_discoveryHopLimit);
  // Configure the request table parameters

  rreqTable->SetUniqueRreqIdSize (m_maxRreqId);
  SetRequestTable (rreqTable);
  // Set the passive buffer parameters using just the send buffer parameters
  Ptr<dsr::DsrPassiveBuffer> passiveBuffer = CreateObject<dsr::DsrPassiveBuffer> ();
  passiveBuffer->SetMaxQueueLen (m_maxSendBuffLen);
  passiveBuffer->SetPassiveBufferTimeout (m_sendBufferTimeout);
  SetPassiveBuffer (passiveBuffer);

              /*
               * Set dsr route cache
               */
              Ptr<dsr::DsrRouteCache> routeCache = CreateObject<dsr::DsrRouteCache> ();
              // Configure the path cache parameters
              routeCache->SetCacheType (m_cacheType);
              routeCache->SetSubRoute (m_subRoute);


      Ptr<Packet> p = Create<Packet> ();
      // Here the segments left value need to plus one to check the earlier hop maintain buffer entry
      DsrMaintainBuffEntry newEntry;
      newEntry.SetPacket (p);
      newEntry.SetSrc (sourceIp);
      newEntry.SetDst (destinationIp);

  return m_node;
}

void DsrRouting::SetRouteCache (Ptr<dsr::DsrRouteCache> r)
{
  // / Set the route cache to use
  m_routeCache = r;
}

Ptr<dsr::DsrRouteCache>
DsrRouting::GetRouteCache () const
{
  // / Get the route cache to use
  return m_routeCache;
}

void DsrRouting::SetRequestTable (Ptr<dsr::DsrRreqTable> q)
{
  // / Set the request table to use
  m_rreqTable = q;
}

Ptr<dsr::DsrRreqTable>
DsrRouting::GetRequestTable () const
{
  // / Get the request table to use
  return m_rreqTable;
}

void DsrRouting::SetPassiveBuffer (Ptr<dsr::DsrPassiveBuffer> p)
{
  // / Set the request table to use
  m_passiveBuffer = p;
}

Ptr<dsr::DsrPassiveBuffer>
DsrRouting::GetPassiveBuffer () const
{
  // / Get the request table to use

  return m_routeCache->IsLinkCache ();
}

void DsrRouting::UseExtends (DsrRouteCacheEntry::IP_VECTOR rt)
{
  m_routeCache->UseExtends (rt);
}

bool DsrRouting::LookupRoute (Ipv4Address id, DsrRouteCacheEntry & rt)
{
  return m_routeCache->LookupRoute (id, rt);
}

bool DsrRouting::AddRoute_Link (DsrRouteCacheEntry::IP_VECTOR nodelist, Ipv4Address source)
{
  Ipv4Address nextHop = SearchNextHop (source, nodelist);
  m_errorBuffer.DropPacketForErrLink (source, nextHop);
  return m_routeCache->AddRoute_Link (nodelist, source);
}

bool DsrRouting::AddRoute (DsrRouteCacheEntry & rt)
{
  std::vector<Ipv4Address> nodelist = rt.GetVector ();
  Ipv4Address nextHop = SearchNextHop (m_mainAddress, nodelist);

  NS_LOG_INFO (Simulator::Now ().GetSeconds ()
               << " Checking send buffer at " << m_mainAddress << " with size " << m_sendBuffer.GetSize ());

  for (std::vector<DsrSendBuffEntry>::iterator i = m_sendBuffer.GetBuffer ().begin (); i != m_sendBuffer.GetBuffer ().end (); )
    {
      NS_LOG_DEBUG ("Here we try to find the data packet in the send buffer");
      Ipv4Address destination = i->GetDestination ();
      DsrRouteCacheEntry toDst;
      bool findRoute = m_routeCache->LookupRoute (destination, toDst);
      if (findRoute)
        {

              cleanP->AddHeader (dsrRoutingHeader);
              Ptr<const Packet> mtP = cleanP->Copy ();
              // Put the data packet in the maintenance queue for data packet retransmission
              DsrMaintainBuffEntry newEntry (/*Packet=*/ mtP, /*Ipv4Address=*/ m_mainAddress, /*nextHop=*/ nextHop,
                                                      /*source=*/ m_mainAddress, /*destination=*/ destination, /*ackId=*/ 0,
                                                      /*SegsLeft=*/ nodeList.size () - 2, /*expire time=*/ m_maxMaintainTime);
              bool result = m_maintainBuffer.Enqueue (newEntry); // Enqueue the packet the the maintenance buffer

{
  NS_LOG_FUNCTION (this << packet << source << destination << (uint32_t)protocol);
  // Look up routes for the specific destination
  DsrRouteCacheEntry toDst;
  bool findRoute = m_routeCache->LookupRoute (destination, toDst);
  // Queue the packet if there is no route pre-existing
  if (!findRoute)

                   << "s " << m_mainAddress << " there is no route for this packet, queue the packet");

      Ptr<Packet> p = packet->Copy ();
      DsrSendBuffEntry newEntry (p, destination, m_sendBufferTimeout, protocol);     // Create a new entry for send buffer
      bool result = m_sendBuffer.Enqueue (newEntry);     // Enqueue the packet in send buffer
      if (result)
        {

      Ptr<const Packet> mtP = cleanP->Copy ();
      SetRoute (nextHop, m_mainAddress);
      // Put the data packet in the maintenance queue for data packet retransmission
      DsrMaintainBuffEntry newEntry (/*Packet=*/ mtP, /*Ipv4Address=*/ m_mainAddress, /*nextHop=*/ nextHop,
                                              /*source=*/ source, /*destination=*/ destination, /*ackId=*/ 0,
                                              /*SegsLeft=*/ nodeList.size () - 2, /*expire time=*/ m_maxMaintainTime);
      bool result = m_maintainBuffer.Enqueue (newEntry);     // Enqueue the packet the the maintenance buffer

  uint8_t rerrLength = rerrUnreachHeader.GetLength ();


  DsrRouteCacheEntry toDst;
  bool findRoute = m_routeCache->LookupRoute (destination, toDst);
  // Queue the packet if there is no route pre-existing
  Ptr<Packet> newPacket = Create<Packet> ();

        newPacket->AddHeader (dsrRoutingHeader);
        Ptr<Packet> p = newPacket->Copy ();
        // Save the error packet in the error buffer
        DsrErrorBuffEntry newEntry (p, destination, m_mainAddress, unreachNode, m_sendBufferTimeout, protocol);
        bool result = m_errorBuffer.Enqueue (newEntry);                    // Enqueue the packet in send buffer
        if (result)
          {

  else
    {
      // Look up routes for the specific destination
      DsrRouteCacheEntry toDst;
      bool findRoute = m_routeCache->LookupRoute (destination, toDst);
      // Queue the packet if there is no route pre-existing
      if (!findRoute)

                       << "s " << m_mainAddress << " there is no route for this packet, queue the packet");

          Ptr<Packet> p = packet->Copy ();
          DsrSendBuffEntry newEntry (p, destination, m_sendBufferTimeout, protocol);     // Create a new entry for send buffer
          bool result = m_sendBuffer.Enqueue (newEntry);     // Enqueue the packet in send buffer
          if (result)
            {

          Ptr<const Packet> mtP = cleanP->Copy ();
          NS_LOG_DEBUG ("maintain packet size " << cleanP->GetSize ());
          // Put the data packet in the maintenance queue for data packet retransmission
          DsrMaintainBuffEntry newEntry (/*Packet=*/ mtP, /*ourAddress=*/ m_mainAddress, /*nextHop=*/ nextHop,
                                                  /*source=*/ source, /*destination=*/ destination, /*ackId=*/ 0,
                                                  /*SegsLeft=*/ nodeList.size () - 2, /*expire time=*/ m_maxMaintainTime);
          bool result = m_maintainBuffer.Enqueue (newEntry);       // Enqueue the packet the the maintenance buffer

        {
          m_routeCache->UseExtends (nodeList);
        }
      DsrSendBuffEntry entry;
      if (m_sendBuffer.Dequeue (destination, entry))
        {
          Ptr<Packet> packet = entry.GetPacket ()->Copy ();


          Ptr<const Packet> mtP = p->Copy ();
          // Put the data packet in the maintenance queue for data packet retransmission
          DsrMaintainBuffEntry newEntry (/*Packet=*/ mtP, /*ourAddress=*/ m_mainAddress, /*nextHop=*/ nextHop,
                                      /*source=*/ source, /*destination=*/ destination, /*ackId=*/ 0,
                                      /*SegsLeft=*/ nodeList.size () - 2, /*expire time=*/ m_maxMaintainTime);
          bool result = m_maintainBuffer.Enqueue (newEntry);       // Enqueue the packet the the maintenance buffer

   */
  else if (m_errorBuffer.Find (destination))
    {
      DsrErrorBuffEntry entry;
      if (m_errorBuffer.Dequeue (destination, entry))
        {
          Ptr<Packet> packet = entry.GetPacket ()->Copy ();


  Ptr<Packet> p = packet->Copy ();
  // Here the segments left value need to plus one to check the earlier hop maintain buffer entry
  DsrPassiveBuffEntry newEntry;
  newEntry.SetPacket (p);
  newEntry.SetSource (source);
  newEntry.SetDestination (destination);

      // It only compares the source and destination address, ackId, and the segments left value
      NS_LOG_DEBUG ("We get the all equal for passive buffer here");

      DsrMaintainBuffEntry mbEntry;
      mbEntry.SetPacket (p);
      mbEntry.SetSrc (source);
      mbEntry.SetDst (destination);


  Ptr<Packet> p = packet->Copy ();
  // Here the segments left value need to plus one to check the earlier hop maintain buffer entry
  DsrMaintainBuffEntry newEntry;
  newEntry.SetPacket (p);
  newEntry.SetSrc (source);
  newEntry.SetDst (destination);

   * The reason is ack header doesn't have the original packet copy
   */
  Ptr<Packet> mainP = Create<Packet> ();
  DsrMaintainBuffEntry newEntry (/*Packet=*/ mainP, /*ourAddress=*/ sender, /*nextHop=*/ receiver,
                                          /*source=*/ realSrc, /*destination=*/ realDst, /*ackId=*/ ackId,
                                          /*SegsLeft=*/ 0, /*expire time=*/ Simulator::Now ());
  CancelNetworkPacketTimer (newEntry);  // Only need to cancel network packet timer
}

void 
DsrRouting::CancelPacketAllTimer (DsrMaintainBuffEntry & mb)
{
  NS_LOG_FUNCTION (this);
  CancelLinkPacketTimer (mb);

}

void
DsrRouting::CancelLinkPacketTimer (DsrMaintainBuffEntry & mb)
{
  NS_LOG_FUNCTION (this);
  LinkKey linkKey;

}

void
DsrRouting::CancelNetworkPacketTimer (DsrMaintainBuffEntry & mb)
{
  NS_LOG_FUNCTION (this);
  NetworkKey networkKey;

}

void
DsrRouting::CancelPassivePacketTimer (DsrMaintainBuffEntry & mb)
{
  NS_LOG_FUNCTION (this);
  PassiveKey passiveKey;

{
  NS_LOG_FUNCTION (this << nextHop << (uint32_t)protocol);

  DsrMaintainBuffEntry entry;
  std::vector<Ipv4Address> previousErrorDst;
  if (m_maintainBuffer.Dequeue (nextHop, entry))
    {

  /*
   * Look in the route cache for other routes for this destination
   */
  DsrRouteCacheEntry toDst;
  bool findRoute = m_routeCache->LookupRoute (dst, toDst);
  if (findRoute && (salvage < m_maxSalvageCount))
    {

}

void
DsrRouting::ScheduleLinkPacketRetry (DsrMaintainBuffEntry & mb,
                                     uint8_t protocol)
{
  NS_LOG_FUNCTION (this << (uint32_t) protocol);

}

void
DsrRouting::SchedulePassivePacketRetry (DsrMaintainBuffEntry & mb,
                                        uint8_t protocol)
{
  NS_LOG_FUNCTION (this << (uint32_t)protocol);

}

void
DsrRouting::ScheduleNetworkPacketRetry (DsrMaintainBuffEntry & mb,
                                        bool isFirst,
                                        uint8_t protocol)
{

      SendPacket (p, source, nextHop, protocol);

      dsrP = p->Copy ();
      DsrMaintainBuffEntry newEntry = mb;
      // The function AllEqual will find the exact entry and delete it if found
      m_maintainBuffer.AllEqual (mb);
      newEntry.SetPacket (dsrP);

}

void
DsrRouting::LinkScheduleTimerExpire  (DsrMaintainBuffEntry & mb,
                                      uint8_t protocol)
{
  NS_LOG_FUNCTION (this << (uint32_t)protocol);

}

void
DsrRouting::PassiveScheduleTimerExpire  (DsrMaintainBuffEntry & mb,
                                         uint8_t protocol)
{
  NS_LOG_FUNCTION (this << (uint32_t)protocol);

}

void
DsrRouting::NetworkScheduleTimerExpire  (DsrMaintainBuffEntry & mb,
                                         uint8_t protocol)
{
  Ptr<Packet> p = mb.GetPacket ()->Copy ();


  Ptr<const Packet> mtP = p->Copy ();

  DsrMaintainBuffEntry newEntry (/*Packet=*/ mtP, /*ourAddress=*/ m_mainAddress, /*nextHop=*/ nextHop,
                              /*source=*/ source, /*destination=*/ targetAddress, /*ackId=*/ m_ackId,
                              /*SegsLeft=*/ sourceRoute.GetSegmentsLeft (), /*expire time=*/ m_maxMaintainTime);
  bool result = m_maintainBuffer.Enqueue (newEntry);

  NS_LOG_DEBUG ("our own address here " << m_mainAddress << " error source " << rerr.GetErrorSrc () << " error destination " << rerr.GetErrorDst ()
                                        << " error next hop " << rerr.GetUnreachNode () << " original dst " << rerr.GetOriginalDst ()
                );
  DsrRouteCacheEntry toDst;
  if (m_routeCache->LookupRoute (dst, toDst))
    {
      /*


  Ipv4Address source = address[0];
  Ipv4Address dst = address[1];
  DsrRouteCacheEntry toDst;
  if (m_routeCache->LookupRoute (dst, toDst))
    {
      /*




   * \brief Set the route cache.
   * \param r the route cache to set
   */
  void SetRouteCache (Ptr<dsr::DsrRouteCache> r);
  /**
   * \brief Get the route cache.
   * \return the route cache
   */
  Ptr<dsr::DsrRouteCache> GetRouteCache () const;
  /**
   * \brief Set the node.
   * \param r the request table to set
   */
  void SetRequestTable (Ptr<dsr::DsrRreqTable> r);
  /**
    * \brief Get the request table.
    * \return the request table
    */
  Ptr<dsr::DsrRreqTable> GetRequestTable () const;
  /**
   * \brief Set the node.
   * \param r the passive buffer to set
   */
  void SetPassiveBuffer (Ptr<dsr::DsrPassiveBuffer> r);
  /**
    * \brief Get the passive buffer
    * \return the passive buffer
    */
  Ptr<dsr::DsrPassiveBuffer> GetPassiveBuffer () const;

  /// functions used to direct to route cache
  //\{
  bool IsLinkCache ();
  void UseExtends (DsrRouteCacheEntry::IP_VECTOR rt);
  bool LookupRoute (Ipv4Address id, DsrRouteCacheEntry & rt);
  bool AddRoute_Link (DsrRouteCacheEntry::IP_VECTOR nodelist, Ipv4Address source);
  bool AddRoute (DsrRouteCacheEntry & rt);
  void DeleteAllRoutesIncludeLink (Ipv4Address errorSrc, Ipv4Address unreachNode, Ipv4Address node);
  bool UpdateRouteEntry (Ipv4Address dst);
  bool FindSourceEntry (Ipv4Address src, Ipv4Address dst, uint16_t id);

  /**
  * \brief Cancel all the packet timers
  */
  void CancelPacketAllTimer (DsrMaintainBuffEntry & mb);
  /**
   * \brief Cancel the passive timer
   */

  /**
   * \brief Cancel the network packet retransmission timer for a specific maintenance entry
   */
  void CancelNetworkPacketTimer (DsrMaintainBuffEntry & mb);
  /**
   * \brief Cancel the passive packet retransmission timer for a specific maintenance entry
   */
  void CancelPassivePacketTimer (DsrMaintainBuffEntry & mb);
  /**
   * \brief Cancel the link packet retransmission timer for a specific maintenance entry
   */
  void CancelLinkPacketTimer (DsrMaintainBuffEntry & mb);
  /**
   * \brief Cancel the packet retransmission timer for a all maintenance entries with nextHop address
   */

   * \param mb maintainenace buffer entry
   * \param protocol the protocol number
   */
  void ScheduleLinkPacketRetry   (DsrMaintainBuffEntry & mb,
                                  uint8_t protocol);
  /**
   * \brief Schedule the packet retransmission based on passive acknowledgment
   * \param mb maintainenace buffer entry
   * \param protocol the protocol number
   */
  void SchedulePassivePacketRetry   (DsrMaintainBuffEntry & mb,
                                     uint8_t protocol);
  /**
   * \brief Schedule the packet retransmission based on network layer acknowledgment

   * \param isFirst see if this is the first packet retry or not
   * \param protocol the protocol number
   */
  void ScheduleNetworkPacketRetry   (DsrMaintainBuffEntry & mb,
                                     bool isFirst,
                                     uint8_t protocol);
  /**
   * \brief This function deals with packet retransmission timer expire using link acknowledgment
   */
  void LinkScheduleTimerExpire  (DsrMaintainBuffEntry & mb,
                                 uint8_t protocol);
  /**
   * \brief This function deals with packet retransmission timer expire using network acknowledgment
   */
  void NetworkScheduleTimerExpire  (DsrMaintainBuffEntry & mb,
                                    uint8_t protocol);
  /**
   * \brief This function deals with packet retransmission timer expire using passive acknowledgment
   */
  void PassiveScheduleTimerExpire  (DsrMaintainBuffEntry & mb,
                                    uint8_t protocol);
  /**
   * \brief Forward the packet using the route saved in the source route option header


  Time  m_sendBufferTimeout;                            ///< The maximum period of time that a routing protocol is allowed to buffer a packet for.

  DsrSendBuffer m_sendBuffer;                           ///< The send buffer

  DsrErrorBuffer m_errorBuffer;                         ///< The error buffer to save the error messages

  uint32_t  m_maxMaintainLen;                           ///< Max # of entries for maintainance buffer



  uint32_t  m_maxEntriesEachDst;                        ///< Max number of route entries to save for each destination

  DsrMaintainBuffer m_maintainBuffer;                   ///< The declaration of maintain buffer

  uint32_t m_requestId;                                 ///< The id assigned to each route request



  std::map<LinkKey, Timer> m_linkAckTimer;              ///< The timer for link acknowledgment

  Ptr<dsr::DsrRouteCache> m_routeCache;                 ///< A "drop-front" queue used by the routing layer to cache routes found.

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

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

  uint32_t m_numPriorityQueues;                         ///< The number of priority queues used



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

  DsrGraReply m_graReply;                               ///< The gratuitous route reply.

  DsrNetworkQueue m_networkQueue;                       ///< The network queue.






namespace ns3 {

NS_LOG_COMPONENT_DEFINE ("DsrRreqTable");
  
namespace dsr {

NS_OBJECT_ENSURE_REGISTERED (DsrRreqTable);

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

DsrRreqTable::DsrRreqTable ()
  : m_linkStates (PROBABLE)
{
}

DsrRreqTable::~DsrRreqTable ()
{
  NS_LOG_FUNCTION_NOARGS ();
}

void
DsrRreqTable::RemoveLeastExpire (std::map<Ipv4Address, RreqTableEntry > & rreqDstMap)
{
  NS_LOG_FUNCTION (this);
  Ipv4Address firstExpire;

}

void
DsrRreqTable::FindAndUpdate (Ipv4Address dst)
{
  NS_LOG_FUNCTION (this << dst);
  std::map<Ipv4Address, RreqTableEntry >::const_iterator i =

}

void
DsrRreqTable::RemoveRreqEntry (Ipv4Address dst)
{
  NS_LOG_FUNCTION (this << dst);
  std::map<Ipv4Address, RreqTableEntry >::const_iterator i =

}

uint32_t
DsrRreqTable::GetRreqCnt (Ipv4Address dst)
{
  NS_LOG_FUNCTION (this << dst);
  std::map<Ipv4Address, RreqTableEntry >::const_iterator i =

 * Essentially a counter
 */
uint32_t
DsrRreqTable::CheckUniqueRreqId (Ipv4Address dst)
{
  NS_LOG_LOGIC ("The size of id cache " << m_rreqIdCache.size ());
  std::map<Ipv4Address, uint32_t>::const_iterator i =

}

uint32_t
DsrRreqTable::GetRreqSize ()
{
  return m_rreqIdCache.size ();
}

 */

void
DsrRreqTable::Invalidate ()
{
  if (m_linkStates == QUESTIONABLE)
    {

}

BlackList*
DsrRreqTable::FindUnidirectional (Ipv4Address neighbor)
{
  PurgeNeighbor ();  // purge the neighbor cache
  for (std::vector<BlackList>::iterator i = m_blackList.begin ();

}

bool
DsrRreqTable::MarkLinkAsUnidirectional (Ipv4Address neighbor, Time blacklistTimeout)
{
  NS_LOG_LOGIC ("Add neighbor address in blacklist " << m_blackList.size ());
  for (std::vector<BlackList>::iterator i = m_blackList.begin (); i != m_blackList.end (); i++)

}

void
DsrRreqTable::PurgeNeighbor ()
{
  /*
   * Purge the expired blacklist entries

}

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

        }
      Ipv4Address src = i->first;
      // We loop the receive rreq entry to find duplicate
      for (std::list<DsrReceivedRreqEntry>::const_iterator j = receivedRreqEntryList.begin (); j != receivedRreqEntryList.end (); ++j)
        {
          if (*j == rreqEntry)          /// Check if we have found one duplication entry or not
            {




 * 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 DsrReceivedRreqEntry
{
public:
  /**
   * Construct a DsrReceivedRreqEntry with the given parameters
   *
   * \param d IPv4 address of the destination
   * \param i identification
   */
  DsrReceivedRreqEntry (Ipv4Address d = Ipv4Address (), uint16_t i = 0)
    : m_destination (d),
      m_identification (i)
  {
  }
  /**
   * \brief Compare send buffer entries (destination address and identification)
   * \param o another DsrReceivedRreqEntry
   * \return true if equal
   */
  bool operator== (DsrReceivedRreqEntry const & o) const
  {
    return ((m_destination == o.m_destination) && (m_identification == o.m_identification)
           );


/**
 * \ingroup dsr
 * \brief maintain list of DsrRreqTable entry
 */
class DsrRreqTable  : public Object
{
public:

  static TypeId GetTypeId ();

  DsrRreqTable ();
  virtual ~DsrRreqTable ();

  /**
   * Set the initial discovert hop limit

  /// The state of the unidirectional link
  LinkStates m_linkStates;
  /// Map of entries
  std::list<DsrReceivedRreqEntry> 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<DsrReceivedRreqEntry> > m_sourceRreqMap;

  /// The Black list
  std::vector<BlackList> m_blackList;




namespace dsr {

uint32_t
DsrSendBuffer::GetSize ()
{
  Purge ();
  return m_sendBuffer.size ();
}

bool
DsrSendBuffer::Enqueue (DsrSendBuffEntry & entry)
{
  Purge ();
  for (std::vector<DsrSendBuffEntry>::const_iterator i = m_sendBuffer.begin (); i
       != m_sendBuffer.end (); ++i)
    {
//      NS_LOG_DEBUG ("packet id " << i->GetPacket ()->GetUid () << " " << entry.GetPacket ()->GetUid ()

}

void
DsrSendBuffer::DropPacketWithDst (Ipv4Address dst)
{
  NS_LOG_FUNCTION (this << dst);
  Purge ();
  /*
   * Drop the packet with destination address dst
   */
  for (std::vector<DsrSendBuffEntry>::iterator i = m_sendBuffer.begin (); i
       != m_sendBuffer.end (); ++i)
    {
      if (IsEqual (*i, dst))

        }
    }
  m_sendBuffer.erase (std::remove_if (m_sendBuffer.begin (), m_sendBuffer.end (),
                                      std::bind2nd (std::ptr_fun (DsrSendBuffer::IsEqual), dst)), m_sendBuffer.end ());
}

bool
DsrSendBuffer::Dequeue (Ipv4Address dst, DsrSendBuffEntry & entry)
{
  Purge ();
  /*
   * Dequeue the entry with destination address dst
   */
  for (std::vector<DsrSendBuffEntry>::iterator i = m_sendBuffer.begin (); i != m_sendBuffer.end (); ++i)
    {
      if (i->GetDestination () == dst)
        {

}

bool
DsrSendBuffer::Find (Ipv4Address dst)
{
  /*
   * Make sure if the send buffer contains entry with certain dst
   */
  for (std::vector<DsrSendBuffEntry>::const_iterator i = m_sendBuffer.begin (); i
       != m_sendBuffer.end (); ++i)
    {
      if (i->GetDestination () == dst)

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

};

void
DsrSendBuffer::Purge ()
{
  /*
   * Purge the buffer to eliminate expired entries
   */
  NS_LOG_INFO ("The send buffer size " << m_sendBuffer.size ());
  IsExpired pred;
  for (std::vector<DsrSendBuffEntry>::iterator i = m_sendBuffer.begin (); i
       != m_sendBuffer.end (); ++i)
    {
      if (pred (*i))

}

void
DsrSendBuffer::Drop (DsrSendBuffEntry en, std::string reason)
{
  NS_LOG_LOGIC (reason << en.GetPacket ()->GetUid () << " " << en.GetDestination ());
//  en.GetErrorCallback () (en.GetPacket (), en.GetDestination (),




 * \ingroup dsr
 * \brief DSR Send Buffer Entry
 */
class DsrSendBuffEntry
{
public:
  /**
   * Construct DsrSendBuffEntry with the given parameters.
   *
   * \param pa packet
   * \param d destination address
   * \param exp expiration time
   * \param p protocol number
   */
  DsrSendBuffEntry (Ptr<const Packet> pa = 0, Ipv4Address d = Ipv4Address (),
                 Time exp = Simulator::Now (), uint8_t p = 0)
    : m_packet (pa),
      m_dst (d),

  }
  /**
   * Compare send buffer entries
   * \param o another DsrSendBuffEntry
   * \return true if equal
   */
  bool operator== (DsrSendBuffEntry const & o) const
  {
    return ((m_packet == o.m_packet) && (m_dst == o.m_dst) && (m_expire == o.m_expire));
  }

 * \brief DSR send buffer
 */
/************************************************************************************************************************/
class DsrSendBuffer
{
public:
  /**
   * Default constructor
   */
  DsrSendBuffer ()
  {
  }
  /**
   * Push entry in queue, if there is no entry with
   * the same packet and destination address in queue.
   *
   * \param entry DsrSendBuffEntry to put in the queue
   * \return true if successfully enqueued,
   *         false otherwise
   */
  bool Enqueue (DsrSendBuffEntry & entry);
  /**
   * Return first found (the earliest) entry for
   * the given destination.

   * \return true if successfully dequeued,
   *         false otherwise
   */
  bool Dequeue (Ipv4Address dst, DsrSendBuffEntry & entry);
  /**
   * Remove all packets with destination IP address dst
   *

   *
   * \return a pointer to the internal queue
   */
  std::vector<DsrSendBuffEntry> & GetBuffer ()
  {
    return m_sendBuffer;
  }

private:

  std::vector<DsrSendBuffEntry> m_sendBuffer;                   ///< The send buffer to cache unsent packet
  void Purge ();                                                ///< Remove all expired entries
  void Drop (DsrSendBuffEntry en, std::string reason);          ///< Notify that packet is dropped from queue by timeout
  uint32_t m_maxLen;                                            ///< The maximum number of packets that we allow a routing protocol to buffer.
  Time m_sendBufferTimeout;                                     ///< The maximum period of time that a routing protocol is allowed to buffer a packet for, seconds.
  /**

   * \return true if the SendBufferEntry destination is the same,
   *         false otherwise
   */
  static bool IsEqual (DsrSendBuffEntry en, const Ipv4Address dst)
  {
    return (en.GetDestination () == dst);
  }




void
DsrCacheEntryTest::DoRun ()
{
  Ptr<dsr::DsrRouteCache> rcache = CreateObject<dsr::DsrRouteCache> ();
  std::vector<Ipv4Address> ip;
  ip.push_back (Ipv4Address ("0.0.0.0"));
  ip.push_back (Ipv4Address ("0.0.0.1"));
  Ipv4Address dst = Ipv4Address ("0.0.0.1");
  dsr::DsrRouteCacheEntry entry (ip, dst, Seconds (1));
  NS_TEST_EXPECT_MSG_EQ (entry.GetVector ().size (), 2, "trivial");
  NS_TEST_EXPECT_MSG_EQ (entry.GetDestination (), Ipv4Address ("0.0.0.1"), "trivial");
  NS_TEST_EXPECT_MSG_EQ (entry.GetExpireTime (), Seconds (1), "trivial");

  ip2.push_back (Ipv4Address ("1.1.1.0"));
  ip2.push_back (Ipv4Address ("1.1.1.1"));
  Ipv4Address dst2 = Ipv4Address ("1.1.1.1");
  dsr::DsrRouteCacheEntry entry2 (ip2, dst2, Seconds (2));
  dsr::DsrRouteCacheEntry newEntry;
  NS_TEST_EXPECT_MSG_EQ (rcache->AddRoute (entry2), true, "trivial");
  NS_TEST_EXPECT_MSG_EQ (rcache->LookupRoute (dst2, newEntry), true, "trivial");
  NS_TEST_EXPECT_MSG_EQ (rcache->DeleteRoute (Ipv4Address ("2.2.2.2")), false, "trivial");

  void CheckSizeLimit ();
  void CheckTimeout ();

  dsr::DsrSendBuffer q;
};
DsrSendBuffTest::DsrSendBuffTest ()
  : TestCase ("DSR SendBuff"),


  Ptr<const Packet> packet = Create<Packet> ();
  Ipv4Address dst1 = Ipv4Address ("0.0.0.1");
  dsr::DsrSendBuffEntry e1 (packet, dst1, Seconds (1));
  q.Enqueue (e1);
  q.Enqueue (e1);
  q.Enqueue (e1);

  NS_TEST_EXPECT_MSG_EQ (q.GetSize (), 0, "trivial");

  Ipv4Address dst2 = Ipv4Address ("0.0.0.2");
  dsr::DsrSendBuffEntry e2 (packet, dst2, Seconds (1));
  q.Enqueue (e1);
  q.Enqueue (e2);
  Ptr<Packet> packet2 = Create<Packet> ();
  dsr::DsrSendBuffEntry e3 (packet2, dst2, Seconds (1));
  NS_TEST_EXPECT_MSG_EQ (q.Dequeue (Ipv4Address ("0.0.0.3"), e3), false, "trivial");
  NS_TEST_EXPECT_MSG_EQ (q.Dequeue (Ipv4Address ("0.0.0.2"), e3), true, "trivial");
  NS_TEST_EXPECT_MSG_EQ (q.Find (Ipv4Address ("0.0.0.2")), false, "trivial");

  NS_TEST_EXPECT_MSG_EQ (q.GetSize (), 2, "trivial");
  Ptr<Packet> packet4 = Create<Packet> ();
  Ipv4Address dst4 = Ipv4Address ("0.0.0.4");
  dsr::DsrSendBuffEntry e4 (packet4, dst4, Seconds (20));
  q.Enqueue (e4);
  NS_TEST_EXPECT_MSG_EQ (q.GetSize (), 3, "trivial");
  q.DropPacketWithDst (Ipv4Address ("0.0.0.4"));

{
  Ptr<Packet> packet = Create<Packet> ();
  Ipv4Address dst;
  dsr::DsrSendBuffEntry e1 (packet, dst, Seconds (1));

  for (uint32_t i = 0; i < q.GetMaxQueueLen (); ++i)
    {

Return to bug 2246