Attachment #2422 for bug #2402

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




}

void
RoutingProtocol::DeferredRouteOutput (Ptr<const Packet> p, const Ipv4Header & header, Ptr<const NetDevice> idev,
                                      UnicastForwardCallback ucb, ErrorCallback ecb)
{
  NS_LOG_FUNCTION (this << p << header);
  NS_ASSERT (p != 0 && p != Ptr<Packet> ());

  QueueEntry newEntry (p, header, idev, ucb, ecb);
  bool result = m_queue.Enqueue (newEntry);
  if (result)
    {

      DeferredRouteOutputTag tag;
      if (p->PeekPacketTag (tag))
        {
          DeferredRouteOutput (p, header, idev, ucb, ecb);
          return true;
        }
    }

                if (m_routingTable.LookupRoute (dst, toBroadcast))
                  {
                    Ptr<Ipv4Route> route = toBroadcast.GetRoute ();
                    ucb (idev, route, packet, header);
                  }
                else
                  {

      return true;
    }

  // Check if input device supports IP forwarding
  if (m_ipv4->IsForwarding (iif) == false)
    {
      NS_LOG_LOGIC ("Forwarding disabled for this interface");
      ecb (p, header, Socket::ERROR_NOROUTETOHOST);
      return true;
    }

  // Forwarding
  return Forwarding (p, header, idev, ucb, ecb);
}

bool
RoutingProtocol::Forwarding (Ptr<const Packet> p, const Ipv4Header & header, Ptr<const NetDevice> idev,
                             UnicastForwardCallback ucb, ErrorCallback ecb)
{
  NS_LOG_FUNCTION (this);

          m_nb.Update (route->GetGateway (), ActiveRouteTimeout);
          m_nb.Update (toOrigin.GetNextHop (), ActiveRouteTimeout);

          ucb (idev, route, p, header);
          return true;
        }
      else

      Ipv4Header header = queueEntry.GetIpv4Header ();
      header.SetSource (route->GetSource ());
      header.SetTtl (header.GetTtl () + 1); // compensate extra TTL decrement by fake loopback routing
      ucb (queueEntry.GetInputDevice (), route, p, header);
    }
}


(-)a/src/aodv/model/aodv-routing-protocol.h (-2 / +2 lines)

Lines 168-176	Link Here

168

  /// Start protocol operation

168

  /// Start protocol operation

169

  void Start ();

169

  void Start ();

170

  /// Queue packet and send route request

170

  /// Queue packet and send route request

171

  void DeferredRouteOutput (Ptr<const Packet> p, const Ipv4Header & header, UnicastForwardCallback ucb, ErrorCallback ecb);

171

  void DeferredRouteOutput (Ptr<const Packet> p, const Ipv4Header & header, Ptr<const NetDevice> idev, UnicastForwardCallback ucb, ErrorCallback ecb);

172

  /// If route exists and valid, forward packet.

172

  /// If route exists and valid, forward packet.

173

  bool Forwarding (Ptr<const Packet> p, const Ipv4Header & header, UnicastForwardCallback ucb, ErrorCallback ecb);

173

  bool Forwarding (Ptr<const Packet> p, const Ipv4Header & header, Ptr<const NetDevice> idev, UnicastForwardCallback ucb, ErrorCallback ecb);

174

