Ns3 Projects for B.E/B.Tech M.E/M.Tech PhD Scholars.  Phone-Number:9790238391   E-mail: ns3simulation@gmail.com

How to Implement Next Hop protocol in ns3

For implementing custom Next Hop protocol, first we should create a basic routing protocol which decides the next hop on the basis predefined or dynamic method. Here is a complete guide on setting up a basic next hop routing protocol, which includes custom logic for next hop selection.

Steps for implementing a Custom Next Hop Protocol in ns3

  1. Set up your environment

Make sure that ns3 is installed in the computer. If not, install it from the official ns3 website.

  1. Create a new ns3 module

On your ns3 installation, create a new module in the src directory for the custom next Hop protocol. For this, you have to create the necessary directory structure and files.

cd ns-3.xx

cd src

mkdir -p next-hop-protocol/model

mkdir -p next-hop-protocol/helper

  1. Create the layer 3 routed protocol header file

In the model directory, create the header file next-hop-routing-protocol.h  for the next Hop routing protocol.

#ifndef NEXT_HOP_ROUTING_PROTOCOL_H

#define NEXT_HOP_ROUTING_PROTOCOL_H

#include “ns3/ipv4-routing-protocol.h”

#include “ns3/ipv4-address.h”

#include “ns3/timer.h”

#include “ns3/mobility-model.h”

#include “ns3/node.h”

#include “ns3/net-device.h”

#include “ns3/ipv4.h”

#include “ns3/ipv4-routing-table-entry.h”

#include <map>

namespace ns3 {

class NextHopRoutingProtocol : public Ipv4RoutingProtocol

{

public:

  static TypeId GetTypeId (void);

  NextHopRoutingProtocol ();

  virtual ~NextHopRoutingProtocol ();

  // Inherited from Ipv4RoutingProtocol

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

  virtual bool RouteInput (Ptr<const Packet> p, const Ipv4Header &header, Ptr<const NetDevice> idev,

                           UnicastForwardCallback ucb, MulticastForwardCallback mcb, LocalDeliverCallback lcb, ErrorCallback ecb);

  virtual void NotifyInterfaceUp (uint32_t interface);

  virtual void NotifyInterfaceDown (uint32_t interface);

  virtual void NotifyAddAddress (uint32_t interface, Ipv4InterfaceAddress address);

  virtual void NotifyRemoveAddress (uint32_t interface, Ipv4InterfaceAddress address);

  virtual void SetIpv4 (Ptr<Ipv4> ipv4);

  virtual void PrintRoutingTable (Ptr<OutputStreamWrapper> stream) const;

private:

  Ptr<Ipv4> m_ipv4;

  std::map<Ipv4Address, Ipv4RoutingTableEntry> m_routingTable;

  Ptr<NetDevice> GetNetDevice (uint32_t interface);

  Ptr<MobilityModel> GetMobilityModel (Ptr<NetDevice> netDevice);

  Ipv4Address GetNextHop (Ipv4Address dest);

};

} // namespace ns3

#endif /* NEXT_HOP_ROUTING_PROTOCOL_H */

  1. Create the Layer 3 Routed Protocol Source File

In the model directory, create the source file next-hop-routing-protocol.cc for the next Hop routing protocol.

#include “next-hop-routing-protocol.h”

#include “ns3/log.h”

#include “ns3/ipv4-route.h”

#include “ns3/simulator.h”

