/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2016 Universita' di Firenze, Italy

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 * Author: Tommaso Pecorella <tommaso.pecorella@unifi.it>

 */

// Network topology

//

//    SRC

//     |<=== source network

//     A-----B

//      \   / \   all networks have cost 1, except

//       \ /  |   for the direct link from C to D, which

//        C  /    has cost 10

//        | /

//        |/

//        D

//        |<=== target network

//       DST

//

//

// A, B, C and D are RIPng routers.

// A and D are configured with static addresses.

// SRC and DST will exchange packets.

//

// After about 3 seconds, the topology is built, and Echo Reply will be received.

// After 40 seconds, the link between B and D will break, causing a route failure.

// After 44 seconds from the failure, the routers will recovery from the failure.

// Split Horizoning should affect the recovery time, but it is not. See the manual

// for an explanation of this effect.

//

// If "showPings" is enabled, the user will see:

// 1) if the ping has been acknowledged

// 2) if a Destination Unreachable has been received by the sender

// 3) nothing, when the Echo Request has been received by the destination but

//    the Echo Reply is unable to reach the sender.

// Examining the .pcap files with Wireshark can confirm this effect.

#include <fstream>

#include "ns3/core-module.h"

#include "ns3/internet-module.h"

#include "ns3/csma-module.h"

#include "ns3/internet-apps-module.h"

#include "ns3/ipv4-static-routing-helper.h"

#include "ns3/ipv4-routing-table-entry.h"

using namespace ns3;

NS_LOG_COMPONENT_DEFINE ("RipSimpleRouting");

void TearDownLink (Ptr<Node> nodeA, Ptr<Node> nodeB, uint32_t interfaceA, uint32_t interfaceB)

{

  nodeA->GetObject<Ipv4> ()->SetDown (interfaceA);

  nodeB->GetObject<Ipv4> ()->SetDown (interfaceB);

}

int main (int argc, char **argv)

{

  bool verbose = false;

  bool printRoutingTables = false;

  bool showPings = false;

  std::string SplitHorizon ("PoisonReverse");

  CommandLine cmd;

  cmd.AddValue ("verbose", "turn on log components", verbose);

  cmd.AddValue ("printRoutingTables", "Print routing tables at 30, 60 and 90 seconds", printRoutingTables);

  cmd.AddValue ("showPings", "Show Ping6 reception", showPings);

  cmd.AddValue ("splitHorizonStrategy", "Split Horizon strategy to use (NoSplitHorizon, SplitHorizon, PoisonReverse)", SplitHorizon);

  cmd.Parse (argc, argv);

  if (verbose)

    {

      LogComponentEnableAll (LogLevel (LOG_PREFIX_TIME | LOG_PREFIX_NODE));

      LogComponentEnable ("RipSimpleRouting", LOG_LEVEL_INFO);

      LogComponentEnable ("Rip", LOG_LEVEL_ALL);

      LogComponentEnable ("Ipv4Interface", LOG_LEVEL_ALL);

      LogComponentEnable ("Icmpv4L4Protocol", LOG_LEVEL_ALL);

      LogComponentEnable ("Ipv4L3Protocol", LOG_LEVEL_ALL);

      LogComponentEnable ("ArpCache", LOG_LEVEL_ALL);

      LogComponentEnable ("V4Ping", LOG_LEVEL_ALL);

    }

  if (SplitHorizon == "NoSplitHorizon")

    {

      Config::SetDefault ("ns3::Rip::SplitHorizon", EnumValue (RipNg::NO_SPLIT_HORIZON));

    }

  else if (SplitHorizon == "SplitHorizon")

    {

      Config::SetDefault ("ns3::Rip::SplitHorizon", EnumValue (RipNg::SPLIT_HORIZON));

    }

  else

    {

      Config::SetDefault ("ns3::Rip::SplitHorizon", EnumValue (RipNg::POISON_REVERSE));

    }

  NS_LOG_INFO ("Create nodes.");

  Ptr<Node> src = CreateObject<Node> ();

  Names::Add ("SrcNode", src);

  Ptr<Node> dst = CreateObject<Node> ();

  Names::Add ("DstNode", dst);

  Ptr<Node> a = CreateObject<Node> ();

  Names::Add ("RouterA", a);

  Ptr<Node> b = CreateObject<Node> ();

  Names::Add ("RouterB", b);

  Ptr<Node> c = CreateObject<Node> ();

  Names::Add ("RouterC", c);

  Ptr<Node> d = CreateObject<Node> ();

  Names::Add ("RouterD", d);

  NodeContainer net1 (src, a);

  NodeContainer net2 (a, b);

  NodeContainer net3 (a, c);

  NodeContainer net4 (b, c);

  NodeContainer net5 (c, d);

  NodeContainer net6 (b, d);

  NodeContainer net7 (d, dst);

  NodeContainer routers (a, b, c, d);

  NodeContainer nodes (src, dst);

  NS_LOG_INFO ("Create channels.");

  CsmaHelper csma;

  csma.SetChannelAttribute ("DataRate", DataRateValue (5000000));

  csma.SetChannelAttribute ("Delay", TimeValue (MilliSeconds (2)));

  NetDeviceContainer ndc1 = csma.Install (net1);

  NetDeviceContainer ndc2 = csma.Install (net2);

  NetDeviceContainer ndc3 = csma.Install (net3);

  NetDeviceContainer ndc4 = csma.Install (net4);

  NetDeviceContainer ndc5 = csma.Install (net5);

  NetDeviceContainer ndc6 = csma.Install (net6);

  NetDeviceContainer ndc7 = csma.Install (net7);

  NS_LOG_INFO ("Create IPv4 and routing");

  RipHelper ripRouting;

  // Rule of thumb:

  // Interfaces are added sequentially, starting from 0

  // However, interface 0 is always the loopback...

  ripRouting.ExcludeInterface (a, 1);

  ripRouting.ExcludeInterface (d, 3);

  ripRouting.SetInterfaceMetric (c, 3, 10);

  ripRouting.SetInterfaceMetric (d, 1, 10);

  Ipv4ListRoutingHelper listRH;

  listRH.Add (ripRouting, 0);

//  Ipv4StaticRoutingHelper staticRh;

//  listRH.Add (staticRh, 5);

  InternetStackHelper internet;

  internet.SetIpv6StackInstall (false);

  internet.SetRoutingHelper (listRH);

  internet.Install (routers);

  InternetStackHelper internetNodes;

  internetNodes.SetIpv6StackInstall (false);

  internetNodes.Install (nodes);

  // Assign addresses.

  // The source and destination networks have global addresses

  // The "core" network just needs link-local addresses for routing.

  // We assign global addresses to the routers as well to receive

  // ICMPv6 errors.

  NS_LOG_INFO ("Assign IPv4 Addresses.");

  Ipv4AddressHelper ipv4;

  ipv4.SetBase (Ipv4Address ("10.0.0.0"), Ipv4Mask ("255.255.255.0"));

  Ipv4InterfaceContainer iic1 = ipv4.Assign (ndc1);

  ipv4.SetBase (Ipv4Address ("10.0.1.0"), Ipv4Mask ("255.255.255.0"));

  Ipv4InterfaceContainer iic2 = ipv4.Assign (ndc2);

  ipv4.SetBase (Ipv4Address ("10.0.2.0"), Ipv4Mask ("255.255.255.0"));

  Ipv4InterfaceContainer iic3 = ipv4.Assign (ndc3);

  ipv4.SetBase (Ipv4Address ("10.0.3.0"), Ipv4Mask ("255.255.255.0"));

  Ipv4InterfaceContainer iic4 = ipv4.Assign (ndc4);

  ipv4.SetBase (Ipv4Address ("10.0.4.0"), Ipv4Mask ("255.255.255.0"));

  Ipv4InterfaceContainer iic5 = ipv4.Assign (ndc5);

  ipv4.SetBase (Ipv4Address ("10.0.5.0"), Ipv4Mask ("255.255.255.0"));

  Ipv4InterfaceContainer iic6 = ipv4.Assign (ndc6);

  ipv4.SetBase (Ipv4Address ("10.0.6.0"), Ipv4Mask ("255.255.255.0"));

  Ipv4InterfaceContainer iic7 = ipv4.Assign (ndc7);

  Ptr<Ipv4StaticRouting> staticRouting;

  staticRouting = Ipv4RoutingHelper::GetRouting <Ipv4StaticRouting> (src->GetObject<Ipv4> ()->GetRoutingProtocol ());

  staticRouting->SetDefaultRoute ("10.0.0.2", 1 );

  staticRouting = Ipv4RoutingHelper::GetRouting <Ipv4StaticRouting> (dst->GetObject<Ipv4> ()->GetRoutingProtocol ());

  staticRouting->SetDefaultRoute ("10.0.6.1", 1 );

  if (printRoutingTables)

    {

      RipHelper routingHelper;

      Ptr<OutputStreamWrapper> routingStream = Create<OutputStreamWrapper> (&std::cout);

      routingHelper.PrintRoutingTableAt (Seconds (30.0), a, routingStream);

      routingHelper.PrintRoutingTableAt (Seconds (30.0), b, routingStream);

      routingHelper.PrintRoutingTableAt (Seconds (30.0), c, routingStream);

      routingHelper.PrintRoutingTableAt (Seconds (30.0), d, routingStream);

      routingHelper.PrintRoutingTableAt (Seconds (60.0), a, routingStream);

      routingHelper.PrintRoutingTableAt (Seconds (60.0), b, routingStream);

      routingHelper.PrintRoutingTableAt (Seconds (60.0), c, routingStream);

      routingHelper.PrintRoutingTableAt (Seconds (60.0), d, routingStream);

      routingHelper.PrintRoutingTableAt (Seconds (90.0), a, routingStream);

      routingHelper.PrintRoutingTableAt (Seconds (90.0), b, routingStream);

      routingHelper.PrintRoutingTableAt (Seconds (90.0), c, routingStream);

      routingHelper.PrintRoutingTableAt (Seconds (90.0), d, routingStream);

    }

  NS_LOG_INFO ("Create Applications.");

  uint32_t packetSize = 1024;

  Time interPacketInterval = Seconds (1.0);

  V4PingHelper ping ("10.0.6.2");

  ping.SetAttribute ("Interval", TimeValue (interPacketInterval));

  ping.SetAttribute ("Size", UintegerValue (packetSize));

  if (showPings)

    {

      ping.SetAttribute ("Verbose", BooleanValue (true));

    }

  ApplicationContainer apps = ping.Install (src);

  apps.Start (Seconds (1.0));

  apps.Stop (Seconds (110.0));

  AsciiTraceHelper ascii;

  csma.EnableAsciiAll (ascii.CreateFileStream ("rip-simple-routing.tr"));

  csma.EnablePcapAll ("rip-simple-routing", true);

  Simulator::Schedule (Seconds (40), &TearDownLink, b, d, 3, 2);

  /* Now, do the actual simulation. */

  NS_LOG_INFO ("Run Simulation.");

  Simulator::Stop (Seconds (131.0));

  Simulator::Run ();

  Simulator::Destroy ();

  NS_LOG_INFO ("Done.");

}

    obj = bld.create_ns3_program('rip-simple-network',

                                 ['csma', 'internet', 'internet-apps'])

    obj.source = 'rip-simple-network.cc'

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2016 Universita' di Firenze, Italy

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 * Author: Tommaso Pecorella <tommaso.pecorella@unifi.it>

 */