/**

174

/**

175

  * To reduce congestion in a network, repeated attempts by a source node at route discovery

175

  * To reduce congestion in a network, repeated attempts by a source node at route discovery

176

  * for a single destination MUST utilize a binary exponential backoff.

176

  * for a single destination MUST utilize a binary exponential backoff.




RequestQueue::Enqueue (QueueEntry & entry)
{
  Purge ();
  for (std::vector<QueueEntry>::const_iterator i = m_queue.begin (); i != m_queue.end (); ++i)
       != m_queue.end (); ++i)
    {
      if ((i->GetPacket ()->GetUid () == entry.GetPacket ()->GetUid ())
          && (i->GetIpv4Header ().GetDestination () == entry.GetIpv4Header ().GetDestination ()))
              == entry.GetIpv4Header ().GetDestination ()))
        return false;
    }
  entry.SetExpireTime (m_queueTimeout);




  typedef Ipv4RoutingProtocol::ErrorCallback ErrorCallback;
  /// c-tor
  QueueEntry (Ptr<const Packet> pa = 0, Ipv4Header const & h = Ipv4Header (),
              Ptr<const NetDevice> idev = 0,
              UnicastForwardCallback ucb = UnicastForwardCallback (),
              ErrorCallback ecb = ErrorCallback (), Time exp = Simulator::Now ()) :
    m_packet (pa), m_header (h), m_idev(idev), m_ucb (ucb), m_ecb (ecb),
    m_expire (exp + Simulator::Now ())
  {}


  void SetIpv4Header (Ipv4Header h) { m_header = h; }
  void SetExpireTime (Time exp) { m_expire = exp + Simulator::Now (); }
  Time GetExpireTime () const { return m_expire - Simulator::Now (); }
  void SetInputDevice (Ptr<const NetDevice> idev) { m_idev = idev; }
  Ptr<const NetDevice> GetInputDevice () const { return m_idev; }
private:
  
  /// Data packet
  Ptr<const Packet> m_packet;
  /// IP header
  Ipv4Header m_header;
  /// Input Device
  Ptr<const NetDevice> m_idev;
  /// Unicast forward callback
  UnicastForwardCallback m_ucb;
  /// Error callback




struct QueueEntryTest : public TestCase
{
  QueueEntryTest () : TestCase ("QueueEntry") {}
  void Unicast (Ptr<const NetDevice> idev, Ptr<Ipv4Route> route, Ptr<const Packet> packet, const Ipv4Header & header) {}
  void Error (Ptr<const Packet>, const Ipv4Header &, Socket::SocketErrno) {}
  void Unicast2 (Ptr<const NetDevice> idev, Ptr<Ipv4Route> route, Ptr<const Packet> packet, const Ipv4Header & header) {}
  void Error2 (Ptr<const Packet>, const Ipv4Header &, Socket::SocketErrno) {}
  virtual void DoRun ()
  {

    h.SetSource (Ipv4Address ("4.3.2.1"));
    Ipv4RoutingProtocol::UnicastForwardCallback ucb = MakeCallback (&QueueEntryTest::Unicast, this);
    Ipv4RoutingProtocol::ErrorCallback ecb = MakeCallback (&QueueEntryTest::Error, this);
    QueueEntry entry (packet, h, 0, ucb, ecb, Seconds (1));
    NS_TEST_EXPECT_MSG_EQ (h.GetDestination (),  entry.GetIpv4Header ().GetDestination (), "trivial");
    NS_TEST_EXPECT_MSG_EQ (h.GetSource (),  entry.GetIpv4Header ().GetSource (), "trivial");
    NS_TEST_EXPECT_MSG_EQ (ucb.IsEqual (entry.GetUnicastForwardCallback ()), true, "trivial");

{
  AodvRqueueTest () : TestCase ("Rqueue"), q (64, Seconds (30)) {}
  virtual void DoRun ();
  void Unicast (Ptr<const NetDevice> idev, Ptr<Ipv4Route> route, Ptr<const Packet> packet, const Ipv4Header & header) {}
  void Error (Ptr<const Packet>, const Ipv4Header &, Socket::SocketErrno) {}
  void CheckSizeLimit ();
  void CheckTimeout ();

  h.SetSource (Ipv4Address ("4.3.2.1"));
  Ipv4RoutingProtocol::UnicastForwardCallback ucb = MakeCallback (&AodvRqueueTest::Unicast, this);
  Ipv4RoutingProtocol::ErrorCallback ecb = MakeCallback (&AodvRqueueTest::Error, this);
  QueueEntry e1 (packet, h, 0, ucb, ecb, Seconds (1));
  q.Enqueue (e1);
  q.Enqueue (e1);
  q.Enqueue (e1);

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

  h.SetDestination (Ipv4Address ("2.2.2.2"));
  QueueEntry e2 (packet, h, 0, ucb, ecb, Seconds (1));
  q.Enqueue (e1);
  q.Enqueue (e2);
  Ptr<Packet> packet2 = Create<Packet> ();
  QueueEntry e3 (packet2, h, 0, ucb, ecb, Seconds (1));
  NS_TEST_EXPECT_MSG_EQ (q.Dequeue (Ipv4Address ("3.3.3.3"), e3), false, "trivial");
  NS_TEST_EXPECT_MSG_EQ (q.Dequeue (Ipv4Address ("2.2.2.2"), e3), true, "trivial");
  NS_TEST_EXPECT_MSG_EQ (q.Find (Ipv4Address ("2.2.2.2")), false, "trivial");

  NS_TEST_EXPECT_MSG_EQ (q.GetSize (), 2, "trivial");
  Ptr<Packet> packet4 = Create<Packet> ();
  h.SetDestination (Ipv4Address ("1.2.3.4"));
  QueueEntry e4 (packet4, h, 0, ucb, ecb, Seconds (20));
  q.Enqueue (e4);
  NS_TEST_EXPECT_MSG_EQ (q.GetSize (), 3, "trivial");
  q.DropPacketWithDst (Ipv4Address ("1.2.3.4"));

  Ipv4Header header;
  Ipv4RoutingProtocol::UnicastForwardCallback ucb = MakeCallback (&AodvRqueueTest::Unicast, this);
  Ipv4RoutingProtocol::ErrorCallback ecb = MakeCallback (&AodvRqueueTest::Error, this);
  QueueEntry e1 (packet, header, 0, ucb, ecb, Seconds (1));

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




  typedef Ipv4RoutingProtocol::ErrorCallback ErrorCallback;
  /// c-tor
  QueueEntry (Ptr<const Packet> pa = 0, Ipv4Header const & h = Ipv4Header (),
              Ptr<const NetDevice> idev = 0,
              UnicastForwardCallback ucb = UnicastForwardCallback (),
              ErrorCallback ecb = ErrorCallback ())
    : m_packet (pa),
      m_header (h),
      m_idev (idev),
      m_ucb (ucb),
      m_ecb (ecb),
      m_expire (Seconds (0))

  {
    m_header = h;
  }
  Ptr<const NetDevice> GetInputDevice () const
  {
    return m_idev;
  }
  void SetInputDevice (Ptr<const NetDevice> idev)
  {
    m_idev = idev;
  }
  void SetExpireTime (Time exp)
  {
    m_expire = exp + Simulator::Now ();

  Ptr<const Packet> m_packet;
  /// IP header
  Ipv4Header m_header;
  /// Input Device
  Ptr<const NetDevice> m_idev;
  /// Unicast forward callback
  UnicastForwardCallback m_ucb;
  /// Error callback




void
RoutingProtocol::DeferredRouteOutput (Ptr<const Packet> p,
                                      const Ipv4Header & header,
                                      Ptr<const NetDevice> idev,
                                      UnicastForwardCallback ucb,
                                      ErrorCallback ecb)
{
  NS_LOG_FUNCTION (this << p << header);
  NS_ASSERT (p != 0 && p != Ptr<Packet> ());
  QueueEntry newEntry (p,header,idev,ucb,ecb);
  bool result = m_queue.Enqueue (newEntry);
  if (result)
    {

      DeferredRouteOutputTag tag;
      if (p->PeekPacketTag (tag))
        {
          DeferredRouteOutput (p,header,idev,ucb,ecb);
          return true;
        }
    }

                  if (m_routingTable.LookupRoute (dst,toBroadcast,true))
                    {
                      Ptr<Ipv4Route> route = toBroadcast.GetRoute ();
                      ucb (idev, route,packet,header);
                    }
                  else
                    {

        }
      return true;
    }

  // Check if input device supports IP forwarding
  if (m_ipv4->IsForwarding (iif) == false)
    {
      NS_LOG_LOGIC ("Forwarding disabled for this interface");
      ecb (p, header, Socket::ERROR_NOROUTETOHOST);
      return true;
    }

  RoutingTableEntry toDst;
  if (m_routingTable.LookupRoute (dst,toDst))
    {

                                      << " to " << dst
                                      << " from " << header.GetSource ()
                                      << " via nexthop neighbor " << toDst.GetNextHop ());
          ucb (idev, route, p, header);
          return true;
        }
    }

}

void
RoutingProtocol::Send (Ptr<const NetDevice> idev,
                       Ptr<Ipv4Route> route,
                       Ptr<const Packet> packet,
                       const Ipv4Header & header)
{

{
  NS_LOG_DEBUG (m_mainAddress << " is sending a queued packet to destination " << dst);
  QueueEntry queueEntry;
  if (m_queue.Dequeue (dst, queueEntry))
    {
      DeferredRouteOutputTag tag;
      Ptr<Packet> p = ConstCast<Packet> (queueEntry.GetPacket ());

      Ipv4Header header = queueEntry.GetIpv4Header ();
      header.SetSource (route->GetSource ());
      header.SetTtl (header.GetTtl () + 1); // compensate extra TTL decrement by fake loopback routing
      ucb (queueEntry.GetInputDevice (), route, p, header);
      if (m_queue.GetSize () != 0 && m_queue.Find (dst))
        {
          Simulator::Schedule (MilliSeconds (m_uniformRandomVariable->GetInteger (0,100)),
                               &RoutingProtocol::SendPacketFromQueue, this, dst, route);
        }
    }
}

(-)a/src/dsdv/model/dsdv-routing-protocol.h (-2 / +2 lines)

Lines 149-155	Link Here

149

  Start ();

149

  Start ();

150

  /// Queue packet untill we find a route

150

  /// Queue packet untill we find a route

151

  void

151

  void

152

  DeferredRouteOutput (Ptr<const Packet> p, const Ipv4Header & header, UnicastForwardCallback ucb, ErrorCallback ecb);

152

  DeferredRouteOutput (Ptr<const Packet> p, const Ipv4Header & header, Ptr<const NetDevice> idev, UnicastForwardCallback ucb, ErrorCallback ecb);

153

  /// Look for any queued packets to send them out

153

  /// Look for any queued packets to send them out

154

  void

154

  void

155

  LookForQueuedPackets (void);

155

  LookForQueuedPackets (void);

Lines 170-176	Link Here

170

  RecvDsdv (Ptr<Socket> socket);

170

  RecvDsdv (Ptr<Socket> socket);

171

172

  void

172

  void

173

  Send (Ptr<Ipv4Route>, Ptr<const Packet>, const Ipv4Header &);

173

  Send (Ptr<const NetDevice> idev, Ptr<Ipv4Route>, Ptr<const Packet>, const Ipv4Header &);

174

  /// Create loopback route for given header

174

  /// Create loopback route for given header

175

  Ptr<Ipv4Route>

175

  Ptr<Ipv4Route>

176

  LoopbackRoute (const Ipv4Header & header, Ptr<NetDevice> oif) const;

176

  LoopbackRoute (const Ipv4Header & header, Ptr<NetDevice> oif) const;




}

bool 
Ipv4GlobalRouting::RouteInput  (Ptr<const Packet> p, const Ipv4Header &header, Ptr<const NetDevice> idev,
                                UnicastForwardCallback ucb, MulticastForwardCallback mcb,
                                LocalDeliverCallback lcb, ErrorCallback ecb)
{ 
  NS_LOG_FUNCTION (this << p << header << header.GetSource () << header.GetDestination () << idev << &lcb << &ecb);

    {
      NS_LOG_LOGIC ("Forwarding disabled for this interface");
      ecb (p, header, Socket::ERROR_NOROUTETOHOST);
      return true;
    }
  // Next, try to find a route
  NS_LOG_LOGIC ("Unicast destination- looking up global route");

  if (rtentry != 0)
    {
      NS_LOG_LOGIC ("Found unicast destination- calling unicast callback");
      ucb (idev, rtentry, p, header);
      return true;
    }
  else





// This function analogous to Linux ip_mr_forward()
void
Ipv4L3Protocol::IpMulticastForward (Ptr<const NetDevice> idev, Ptr<Ipv4MulticastRoute> mrtentry, Ptr<const Packet> p, const Ipv4Header &header)
{
  NS_LOG_FUNCTION (this << mrtentry << p << header);
  NS_LOG_LOGIC ("Multicast forwarding logic for node: " << m_node->GetId ());

  if (GetInterface (GetInterfaceForDevice (idev))->IsForwarding () == false)
    {
      NS_LOG_LOGIC ("Forwarding disabled for this interface");
      RouteInputError (p, header, Socket::ERROR_NOROUTETOHOST);
      return;
    }

  std::map<uint32_t, uint32_t> ttlMap = mrtentry->GetOutputTtlMap ();
  std::map<uint32_t, uint32_t>::iterator mapIter;



// This function analogous to Linux ip_forward()
void
Ipv4L3Protocol::IpForward (Ptr<const NetDevice> idev, Ptr<Ipv4Route> rtentry, Ptr<const Packet> p, const Ipv4Header &header)
{
  NS_LOG_FUNCTION (this << rtentry << p << header);
  NS_LOG_LOGIC ("Forwarding logic for node: " << m_node->GetId ());

  if (GetInterface (GetInterfaceForDevice (idev))->IsForwarding () == false)
    {
      NS_LOG_LOGIC ("Forwarding disabled for this interface");
      RouteInputError (p, header, Socket::ERROR_NOROUTETOHOST);
      return;
    }

  // Forwarding
  Ipv4Header ipHeader = header;
  Ptr<Packet> packet = p->Copy ();




  void SendWithHeader (Ptr<Packet> packet, Ipv4Header ipHeader, Ptr<Ipv4Route> route);

  uint32_t AddInterface (Ptr<NetDevice> device);
  /**
   * \brief Get an interface.
   * \param i interface index
   * \return IPv4 interface pointer
   */
  Ptr<Ipv4Interface> GetInterface (uint32_t i) const;
  uint32_t GetNInterfaces (void) const;



  /**
   * \brief Forward a packet.
   * \param idev Pointer to ingress network device
   * \param rtentry route
   * \param p packet to forward
   * \param header IPv4 header to add to the packet
   */
  void 
  IpForward (Ptr<const NetDevice> idev,
             Ptr<Ipv4Route> rtentry,
             Ptr<const Packet> p, 
             const Ipv4Header &header);

  /**
   * \brief Forward a multicast packet.
   * \param idev Pointer to ingress network device
   * \param mrtentry route
   * \param p packet to forward
   * \param header IPv4 header to add to the packet
   */
  void
  IpMulticastForward (Ptr<const NetDevice> idev,
                      Ptr<Ipv4MulticastRoute> mrtentry,
                      Ptr<const Packet> p, 
                      const Ipv4Header &header);


