More on ns2

So far we've looked at running simulations in ns2 and then view the outputs of the simulation in nam
This is fine for visualization what is going on for certain kinds of network traffic, but it is hard to get statistics that might be used for a paper from this.
Today, we are going to look at how to get statistical data directly out of an ns2 trace file.
To begin let's look at a simple tcl script which was adapted from a script at the University of Alexandria:

ns2 script with ftp, cbr traffic.

set ns [new Simulator]


#open trace files for writing
set tf [open out.tr w]
set nf [open out.nam w]
$ns trace-all $tf
$ns namtrace-all $nf

proc finish {} {
    global ns nf tf
        $ns flush-trace
        close $tf
        close $nf
    #close trace files
        exit 0
}

#Create nodes
set n0 [$ns node]
set n1 [$ns node]
set n2 [$ns node]
set n3 [$ns node]

#Create link between nodes
$ns duplex-link $n0 $n2 2Mb 10ms DropTail
$ns duplex-link $n1 $n2 2Mb 10ms DropTail
$ns duplex-link $n2 $n3 1.7Mb 20ms DropTail

#Set Queue Size of link (n2-n3) to 10
$ns queue-limit $n2 $n3 10

#Set up a TCP connection
set tcp [new Agent/TCP]
$tcp set class_ 2
$ns attach-agent $n0 $tcp
set sink [new Agent/TCPSink]
$ns attach-agent $n3 $sink
$ns connect $tcp $sink
$tcp set fid_ 1

#Setup a Ftp over TCP connection
set ftp [new Application/FTP]
$ftp attach-agent $tcp
$ftp set type_ FTP

#Set up a UDP connection
set udp [new Agent/UDP]
$ns attach-agent $n1 $udp
set null [new Agent/Null]
$ns attach-agent $n3 $null
$ns connect $udp $null
$udp set fid_ 2

set cbr [new Application/Traffic/CBR]
$cbr attach-agent $udp
$cbr set type_ CBR
$cbr set packet_size_ 1000
$cbr set rate_ 1mb
$cbr set random_ false

#Schedule event for our traffic
$ns at 0.1 "$cbr start"
$ns at 1.0 "$ftp start"
$ns at 4.0 "$ftp stop"
$ns at 4.5 "$cbr stop"

$ns at 5.0 "finish"
$ns run

Some Remarks on the Script

Notice how we attach the ftp agent to the tcp agent, so that we get ftp running over tcp.
fid_ == flow id
This script output two files: out.tr, a trace file; and out.nam, a file readable by nam for visualization.
You can trace a subset of the events using a command like:
```
$ns trace-queue $n2 $n3 $file1
```
Here's a screenshot from nam for this example:

The ns2 trace file format

Here is a brief snippet out of the out.tr tracefile, slightly after the 1 second mark so that we can we both the cbr and tcp traffic:

r 1.109002 2 3 cbr 1000 ------- 2 1.0 3.1 121 125
r 1.113896 2 3 tcp 1040 ------- 1 0.0 3.0 2 124
+ 1.113896 3 2 ack 40 ------- 1 3.0 0.0 2 132
- 1.113896 3 2 ack 40 ------- 1 3.0 0.0 2 132
r 1.114 1 2 cbr 1000 ------- 2 1.0 3.1 125 129
+ 1.114 2 3 cbr 1000 ------- 2 1.0 3.1 125 129
- 1.114 2 3 cbr 1000 ------- 2 1.0 3.1 125 129
+ 1.116 1 2 cbr 1000 ------- 2 1.0 3.1 127 133

More ns2 trace file format

The first character on the line is an event descriptor. It is one of r (receive), + (enqueue), - (dequeue), d (drop).
The next float is the time of the event.
This is followed by the from and to nodes
Then one has the packet type and packet size.

The hyphens can contain a list of flags. These are:

    "-": disable
    1st = "E": ECN (Explicit Congestion Notification) echo is enabled.
    2nd = "P": the priority in the IP header is enabled.
    3rd : Not in use
    4th = "A": Congestion action
    5th = "E": Congestion has occurred.
    6th = "F": The TCP fast start is used.
    7th = "N": Explicit Congestion Notification (ECN) is on.

Next we have the flow id, followed by the source and destination address (node.port).
Finally, we have the network sequence address and the unique id for the packet.
Recall we can also directly write things into the trace file using a command like:
```
$ns at $time "$ns trace-annotate \"My comment\""
```
Such a line would might look like:
```
v $time eval {set sim_annotation {My Comment}}
```
in the trace file.

Mining trace files

It is common to write scripts to read such trace files, and keep running statistic of the number of rows in the file that have certain properties.
Commonly, grep and awk are used to do this.
grep is a unix command. It can be use from the command line with a syntax like:
```
grep "regex" input_file_name > output_file_name
```
It looks at each line of the input file and checks if it matches the given regular expression. If it does it outputs that line to its output. With the redirect above, that would be to output_file_name.

Here are some examples:

grep "0 2 tcp" out.tr > node12.tr  
   #only packets going from node 0 to 2
grep "^r" out.tr > received.tr 
   #only lines starting with r i.e., received lines