#include "ns3/node.h"

#include "ns3/node-list.h"

#include "ns3/ipv4-list-routing.h"

#include "ns3/rip.h"

#include "rip-helper.h"

namespace ns3 {

RipHelper::RipHelper ()

{

  m_factory.SetTypeId ("ns3::Rip");

}

RipHelper::RipHelper (const RipHelper &o)

  : m_factory (o.m_factory)

{

  m_interfaceExclusions = o.m_interfaceExclusions;

  m_interfaceMetrics = o.m_interfaceMetrics;

}

RipHelper::~RipHelper ()

{

  m_interfaceExclusions.clear ();

  m_interfaceMetrics.clear ();

}

RipHelper*

RipHelper::Copy (void) const

{

  return new RipHelper (*this);

}

Ptr<Ipv4RoutingProtocol>

RipHelper::Create (Ptr<Node> node) const

{

  Ptr<Rip> rip = m_factory.Create<Rip> ();

  std::map<Ptr<Node>, std::set<uint32_t> >::const_iterator it = m_interfaceExclusions.find (node);

  if(it != m_interfaceExclusions.end ())

    {

      rip->SetInterfaceExclusions (it->second);

    }

  std::map< Ptr<Node>, std::map<uint32_t, uint8_t> >::const_iterator iter = m_interfaceMetrics.find (node);

  if(iter != m_interfaceMetrics.end ())

    {

      std::map<uint32_t, uint8_t>::const_iterator subiter;

      for (subiter = iter->second.begin (); subiter != iter->second.end (); subiter++)

        {

          rip->SetInterfaceMetric (subiter->first, subiter->second);

        }

    }

  node->AggregateObject (rip);

  return rip;

}

void

RipHelper::Set (std::string name, const AttributeValue &value)

{

  m_factory.Set (name, value);

}

int64_t

RipHelper::AssignStreams (NodeContainer c, int64_t stream)

{

  int64_t currentStream = stream;

  Ptr<Node> node;

  for (NodeContainer::Iterator i = c.Begin (); i != c.End (); ++i)

    {

      node = (*i);

      Ptr<Ipv4> ipv4 = node->GetObject<Ipv4> ();

      NS_ASSERT_MSG (ipv4, "Ipv4 not installed on node");

      Ptr<Ipv4RoutingProtocol> proto = ipv4->GetRoutingProtocol ();

      NS_ASSERT_MSG (proto, "Ipv4 routing not installed on node");

      Ptr<Rip> rip = DynamicCast<Rip> (proto);

      if (rip)

        {

          currentStream += rip->AssignStreams (currentStream);

          continue;

        }

      // RIP may also be in a list

      Ptr<Ipv4ListRouting> list = DynamicCast<Ipv4ListRouting> (proto);

      if (list)

        {

          int16_t priority;

          Ptr<Ipv4RoutingProtocol> listProto;

          Ptr<Rip> listRip;

          for (uint32_t i = 0; i < list->GetNRoutingProtocols (); i++)

            {

              listProto = list->GetRoutingProtocol (i, priority);

              listRip = DynamicCast<Rip> (listProto);

              if (listRip)

                {

                  currentStream += listRip->AssignStreams (currentStream);

                  break;

                }

            }

        }

    }

  return (currentStream - stream);

}

void RipHelper::SetDefaultRouter (Ptr<Node> node, Ipv4Address nextHop, uint32_t interface)

{

  Ptr<Ipv4> ipv4 = node->GetObject<Ipv4> ();

  NS_ASSERT_MSG (ipv4, "Ipv4 not installed on node");

  Ptr<Ipv4RoutingProtocol> proto = ipv4->GetRoutingProtocol ();

  NS_ASSERT_MSG (proto, "Ipv4 routing not installed on node");

  Ptr<Rip> rip = DynamicCast<Rip> (proto);

  if (rip)

    {

      rip->AddDefaultRouteTo (nextHop, interface);

    }

  // RIP may also be in a list

  Ptr<Ipv4ListRouting> list = DynamicCast<Ipv4ListRouting> (proto);

  if (list)

    {

      int16_t priority;

      Ptr<Ipv4RoutingProtocol> listProto;

      Ptr<Rip> listRip;

      for (uint32_t i = 0; i < list->GetNRoutingProtocols (); i++)

        {

          listProto = list->GetRoutingProtocol (i, priority);

          listRip = DynamicCast<Rip> (listProto);

          if (listRip)

            {

              listRip->AddDefaultRouteTo (nextHop, interface);

              break;

            }

        }

    }

}

void

RipHelper::ExcludeInterface (Ptr<Node> node, uint32_t interface)

{

  std::map< Ptr<Node>, std::set<uint32_t> >::iterator it = m_interfaceExclusions.find (node);

  if (it == m_interfaceExclusions.end ())

    {

      std::set<uint32_t> interfaces;

      interfaces.insert (interface);

      m_interfaceExclusions.insert (std::make_pair (node, interfaces));

    }

  else

    {

      it->second.insert (interface);

    }

}

void RipHelper::SetInterfaceMetric (Ptr<Node> node, uint32_t interface, uint8_t metric)

{

  m_interfaceMetrics[node][interface] = metric;

}

}

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2016 Universita' di Firenze, Italy

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 * Author: Tommaso Pecorella <tommaso.pecorella@unifi.it>

 */