(-)a/src/internet/model/ipv4-list-routing.cc (-1 / +1 lines)

Lines 161-167	Link Here

161

162

      NS_LOG_LOGIC ("Forwarding disabled for this interface");

162

      NS_LOG_LOGIC ("Forwarding disabled for this interface");

163

      ecb (p, header, Socket::ERROR_NOROUTETOHOST);

163

      ecb (p, header, Socket::ERROR_NOROUTETOHOST);

164

      return false;

164

      return true;

165

166

  // Next, try to find a route

166

  // Next, try to find a route

167

  // If we have already delivered a packet locally (e.g. multicast)

167

  // If we have already delivered a packet locally (e.g. multicast)

(-)a/src/internet/model/ipv4-routing-protocol.h (-2 / +2 lines)

Lines 57-66	Link Here

  static TypeId GetTypeId (void);

  static TypeId GetTypeId (void);

  /// Callback for unicast packets to be forwarded

  /// Callback for unicast packets to be forwarded

  typedef Callback<void, Ptr<Ipv4Route>, Ptr<const Packet>, const Ipv4Header &> UnicastForwardCallback;

  typedef Callback<void, Ptr<const NetDevice>, Ptr<Ipv4Route>, Ptr<const Packet>, const Ipv4Header &> UnicastForwardCallback;

  /// Callback for multicast packets to be forwarded

  /// Callback for multicast packets to be forwarded

  typedef Callback<void, Ptr<Ipv4MulticastRoute>, Ptr<const Packet>, const Ipv4Header &> MulticastForwardCallback;

  typedef Callback<void, Ptr<const NetDevice>, Ptr<Ipv4MulticastRoute>, Ptr<const Packet>, const Ipv4Header &> MulticastForwardCallback;

  /// Callback for packets to be locally delivered

  /// Callback for packets to be locally delivered

  typedef Callback<void, Ptr<const Packet>, const Ipv4Header &, uint32_t > LocalDeliverCallback;

  typedef Callback<void, Ptr<const Packet>, const Ipv4Header &, uint32_t > LocalDeliverCallback;




      if (mrtentry)
        {
          NS_LOG_LOGIC ("Multicast route found");
          mcb (idev, mrtentry, p, ipHeader); // multicast forwarding callback
          return true;
        }
      else

    {
      NS_LOG_LOGIC ("Forwarding disabled for this interface");
      ecb (p, ipHeader, Socket::ERROR_NOROUTETOHOST);
      return true;
    }

  // Next, try to find a route
  Ptr<Ipv4Route> rtentry = LookupStatic (ipHeader.GetDestination ());
  if (rtentry != 0)
    {
      NS_LOG_LOGIC ("Found unicast destination- calling unicast callback");
      ucb (idev, rtentry, p, ipHeader);  // unicast forwarding callback
      return true;
    }
  else

