How to Implement Network Telnet in NS2

To implement a Telnet network simulation in NS2, we would replicate the Telnet traffic among nodes using TCP (while Telnet performs over TCP). The main aim is to mimic the communication among a Telnet client and server, with the data transfer among the nodes being denoted as Telnet traffic.

For guidance on any type of Network Telnet implementation in NS2, please do not hesitate to reach out to us. We are committed to delivering optimal results for your needs.

The below is a guide to implement the Telnet in ns2:

Step-by-Step Implementation:

  1. Set up the Basic Network Topology

Identical to the SSH simulation, we initiate by generating nodes and links among them. While Telnet is a TCP-based protocol, we replicate TCP traffic among two nodes to denote a Telnet connection.

Example Tcl Script for Telnet Simulation:

# Create a simulator object

set ns [new Simulator]

# Define the trace file for analysis

set tracefile [open out.tr w]

$ns trace-all $tracefile

# Define the animation file for visualization in NAM

set namfile [open out.nam w]

$ns namtrace-all $namfile

# Create nodes (Telnet client and server)

set n0 [$ns node]

set n1 [$ns node]

# Create a duplex link between the nodes

$ns duplex-link $n0 $n1 1Mb 10ms DropTail

# Set up queue limit

$ns queue-limit $n0 $n1 50

# Define TCP agent (Telnet operates over TCP)

set tcp0 [new Agent/TCP]

$ns attach-agent $n0 $tcp0

set sink [new Agent/TCPSink]

$ns attach-agent $n1 $sink

# Connect TCP agent to the sink (representing Telnet session)

$ns connect $tcp0 $sink

# Create a Telnet-like application using a Traffic Generator

set telnet [new Application/Telnet]

$telnet attach-agent $tcp0

# Set the parameters for the Telnet traffic

$telnet set type_ Telnet

$telnet set packetSize_ 512   # Typical Telnet packet size

$telnet set interval_ 0.01    # Sending interval (to simulate typing or command input)

$telnet set random_ false     # No randomization for Telnet traffic

# Schedule Telnet traffic between nodes

$ns at 0.5 “$telnet start”

$ns at 4.5 “$telnet stop”

# Set the end of simulation

$ns at 5.0 “finish”

# Procedure to end simulation

proc finish {} {

global ns tracefile namfile

$ns flush-trace

close $tracefile

close $namfile

exec nam out.nam &

exit 0

}

# Start the simulation

$ns run

Explanation of the Script:

  1. Node Creation:
    • Two nodes are generated, that denotes the Telnet client (n0) and the Telnet server (n1).
  2. Link Setup:
    • A duplex link is configuring among the client and server with a bandwidth of 1Mb and a latency of 10ms.
  3. TCP Setup:
    • Telnet uses the TCP protocol for reliable interaction, so the TCP agent is attached to the nodes to mimic a Telnet session.
  4. Traffic Generation:
    • A Telnet-like application is attached to the TCP agent using NS2’s Application/Telnet (a basic traffic generator to mimic Telnet traffic).
    • The traffic generator’s packet size is set to 512 bytes, and the interval between packets is 0.01 seconds to mimic user typing or command comunication in a Telnet session.
  5. Simulation Scheduling:
    • The Telnet traffic initiates at 0.5 seconds and terminate at 4.5 seconds.
    • The simulation terminates at 5.0 seconds, and the output is saved in trace and NAM files for further analysis.
  1. Running the Simulation
  • Save the script with a .tcl extension, like telnet_simulation.tcl.
  • execute the simulation using NS2 by implementing the following command in terminal:

ns telnet_simulation.tcl

  • This will generate two output files:
    1. out.tr (trace file): Contains comprehensive network event traces such as packet sending, receiving, dropping, etc.
    2. out.nam (NAM file): Used for network animation.

We can envision the simulation in NAM (Network Animator) using the following command:

nam out.nam

  1. Adjusting Parameters
  • We can adjust numerous metrics, like link bandwidth, packet sizes, and the interval to replicate diverse Telnet network conditions like slow or fast typing.
  • For example, increasing the link latency will mimic Telnet performance over long-distance networks or high-latency connections.
  1. Analysing Simulation Output
  • We can evaluate the output in the trace file to acquire information on packet transmission and reception. Use the trace file to estimate parameters like throughput, latency, and packet loss that are critical for evaluating the performance of Telnet.
  1. Visualizing the Telnet Session
  • Using NAM, we can envision the Telnet traffic as it is transferred among the client and server nodes that demonstrated the packets being sent and received during the session.

In this process, we had covered the details about Telnet network implementation procedures and how to evaluate the Telnet network outcomes across the ns2 tool. Further details regarding the Telnet network will be provided in upcoming manuals.