#ifndef RIP_HELPER_H

#define RIP_HELPER_H

#include "ns3/object-factory.h"

#include "ns3/ipv4-routing-helper.h"

#include "ns3/node-container.h"

#include "ns3/node.h"

namespace ns3 {

/**

 * \brief Helper class that adds RIP routing to nodes.

 *

 * This class is expected to be used in conjunction with

 * ns3::InternetStackHelper::SetRoutingHelper

 *

 */

class RipHelper : public Ipv4RoutingHelper

{

public:

  /*

   * Construct an RipHelper to make life easier while adding RIP

   * routing to nodes.

   */

  RipHelper ();

  /**

   * \brief Construct an RipHelper from another previously

   * initialized instance (Copy Constructor).

   */

  RipHelper (const RipHelper &);

  virtual ~RipHelper ();

  /**

   * \returns pointer to clone of this RipHelper

   *

   * This method is mainly for internal use by the other helpers;

   * clients are expected to free the dynamic memory allocated by this method

   */

  RipHelper* Copy (void) const;

  /**

   * \param node the node on which the routing protocol will run

   * \returns a newly-created routing protocol

   *

   * This method will be called by ns3::InternetStackHelper::Install

   */

  virtual Ptr<Ipv4RoutingProtocol> Create (Ptr<Node> node) const;

  /**

   * \param name the name of the attribute to set

   * \param value the value of the attribute to set.

   *

   * This method controls the attributes of ns3::Ripng

   */

  void Set (std::string name, const AttributeValue &value);

  /**

   * Assign a fixed random variable stream number to the random variables

   * used by this model. Return the number of streams (possibly zero) that

   * have been assigned. The Install() method should have previously been

   * called by the user.

   *

   * \param c NetDeviceContainer of the set of net devices for which the

   *          SixLowPanNetDevice should be modified to use a fixed stream

   * \param stream first stream index to use

   * \return the number of stream indices assigned by this helper

   */

  int64_t AssignStreams (NodeContainer c, int64_t stream);

  /**

   * \brief Install a default route in the node.

   *

   * The traffic will be routed to the nextHop, located on the specified

   * interface, unless a more specific route is found.

   *

   * \param node the node

   * \param nextHop the next hop

   * \param interface the network interface

   */

  void SetDefaultRouter (Ptr<Node> node, Ipv4Address nextHop, uint32_t interface);

  /**

   * \brief Exclude an interface from RIP protocol.

   *

   * You have to call this function \a before installing RIP in the nodes.

   *

   * Note: the exclusion means that RIP will not be propagated on that interface.

   * The network prefix on that interface will be still considered in RIP.

   *

   * \param node the node

   * \param interface the network interface to be excluded

   */

  void ExcludeInterface (Ptr<Node> node, uint32_t interface);

  /**

   * \brief Set a metric for an interface.

   *

   * You have to call this function \a before installing RIP in the nodes.

   *

   * Note: RIP will apply the metric on route message reception.

   * As a consequence, interface metric should be set on the receiver.

   *

   * \param node the node

   * \param interface the network interface

   * \param metric the interface metric

   */

  void SetInterfaceMetric (Ptr<Node> node, uint32_t interface, uint8_t metric);

private:

  /**

   * \brief Assignment operator declared private and not implemented to disallow

   * assignment and prevent the compiler from happily inserting its own.

   */

  RipHelper &operator = (const RipHelper &o);

  ObjectFactory m_factory; //!< Object Factory

  std::map< Ptr<Node>, std::set<uint32_t> > m_interfaceExclusions; //!< Interface Exclusion set

  std::map< Ptr<Node>, std::map<uint32_t, uint8_t> > m_interfaceMetrics; //!< Interface Metric set

};

} // namespace ns3

#endif /* RIP_HELPER_H */

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2016 Universita' di Firenze, Italy

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 * Author: Tommaso Pecorella <tommaso.pecorella@unifi.it>

 */

#include "rip-header.h"

namespace ns3 {

/*

 * RipRte

 */

NS_OBJECT_ENSURE_REGISTERED (RipRte);

RipRte::RipRte ()

  : m_tag (0), m_prefix ("127.0.0.1"), m_subnetMask ("0.0.0.0"), m_nextHop ("0.0.0.0"), m_metric (16)

{

}

TypeId RipRte::GetTypeId (void)

{

  static TypeId tid = TypeId ("ns3::RipRte")

    .SetParent<Header> ()

    .SetGroupName ("Internet")

    .AddConstructor<RipRte> ();

  return tid;

}

TypeId RipRte::GetInstanceTypeId (void) const

{

  return GetTypeId ();

}

void RipRte::Print (std::ostream & os) const

{

  os << "prefix " << m_prefix << "/" << m_subnetMask.GetPrefixLength () << " Metric " << int(m_metric);

  os << " Tag " << int(m_tag) << " Next Hop " << m_nextHop;

}

uint32_t RipRte::GetSerializedSize () const

{

  return 20;

}

void RipRte::Serialize (Buffer::Iterator i) const

{

  i.WriteHtonU16 (2);

  i.WriteHtonU16 (m_tag);

  i.WriteHtonU32 (m_prefix.Get ());

  i.WriteHtonU32 (m_subnetMask.Get ());

  i.WriteHtonU32 (m_nextHop.Get ());

  i.WriteHtonU32 (m_metric);

}

uint32_t RipRte::Deserialize (Buffer::Iterator i)

{

  uint16_t tmp;

  tmp = i.ReadNtohU16 ();

  if (tmp != 2)

    {

      return 0;

    }

  m_tag = i.ReadNtohU16 ();

  m_prefix.Set (i.ReadNtohU32 ());

  m_subnetMask.Set (i.ReadNtohU32 ());

  m_nextHop.Set (i.ReadNtohU32 ());

  m_metric = i.ReadNtohU32 ();

  return GetSerializedSize ();

}

void RipRte::SetPrefix (Ipv4Address prefix)

{

  m_prefix = prefix;

}

Ipv4Address RipRte::GetPrefix () const

{

  return m_prefix;

}

void RipRte::SetSubnetMask (Ipv4Mask subnetMask)

{

  m_subnetMask = subnetMask;

}

Ipv4Mask RipRte::GetSubnetMask () const

{

  return m_subnetMask;

}

void RipRte::SetRouteTag (uint16_t routeTag)

{

  m_tag = routeTag;

}

uint16_t RipRte::GetRouteTag () const

{

  return m_tag;

}

void RipRte::SetRouteMetric (uint32_t routeMetric)

{

  m_metric = routeMetric;

}

uint32_t RipRte::GetRouteMetric () const

{

  return m_metric;

}

void RipRte::SetNextHop (Ipv4Address nextHop)

{

  m_nextHop = nextHop;

}

Ipv4Address RipRte::GetNextHop () const

{

  return m_nextHop;

}

std::ostream & operator << (std::ostream & os, const RipRte & h)

{

  h.Print (os);

  return os;

}

/*

 * RipHeader

 */

NS_OBJECT_ENSURE_REGISTERED (RipHeader)