(-)a/src/internet/model/ipv4.h (+8 lines)

Lines 36-41	Link Here

class Ipv4RoutingProtocol;

class Ipv4RoutingProtocol;

class IpL4Protocol;

class IpL4Protocol;

class Ipv4Header;

class Ipv4Header;

class Ipv4Interface;

/**

/**

 * \ingroup internet

 * \ingroup internet

Lines 114-119	Link Here

114

  virtual uint32_t AddInterface (Ptr<NetDevice> device) = 0;

115

  virtual uint32_t AddInterface (Ptr<NetDevice> device) = 0;

115

116

/**

117

/**

118

   * \brief Get an interface.

119

   * \param i interface index

120

   * \return IPv4 interface pointer

121

*/

122

  virtual Ptr<Ipv4Interface> GetInterface (uint32_t i) const = 0;

123

124

/**

117

   * \returns the number of interfaces added by the user.

125

   * \returns the number of interfaces added by the user.

118

*/

126

*/

119

  virtual uint32_t GetNInterfaces (void) const = 0;

127

  virtual uint32_t GetNInterfaces (void) const = 0;

(-)a/src/internet/model/ipv6-list-routing.cc (-1 / +1 lines)

Lines 115-121	Link Here

115

116

      NS_LOG_LOGIC ("Forwarding disabled for this interface");

