How to Begin Implement Path Vector Routing in NS3

To begin the Path Vector Routing is a routing protocol in which every router advertises paths such as a sequence of nodes or ASes to its neighbor. It is normally used in protocols such as BGP (Border Gateway Protocol), in which the path is state a sequence of AS numbers.

Here’s a step-by-step guide to implementing Path Vector Routing in NS-3:

Steps to Begin Implement Path Vector Routing in NS3

Step 1: Understand Path Vector Routing

1. Key Concepts:
   • Each node maintains:
     • A path vector table has including the paths for all recognised destinations.
     • Every path contains the sequence of nodes or ASes.
   • Nodes are modifying the path vector tables by neighbors.
   • Bring up-to-date are made to prevent the loops and select the best path according to their policy or metrics.
2. Comparison with Distance Vector:
   • In Distance Vector, only the cost of destination is distributed.
   • In Path Vector, distribute the full path for a destination.
3. Path Vector Workflow:
   • Nodes are beginning their tables by direct connections.
   • A node is modifying the path vectors have periodically or on bring up-to-date.
   • Nodes are reject routes which involves themselves such as loop prevention.

Step 2: Set Up NS-3

1. Install NS-3:

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

cd ns-3-dev

./ns3 configure –enable-examples –enable-tests

./ns3 build

1. Verify Installation: Run a sample script:

./ns3 run examples/tutorial/first

Step 3: Plan the Protocol Design

1. Core Components:
   • Path Vector Table: Register the paths for every destination.
   • Update Exchange: Periodically has replaced the path vector information by neighbors.
   • Path Validation: Eliminate the loops and select the paths according to the policies.
2. Implementation Workflow:
   • Start the table by direct neighbors.
   • Alter the path vector bring up-to-date through neighbors.
   • Keep informed the path vector table according to their received updates.
   • According to select the path for transmitting the packets.

Step 4: Implement Path Vector Routing

Step 4.1: Define the Protocol Class

Encompass the Ipv4RoutingProtocol class:

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

#include “ns3/socket.h”

#include <map>

#include <vector>

using namespace ns3;

class PathVectorRouting : public Ipv4RoutingProtocol {

public:

static TypeId GetTypeId(void);

PathVectorRouting();

virtual ~PathVectorRouting();

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

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

virtual bool RouteInput(Ptr<const Packet> packet, 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;

private:

struct PathEntry {

std::vector<Ipv4Address> path; // Sequence of nodes in the path

Ipv4Address nextHop;          // Next hop to reach the destination

uint32_t cost;                // Path cost (optional)

};

void InitializePathVectorTable();

void SendPathVectorUpdates();

void ReceivePathVectorUpdates(Ptr<Socket> socket);

void UpdatePathVectorTable(Ipv4Address neighbor, const std::map<Ipv4Address, PathEntry> &neighborTable);

std::map<Ipv4Address, PathEntry> m_pathVectorTable; // Destination -> PathEntry

Ptr<Socket> m_socket;

};

Step 4.2: Implement Core Functions

• Path Vector Table Initialization: Populate the table by direct neighbors.

void PathVectorRouting::InitializePathVectorTable() {

for (uint32_t i = 0; i < GetNode()->GetNDevices(); ++i) {

Ptr<NetDevice> device = GetNode()->GetDevice(i);

Ipv4Address address = GetNode()->GetObject<Ipv4>()->GetAddress(i, 0).GetLocal();

m_pathVectorTable[address] = {{address}, address, 0}; // Direct connection, cost 0

}

}

• Send Path Vector Updates: Periodically has propagation path vector bring up-to-date to neighbors.

void PathVectorRouting::SendPathVectorUpdates() {

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

for (const auto &entry : m_pathVectorTable) {

// Serialize path vector table entries into packet

}

for (uint32_t i = 0; i < GetNode()->GetNDevices(); ++i) {

Ptr<NetDevice> device = GetNode()->GetDevice(i);

m_socket->SendTo(packet, 0, InetSocketAddress(Ipv4Address(“255.255.255.255”), 520));

}

Simulator::Schedule(Seconds(10.0), &PathVectorRouting::SendPathVectorUpdates, this);

}

• Update the Path Vector Table: Bring up-to-date the table terms on received updates for eliminate the loop.

void PathVectorRouting::UpdatePathVectorTable(Ipv4Address neighbor,

const std::map<Ipv4Address, PathEntry> &neighborTable) {

for (const auto &entry : neighborTable) {

Ipv4Address dest = entry.first;

PathEntry newEntry = entry.second;

// Check for loops

if (std::find(newEntry.path.begin(), newEntry.path.end(),

GetNode()->GetObject<Ipv4>()->GetAddress(1, 0).GetLocal()) != newEntry.path.end()) {

continue; // Skip paths that include the current node

}

// Update path vector table

uint32_t newCost = newEntry.cost + 1; // Increment cost

if (m_pathVectorTable.find(dest) == m_pathVectorTable.end() || newCost < m_pathVectorTable[dest].cost) {

newEntry.path.push_back(GetNode()->GetObject<Ipv4>()->GetAddress(1, 0).GetLocal());

m_pathVectorTable[dest] = {newEntry.path, neighbor, newCost};

}

}

}

• Packet Forwarding: Forward packets based on the path vector table.

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

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

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

auto it = m_pathVectorTable.find(header.GetDestination());

if (it != m_pathVectorTable.end()) {

route->SetDestination(header.GetDestination());

route->SetGateway(it->second.nextHop); // Use next hop from path vector table

route->SetOutputDevice(oif);

}

return route;

}

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