  ;

RipHeader::RipHeader ()

  : m_command (0)

{

}

TypeId RipHeader::GetTypeId (void)

{

  static TypeId tid = TypeId ("ns3::RipHeader")

    .SetParent<Header> ()

    .SetGroupName ("Internet")

    .AddConstructor<RipHeader> ();

  return tid;

}

TypeId RipHeader::GetInstanceTypeId (void) const

{

  return GetTypeId ();

}

void RipHeader::Print (std::ostream & os) const

{

  os << "command " << int(m_command);

  for (std::list<RipRte>::const_iterator iter = m_rteList.begin ();

      iter != m_rteList.end (); iter ++)

    {

      os << " | ";

      iter->Print (os);

    }

}

uint32_t RipHeader::GetSerializedSize () const

{

  RipRte rte;

  return 4 + m_rteList.size () * rte.GetSerializedSize ();

}

void RipHeader::Serialize (Buffer::Iterator start) const

{

  Buffer::Iterator i = start;

  i.WriteU8 (uint8_t (m_command));

  i.WriteU8 (1);

  i.WriteU16 (0);

  for (std::list<RipRte>::const_iterator iter = m_rteList.begin ();

      iter != m_rteList.end (); iter ++)

    {

      iter->Serialize (i);

      i.Next(iter->GetSerializedSize ());

    }

}

uint32_t RipHeader::Deserialize (Buffer::Iterator start)

{

  Buffer::Iterator i = start;

  uint8_t temp;

  temp = i.ReadU8 ();

  if ((temp == REQUEST) || (temp == RESPONSE))

    {

      m_command = temp;

    }

  else

    {

      return 0;

    }

  temp = i.ReadU8 ();

  NS_ASSERT_MSG (temp == 1, "RIP received a message with mismatch version, aborting.");

  uint16_t temp16 = i.ReadU16 ();

  NS_ASSERT_MSG (temp16 == 0, "RIP received a message with invalid filled flags, aborting.");

  uint8_t rteNumber = (i.GetSize () - 4)/20;

  for (uint8_t n=0; n<rteNumber; n++)

    {

      RipRte rte;

      i.Next (rte.Deserialize (i));

      m_rteList.push_back (rte);

    }

  return GetSerializedSize ();

}

void RipHeader::SetCommand (RipHeader::Command_e command)

{

  m_command = command;

}

RipHeader::Command_e RipHeader::GetCommand () const

{

  return RipHeader::Command_e (m_command);

}

void RipHeader::AddRte (RipRte rte)

{

  m_rteList.push_back (rte);

}

void RipHeader::ClearRtes ()

{

  m_rteList.clear ();

}

uint16_t RipHeader::GetRteNumber (void) const

{

  return m_rteList.size ();

}

std::list<RipRte> RipHeader::GetRteList (void) const

{

  return m_rteList;

}

std::ostream & operator << (std::ostream & os, const RipHeader & h)

{

  h.Print (os);

  return os;

}

}

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2016 Universita' di Firenze, Italy

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 * Author: Tommaso Pecorella <tommaso.pecorella@unifi.it>

 */

#ifndef RIP_HEADER_H

#define RIP_HEADER_H

#include <list>

#include "ns3/header.h"

#include "ns3/ipv4-address.h"

#include "ns3/packet.h"

#include "ns3/ipv4-header.h"

namespace ns3 {

/**

 * \ingroup rip

 * \brief Rip v2 Routing Table Entry (RTE) - see \RFC{2453}.

 */

class RipRte : public Header

{

public:

  RipRte (void);

  /**

   * \brief Get the type ID.

   * \return The object TypeId.

   */

  static TypeId GetTypeId (void);

  /**

   * \brief Return the instance type identifier.

   * \return Instance type ID.

   */

  virtual TypeId GetInstanceTypeId (void) const;

  virtual void Print (std::ostream& os) const;

  /**

   * \brief Get the serialized size of the packet.

   * \return Size.

   */

  virtual uint32_t GetSerializedSize (void) const;

  /**

   * \brief Serialize the packet.

   * \param start Buffer iterator.

   */

  virtual void Serialize (Buffer::Iterator start) const;

  /**

   * \brief Deserialize the packet.

   * \param start Buffer iterator.

   * \return Size of the packet.

   */

  virtual uint32_t Deserialize (Buffer::Iterator start);

  /**

   * \brief Set the prefix.

   * \param prefix The prefix.

   */

  void SetPrefix (Ipv4Address prefix);

  /**

   * \brief Get the prefix.

   * \returns The prefix.

   */

  Ipv4Address GetPrefix (void) const;

  /**

   * \brief Set the subnet mask.

   * \param subnetMask The subnet mask.

   */

  void SetSubnetMask (Ipv4Mask subnetMask);

  /**

   * \brief Get the subnet mask.

   * \returns The subnet mask.

   */

  Ipv4Mask GetSubnetMask (void) const;

  /**

   * \brief Set the route tag.

   * \param routeTag The route tag.

   */

  void SetRouteTag (uint16_t routeTag);

  /**

   * \brief Get the route tag.

   * \returns The route tag.

   */

  uint16_t GetRouteTag (void) const;

  /**

   * \brief Set the route metric.

   * \param routeMetric The route metric.

   */

  void SetRouteMetric (uint32_t routeMetric);

  /**

   * \brief Get the route metric.

   * \returns The route metric.

   */

  uint32_t GetRouteMetric (void) const;

  /**

   * \brief Set the route metric.

   * \param routeMetric The route metric.

   */

  void SetNextHop (Ipv4Address nextHop);

  /**

   * \brief Get the route metric.

   * \returns The route metric.

   */

  Ipv4Address GetNextHop (void) const;

private:

  uint16_t m_tag; //!< Route tag.

  Ipv4Address m_prefix; //!< Advertised prefix.

  Ipv4Mask m_subnetMask; //!< Subnet mask.

  Ipv4Address m_nextHop; //!< Next hop.

  uint32_t m_metric; //!< Route metric.

};

/**

 * \brief Stream insertion operator.

 *

 * \param os the reference to the output stream

 * \param h the Routing Table Entry

 * \returns the reference to the output stream

 */

std::ostream & operator << (std::ostream & os, const RipRte & h);

/**

 * \ingroup rip

 * \brief RipHeader - see \RFC{2453}

 */

class RipHeader : public Header

{

public:

  RipHeader (void);

  /**

   * \brief Get the type ID.

   * \return the object TypeId

   */

  static TypeId GetTypeId (void);

  /**

   * \brief Return the instance type identifier.

   * \return instance type ID

   */

  virtual TypeId GetInstanceTypeId (void) const;

  virtual void Print (std::ostream& os) const;