116

      NS_LOG_LOGIC ("Forwarding disabled for this interface");

117

      ecb (p, header, Socket::ERROR_NOROUTETOHOST);

117

      ecb (p, header, Socket::ERROR_NOROUTETOHOST);

118

      return false;

118

      return true;

119

120

121

  // We disable error callback for the called protocols.

121

  // We disable error callback for the called protocols.

(-)a/src/internet/model/ipv6-static-routing.cc (-1 / +1 lines)

Lines 623-629	Link Here

623

624

          ecb (p, header, Socket::ERROR_NOROUTETOHOST);

624

          ecb (p, header, Socket::ERROR_NOROUTETOHOST);

625

626

      return false;

626

      return true;

627

628

  // Next, try to find a route

628

  // Next, try to find a route

629

  NS_LOG_LOGIC ("Unicast destination");

629

  NS_LOG_LOGIC ("Unicast destination");

(-)a/src/internet/model/rip.cc (-2 / +2 lines)

Lines 268-274	Link Here

268

269

          ecb (p, header, Socket::ERROR_NOROUTETOHOST);

269

          ecb (p, header, Socket::ERROR_NOROUTETOHOST);

270

271

      return false;

271

      return true;

272

273

  // Next, try to find a route

273

  // Next, try to find a route

274

  NS_LOG_LOGIC ("Unicast destination");