namespace ns3 {

NS_LOG_COMPONENT_DEFINE (“NextHopRoutingProtocol”);

NS_OBJECT_ENSURE_REGISTERED (NextHopRoutingProtocol);

TypeId

NextHopRoutingProtocol::GetTypeId (void)

{

  static TypeId tid = TypeId (“ns3::NextHopRoutingProtocol”)

    .SetParent<Ipv4RoutingProtocol> ()

    .SetGroupName(“Internet”)

    .AddConstructor<NextHopRoutingProtocol> ();

  return tid;

}

NextHopRoutingProtocol::NextHopRoutingProtocol ()

{

}

NextHopRoutingProtocol::~NextHopRoutingProtocol ()

{

}

void

NextHopRoutingProtocol::SetIpv4 (Ptr<Ipv4> ipv4)

{

  m_ipv4 = ipv4;

}

Ptr<NetDevice>

NextHopRoutingProtocol::GetNetDevice (uint32_t interface)

{

  return m_ipv4->GetNetDevice (interface);

}

Ptr<MobilityModel>

NextHopRoutingProtocol::GetMobilityModel (Ptr<NetDevice> netDevice)

{

  return netDevice->GetNode ()->GetObject<MobilityModel> ();

}

Ipv4Address

NextHopRoutingProtocol::GetNextHop (Ipv4Address dest)

{

  // Simplified example of next hop selection

  if (m_routingTable.find(dest) != m_routingTable.end())

    {

      return m_routingTable[dest].GetGateway();

    }

  return Ipv4Address::GetBroadcast ();

}

Ptr<Ipv4Route>

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

{

  Ipv4Address dest = header.GetDestination ();

  Ipv4Address nextHop = GetNextHop (dest);

  if (nextHop == Ipv4Address::GetBroadcast ())

    {

      sockerr = Socket::ERROR_NOROUTETOHOST;

      return nullptr;

    }

  Ptr<Ipv4Route> route = Create<Ipv4Route> ();

  route->SetDestination (dest);

  route->SetGateway (nextHop);

  route->SetOutputDevice (m_ipv4->GetNetDevice (m_ipv4->GetInterfaceForAddress (nextHop)));

  return route;

}

bool

NextHopRoutingProtocol::RouteInput (Ptr<const Packet> p, const Ipv4Header &header, Ptr<const NetDevice> idev,

                                    UnicastForwardCallback ucb, MulticastForwardCallback mcb, LocalDeliverCallback lcb, ErrorCallback ecb)

{

  Ipv4Address dest = header.GetDestination ();

  Ipv4Address nextHop = GetNextHop (dest);

  if (nextHop == Ipv4Address::GetBroadcast ())

    {

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

      return false;

    }

  Ptr<Ipv4Route> route = Create<Ipv4Route> ();

  route->SetDestination (dest);

  route->SetGateway (nextHop);

  route->SetOutputDevice (m_ipv4->GetNetDevice (m_ipv4->GetInterfaceForAddress (nextHop)));

  ucb (route, p, header);

  return true;

}

void

NextHopRoutingProtocol::NotifyInterfaceUp (uint32_t interface)

{

}

void

NextHopRoutingProtocol::NotifyInterfaceDown (uint32_t interface)

{

}

void

NextHopRoutingProtocol::NotifyAddAddress (uint32_t interface, Ipv4InterfaceAddress address)

{

}

void

NextHopRoutingProtocol::NotifyRemoveAddress (uint32_t interface, Ipv4InterfaceAddress address)

{

}

void

NextHopRoutingProtocol::PrintRoutingTable (Ptr<OutputStreamWrapper> stream) const

{

  *stream->GetStream () << “Next Hop Routing Table” << std::endl;

  for (auto const &entry : m_routingTable)

    {

      *stream->GetStream () << entry.first << ” -> ” << entry.second.GetGateway () << ” via ” << entry.second.GetInterface () << std::endl;

    }

}

} // namespace ns3

  1. Define Layer 3 Helper

In the helper directory, create the helper header file next-hop-helper.h for the next Hop.

#ifndef NEXT_HOP_HELPER_H

#define NEXT_HOP_HELPER_H

#include “ns3/ipv4-routing-helper.h”

#include “next-hop-routing-protocol.h”

namespace ns3 {

class NextHopHelper : public Ipv4RoutingHelper

{

public:

  NextHopHelper ();

  virtual ~NextHopHelper ();

  NextHopHelper* Copy (void) const;

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

};

} // namespace ns3

#endif /* NEXT_HOP_HELPER_H */

Create the next hop helper source file next-hop-helper.cc in the helper directory.

#include “next-hop-helper.h”

#include “ns3/node.h”

#include “ns3/ipv4.h”

namespace ns3 {

NextHopHelper::NextHopHelper ()

{

}

NextHopHelper::~NextHopHelper ()

{

}

NextHopHelper*

NextHopHelper::Copy (void) const

{

  return new NextHopHelper (*this);

}

Ptr<Ipv4RoutingProtocol>

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

{

  Ptr<NextHopRoutingProtocol> nextHopRouting = CreateObject<NextHopRoutingProtocol> ();

  node->AggregateObject (nextHopRouting);

  return nextHopRouting;

} // namespace ns3