grep "^r" out.tr | grep "tcp 1040" > received.tr 
   #only received tcp packets with size 1040

Mining trace file -- awk

AWK is a general purpose language for text-based processing developed by Aho, Weinberger and Kernighan at AT&T in the 1970s.

AWK can be run from the command line with a syntax like:

awk -f my_code.awk my_data.txt

or

awk -f my_code.awk my_data.txt > my_output.txt

In the first case, output would be to the console. In the second case to my_output.txt.
my_code.awk should contain an AWK program and my_data.txt should be the file you want to process.

AWK code

A typical AWK program consists of a sequence of lines of the form:
```
/pattern/ {action}
```
Here pattern is a regular expression and action is some kind of command.
AWK looks through the input file line-by-line. When it finds a line that matches the pattern, it performs the commands given by action.

There are a few special cases to the general line format give above:

BEGIN {action }   
   # executes action commands before processing any of the file
END {action } 
   # executes action commands after processing the file
/pattern/ 
   # (no action) prints the line
{ action } 
   #(no pattern) executes the command for each line of the input

For example, the following code could be used to echo up to the first field separator (space) of each line of a file:
```
{print $1}
```
$0 - wholeline, $n - nth field

More awk examples

# use tab rather than space as a field separator (FS)
# compute the average length of first field
BEGIN {FS = "\t"}
{nl++}
{s=s+length($1)}
END{ print "average = " s/nl}

Beside FS, other built-in variables include NR - number of records (lines), RS - record separator (what should end a line), FILENAME - name of the data file, NF - number of fields in a record, OFS - output field separator, ORS -output record separator, OFMT - the format for numeric output

#As another example - compute
# the number of lines, number of words, and the number of char's in a file
{w += NF; c += length}
END {print NR, w, c}

Associative Arrays in AWK

# computes word frequencies in a doc
BEGIN { FS = "[^a-zA-Z]+"}
{ for(i = 1; i < NF; i++)
    words[tolower($i)]++
} 
END { for (i in words)
    print i, words[i]
}

Associative Arrays in AWK

function Square(number, temp) {
   temp = number * number
   return temp
}
END {print Square(9)}

Notice in the argument list we include local variables of the function; however, when we call the function we just give the value for the non-local variables.

An example of an AWK script for use with an NS-2 trace file

# Script to compute the packet loss rate between
# nodes 1,2 for the application having the flow id = 2
#
BEGIN {
#fsDrops : packets dropped.  numFS: packets sent
    fsDrops = 0;
    numFs = 0;
}
{
    action = $1;
    time = $2;
    from = $3;
    to =  $4;
    type = $5;
    pktsize = $6;
    flags = $7;
    flow_id = $8
    src = $9;
    dst = $10;
    seq_no = $11;
    packet_id = $12;

    if(from == 1 && to == 2 && action = "+") numFs++;
    if(flow_id == 2 && action == "d") fsDrops++;
}
END {
   printf("number of packets sent:%d lost %d\n", numFs, fsDrops);
}

Error Reporting (ICMP)

IP is perfectly willing to drop datagrams -- for instance, if the router does not know how to forward the datagram or when one fragment of a datagram fails to arrive at the destination.
IP does not always fail silently.
It is configured with a companion protocol known as ICMP (Internet Control Message Protocol) that defines a collection of error messages that are sent back to the source host whenever a router or host is unable to process an IP datagram successfully.
For example, ICMP defines error messages indicating that the destination host is unreachable, that the reassembly process failed, that the TTL has reached 0, that the IP header checksum failed, and so on.
ICMP can also send some control messages from a router back to a host. One example of this is an ICMP-Redirect, which tells the host that a better route to a destination exists.

Virtual Networks and Tunnels

So far, we have been interested in making it possible for nodes on different networks to communicate.
Sometimes it is useful to be able to only allow a subset of the nodes in the Internet to communicate in what is called a virtual private network (VPN).
The key building block for a VPN is an IP Tunnel. This is a virtual point-to-point link between a pair of nodes that are actually separated by an arbitrary number of networks.
Such a link has a router at the entrance to the tunnel and a router at the exit of the tunnel.
Whenever the entrance router wants to send data over the link it encapsulates it in an IP packet with a destination IP address of the router on the other end of the tunnel.
So if the original data was an IP datagram, we might encapsulate this datagram in a IP datagram destined for the end of the tunnel.
The routing table entry for a VPN link looks like a standard routing table entry.
Several tunnels can be stuck together to build up a virtual network.

Why bother to use tunnels?

Tunnels can be combined with encryption so that the traffic over the VPN cannot be read by everyone on the internet.
The VPN routers might be able to support protocols (MBone multicast) that standard routers do not.
It allows one to carry packets from different protocols across an IP network.

More ns2; More Internetworks

Outline

More on ns2

ns2 script with ftp, cbr traffic.

Some Remarks on the Script

The ns2 trace file format

More ns2 trace file format

Mining trace files

Mining trace file -- awk

AWK code

More awk examples

Associative Arrays in AWK

Associative Arrays in AWK

An example of an AWK script for use with an NS-2 trace file

Error Reporting (ICMP)

Virtual Networks and Tunnels

Why bother to use tunnels?