274

  NS_LOG_LOGIC ("Unicast destination");

Lines 277-283	Link Here

277

  if (rtentry != 0)

277

  if (rtentry != 0)

278

279

      NS_LOG_LOGIC ("Found unicast destination - calling unicast callback");

279

      NS_LOG_LOGIC ("Found unicast destination - calling unicast callback");

280

      ucb (rtentry, p, header);  // unicast forwarding callback

280

      ucb (idev, rtentry, p, header);  // unicast forwarding callback

281

      return true;

281

      return true;

282

283

  else

283

  else

(-)a/src/internet/model/ripng.cc (-1 / +1 lines)

Lines 244-250	Link Here

244

245

          ecb (p, header, Socket::ERROR_NOROUTETOHOST);

245

          ecb (p, header, Socket::ERROR_NOROUTETOHOST);

246

247

      return false;

247

      return true;

248

249

  // Next, try to find a route

249

  // Next, try to find a route

250

  NS_LOG_LOGIC ("Unicast destination");

250

  NS_LOG_LOGIC ("Unicast destination");

(-)a/src/nix-vector-routing/examples/nix-simple.cc (+2 lines)

Lines 48-53	Link Here

  LogComponentEnable ("UdpEchoClientApplication", LOG_LEVEL_INFO);

  LogComponentEnable ("UdpEchoClientApplication", LOG_LEVEL_INFO);

  LogComponentEnable ("UdpEchoServerApplication", LOG_LEVEL_INFO);

  LogComponentEnable ("UdpEchoServerApplication", LOG_LEVEL_INFO);

  Packet::EnablePrinting ();

  NodeContainer nodes12;

  NodeContainer nodes12;

  nodes12.Create (2);

  nodes12.Create (2);