  /**

   * \brief Get the serialized size of the packet.

   * \return size

   */

  virtual uint32_t GetSerializedSize (void) const;

  /**

   * \brief Serialize the packet.

   * \param start Buffer iterator

   */

  virtual void Serialize (Buffer::Iterator start) const;

  /**

   * \brief Deserialize the packet.

   * \param start Buffer iterator

   * \return size of the packet

   */

  virtual uint32_t Deserialize (Buffer::Iterator start);

  /**

   * Commands to be used in Rip headers

   */

  enum Command_e

  {

    REQUEST = 0x1,

    RESPONSE = 0x2,

  };

  /**

   * \brief Set the command

   * \param command the command

   */

  void SetCommand (Command_e command);

  /**

   * \brief Get the command

   * \returns the command

   */

  Command_e GetCommand (void) const;

  /**

   * \brief Add a RTE to the message

   * \param rte the RTE

   */

  void AddRte (RipRte rte);

  /**

   * \brief Clear all the RTEs from the header

   */

  void ClearRtes ();

  /**

   * \brief Get the number of RTE included in the message

   * \returns the number of RTE in the message

   */

  uint16_t GetRteNumber (void) const;

  /**

   * \brief Get the list of the RTEs included in the message

   * \returns the list of the RTEs in the message

   */

  std::list<RipRte> GetRteList (void) const;

private:

  uint8_t m_command; //!< command type

  std::list<RipRte> m_rteList; //!< list of the RTEs in the message

};

/**

 * \brief Stream insertion operator.

 *

 * \param os the reference to the output stream

 * \param h the Rip header

 * \returns the reference to the output stream

 */

std::ostream & operator << (std::ostream & os, const RipHeader & h);

}

#endif /* Rip_HEADER_H */

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2016 Universita' di Firenze, Italy

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 * Author: Tommaso Pecorella <tommaso.pecorella@unifi.it>

 */

#include <iomanip>

#include "rip.h"

#include "ns3/log.h"

#include "ns3/abort.h"

#include "ns3/assert.h"

#include "ns3/unused.h"

#include "ns3/random-variable-stream.h"

#include "ns3/ipv4-route.h"

#include "ns3/node.h"

#include "ns3/names.h"

#include "ns3/rip-header.h"

#include "ns3/udp-header.h"

#include "ns3/enum.h"

#include "ns3/uinteger.h"

#include "ns3/ipv4-packet-info-tag.h"

#include "ns3/loopback-net-device.h"

#define RIP_ALL_NODE "224.0.0.9"

#define RIP_PORT 520

namespace ns3 {

NS_LOG_COMPONENT_DEFINE ("Rip");

NS_OBJECT_ENSURE_REGISTERED (Rip);

Rip::Rip ()

  : m_ipv4 (0), m_splitHorizonStrategy (Rip::POISON_REVERSE), m_initialized (false)

{

  m_rng = CreateObject<UniformRandomVariable> ();

}

Rip::~Rip ()

{

}

TypeId

Rip::GetTypeId (void)

{

  static TypeId tid = TypeId ("ns3::Rip")

    .SetParent<Ipv4RoutingProtocol> ()

    .SetGroupName ("Internet")

    .AddConstructor<Rip> ()

    .AddAttribute ("UnsolicitedRoutingUpdate", "The time between two Unsolicited Routing Updates.",

                   TimeValue (Seconds(30)),

                   MakeTimeAccessor (&Rip::m_unsolicitedUpdate),

                   MakeTimeChecker ())

    .AddAttribute ("StartupDelay", "Maximum random delay for protocol startup (send route requests).",

                   TimeValue (Seconds(1)),

                   MakeTimeAccessor (&Rip::m_startupDelay),

                   MakeTimeChecker ())

    .AddAttribute ("TimeoutDelay", "The delay to invalidate a route.",

                   TimeValue (Seconds(180)),

                   MakeTimeAccessor (&Rip::m_timeoutDelay),

                   MakeTimeChecker ())

    .AddAttribute ("GarbageCollectionDelay", "The delay to delete an expired route.",

                   TimeValue (Seconds(120)),

                   MakeTimeAccessor (&Rip::m_garbageCollectionDelay),

                   MakeTimeChecker ())

    .AddAttribute ("MinTriggeredCooldown", "Min cooldown delay after a Triggered Update.",

                   TimeValue (Seconds(1)),

                   MakeTimeAccessor (&Rip::m_minTriggeredUpdateDelay),

                   MakeTimeChecker ())

    .AddAttribute ("MaxTriggeredCooldown", "Max cooldown delay after a Triggered Update.",

                   TimeValue (Seconds(5)),

                   MakeTimeAccessor (&Rip::m_maxTriggeredUpdateDelay),

                   MakeTimeChecker ())

    .AddAttribute ("SplitHorizon", "Split Horizon strategy.",

                   EnumValue (Rip::POISON_REVERSE),

                   MakeEnumAccessor (&Rip::m_splitHorizonStrategy),

                   MakeEnumChecker (Rip::NO_SPLIT_HORIZON, "NoSplitHorizon",

                                    Rip::SPLIT_HORIZON, "SplitHorizon",

                                    Rip::POISON_REVERSE, "PoisonReverse"))

    .AddAttribute ("LinkDownValue", "Value for link down in count to infinity.",

                   UintegerValue (16),

                   MakeUintegerAccessor (&Rip::m_linkDown),

                   MakeUintegerChecker<uint32_t> ())

    ;

  return tid;

}

int64_t Rip::AssignStreams (int64_t stream)

{

  NS_LOG_FUNCTION (this << stream);

  m_rng->SetStream (stream);

  return 1;

}

void Rip::DoInitialize ()

{

  NS_LOG_FUNCTION (this);

  bool addedGlobal = false;

  m_initialized = true;

  Time delay = m_unsolicitedUpdate + Seconds (m_rng->GetValue (0, 0.5*m_unsolicitedUpdate.GetSeconds ()) );

  m_nextUnsolicitedUpdate = Simulator::Schedule (delay, &Rip::SendUnsolicitedRouteUpdate, this);

  for (uint32_t i = 0 ; i < m_ipv4->GetNInterfaces (); i++)

    {

      Ptr<LoopbackNetDevice> check = DynamicCast<LoopbackNetDevice> (m_ipv4->GetNetDevice (i));

      if (check)

        {

          continue;

        }

      bool activeInterface = false;

      if (m_interfaceExclusions.find (i) == m_interfaceExclusions.end ())

        {

          activeInterface = true;

          m_ipv4->SetForwarding (i, true);

        }

      for (uint32_t j = 0; j < m_ipv4->GetNAddresses (i); j++)

        {

          Ipv4InterfaceAddress address = m_ipv4->GetAddress (i, j);

          if (address.GetScope() != Ipv4InterfaceAddress::HOST && activeInterface == true)

            {

              NS_LOG_LOGIC ("RIP: adding socket to " << address.GetLocal ());

              TypeId tid = TypeId::LookupByName ("ns3::UdpSocketFactory");

              Ptr<Node> theNode = GetObject<Node> ();

              Ptr<Socket> socket = Socket::CreateSocket (theNode, tid);

              InetSocketAddress local = InetSocketAddress (address.GetLocal (), RIP_PORT);

              int ret = socket->Bind (local);

              NS_ASSERT_MSG (ret == 0, "Bind unsuccessful");

              socket->BindToNetDevice (m_ipv4->GetNetDevice (i));

              socket->SetIpRecvTtl (true);

              m_sendSocketList[socket] = i;

            }

          else if (m_ipv4->GetAddress (i, j).GetScope() == Ipv4InterfaceAddress::GLOBAL)

            {

              addedGlobal = true;

            }

        }

    }

  if (!m_recvSocket)

    {

      NS_LOG_LOGIC ("RIP: adding receiving socket");

      TypeId tid = TypeId::LookupByName ("ns3::UdpSocketFactory");

      Ptr<Node> theNode = GetObject<Node> ();

      m_recvSocket = Socket::CreateSocket (theNode, tid);

      InetSocketAddress local = InetSocketAddress (RIP_ALL_NODE, RIP_PORT);

      m_recvSocket->Bind (local);

      m_recvSocket->SetRecvCallback (MakeCallback (&Rip::Receive, this));

      m_recvSocket->SetIpRecvTtl (true);

      m_recvSocket->SetRecvPktInfo (true);

    }

  if (addedGlobal)

    {

      Time delay = Seconds (m_rng->GetValue (m_minTriggeredUpdateDelay.GetSeconds (), m_maxTriggeredUpdateDelay.GetSeconds ()));

      m_nextTriggeredUpdate = Simulator::Schedule (delay, &Rip::DoSendRouteUpdate, this, false);

    }

  delay = Seconds (m_rng->GetValue (0.01, m_startupDelay.GetSeconds ()));

  m_nextTriggeredUpdate = Simulator::Schedule (delay, &Rip::SendRouteRequest, this);

  Ipv4RoutingProtocol::DoInitialize ();

}

Ptr<Ipv4Route> Rip::RouteOutput (Ptr<Packet> p, const Ipv4Header &header, Ptr<NetDevice> oif, Socket::SocketErrno &sockerr)

{

  NS_LOG_FUNCTION (this << header << oif);

  Ipv4Address destination = header.GetDestination ();

  Ptr<Ipv4Route> rtentry = 0;

  if (destination.IsMulticast ())

    {

      // Note:  Multicast routes for outbound packets are stored in the

      // normal unicast table.  An implication of this is that it is not

      // possible to source multicast datagrams on multiple interfaces.

      // This is a well-known property of sockets implementation on

      // many Unix variants.

      // So, we just log it and fall through to LookupStatic ()

      NS_LOG_LOGIC ("RouteOutput (): Multicast destination");

    }

  rtentry = Lookup (destination, oif);

  if (rtentry)

    {

      sockerr = Socket::ERROR_NOTERROR;

    }

  else

    {

      sockerr = Socket::ERROR_NOROUTETOHOST;

    }

  return rtentry;

}

bool Rip::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);

  NS_ASSERT (m_ipv4 != 0);

  // Check if input device supports IP

  NS_ASSERT (m_ipv4->GetInterfaceForDevice (idev) >= 0);

  uint32_t iif = m_ipv4->GetInterfaceForDevice (idev);

  Ipv4Address dst = header.GetDestination ();

    if (m_ipv4->IsDestinationAddress (header.GetDestination (), iif))

    {

      if (!lcb.IsNull ())

        {

          NS_LOG_LOGIC ("Local delivery to " << header.GetDestination ());

          lcb (p, header, iif);

          return true;

        }

      else

        {

          // The local delivery callback is null.  This may be a multicast

          // or broadcast packet, so return false so that another

          // multicast routing protocol can handle it.  It should be possible

          // to extend this to explicitly check whether it is a unicast

          // packet, and invoke the error callback if so

          return false;

        }

    }

    if (dst.IsMulticast ())

      {

        NS_LOG_LOGIC ("Multicast route not supported by RIP");

        return false; // Let other routing protocols try to handle this

      }

  if (header.GetDestination ().IsBroadcast ())

    {

      NS_LOG_LOGIC ("Dropping packet not for me and with dst Broadcast");

      if (!ecb.IsNull ())

        {

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

        }

      return false;

    }

  // Check if input device supports IP forwarding

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

    {

      NS_LOG_LOGIC ("Forwarding disabled for this interface");

      if (!ecb.IsNull ())

        {

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

        }

      return false;

    }

  // Next, try to find a route

  NS_LOG_LOGIC ("Unicast destination");

  Ptr<Ipv4Route> rtentry = Lookup (header.GetDestination ());

  if (rtentry != 0)

    {

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

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

      return true;

    }

  else

    {

      NS_LOG_LOGIC ("Did not find unicast destination - returning false");

      return false; // Let other routing protocols try to handle this

    }

}

