How to Begin Implement a Border Gateway Protocol in NS3

To start executing the Border Gateway Protocol (BGP) using NS3 that wants to replicate their inter-domain routing behavior for swapping routing data among the autonomous systems (ASes). Although NS3 doesn’t directly support BGP, we need to make a custom execution by prolonging the routing framework or combining an external library such as Quagga which is a routing software suite.

Below is a step-by-step guide on how to begin executing BGP in NS3:

Overview of BGP

1. Key Features:
   • It functions at Layer 3 for inter-domain routing.
   • Swaps routing data among the ASes.
   • It utilizes path vector routing for avoiding loops.
2. Components:
   • BGP Peers: Routers are set up for swapping BGP messages.
   • BGP Messages: It contains Open, Update, Keepalive, and Notification messages.
   • Routing Table: Saves BGP routes including path attributes.

Steps to Implement BGP in ns3

1. Set Up ns3 Environment

1. Install ns3:
   • We should download and set up ns3 on the system.
   • Confirm installation by executing a simple instance script as./waf –run hello-simulator.
2. Include Required Modules:
   • Make sure that we have contained necessary modules such as internet, ipv4, applications, and csma.

2. Understand BGP Protocol Logic

1. BGP Sessions:
   • Introduce TCP links among the BGP peers.
   • Swap routing data via BGP Update messages.
2. Path Attributes:
   • Every single route contains attributes such as AS path, next-hop IP, and route preference.
   • For route selection, we can utilize these attributes.
3. Route Selection:
   • Desire shortest AS path.
   • Make use of policy-based routing decisions as needed.

3. Create a Custom BGP Implementation
4. Define BGP Protocol Class

Make a new class, which manages the message exchange and route processing for BGP:

class BgpRoutingProtocol : public Ipv4RoutingProtocol {

public:

static TypeId GetTypeId();

BgpRoutingProtocol();

virtual ~BgpRoutingProtocol();

// Override required methods

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

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

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

Ptr<const NetDevice> idev, UnicastForwardCallback ucb,

MulticastForwardCallback mcb, LocalDeliverCallback lcb,

ErrorCallback ecb) override;

void NotifyInterfaceUp(uint32_t interface) override;

void NotifyInterfaceDown(uint32_t interface) override;

void NotifyAddAddress(uint32_t interface, Ipv4InterfaceAddress address) override;

void NotifyRemoveAddress(uint32_t interface, Ipv4InterfaceAddress address) override;

void SetIpv4(Ptr<Ipv4> ipv4) override;

void EstablishBgpSession(Ipv4Address peerAddress, uint16_t localAs, uint16_t peerAs);

void ProcessBgpUpdateMessage(Ptr<Packet> packet);

private:

Ptr<Ipv4> m_ipv4;

std::map<Ipv4Address, uint16_t> m_peerAs; // Mapping of peers to their AS

std::vector<Ipv4Route> m_routingTable;   // BGP routing table

};

1. Implement BGP Session Management

1. Establish TCP Sessions:
   • Launch a TCP links among the BGP peers utilising a socket.

void BgpRoutingProtocol::EstablishBgpSession(Ipv4Address peerAddress, uint16_t localAs, uint16_t peerAs) {

Ptr<Socket> socket = Socket::CreateSocket(GetObject<Node>(), TcpSocketFactory::GetTypeId());

socket->Connect(InetSocketAddress(peerAddress, 179)); // BGP runs on port 179

m_peerAs[peerAddress] = peerAs;

}

1. Send BGP Messages:
   • Execute functions to transmit Open, Update, Keepalive, and Notification messages of BGP.

void BgpRoutingProtocol::SendBgpUpdate(Ipv4Address destination, Ipv4Address nextHop, uint16_t asPath) {

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

// Add BGP Update header and attributes

socket->Send(packet);

}

1. Handle Received Messages:
   • Analyse incoming BGP messages and modernize the routing table.

void BgpRoutingProtocol::ProcessBgpUpdateMessage(Ptr<Packet> packet) {

// Parse the packet and update routing table

}

