The trace support for wireless simulations currently use cmu-trace objects. In the future this shall be extended to merge with trace and monitoring support available in ns, which would also include nam support for wireless modules. For now we will explain briefly with cmu-trace objects and how they may be used to trace packets for wireless scenarios.
The cmu-trace objects are of three types - CMUTrace/Drop, CMUTrace/Recv and CMUTrace/Send. These are used for tracing packets that are dropped, received and sent by agents, routers, mac layers or interface queues in . The methods and procedures used for implementing wireless trace support can be found under trace.{cc,h} and tcl/lib/ns-cmutrace.tcl.
A cmu-trace object may be created by the following API:
set sndT [cmu-trace Send "RTR" $self]which creates a trace object, sndT, of the type CMUTrace/Send for tracing all packets that are sent out in a router. The trace objects may be used to trace packets in MAC, agents (routing or others), routers or any other NsObject.
The cmu-trace object CMUTrace is derived from the base class Trace. See Chapter 21 for details on class Trace. The class CMUTrace is defined as the following:
class CMUTrace : public Trace {
public:
CMUTrace(const char *s, char t);
void recv(Packet *p, Handler *h);
void recv(Packet *p, const char* why);
private:
int off_arp_;
int off_mac_;
int off_sr_;
char tracename[MAX_ID_LEN + 1];
int tracetype;
MobileNode *node_;
int initialized() { return node_ && 1; }
int command(int argc, const char*const* argv);
void format(Packet *p, const char *why);
void format_mac(Packet *p, const char *why, int offset);
void format_ip(Packet *p, int offset);
void format_arp(Packet *p, int offset);
void format_dsr(Packet *p, int offset);
void format_msg(Packet *p, int offset);
void format_tcp(Packet *p, int offset);
void format_rtp(Packet *p, int offset);
};
The type field (described in Trace class definition) is used to differentiate among different types of traces. For cmu-trace this can be s for sending, r for receiving or D for dropping a packet. A fourth type f is used to denote forwarding of a packet (When the node is not the originator of the packet). Similar to the method Trace::format(), the CMUTrace::format() defines and dictates the trace file format. The method is shown below:
void CMUTrace::format(Packet* p, const char *why)
{
hdr_cmn *ch = HDR_CMN(p);
int offset = 0;
/*
* Log the MAC Header
*/
format_mac(p, why, offset);
offset = strlen(wrk_);
switch(ch-\>ptype()) {
case PT_MAC:
break;
case PT_ARP:
format_arp(p, offset);
break;
default:
format_ip(p, offset);
offset = strlen(wrk_);
switch(ch-\>ptype()) {
case PT_DSR:
format_dsr(p, offset);
break;
case PT_MESSAGE:
case PT_UDP:
format_msg(p, offset);
break;
case PT_TCP:
case PT_ACK:
format_tcp(p, offset);
break;
case PT_CBR:
format_rtp(p, offset);
break;
..........
}
}
}
The above function calls different format functions depending on the type
of the packet being traced. All traces are written to the buffer wrk_. A
count of the offset for the buffer is kept and is passed along the
different trace functions. The most basic format is defined by
format_mac() and is used to trace all pkt types. The other format
functions print additional information as defined by the packet types. The
mac format prints the following:
\#ifdef LOG_POSITION
double x = 0.0, y = 0.0, z = 0.0;
node_-\>getLoc(&x, &y, &z);
\#endif
sprintf(wrk_ + offset,
\#ifdef LOG_POSITION
"%c %.9f %d (%6.2f %6.2f) %3s %4s %d %s %d [%x %x %x %x] ",
\#else
"%c %.9f _%d_ %3s %4s %d %s %d [%x %x %x %x] ",
\#endif
op, // s, r, D or f
Scheduler::instance().clock(), // time stamp
src_, // the nodeid for this node
\#ifdef LOG_POSITION
x, // x co-ord
y, // y co-ord
\#endif
tracename, // name of object type tracing
why, // reason, if any
ch-\>uid(), // identifier for this event
packet_info.name(ch-\>ptype()), // packet type
ch-\>size(), // size of cmn header
mh-\>dh_duration, // expected time to send data
ETHER_ADDR(mh-\>dh_da), // mac_destination address
ETHER_ADDR(mh-\>dh_sa), // mac_sender address
GET_ETHER_TYPE(mh-\>dh_body)); // type - arp or IP
If the LOG_POSITION is defined the x and y co-ordinates for the mobilenode is also printed. The descriptions for different fields in the mac trace are given in the comments above. For all IP packets additional IP header fields are also added to the above trace. The IP trace is described below:
sprintf(wrk_ + offset, "------- [%d:%d %d:%d %d %d] ",
src, // IP src address
ih-\>sport_, // src port number
dst, // IP dest address
ih-\>dport_, // dest port number
ih-\>ttl_, // TTL value
(ch-\>next_hop_ \< 0) ? 0 : ch-\>next_hop_); // next hopaddress, if any.
An example of a trace for a tcp packet is as follows:
r 160.093884945 _6_ RTR --- 5 tcp 1492 [a2 4 6 800] ------- [655 36:0 16777984:0 31 16777984] [1 0] 2 0Here we see a TCP data packet being received by a node with id of 6. UID of this pkt is 5 with a cmn hdr size of 1492. The mac details shows an IP pkt (ETHERTYPE_IP is defined as 0x0800, ETHERTYPE_IP is 0x0806 ), mac-id of this receiving node is 6. That of the sending node is 4 and expected time to send this data pkt over the wireless channel is a2 (hex2dec conversion: 160+2 sec). Additionally, IP traces information about IP src and destination addresses. The src translates (using a 3 level hier-address of 8/8/8) to a address string of 0.1.0 with port of 0. The dest address is 1.0.3 with port address of 0. The TTL value is 31 and the destination was a hop away from the src. Additionally TCP format prints information about tcp seqno of 1, ackno of 0. See other formats described in /cmu-trace.cc for DSR, UDP/MESSAGE, TCP/ACK and CBR packet types.
Other trace formats are also used by the routing agents (TORA and DSR) to log certain special routing events like "originating" (adding a SR header to a packet) or "ran off the end of a source route" indicating some sort of routing problem with the source route etc. These special event traces begin with "S" for DSR and "T" for Tora and may be found in tora/tora.cc for TORA and dsr/dsrgent.cc for DSR routing agent.