How to Begin Implement a Intra Domain Protocol in NS3

To implement an intra-domain routing protocols in NS3 which are used to transmit in a single administrative domain like network organization. Samples are contain OSPF (Open Shortest Path First) and IS-IS (Intermediate System to Intermediate System). NS3 has restricted inherit support for certain intra-domain protocols, external tools such as Quagga or FRRouting can be combined for a more comprehensive simulation.

Below is a step-by-step guide on how to begin executing an intra-domain routing protocol in ns3:

Steps to Begin Implement a Intra Domain Protocol in NS3

1. Understand Intra-Domain Protocols

• Key Features:
  • It functions in a single autonomous system (AS).
  • Apply link-state or distance-vector mechanisms.
  • Instances:
    • OSPF: It is a link-state routing protocol including hierarchical areas.
    • IS-IS: Link-state protocol supports for both IP and non-IP routing.
• Simulation Goals:
  • Estimate the performance of routing in an AS.
  • Verify network performance parameters such as convergence time, routing overhead, and throughput.

2. Set Up ns3 Environment

1. Install ns3:

git clone https://gitlab.com/nsnam/ns-3-dev.git

cd ns-3-dev

./build.py

1. Confirm the installation:

./ns3 run hello-simulator

3. Plan the Network Topology

• Components:
  • Routers are executing the intra-domain protocol.
  • Subnets and hosts for data traffic.
• Topology:
  • Routers’ hierarchical or flat structure that are associated by links.

4. Implementation Steps for Specific Protocols
5. OSPF using Quagga Integration

1. Install Quagga

sudo apt install quagga

1. Configure OSPF in Quagga
   • For OSPF (ospfd.conf) and Zebra (zebra.conf), we can make configuration files.

Example ospfd.conf:

router ospf

network 10.0.0.0/8 area 0

Example zebra.conf:

hostname Router

password zebra

enable password zebra

1. Set Up Topology in ns3

ns3::NodeContainer routers, hosts;

routers.Create(3);  // Three routers

hosts.Create(2);    // Two hosts

ns3::PointToPointHelper p2p;

p2p.SetDeviceAttribute(“DataRate”, ns3::StringValue(“1Gbps”));

p2p.SetChannelAttribute(“Delay”, ns3::StringValue(“2ms”));

ns3::NetDeviceContainer devices;

devices.Add(p2p.Install(routers.Get(0), routers.Get(1)));  // R1-R2

devices.Add(p2p.Install(routers.Get(1), routers.Get(2)));  // R2-R3

devices.Add(p2p.Install(routers.Get(0), hosts.Get(0)));    // R1-Host1

devices.Add(p2p.Install(routers.Get(2), hosts.Get(1)));    // R3-Host2

1. Integrate Quagga with ns3
   • Connect ns3 nodes including Quagga routers using TapBridgeHelper.

ns3::TapBridgeHelper tapBridge;

tapBridge.SetAttribute(“Mode”, ns3::StringValue(“UseLocal”));

tapBridge.Install(routers.Get(0), devices.Get(0));

1. Generate Traffic Adhere to the steps outlined to create UDP or TCP traffic among the hosts.
2. Run the Simulation

ns3::Simulator::Run();

ns3::Simulator::Destroy();

1. Custom Intra-Domain Protocol

1. Define the Routing Protocol
   • Describe the protocol which is obtain from Ipv4RoutingProtocol.
   • Execute the mechanisms like RouteOutput and RouteInput.

Example Skeleton:

class IntraDomainRoutingProtocol : public ns3::Ipv4RoutingProtocol {

public:

IntraDomainRoutingProtocol() {}

virtual ~IntraDomainRoutingProtocol() {}

Ptr<Ipv4Route> RouteOutput(Ptr<Packet> packet, const Ipv4Header &header,

Ptr<NetDevice> oif, Socket::SocketErrno &sockerr) override {

// Add custom routing logic

return nullptr;

}

bool RouteInput(Ptr<const Packet> packet, const Ipv4Header &header,

Ptr<const NetDevice> idev, UnicastForwardCallback ucb,

MulticastForwardCallback mcb, LocalDeliverCallback lcb,

ErrorCallback ecb) override {

// Handle incoming packets

return false;

}

};

1. Integrate the Protocol
   • Make a helper class for the protocol combination.

class IntraDomainRoutingHelper : public Ipv4RoutingHelper {

public:

Ptr<Ipv4RoutingProtocol> Create(Ptr<Node> node) const override {

return CreateObject<IntraDomainRoutingProtocol>();

}

};

1. • Leverage helper for setting up the protocol:

IntraDomainRoutingHelper intraDomainRouting;

InternetStackHelper stack;

stack.SetRoutingHelper(intraDomainRouting);

stack.Install(routers);

5. Assign IP Addresses

ns3::Ipv4AddressHelper address;

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

address.Assign(devices);

6. Generate Traffic

UDP Traffic

ns3::UdpEchoServerHelper echoServer(9);

ns3::ApplicationContainer serverApp = echoServer.Install(hosts.Get(1));

serverApp.Start(ns3::Seconds(1.0));

serverApp.Stop(ns3::Seconds(20.0));

ns3::UdpEchoClientHelper echoClient(address.Assign(devices.Get(1)).GetAddress(1), 9);

echoClient.SetAttribute(“MaxPackets”, ns3::UintegerValue(10));

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

echoClient.SetAttribute(“PacketSize”, ns3::UintegerValue(512));

ns3::ApplicationContainer clientApp = echoClient.Install(hosts.Get(0));

clientApp.Start(ns3::Seconds(2.0));

clientApp.Stop(ns3::Seconds(20.0));

7. Analyze Results

Metrics:

• Packet Delivery Ratio (PDR):
  • Estimate the percentage of packets which are effectively distributed to total transmitted packets.
• Routing Overhead:
  • During the simulation, count the volume of control packets that are generated.
• Convergence Time:
  • Compute the duration to become stable for routing tables.

Tracing and Visualization:

• Allow .pcap tracing:

ns3::AsciiTraceHelper ascii;

p2p.EnableAsciiAll(ascii.CreateFileStream(“intra-domain.tr”));

p2p.EnablePcapAll(“intra-domain”);

• For visualization, we need to utilize NetAnim:

./waf –run “intra-domain-simulation –vis”

8. Iterate and Enhance

• Advanced Scenarios:
  • Replicate the link or router failures for evaluating the flexibility of protocol.
  • Examine the scalability by experimenting with larger topologies.
• Compare Protocols:
  • Assess the OSPF, IS-IS, and custom protocols performance in same scenarios.
• Custom Extensions:
  • Fine-tune existing protocol logic or enhance advanced aspects.

With NS3 environment, we created a comprehensive execution mechanism for implementing and analysing the Intra Domain Protocol and we can expand it further for added clarity upon request.