Ptr<const NetDevice> idev, UnicastForwardCallback ucb,

MulticastForwardCallback mcb, LocalDeliverCallback lcb,

ErrorCallback ecb) {

if (header.GetDestination() == GetNode()->GetObject<Ipv4>()->GetAddress(1, 0).GetLocal()) {

lcb(packet, header, idev); // Deliver locally

return true;

}

auto it = m_pathVectorTable.find(header.GetDestination());

if (it != m_pathVectorTable.end()) {

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

route->SetDestination(header.GetDestination());

route->SetGateway(it->second.nextHop); // Use next hop from path vector table

ucb(route, packet, header);

return true;

}

return false;

}

Step 5: Register the Protocol

1. TypeId Registration:

TypeId PathVectorRouting::GetTypeId(void) {

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

.SetParent<Ipv4RoutingProtocol>()

.SetGroupName(“Internet”)

.AddConstructor<PathVectorRouting>();

return tid;

}

Step 6: Integrate into a Simulation

1. Simulation Script Example:

#include “ns3/internet-stack-helper.h”

#include “ns3/path-vector-routing.h”

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

NodeContainer nodes;

nodes.Create(4);

PointToPointHelper p2p;

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

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

NetDeviceContainer devices = p2p.Install(nodes.Get(0), nodes.Get(1));

devices.Add(p2p.Install(nodes.Get(1), nodes.Get(2)));

devices.Add(p2p.Install(nodes.Get(2), nodes.Get(3)));

InternetStackHelper stack;

Ptr<PathVectorRouting> pathVectorRouting = CreateObject<PathVectorRouting>();

stack.SetRoutingHelper(pathVectorRouting);

stack.Install(nodes);

Simulator::Run();

Simulator::Destroy();

return 0;

}

Step 7: Test and Debug

1. Enable Logging:

export NS_LOG=”PathVectorRouting=level_all|prefix_time”

./ns3 run my-simulation

1. Verify Results:
   • Inspection the path vector updates.
   • Prove the packet forwarding terms on their paths.

Step 8: Extend and Optimize

1. Enhancements:
   • Choose for the path has improved the policies for instance shortest path, preferred nodes.
   • It contains the performance of parameter metrics such as bandwidth or delay in path decisions.
2. Performance Testing:
   • Validate the larger networks by alter the dynamic topology.

In this above demonstration shows various examples for Path Vector Routing projects that were executed using the ns3 simulation tool. Further assistance regarding the project will be provided in another manual.