void Rip::NotifyInterfaceUp (uint32_t i)

{

  NS_LOG_FUNCTION (this << i);

  Ptr<LoopbackNetDevice> check = DynamicCast<LoopbackNetDevice> (m_ipv4->GetNetDevice (i));

  if (check)

    {

      return;

    }

  for (uint32_t j = 0; j < m_ipv4->GetNAddresses (i); j++)

    {

      Ipv4InterfaceAddress address = m_ipv4->GetAddress (i, j);

      Ipv4Mask networkMask = address.GetMask ();

      Ipv4Address networkAddress = address.GetLocal ().CombineMask (networkMask);

      if (address.GetScope () == Ipv4InterfaceAddress::GLOBAL)

        {

          AddNetworkRouteTo (networkAddress, networkMask, i);

        }

    }

  if (!m_initialized)

    {

      return;

    }

  bool sendSocketFound = false;

  for (SocketListI iter = m_sendSocketList.begin (); iter != m_sendSocketList.end (); iter++ )

    {

      if (iter->second == i)

        {

          sendSocketFound = true;

          break;

        }

    }

  bool activeInterface = false;

  if (m_interfaceExclusions.find (i) == m_interfaceExclusions.end ())

    {

      activeInterface = true;

      m_ipv4->SetForwarding (i, true);

    }

  for (uint32_t j = 0; j < m_ipv4->GetNAddresses (i); j++)

    {

      Ipv4InterfaceAddress address = m_ipv4->GetAddress (i, j);

      if (address.GetScope() != Ipv4InterfaceAddress::HOST && sendSocketFound == false && activeInterface == true)

        {

          NS_LOG_LOGIC ("RIP: adding sending socket to " << address.GetLocal ());

          TypeId tid = TypeId::LookupByName ("ns3::UdpSocketFactory");

          Ptr<Node> theNode = GetObject<Node> ();

          Ptr<Socket> socket = Socket::CreateSocket (theNode, tid);

          InetSocketAddress local = InetSocketAddress (address.GetLocal (), RIP_PORT);

          socket->Bind (local);

          socket->BindToNetDevice (m_ipv4->GetNetDevice (i));

          socket->SetIpRecvTtl (true);

          m_sendSocketList[socket] = i;

        }

      if (address.GetScope () == Ipv4InterfaceAddress::GLOBAL)

        {

          SendTriggeredRouteUpdate ();

        }

    }

  if (!m_recvSocket)

    {

      NS_LOG_LOGIC ("RIP: adding receiving socket");

      TypeId tid = TypeId::LookupByName ("ns3::UdpSocketFactory");

      Ptr<Node> theNode = GetObject<Node> ();

      m_recvSocket = Socket::CreateSocket (theNode, tid);

      InetSocketAddress local = InetSocketAddress (RIP_ALL_NODE, RIP_PORT);

      m_recvSocket->Bind (local);

      m_recvSocket->SetRecvCallback (MakeCallback (&Rip::Receive, this));

      m_recvSocket->SetIpRecvTtl (true);

      m_recvSocket->SetRecvPktInfo (true);

    }

}

void Rip::NotifyInterfaceDown (uint32_t interface)