  1. Update CMakeLists.txt

In the ns3 build system, add a new next Hop module. Edit src/CMakeLists.txt and add the following line:

add_subdirectory (next-hop-protocol)

Create src/next-hop-protocol/CMakeLists.txt with the following content:

ns3_add_library (next-hop-protocol

    model/next-hop-routing-protocol.cc

    helper/next-hop-helper.cc

)

target_link_libraries (next-hop-protocol)

  1. Set up the network topology

To use the next Hop protocol, create a simulation script in the scratch directory.

#include “ns3/core-module.h”

#include “ns3/network-module.h”

#include “ns3/internet-module.h”

#include “ns3/point-to-point-module.h”

#include “ns3/applications-module.h”

#include “ns3/mobility-module.h”

#include “next-hop-helper.h”

using namespace ns3;

int main (int argc, char *argv[])

{

  CommandLine cmd;

  cmd.Parse (argc, argv);

  NodeContainer nodes;

  nodes.Create (10);

  // Set up WiFi

  WifiHelper wifi;

  wifi.SetStandard (WIFI_PHY_STANDARD_80211b);

  YansWifiPhyHelper wifiPhy = YansWifiPhyHelper::Default ();

  YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default ();

  wifiPhy.SetChannel (wifiChannel.Create ());

  WifiMacHelper wifiMac;

  wifiMac.SetType (“ns3::AdhocWifiMac”);

  NetDeviceContainer devices = wifi.Install (wifiPhy, wifiMac, nodes);

  // Set up mobility model

  MobilityHelper mobility;

  Ptr<UniformRandomVariable> random = CreateObject<UniformRandomVariable> ();

  mobility.SetPositionAllocator (“ns3::RandomRectanglePositionAllocator”,

                                 “MinX”, DoubleValue (0.0),

                                 “MinY”, DoubleValue (0.0),

                                 “MaxX”, DoubleValue (100.0),

                                 “MaxY”, DoubleValue (100.0));

  mobility.SetMobilityModel (“ns3::RandomWaypointMobilityModel”,

                             “Speed”, StringValue (“ns3::ConstantRandomVariable[Constant=20.0]”),

                             “Pause”, StringValue (“ns3::ConstantRandomVariable[Constant=0.0]”),

                             “PositionAllocator”, StringValue (“ns3::RandomRectanglePositionAllocator[MinX=0.0|MinY=0.0|MaxX=100.0|MaxY=100.0]”));

  mobility.Install (nodes);

  // Install the internet stack on nodes

  InternetStackHelper stack;

  NextHopHelper nextHop;

  stack.SetRoutingHelper (nextHop);

  stack.Install (nodes);

  // Assign IP addresses to the devices

  Ipv4AddressHelper address;

  address.SetBase (“10.1.1.0”, “255.255.255.0”);

  Ipv4InterfaceContainer interfaces = address.Assign (devices);

  // Set up applications (e.g., a UDP echo server and client)

  UdpEchoServerHelper echoServer (9);

  ApplicationContainer serverApps = echoServer.Install (nodes.Get (9));

  serverApps.Start (Seconds (1.0));

  serverApps.Stop (Seconds (10.0));

  UdpEchoClientHelper echoClient (interfaces.GetAddress (9), 9);

  echoClient.SetAttribute (“MaxPackets”, UintegerValue (1));

  echoClient.SetAttribute (“Interval”, TimeValue (Seconds (1.0)));

  echoClient.SetAttribute (“PacketSize”, UintegerValue (1024));

  ApplicationContainer clientApps = echoClient.Install (nodes.Get (0));

  clientApps.Start (Seconds (2.0));

  clientApps.Stop (Seconds (10.0));

  // Enable tracing

  AsciiTraceHelper ascii;

  wifiPhy.EnableAsciiAll (ascii.CreateFileStream (“next-hop-simulation.tr”));

  wifiPhy.EnablePcapAll (“next-hop-simulation”);

  // Run the simulation

  Simulator::Run ();

  Simulator::Destroy ();

  return 0;

}

