How to Implement DTN Protocols in NS2

 

To implement the Delay-Tolerant Network (DTN) protocols in NS2, we have to build a network scenario that can manage high latency, interruptions and intermittent connectivity-usual characteristics of DTNs. We need to make alterations or expand the ns2 to replicate DTN actions because ns2 was only developed for old-fashioned networks with stable end-to-end routes.

The following procedure has the instruction of DTN protocol’s implementation in ns2:

Step-by-Step Implementation:

Step 1: Understand DTN Protocol Characteristics

DTN protocols are developed to perform in environments where there is no assurance of a stable, end-to-end connection. Vital characteristics such as:

  • Store-and-Forward: Nodes store data until they can direct it to the next hop.
  • Custody Transfer: Nodes may take custody of a message, making sure its delivery even if the sender becomes inaccessible.
  • Fragmentation: Messages may be disjointed to permit partial delivery when full delivery is not possible.
  • Routing: DTN routing frequently involves forwarding data according to the devious encounters or forecast contacts.

Step 2: Set Up NS2

Make sure to install the ns2 on your computer. Due to ns2 can’t support DTNs, we need to execute or replicate the DTN actions manually.

Step 3: Implement DTN Protocols in C++

  1. Create a Basic DTN Agent Class

The DTN agent class will manage the store-and-forward features, custody transfer, and routing depends on the devious encounters.

#include <agent.h>

#include <packet.h>

#include <trace.h>

#include <address.h>

#include <queue>

#include <map>

class DTNAgent : public Agent {

public:

DTNAgent();

void recv(Packet* p, Handler* h);

void sendMessage(Packet* p);

void handleCustodyTransfer(Packet* p);

void forwardMessages();

protected:

std::queue<Packet*> messageQueue_; // Queue to store messages

std::map<int, Packet*> custodyMessages_; // Map to track custody messages

std::map<int, int> routingTable_; // Destination -> Next Hop

};

// Constructor

DTNAgent::DTNAgent() : Agent(PT_UDP) {

// Initialize routing table or other necessary structures

}

// Packet reception

void DTNAgent::recv(Packet* p, Handler* h) {

hdr_ip* iph = hdr_ip::access(p);

if (iph->daddr() == addr()) {

// Packet is for this node; process it

} else if (iph->ttl() <= 0) {

// Drop packet if TTL has expired

drop(p);

} else {

// Store the packet and attempt to forward it later

messageQueue_.push(p);

forwardMessages();

}

}

// Handle custody transfer messages

void DTNAgent::handleCustodyTransfer(Packet* p) {

hdr_ip* iph = hdr_ip::access(p);

int msgID = iph->flowid(); // Example: Use flow ID as message ID

if (custodyMessages_.find(msgID) == custodyMessages_.end()) {

custodyMessages_[msgID] = p->copy();

}

}

// Attempt to forward stored messages

void DTNAgent::forwardMessages() {

while (!messageQueue_.empty()) {

Packet* p = messageQueue_.front();

messageQueue_.pop();

hdr_ip* iph = hdr_ip::access(p);

int dest = iph->daddr();

if (routingTable_.find(dest) != routingTable_.end()) {

int nextHop = routingTable_[dest];

send(p, nextHop);

} else {

// Re-store the packet if no route is found

messageQueue_.push(p);

}

}

}

// Send a message to the next hop

void DTNAgent::sendMessage(Packet* p) {

// Handle the actual sending of the message

forwardMessages();

}

  1. Define Packet Types and Structures

You might need to state custom packet types for DTN-specific operations like custody transfer:

#define PT_DTN_CUSTODY 51

// Add this to the packet.h file in NS2’s source code

packet_t PT_DTN_CUSTODY;

You will also need to alter ns-default.tcl to identify these packet types.

  1. Integrate the Protocol into NS2
  1. Modify the Makefile: Attach your new DTNAgent class to the NS2 Makefile so that it gets compiled with the remains of the simulator.
  2. Recompile NS2:

make clean

make

Step 4: Create a Tcl Script to Simulate the DTN Protocol

After the protocol is executed and compiled, generate a Tcl script to replicate a DTN environment.

Example Tcl Script:

# Create a simulator object

set ns [new Simulator]

# Define the topology

set val(chan)   Channel/WirelessChannel

set val(prop)   Propagation/TwoRayGround

set val(netif)  Phy/WirelessPhy

set val(mac)    Mac/802_11

set val(ifq)    Queue/DropTail/PriQueue

set val(ifqlen) 50

set val(stop)   100.0

# Initialize the topology object

set topo [new Topography]

$topo load_flatgrid 1000 1000

# Create nodes

for {set i 0} {$i < 10} {incr i} {

set node_($i) [$ns node]

}

# Define node positions

$node_(0) set X_ 100.0

$node_(0) set Y_ 200.0

$node_(1) set X_ 300.0

$node_(1) set Y_ 400.0

# … Define the rest of the node positions

# Attach DTN agents to nodes

for {set i 0} {$i < 10} {incr i} {

set dtn_($i) [new Agent/DTNAgent]

$ns attach-agent $node_($i) $dtn_($i)

}

# Set up traffic sources and sinks

set udp [new Agent/UDP]

set null [new Agent/Null]

$ns attach-agent $node_(0) $udp

$ns attach-agent $node_(9) $null

$ns connect $udp $null

# Start sending data from node 0 to node 9

$ns at 0.0 “$udp start”

# Simulation end

$ns at $val(stop) “stop”

$ns at $val(stop) “exit 0”

proc stop {} {

global ns

$ns flush-trace

exit 0

}

# Run the simulation

$ns run

Step 5: Run the Simulation

  1. Save the Tcl script (dtn_protocol_simulation.tcl).
  2. Open a terminal and navigate to the directory where you saved the Tcl script.
  3. Execute the simulation using the given command:

ns dtn_protocol_simulation.tcl

Step 6: Analyze the Results

  • Use trace files and the network animator (NAM) to assess the performance of your DTN protocol, concentrates on metrics like message delivery ratio, latency, and how well the protocol manages disconnected or intermittently linked networks.
  • Compute the effectiveness of the store-and-forward mechanism and custody transmit in making certain message delivery.

Additional Considerations

  • Mobility: Monitor how the DTN protocol adjusts to differences in network topology by replicating node mobility.
  • Scalability: Investigate DTN protocol in larger networks with more nodes and changing levels of connectivity.
  • Optimization: Consider executing optimizations like priority-based forwarding, adaptive message fragmentation, or prediction-based routing.

Through this approach, we offered the overall information regarding the implementation of Network DTN protocol using ns2 tool by generating the network topology and defining the node’s positions. If needed, we can offer extra details of these protocol and their functions. To use DTN Protocols in NS2, visit ns2project.com. We can assist you with new ideas and topics.