1. BGP Route Selection

Execute the logic, according to the BGP path attributes choosing the optimal path:

1. Shortest AS Path:
   • Desire routes including the shortest AS path.
2. Policy-Based Routing:
   • Execute routing policies like filtering or prioritization rules.

4. Set Up Network Topology

1. Create Nodes:
   • Make a network topology that contains nodes to denote the routers and hosts.

NodeContainer routers, hosts;

routers.Create(3); // Three routers in different ASes

hosts.Create(2);   // Two end-hosts

1. Configure Links:
   • Apply PointToPointHelper or CsmaHelper for inter-router and host-router connections.

PointToPointHelper p2p;

p2p.SetDeviceAttribute(“DataRate”, StringValue(“10Mbps”));

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

NetDeviceContainer routerLinks1 = p2p.Install(routers.Get(0), routers.Get(1));

NetDeviceContainer routerLinks2 = p2p.Install(routers.Get(1), routers.Get(2));

1. Install Network Stack:
   • Integrate the network stack and custom BGP protocol.

InternetStackHelper internet;

Ptr<BgpRoutingProtocol> bgp = CreateObject<BgpRoutingProtocol>();

internet.SetRoutingHelper(bgp);

internet.Install(routers);

1. Assign IP Addresses:
   • Allocate an IP addresses to every connections.

Ipv4AddressHelper ipv4;

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

ipv4.Assign(routerLinks1);

ipv4.SetBase(“10.1.2.0”, “255.255.255.0”);

ipv4.Assign(routerLinks2);

5. Simulate Traffic

1. Install Applications:
   • Replicate the traffic leveraging applications such as UdpEchoServer and UdpEchoClient.

UdpEchoServerHelper echoServer(9);

ApplicationContainer serverApps = echoServer.Install(hosts.Get(1)); // Server at Host 2

serverApps.Start(Seconds(1.0));

serverApps.Stop(Seconds(10.0));

UdpEchoClientHelper echoClient(Ipv4Address(“10.1.2.1”), 9); // Client at Host 1

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

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

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

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

clientApps.Start(Seconds(2.0));

clientApps.Stop(Seconds(10.0));

1. Monitor Traffic:
   • Examine received packets with PacketSink for observing the traffic.

6. Enable Tracing

1. Enable PCAP:
   • Seize packet traces for detailed analysis.

p2p.EnablePcapAll(“bgp-protocol”);

1. Enable ASCII Logging:
   • Record BGP session establishment and route updates.

AsciiTraceHelper ascii;

p2p.EnableAsciiAll(ascii.CreateFileStream(“bgp-protocol.tr”));

1. FlowMonitor:
   • Estimate the performance parameters such as latency, throughput, and route convergence time using FlowMonitor.

FlowMonitorHelper flowmon;

Ptr<FlowMonitor> monitor = flowmon.InstallAll();

7. Run and Analyze the Simulation

1. Run the Simulation:

Simulator::Run();

Simulator::Destroy();

1. Analyze Results:
   • Measure the performance of BGP protocol to apply PCAP files and FlowMonitor data.
   • Leverage NetAnim to envision the routing behaviour of BGP.

AnimationInterface anim(“bgp-protocol.xml”);

8. Extend and Optimize

1. Policy-Based Routing:
   • Integrate logic for routing strategies such as route filtering or prioritization.
2. Scalability:
   • Experiment the protocol including several ASes within large-scale topologies.
3. Integration with Quagga:
   • Mimic BGP behavior in ns3 using Quagga for advanced realistic execution.

Example Use Cases

• Inter-Domain Routing:
  • Replicate the realistic internet-like topologies including ASes exchanging routes.
• Policy Enforcement:
  • For certain traffic engineering objectives, experiment BGP policy sets up.
• Failure Recovery:
  • Examine the behaviour of BGP replying to link or node failures.

By using a simple implementation method in NS3, Border Gateway Protocol was executed and analyzed, also we extend it and offered sample use cases of this protocol. More details will be provided as needed.