{

  NS_LOG_FUNCTION (this << interface);

  /* remove all routes that are going through this interface */

  for (RoutesI it = m_routes.begin (); it != m_routes.end (); it++)

    {

      if (it->first->GetInterface () == interface)

        {

          InvalidateRoute (it->first);

        }

    }

  for (SocketListI iter = m_sendSocketList.begin (); iter != m_sendSocketList.end (); iter++ )

    {

      NS_LOG_INFO ("Checking socket for interface " << interface);

      if (iter->second == interface)

        {

          NS_LOG_INFO ("Removed socket for interface " << interface);

          iter->first->Close ();

          m_sendSocketList.erase (iter);

          break;

        }

    }

  if (m_interfaceExclusions.find (interface) == m_interfaceExclusions.end ())

    {

      SendTriggeredRouteUpdate ();

    }

}

void Rip::NotifyAddAddress (uint32_t interface, Ipv4InterfaceAddress address)

{

  NS_LOG_FUNCTION (this << interface << address);

  if (!m_ipv4->IsUp (interface))

    {

      return;

    }

  if (m_interfaceExclusions.find (interface) != m_interfaceExclusions.end ())

    {

      return;

    }

  Ipv4Address networkAddress = address.GetLocal ().CombineMask (address.GetMask ());

  Ipv4Mask networkMask = address.GetMask ();

  if (address.GetScope () == Ipv4InterfaceAddress::GLOBAL)

    {

      AddNetworkRouteTo (networkAddress, networkMask, interface);

    }

  SendTriggeredRouteUpdate ();

}

void Rip::NotifyRemoveAddress (uint32_t interface, Ipv4InterfaceAddress address)

{

  NS_LOG_FUNCTION (this << interface << address);

  if (!m_ipv4->IsUp (interface))

    {

      return;

    }

  if (address.GetScope() != Ipv4InterfaceAddress::GLOBAL)

    {

      return;

    }

  Ipv4Address networkAddress = address.GetLocal ().CombineMask (address.GetMask ());

  Ipv4Mask networkMask = address.GetMask ();

  // Remove all routes that are going through this interface

  // which reference this network

  for (RoutesI it = m_routes.begin (); it != m_routes.end (); it++)

    {

      if (it->first->GetInterface () == interface

          && it->first->IsNetwork ()

          && it->first->GetDestNetwork () == networkAddress

          && it->first->GetDestNetworkMask () == networkMask)

        {

          InvalidateRoute (it->first);

        }

    }

  if (m_interfaceExclusions.find (interface) == m_interfaceExclusions.end ())

    {

      SendTriggeredRouteUpdate ();

    }

}

void Rip::SetIpv4 (Ptr<Ipv4> ipv4)

{

  NS_LOG_FUNCTION (this << ipv4);

  NS_ASSERT (m_ipv4 == 0 && ipv4 != 0);

  uint32_t i = 0;

  m_ipv4 = ipv4;

  for (i = 0; i < m_ipv4->GetNInterfaces (); i++)

    {

      if (m_ipv4->IsUp (i))

        {

          NotifyInterfaceUp (i);

        }

      else

        {

          NotifyInterfaceDown (i);

        }

    }

}

void Rip::PrintRoutingTable (Ptr<OutputStreamWrapper> stream) const

{

  NS_LOG_FUNCTION (this << stream);

  std::ostream* os = stream->GetStream ();

  *os << "Node: " << m_ipv4->GetObject<Node> ()->GetId ()

      << ", Time: " << Now().As (Time::S)

      << ", Local time: " << GetObject<Node> ()->GetLocalTime ().As (Time::S)

      << ", IPv4 RIP table" << std::endl;

  if (!m_routes.empty ())

    {

      *os << "Destination     Gateway         Genmask         Flags Metric Ref    Use Iface" << std::endl;

      for (RoutesCI it = m_routes.begin (); it != m_routes.end (); it++)

        {

          RipRoutingTableEntry* route = it->first;

          RipRoutingTableEntry::Status_e status = route->GetRouteStatus();

          if (status == RipRoutingTableEntry::RIP_VALID)

            {

              std::ostringstream dest, gw, mask, flags;

              dest << route->GetDest ();

              *os << std::setiosflags (std::ios::left) << std::setw (16) << dest.str ();

              gw << route->GetGateway ();

              *os << std::setiosflags (std::ios::left) << std::setw (16) << gw.str ();

              mask << route->GetDestNetworkMask ();

              *os << std::setiosflags (std::ios::left) << std::setw (16) << mask.str ();

              flags << "U";

              if (route->IsHost ())

                {

                  flags << "HS";

                }

              else if (route->IsGateway ())

                {

                  flags << "GS";

                }

              *os << std::setiosflags (std::ios::left) << std::setw (6) << flags.str ();

              *os << std::setiosflags (std::ios::left) << std::setw (7) << int(route->GetRouteMetric ());

              // Ref ct not implemented

              *os << "-" << "      ";

              // Use not implemented

              *os << "-" << "   ";

              if (Names::FindName (m_ipv4->GetNetDevice (route->GetInterface ())) != "")

                {

                  *os << Names::FindName (m_ipv4->GetNetDevice (route->GetInterface ()));

                }

              else

                {

                  *os << route->GetInterface ();

                }

              *os << std::endl;

            }

        }

    }

  *os << std::endl;

}

void Rip::DoDispose ()

{

  NS_LOG_FUNCTION (this);

  for (RoutesI j = m_routes.begin ();  j != m_routes.end (); j = m_routes.erase (j))

    {

      delete j->first;

    }

  m_routes.clear ();

  m_nextTriggeredUpdate.Cancel ();

  m_nextUnsolicitedUpdate.Cancel ();

  m_nextTriggeredUpdate = EventId ();

  m_nextUnsolicitedUpdate = EventId ();

  for (SocketListI iter = m_sendSocketList.begin (); iter != m_sendSocketList.end (); iter++ )

    {

      iter->first->Close ();

    }

  m_sendSocketList.clear ();

  m_recvSocket->Close ();

  m_recvSocket = 0;

  m_ipv4 = 0;

  Ipv4RoutingProtocol::DoDispose ();

}

Ptr<Ipv4Route> Rip::Lookup (Ipv4Address dst, Ptr<NetDevice> interface)

{

  NS_LOG_FUNCTION (this << dst << interface);

  Ptr<Ipv4Route> rtentry = 0;

  uint16_t longestMask = 0;

  /* when sending on local multicast, there have to be interface specified */

  if (dst.IsLocalMulticast ())

    {

      NS_ASSERT_MSG (interface, "Try to send on local multicast address, and no interface index is given!");

      rtentry = Create<Ipv4Route> ();

      rtentry->SetSource (m_ipv4->SourceAddressSelection (m_ipv4->GetInterfaceForDevice (interface), dst));

      rtentry->SetDestination (dst);

      rtentry->SetGateway (Ipv4Address::GetZero ());

      rtentry->SetOutputDevice (interface);

      return rtentry;

    }

  for (RoutesI it = m_routes.begin (); it != m_routes.end (); it++)

    {

      RipRoutingTableEntry* j = it->first;

      if (j->GetRouteStatus () == RipRoutingTableEntry::RIP_VALID)

        {

          Ipv4Mask mask = j->GetDestNetworkMask ();

          uint16_t maskLen = mask.GetPrefixLength ();

          Ipv4Address entry = j->GetDestNetwork ();

          NS_LOG_LOGIC ("Searching for route to " << dst << ", mask length " << maskLen);

          if (mask.IsMatch (dst, entry))

            {

              NS_LOG_LOGIC ("Found global network route " << j << ", mask length " << maskLen);

              /* if interface is given, check the route will output on this interface */

              if (!interface || interface == m_ipv4->GetNetDevice (j->GetInterface ()))

                {

                  if (maskLen < longestMask)

                    {

                      NS_LOG_LOGIC ("Previous match longer, skipping");

                      continue;

                    }

                  longestMask = maskLen;

                  Ipv4RoutingTableEntry* route = j;

                  uint32_t interfaceIdx = route->GetInterface ();

                  rtentry = Create<Ipv4Route> ();

                  if (route->GetDest ().IsAny ()) /* default route */

                    {

                      rtentry->SetSource (m_ipv4->SourceAddressSelection (interfaceIdx, route->GetGateway ()));

                    }

                  else

                    {

                      rtentry->SetSource (m_ipv4->SourceAddressSelection (interfaceIdx, route->GetDest ()));

                    }

                  rtentry->SetDestination (route->GetDest ());

                  rtentry->SetGateway (route->GetGateway ());

                  rtentry->SetOutputDevice (m_ipv4->GetNetDevice (interfaceIdx));

                }

            }

        }

    }

  if (rtentry)

    {

      NS_LOG_LOGIC ("Matching route via " << rtentry->GetDestination () << " (through " << rtentry->GetGateway () << ") at the end");

    }

  return rtentry;

}