  1. Build and run the simulation

Build and run your script after writing.

./waf build

./waf –run scratch/next-hop-simulation

  1. Analyze the results

You can analyze the results after running the simulation, by using the generated trace files (next-hop-simulation.tr and next-hop-simulation-0-0.pcap).

Example script for Next Hop protocol

Below is the example script for your reference:

#include “ns3/core-module.h”

#include “ns3/network-module.h”

#include “ns3/internet-module.h”

#include “ns3/wifi-module.h”

#include “ns3/mobility-module.h”

#include “ns3/applications-module.h”

#include “next-hop-helper.h”

using namespace ns3;

int main (int argc, char *argv[])

{

  CommandLine cmd;

  cmd.Parse (argc, argv);

  NodeContainer nodes;

  nodes.Create (10);

  // Set up WiFi

  WifiHelper wifi;

  wifi.SetStandard (WIFI_PHY_STANDARD_80211b);

  YansWifiPhyHelper wifiPhy = YansWifiPhyHelper::Default ();

  YansWifiChannelHelper wifiChannel = YansWifiChannelHelper::Default ();

  wifiPhy.SetChannel (wifiChannel.Create ());

  WifiMacHelper wifiMac;

  wifiMac.SetType (“ns3::AdhocWifiMac”);

  NetDeviceContainer devices = wifi.Install (wifiPhy, wifiMac, nodes);

  // Set up mobility model

  MobilityHelper mobility;

  Ptr<UniformRandomVariable> random = CreateObject<UniformRandomVariable> ();

  mobility.SetPositionAllocator (“ns3::RandomRectanglePositionAllocator”,

                                 “MinX”, DoubleValue (0.0),

                                 “MinY”, DoubleValue (0.0),

                                 “MaxX”, DoubleValue (100.0),

                                 “MaxY”, DoubleValue (100.0));

  mobility.SetMobilityModel (“ns3::RandomWaypointMobilityModel”,

                             “Speed”, StringValue (“ns3::ConstantRandomVariable[Constant=20.0]”),

                             “Pause”, StringValue (“ns3::ConstantRandomVariable[Constant=0.0]”),

                             “PositionAllocator”, StringValue (“ns3::RandomRectanglePositionAllocator[MinX=0.0|MinY=0.0|MaxX=100.0|MaxY=100.0]”));

  mobility.Install (nodes);

  // Install the internet stack on nodes

  InternetStackHelper stack;

  NextHopHelper nextHop;

  stack.SetRoutingHelper (nextHop);

  stack.Install (nodes);

  // Assign IP addresses to the devices

  Ipv4AddressHelper address;

  address.SetBase (“10.1.1.0”, “255.255.255.0”);

  Ipv4InterfaceContainer interfaces = address.Assign (devices);

  // Set up applications (e.g., a UDP echo server and client)

  UdpEchoServerHelper echoServer (9);

  ApplicationContainer serverApps = echoServer.Install (nodes.Get (9));

  serverApps.Start (Seconds (1.0));

  serverApps.Stop (Seconds (10.0));

  UdpEchoClientHelper echoClient (interfaces.GetAddress (9), 9);

  echoClient.SetAttribute (“MaxPackets”, UintegerValue (1));

  echoClient.SetAttribute (“Interval”, TimeValue (Seconds (1.0)));

  echoClient.SetAttribute (“PacketSize”, UintegerValue (1024));

  ApplicationContainer clientApps = echoClient.Install (nodes.Get (0));

  clientApps.Start (Seconds (2.0));

  clientApps.Stop (Seconds (10.0));

  // Enable tracing

  AsciiTraceHelper ascii;

  wifiPhy.EnableAsciiAll (ascii.CreateFileStream (“next-hop-simulation.tr”));

  wifiPhy.EnablePcapAll (“next-hop-simulation”);

  // Run the simulation

  Simulator::Run ();

  Simulator::Destroy ();

  return 0;

}

Overall, we had learned on implementing a custom “Next Hop Protocol” in ns-3 with creating a simple routing protocol that decides the next hop based on a predefined or dynamic method by our simulation results. Also, we have provided more information on Next Hop protocol so if you are in desperate need of help for simulation then reach out for us.