(-)a/src/nix-vector-routing/model/ipv4-nix-vector-routing.cc (-1 / +16 lines)

Lines 644-654	Link Here

644

645

646

647

  // Check if input device supports IP forwarding

648

  if (m_ipv4->IsForwarding (iif) == false)

649

650

      NS_LOG_LOGIC ("Forwarding disabled for this interface");

651

      ecb (p, header, Socket::ERROR_NOROUTETOHOST);

652

      return true;

653

654

647

  Ptr<Ipv4Route> rtentry;

655

  Ptr<Ipv4Route> rtentry;

648

656

649

  // Get the nix-vector from the packet

657

  // Get the nix-vector from the packet

650

  Ptr<NixVector> nixVector = p->GetNixVector ();

658

  Ptr<NixVector> nixVector = p->GetNixVector ();

651

659

660

  if (nixVector == 0)

661

662

      std::cout << *p << std::endl;

663

      std::cout << header << std::endl;

664

      std::cout << idev << std::endl;

665

666

652

  // If nixVector isn't in packet, something went wrong

667

  // If nixVector isn't in packet, something went wrong

653

  NS_ASSERT (nixVector);

668

  NS_ASSERT (nixVector);

654

669

Lines 690-696	Link Here

690

  // local deliver is handled by Ipv4StaticRoutingImpl

705

  // local deliver is handled by Ipv4StaticRoutingImpl

691

  // so this code is never even called if the packet is

706

  // so this code is never even called if the packet is

692

  // destined for this node.

707

  // destined for this node.

693

  ucb (rtentry, p, header);

708

  ucb (idev, rtentry, p, header);

694

709

695

  return true;

710

  return true;

696

711




        }
    }

  // Check if input device supports IP forwarding
  if (m_ipv4->IsForwarding (iif) == false)
    {
      NS_LOG_LOGIC ("Forwarding disabled for this interface");
      ecb (p, header, Socket::ERROR_NOROUTETOHOST);
      return true;
    }

  // Forwarding
  Ptr<Ipv4Route> rtentry;
  RoutingTableEntry entry1, entry2;

                                 << " --> nextHop=" << entry2.nextAddr
                                 << " interface=" << entry2.interface);

      ucb (idev, rtentry, p, header);
      return true;
    }
  else

Return to bug 2402