void Rip::AddNetworkRouteTo (Ipv4Address network, Ipv4Mask networkPrefix, Ipv4Address nextHop, uint32_t interface)

{

  NS_LOG_FUNCTION (this << network << networkPrefix << nextHop << interface);

  RipRoutingTableEntry* route = new RipRoutingTableEntry (network, networkPrefix, nextHop, interface);

  route->SetRouteMetric (1);

  route->SetRouteStatus (RipRoutingTableEntry::RIP_VALID);

  route->SetRouteChanged (true);

  m_routes.push_back (std::make_pair (route, EventId ()));

}

void Rip::AddNetworkRouteTo (Ipv4Address network, Ipv4Mask networkPrefix, uint32_t interface)

{

  NS_LOG_FUNCTION (this << network << networkPrefix << interface);

  RipRoutingTableEntry* route = new RipRoutingTableEntry (network, networkPrefix, interface);

  route->SetRouteMetric (1);

  route->SetRouteStatus (RipRoutingTableEntry::RIP_VALID);

  route->SetRouteChanged (true);

  m_routes.push_back (std::make_pair (route, EventId ()));

}

void Rip::InvalidateRoute (RipRoutingTableEntry *route)

{

  NS_LOG_FUNCTION (this << *route);

  for (RoutesI it = m_routes.begin (); it != m_routes.end (); it++)

    {

      if (it->first == route)

        {

          route->SetRouteStatus (RipRoutingTableEntry::RIP_INVALID);

          route->SetRouteMetric (m_linkDown);

          route->SetRouteChanged (true);

          if (it->second.IsRunning ())

            {

              it->second.Cancel ();

            }

          it->second = Simulator::Schedule (m_garbageCollectionDelay, &Rip::DeleteRoute, this, route);

          return;

        }

    }

  NS_ABORT_MSG ("RIP::InvalidateRoute - cannot find the route to update");

}

void Rip::DeleteRoute (RipRoutingTableEntry *route)

{

  NS_LOG_FUNCTION (this << *route);

  for (RoutesI it = m_routes.begin (); it != m_routes.end (); it++)

    {

      if (it->first == route)

        {

          delete route;

          m_routes.erase (it);

          return;

        }

    }

  NS_ABORT_MSG ("RIP::DeleteRoute - cannot find the route to delete");

}

void Rip::Receive (Ptr<Socket> socket)

{

  NS_LOG_FUNCTION (this << socket);

  Ptr<Packet> packet = socket->Recv ();

  NS_LOG_INFO ("Received " << *packet);

  Ipv4PacketInfoTag interfaceInfo;

  if (!packet->RemovePacketTag (interfaceInfo))

    {

      NS_ABORT_MSG ("No incoming interface on RIP message, aborting.");

    }

  uint32_t incomingIf = interfaceInfo.GetRecvIf ();

  Ptr<Node> node = this->GetObject<Node> ();

  Ptr<NetDevice> dev = node->GetDevice (incomingIf);

  uint32_t ipInterfaceIndex = m_ipv4->GetInterfaceForDevice (dev);

  SocketIpTtlTag hoplimitTag;

  if (!packet->RemovePacketTag (hoplimitTag))

    {

      NS_ABORT_MSG ("No incoming Hop Count on RIP message, aborting.");

    }

  uint8_t hopLimit = hoplimitTag.GetTtl ();

  SocketAddressTag tag;

  if (!packet->RemovePacketTag (tag))

    {

      NS_ABORT_MSG ("No incoming sender address on RIP message, aborting.");

    }

  Ipv4Address senderAddress = InetSocketAddress::ConvertFrom (tag.GetAddress ()).GetIpv4 ();

  uint16_t senderPort = InetSocketAddress::ConvertFrom (tag.GetAddress ()).GetPort ();

  int32_t interfaceForAddress = m_ipv4->GetInterfaceForAddress (senderAddress);

  if (interfaceForAddress != -1)

    {

      NS_LOG_LOGIC ("Ignoring a packet sent by myself.");

      return;

    }

  RipHeader hdr;

  packet->RemoveHeader (hdr);

  if (hdr.GetCommand () == RipHeader::RESPONSE)

    {

      HandleResponses (hdr, senderAddress, ipInterfaceIndex, hopLimit);

    }

  else if (hdr.GetCommand () == RipHeader::REQUEST)

    {

      HandleRequests (hdr, senderAddress, senderPort, ipInterfaceIndex, hopLimit);

    }

  else

    {

      NS_LOG_LOGIC ("Ignoring message with unknown command: " << int (hdr.GetCommand ()));

    }

  return;

}

void Rip::HandleRequests (RipHeader requestHdr, Ipv4Address senderAddress, uint16_t senderPort, uint32_t incomingInterface, uint8_t hopLimit)

{

  NS_LOG_FUNCTION (this << senderAddress << int (senderPort) << incomingInterface << int (hopLimit) << requestHdr);

  std::list<RipRte> rtes = requestHdr.GetRteList ();

  if (rtes.empty ())

    {

      return;

    }

  // check if it's a request for the full table from a neighbor

  if (rtes.size () == 1)

    {

      if (rtes.begin ()->GetPrefix () == Ipv4Address::GetAny () &&

          rtes.begin ()->GetSubnetMask ().GetPrefixLength () == 0 &&

          rtes.begin ()->GetRouteMetric () == m_linkDown)

        {

          // Output whole thing. Use Split Horizon

          if (m_interfaceExclusions.find (incomingInterface) == m_interfaceExclusions.end ())

            {

              // we use one of the sending sockets, as they're bound to the right interface

              // and the local address might be used on different interfaces.

              Ptr<Socket> sendingSoket;

              for (SocketListI iter = m_sendSocketList.begin (); iter != m_sendSocketList.end (); iter++ )

                {

                  if (iter->second == incomingInterface)

                    {

                      sendingSoket = iter->first;

                    }

                }

              NS_ASSERT_MSG (sendingSoket, "HandleRequest - Impossible to find a socket to send the reply");

              uint16_t mtu = m_ipv4->GetMtu (incomingInterface);

              uint16_t maxRte = (mtu - Ipv4Header ().GetSerializedSize () - UdpHeader ().GetSerializedSize () - RipHeader ().GetSerializedSize ()) / RipRte ().GetSerializedSize ();

              Ptr<Packet> p = Create<Packet> ();

              SocketIpTtlTag tag;

              p->RemovePacketTag (tag);

              if (senderAddress == Ipv4Address(RIP_ALL_NODE))

                {

                  tag.SetTtl (1);

                }