开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 通讯编程 > 查看源码
cmu-trace.cc
资源名称：ns-allinone-2.33.tar.gz　[点击查看]
上传用户：rrhhcc
上传日期：2015-12-11
资源大小：54129k
文件大小：39k
源码类别：

通讯编程

开发平台：

Visual C++

cmu-trace.cc：源码内容
  1. /* -*- Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */
  2. /*
  3.  * Copyright (c) 1997 Regents of the University of California.
  4.  * All rights reserved.
  5.  *
  6.  * Redistribution and use in source and binary forms, with or without
  7.  * modification, are permitted provided that the following conditions
  8.  * are met:
  9.  * 1. Redistributions of source code must retain the above copyright
  10.  *    notice, this list of conditions and the following disclaimer.
  11.  * 2. Redistributions in binary form must reproduce the above copyright
  12.  *    notice, this list of conditions and the following disclaimer in the
  13.  *    documentation and/or other materials provided with the distribution.
  14.  * 3. All advertising materials mentioning features or use of this software
  15.  *    must display the following acknowledgement:
  16.  * This product includes software developed by the Computer Systems
  17.  * Engineering Group at Lawrence Berkeley Laboratory.
  18.  * 4. Neither the name of the University nor of the Laboratory may be used
  19.  *    to endorse or promote products derived from this software without
  20.  *    specific prior written permission.
  21.  *
  22.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32.  * SUCH DAMAGE.
  33.  *
  34.  * Ported from CMU/Monarch's code, appropriate copyright applies.
  35.  * nov'98 -Padma.
  36.  *
  37.  * $Header: /cvsroot/nsnam/ns-2/trace/cmu-trace.cc,v 1.92 2008/02/18 03:39:03 tom_henderson Exp $
  38.  */
  40. #include <packet.h>
  41. #include <ip.h>
  42. #include <tcp.h>
  43. #include <sctp.h>
  44. #include <rtp.h>
  45. #include <arp.h>
  46. #include <dsr/hdr_sr.h> // DSR
  47. #include <mac.h>
  48. #include <mac-802_11.h>
  49. #include <smac.h>
  50. #include <address.h>
  51. #include <tora/tora_packet.h> //TORA
  52. #include <imep/imep_spec.h>         // IMEP
  53. #include <aodv/aodv_packet.h> //AODV
  54. #include <cmu-trace.h>
  55. #include <mobilenode.h>
  56. #include <simulator.h>
  57. //<zheng: add for 802.15.4>
  58. #include "wpan/p802_15_4pkt.h"
  59. #include "wpan/p802_15_4trace.h"
  60. #include "wpan/p802_15_4nam.h"
  61. //</zheng: add for 802.15.4>
  63. #include "diffusion/diff_header.h" // DIFFUSION -- Chalermek
  66. PacketTracer::PacketTracer() : next_(0)
  67. {
  68. }
  69. void PacketTracer::setNext(PacketTracer *next)
  70. {
  71. next_ = next;
  72. }
  74. PacketTracer::~PacketTracer()
  75. {
  76. }
  78. PacketTracer *PacketTracer::getNext()
  79. {
  80. return next_;
  81. }
  83. int PacketTracer::format_unknow(Packet *p, int offset, BaseTrace *pt, int newtrace)
  84. {
  85. return (format(p, offset, pt, newtrace) || (next_ && next_->format_unknow(p, offset, pt, newtrace)));
  86. }
  88. PacketTracer *CMUTrace::pktTrc_ = 0;
  90. void CMUTrace::addPacketTracer(PacketTracer *pt)
  91. {
  92. if(!pt)
  93. return;
  94. pt->setNext(pktTrc_);
  95. pktTrc_ = pt;
  96. }
  99. //#define LOG_POSITION
  101. //extern char* pt_names[];
  103. static class CMUTraceClass : public TclClass {
  104. public:
  105. CMUTraceClass() : TclClass("CMUTrace") { }
  106. TclObject* create(int, const char*const* argv) {
  107. return (new CMUTrace(argv[4], *argv[5]));
  108. }
  109. } cmutrace_class;
  112. //<zheng: ns 2.27 removed the following part, but we need it to control the broadcast radius>
  113. double CMUTrace::bradius = 0.0;
  114. double CMUTrace::radius_scaling_factor_ = 0.0;
  115. double CMUTrace::duration_scaling_factor_ = 0.0;
  116. //</zheng>
  118. CMUTrace::CMUTrace(const char *s, char t) : Trace(t)
  119. {
  120. bzero(tracename, sizeof(tracename));
  121. strncpy(tracename, s, MAX_ID_LEN);
  123.         if(strcmp(tracename, "RTR") == 0) {
  124.                 tracetype = TR_ROUTER;
  125.         }
  126. else if(strcmp(tracename, "TRP") == 0) {
  127.                 tracetype = TR_ROUTER;
  128.         }
  129.         else if(strcmp(tracename, "PHY") == 0) {
  130.                 tracetype = TR_PHY;
  131.         }
  132.         else if(strcmp(tracename, "MAC") == 0) {
  133.                 tracetype = TR_MAC;
  134.         }
  135.         else if(strcmp(tracename, "IFQ") == 0) {
  136.                 tracetype = TR_IFQ;
  137.         }
  138.         else if(strcmp(tracename, "AGT") == 0) {
  139.                 tracetype = TR_AGENT;
  140.         }
  141.         else {
  142.                 fprintf(stderr, "CMU Trace Initialized with invalid typen");
  143.                 exit(1);
  144.         }
  145. // change wrt Mike's code
  146. // assert(type_ == DROP || type_ == SEND || type_ == RECV);
  147. assert(type_ == DROP || type_ == SEND || type_ == RECV
  148.                || ((type_ == EOT) && (tracetype == TR_MAC)));
  152. newtrace_ = 0;
  153. for (int i=0 ; i < MAX_NODE ; i++) 
  154. nodeColor[i] = 3 ;
  155.         node_ = 0;
  156. }
  158. void
  159. CMUTrace::format_mac_common(Packet *p, const char *why, int offset)
  160. {
  161. struct hdr_cmn *ch = HDR_CMN(p);
  162. struct hdr_ip *ih = HDR_IP(p);
  163. struct hdr_mac802_11 *mh;
  164. struct hdr_smac *sh;
  165. char mactype[SMALL_LEN];
  167. strcpy(mactype, Simulator::instance().macType());
  168. if (strcmp (mactype, "Mac/SMAC") == 0)
  169. sh = HDR_SMAC(p);
  170. else
  171. mh = HDR_MAC802_11(p);
  173. double x = 0.0, y = 0.0, z = 0.0;
  174.        
  175. char op = (char) type_;
  176. Node* thisnode = Node::get_node_by_address(src_);
  177. double energy = -1;
  178. if (thisnode) {
  179.     if (thisnode->energy_model()) {
  180.     energy = thisnode->energy_model()->energy();
  181.     }
  182. }
  184. // hack the IP address to convert pkt format to hostid format
  185. // for now until port ids are removed from IP address. -Padma.
  187. int src = Address::instance().get_nodeaddr(ih->saddr());
  189. if(tracetype == TR_ROUTER && type_ == SEND) {
  190. if(src_ != src)
  191. op = FWRD;
  192. }
  194. // use tagged format if appropriate
  195. if (pt_->tagged()) {
  196. int next_hop = -1 ;
  197. Node* nextnode = Node::get_node_by_address(ch->next_hop_);
  198.          if (nextnode) next_hop = nextnode->nodeid(); 
  200. node_->getLoc(&x, &y, &z);
  202. if (op == DROP) op = 'd';
  203. if (op == SEND) op = '+';
  204. if (op == FWRD) op = 'h';
  206. sprintf(pt_->buffer() + offset,
  207. "%c "TIME_FORMAT" -s %d -d %d -p %s -k %3s -i %d "
  208. "-N:loc {%.2f %.2f %.2f} -N:en %f ",
  210. op, // event type
  211. Scheduler::instance().clock(), // time
  212. src_, // this node
  213. next_hop, // next hop
  214. packet_info.name(ch->ptype()), // packet type
  215. tracename, // trace level
  216. ch->uid(), // event id
  217. x, y, z, // location
  218. energy); // energy
  220. offset = strlen(pt_->buffer());
  221. if (strcmp (mactype, "Mac/SMAC") == 0) {
  222. format_smac(p, offset);
  223. } else {
  224. format_mac(p, offset);
  225. }
  226. return;
  227. }
  230. // Use new ns trace format to replace the old cmu trace format)
  231. if (newtrace_) {
  232.     
  233.     node_->getLoc(&x, &y, &z);
  234.     // consistence
  235.     if ( op == DROP ) { op = 'd';}
  237.         // basic trace infomation + basic exenstion
  239.     sprintf(pt_->buffer() + offset,
  240.    "%c -t %.9f -Hs %d -Hd %d -Ni %d -Nx %.2f -Ny %.2f -Nz %.2f -Ne %f -Nl %3s -Nw %s ",
  241.     op,                       // event type
  242.     Scheduler::instance().clock(),  // time
  243.     src_,                           // this node
  244.                     ch->next_hop_,                  // next hop
  245.     src_,                           // this node
  246.     x,                              // x coordinate
  247.     y,                              // y coordinate
  248.     z,                              // z coordinate
  249.     energy,                         // energy, -1 = not existing
  250.     tracename,                      // trace level
  251.                     why);                            // reason
  253.     // mac layer extension
  255.     offset = strlen(pt_->buffer());
  256.     if (strcmp(mactype, "Mac/SMAC") == 0) {
  257.     format_smac(p, offset);
  258.     } else {
  259.     format_mac(p, offset);
  260.     }
  261.     return;
  262. }
  265. #ifdef LOG_POSITION
  266.         x = 0.0, y = 0.0, z = 0.0;
  267.         node_->getLoc(&x, &y, &z);
  268. #endif
  269. sprintf(pt_->buffer() + offset,
  270. #ifdef LOG_POSITION
  271. "%c %.9f %d (%6.2f %6.2f) %3s %4s %d %s %d ",
  272. #else
  273. "%c %.9f _%d_ %3s %4s %d %s %d",
  274. #endif
  275. op,
  276. Scheduler::instance().clock(),
  277.                 src_,                           // this node
  278. #ifdef LOG_POSITION
  279.                 x,
  280.                 y,
  281. #endif
  282. tracename,
  283. why,
  285.                 ch->uid(),                      // identifier for this event
  287. ((ch->ptype() == PT_MAC) ? (
  288.   (mh->dh_fc.fc_type == MAC_Type_Control) ? (
  289.   (mh->dh_fc.fc_subtype == MAC_Subtype_RTS) ? "RTS"  :
  290.   (mh->dh_fc.fc_subtype == MAC_Subtype_CTS) ? "CTS"  :
  291.   (mh->dh_fc.fc_subtype == MAC_Subtype_ACK) ? "ACK":
  292.   //<zheng: add for 802.15.4>
  293.   (mh->dh_fc.fc_subtype == MAC_Subtype_Beacon) ? "BCN"  : //Beacon
  294.   (mh->dh_fc.fc_subtype == MAC_Subtype_Command_AssoReq) ? "CM1"  : //CMD: Association request
  295.   (mh->dh_fc.fc_subtype == MAC_Subtype_Command_AssoRsp) ? "CM2"  : //CMD: Association response
  296.   (mh->dh_fc.fc_subtype == MAC_Subtype_Command_DAssNtf) ? "CM3"  : //CMD: Disassociation notification
  297.   (mh->dh_fc.fc_subtype == MAC_Subtype_Command_DataReq) ? "CM4"  : //CMD: Data request
  298.   (mh->dh_fc.fc_subtype == MAC_Subtype_Command_PIDCNtf) ? "CM5"  : //CMD: PAN ID conflict notification
  299.   (mh->dh_fc.fc_subtype == MAC_Subtype_Command_OrphNtf) ? "CM6"  : //CMD: Orphan notification
  300.   (mh->dh_fc.fc_subtype == MAC_Subtype_Command_BconReq) ? "CM7"  : //CMD: Beacon request
  301.   (mh->dh_fc.fc_subtype == MAC_Subtype_Command_CoorRea) ? "CM8"  : //CMD: Coordinator realignment
  302.   (mh->dh_fc.fc_subtype == MAC_Subtype_Command_GTSReq) ? "CM9"  : //CMD: GTS request
  303.           "UNKN") :
  304.    (mh->dh_fc.fc_type == MAC_Type_Management) ? (
  305.   (mh->dh_fc.fc_subtype == MAC_Subtype_80211_Beacon) ? "BCN"  :
  306.   (mh->dh_fc.fc_subtype == MAC_Subtype_AssocReq) ? "ACRQ"  :
  307.   (mh->dh_fc.fc_subtype == MAC_Subtype_AssocRep) ? "ACRP"  : 
  308.   (mh->dh_fc.fc_subtype == MAC_Subtype_Auth) ? "AUTH"  :
  309.   (mh->dh_fc.fc_subtype == MAC_Subtype_ProbeReq) ? "PRRQ"  :
  310.   (mh->dh_fc.fc_subtype == MAC_Subtype_ProbeRep) ? "PRRP"  :
  311.   "UNKN") :
  312.   "UNKN") :
  313.  (ch->ptype() == PT_SMAC) ? (
  314.   (sh->type == RTS_PKT) ? "RTS" :
  315.   (sh->type == CTS_PKT) ? "CTS" :
  316.   (sh->type == ACK_PKT) ? "ACK" :
  317.   (sh->type == SYNC_PKT) ? "SYNC" :
  318.   "UNKN") : 
  319.  packet_info.name(ch->ptype())),
  320. ch->size());
  322. offset = strlen(pt_->buffer());
  324. if(tracetype == TR_PHY) {
  325. format_phy(p, offset);
  326. offset = strlen(pt_->buffer());
  327. return;
  328. }
  330. if (strncmp (mactype, "Mac/SMAC", 8) == 0) {
  331. format_smac(p, offset);
  332. } else {
  333. format_mac(p, offset);
  334.         }
  336. offset = strlen(pt_->buffer());
  338. if (thisnode) {
  339. if (thisnode->energy_model()) {
  340. // log detailed energy consumption
  341. // total energy and breakdown in idle, sleep, transmit and receive modes
  342. sprintf(pt_->buffer() + offset,
  343. "[energy %f ei %.3f es %.3f et %.3f er %.3f] ",
  344. thisnode->energy_model()->energy(),
  345. thisnode->energy_model()->ei(),
  346. thisnode->energy_model()->es(),
  347. thisnode->energy_model()->et(),
  348. thisnode->energy_model()->er());
  349. }
  350.         }
  351. }
  353. void
  354. CMUTrace::format_phy(Packet *p, int offset)
  355. {
  356. sprintf(pt_->buffer() + offset, " ");
  357. }
  360. void
  361. CMUTrace::format_mac(Packet *p, int offset)
  362. {
  363. struct hdr_mac802_11 *mh = HDR_MAC802_11(p);
  365. if (pt_->tagged()) {
  366. sprintf(pt_->buffer() + offset,
  367. "-M:dur %x -M:s %x -M:d %x -M:t %x ",
  368. mh->dh_duration, // MAC: duration
  370. // change wrt Mike's code
  371. //ETHER_ADDR(mh->dh_da), // MAC: source
  372. //ETHER_ADDR(mh->dh_sa), // MAC: destination
  373. ETHER_ADDR(mh->dh_ra),          // MAC: source
  374.                        ETHER_ADDR(mh->dh_ta),          // MAC: destination
  377. GET_ETHER_TYPE(mh->dh_body)); // MAC: type
  378. } else if (newtrace_) {
  379. sprintf(pt_->buffer() + offset, 
  380. "-Ma %x -Md %x -Ms %x -Mt %x ",
  381. mh->dh_duration,
  383. // change wrt Mike's code
  384. //ETHER_ADDR(mh->dh_da),
  385. //ETHER_ADDR(mh->dh_sa),
  387.     ETHER_ADDR(mh->dh_ra),
  388.                    ETHER_ADDR(mh->dh_ta),
  390. GET_ETHER_TYPE(mh->dh_body));
  391. } else {
  392. sprintf(pt_->buffer() + offset,
  393. " [%x %x %x %x] ",
  394. //*((u_int16_t*) &mh->dh_fc),
  395. mh->dh_duration,
  397. // change wrt Mike's code
  398. //ETHER_ADDR(mh->dh_da),
  399. //ETHER_ADDR(mh->dh_sa),
  400. ETHER_ADDR(mh->dh_ra),
  401.                         ETHER_ADDR(mh->dh_ta),
  404. GET_ETHER_TYPE(mh->dh_body));
  405. }
  406. }
  408. void
  409. CMUTrace::format_smac(Packet *p, int offset)
  410. {
  411. struct hdr_smac *sh = HDR_SMAC(p);
  412. sprintf(pt_->buffer() + offset,
  413. " [%.2f %d %d] ",
  414. sh->duration,
  415. sh->dstAddr,
  416. sh->srcAddr);
  417. }
  420. void
  421. CMUTrace::format_ip(Packet *p, int offset)
  422. {
  423.         struct hdr_cmn *ch = HDR_CMN(p);
  424. struct hdr_ip *ih = HDR_IP(p);
  426. // hack the IP address to convert pkt format to hostid format
  427. // for now until port ids are removed from IP address. -Padma.
  428. int src = Address::instance().get_nodeaddr(ih->saddr());
  429. int dst = Address::instance().get_nodeaddr(ih->daddr());
  431. if (pt_->tagged()) {
  432. sprintf(pt_->buffer() + offset,
  433. "-IP:s %d -IP:sp %d -IP:d %d -IP:dp %d -p %s -e %d "
  434. "-c %d -i %d -IP:ttl %d ",
  435. src,                           // packet src
  436. ih->sport(),                   // src port
  437. dst,                           // packet dest
  438. ih->dport(),                   // dst port
  439. packet_info.name(ch->ptype()), // packet type
  440. ch->size(),                    // packet size
  441. ih->flowid(),                  // flow id
  442. ch->uid(),                     // unique id
  443. ih->ttl_                       // ttl
  444. );
  445. } else if (newtrace_) {
  446.     sprintf(pt_->buffer() + offset,
  447.     "-Is %d.%d -Id %d.%d -It %s -Il %d -If %d -Ii %d -Iv %d ",
  448.     src,                           // packet src
  449.     ih->sport(),                   // src port
  450.     dst,                           // packet dest
  451.     ih->dport(),                   // dst port
  452.     packet_info.name(ch->ptype()),  // packet type
  453.     ch->size(),                     // packet size
  454.     ih->flowid(),                   // flow id
  455.     ch->uid(),                      // unique id
  456.     ih->ttl_);                      // ttl
  457. } else {
  458.     sprintf(pt_->buffer() + offset, "------- [%d:%d %d:%d %d %d] ",
  459. src, ih->sport(),
  460. dst, ih->dport(),
  461. ih->ttl_, (ch->next_hop_ < 0) ? 0 : ch->next_hop_);
  462. }
  463. }
  465. // Note:  HDLC format (format_hdlc()) has moved to satellite tracing
  467. void
  468. CMUTrace::format_arp(Packet *p, int offset)
  469. {
  470. struct hdr_arp *ah = HDR_ARP(p);
  472. if (pt_->tagged()) {
  473.     sprintf(pt_->buffer() + offset,
  474.     "-arp:op %s -arp:ms %d -arp:s %d -arp:md %d -arp:d %d ",
  475.     ah->arp_op == ARPOP_REQUEST ?  "REQUEST" : "REPLY",
  476.     ah->arp_sha,
  477.     ah->arp_spa,
  478.     ah->arp_tha,
  479.     ah->arp_tpa);
  480. } else if (newtrace_) {
  481.     sprintf(pt_->buffer() + offset,
  482.     "-P arp -Po %s -Pms %d -Ps %d -Pmd %d -Pd %d ",
  483.     ah->arp_op == ARPOP_REQUEST ?  "REQUEST" : "REPLY",
  484.     ah->arp_sha,
  485.     ah->arp_spa,
  486.     ah->arp_tha,
  487.     ah->arp_tpa);
  488. } else {
  490.     sprintf(pt_->buffer() + offset,
  491. "------- [%s %d/%d %d/%d]",
  492. ah->arp_op == ARPOP_REQUEST ?  "REQUEST" : "REPLY",
  493. ah->arp_sha,
  494. ah->arp_spa,
  495. ah->arp_tha,
  496. ah->arp_tpa);
  497. }
  498. }
  500. void
  501. CMUTrace::format_dsr(Packet *p, int offset)
  502. {
  503. hdr_sr *srh = hdr_sr::access(p);
  505. if (pt_->tagged()) {
  506.     sprintf(pt_->buffer() + offset,
  507.     "-dsr:h %d -dsr:q %d -dsr:s %d -dsr:p %d -dsr:n %d "
  508.     "-dsr:l %d -dsr:e {%d %d} -dsr:w %d -dsr:m %d -dsr:c %d "
  509.     "-dsr:b {%d %d} ",
  510.     srh->num_addrs(),
  511.     srh->route_request(),
  512.     srh->rtreq_seq(),
  513.     srh->route_reply(),
  514.     srh->rtreq_seq(),
  515.     srh->route_reply_len(),
  516.     srh->reply_addrs()[0].addr,
  517.     srh->reply_addrs()[srh->route_reply_len()-1].addr,
  518.     srh->route_error(),
  519.     srh->num_route_errors(),
  520.     srh->down_links()[srh->num_route_errors() - 1].tell_addr,
  521.     srh->down_links()[srh->num_route_errors() - 1].from_addr,
  522.     srh->down_links()[srh->num_route_errors() - 1].to_addr);
  523.     return;
  524. } else if (newtrace_) {
  525.     sprintf(pt_->buffer() + offset, 
  526. "-P dsr -Ph %d -Pq %d -Ps %d -Pp %d -Pn %d -Pl %d -Pe %d->%d -Pw %d -Pm %d -Pc %d -Pb %d->%d ",
  527.     srh->num_addrs(),                   // how many nodes travered
  529. srh->route_request(),
  530. srh->rtreq_seq(),
  532. srh->route_reply(),
  533. srh->rtreq_seq(),
  534. srh->route_reply_len(),
  535. // the dest of the src route
  536. srh->reply_addrs()[0].addr,
  537. srh->reply_addrs()[srh->route_reply_len()-1].addr,
  539. srh->route_error(),
  540. srh->num_route_errors(),
  541. srh->down_links()[srh->num_route_errors() - 1].tell_addr,
  542. srh->down_links()[srh->num_route_errors() - 1].from_addr,
  543. srh->down_links()[srh->num_route_errors() - 1].to_addr);
  545.    return;
  546. }
  547. sprintf(pt_->buffer() + offset, 
  548. "%d [%d %d] [%d %d %d %d->%d] [%d %d %d %d->%d]",
  549. srh->num_addrs(),
  551. srh->route_request(),
  552. srh->rtreq_seq(),
  554. srh->route_reply(),
  555. srh->rtreq_seq(),
  556. srh->route_reply_len(),
  557. // the dest of the src route
  558. srh->reply_addrs()[0].addr,
  559. srh->reply_addrs()[srh->route_reply_len()-1].addr,
  561. srh->route_error(),
  562. srh->num_route_errors(),
  563. srh->down_links()[srh->num_route_errors() - 1].tell_addr,
  564. srh->down_links()[srh->num_route_errors() - 1].from_addr,
  565. srh->down_links()[srh->num_route_errors() - 1].to_addr);
  566. }
  568. void
  569. CMUTrace::format_msg(Packet *, int)
  570. {
  571. }
  573. void
  574. CMUTrace::format_tcp(Packet *p, int offset)
  575. {
  576. struct hdr_cmn *ch = HDR_CMN(p);
  577. struct hdr_tcp *th = HDR_TCP(p);
  579. if (pt_->tagged()) {
  580.     sprintf(pt_->buffer() + offset,
  581.     "-tcp:s %d -tcp:a %d -tcp:f %d -tcp:o %d ",
  582.     th->seqno_,
  583.     th->ackno_,
  584.     ch->num_forwards(),
  585.     ch->opt_num_forwards());
  586. } else if (newtrace_) {
  587.     sprintf(pt_->buffer() + offset,
  588. "-Pn tcp -Ps %d -Pa %d -Pf %d -Po %d ",
  589. th->seqno_,
  590. th->ackno_,
  591. ch->num_forwards(),
  592. ch->opt_num_forwards());
  594. } else {
  595.     sprintf(pt_->buffer() + offset,
  596. "[%d %d] %d %d",
  597. th->seqno_,
  598. th->ackno_,
  599. ch->num_forwards(),
  600. ch->opt_num_forwards());
  601. }
  602. }
  604. /* Armando L. Caro Jr. <acaro@@cis,udel,edu> 6/5/2002
  605.  * (with help from Florina Almenrez <florina@@it,uc3m,es>)
  606.  */
  607. void
  608. CMUTrace::format_sctp(Packet* p,int offset)
  609. {
  610. struct hdr_cmn *ch = HDR_CMN(p);
  611. struct hdr_sctp *sh = HDR_SCTP(p);
  612. //struct hdr_ip *ih = HDR_IP(p);
  613. char cChunkType;
  614.   
  615. for(u_int i = 0; i < sh->NumChunks(); i++) {
  616. switch(sh->SctpTrace()[i].eType) {
  617. case SCTP_CHUNK_INIT:
  618. case SCTP_CHUNK_INIT_ACK:
  619. case SCTP_CHUNK_COOKIE_ECHO:
  620. case SCTP_CHUNK_COOKIE_ACK:
  621. cChunkType = 'I';       // connection initialization
  622. break;
  623.       
  624. case SCTP_CHUNK_DATA:
  625. cChunkType = 'D';
  626. break;
  627.       
  628. case SCTP_CHUNK_SACK:
  629. cChunkType = 'S';
  630. break;
  631.       
  632. case SCTP_CHUNK_FORWARD_TSN:
  633. cChunkType = 'R';
  634. break;
  636. case SCTP_CHUNK_HB:
  637. cChunkType = 'H';
  638. break;
  640. case SCTP_CHUNK_HB_ACK:
  641. cChunkType = 'B';
  642. break;
  643. default:
  644. // quiet compiler
  645. cChunkType = ' ';
  646. assert (false);
  647. break;
  648. }
  649.     
  650. if( newtrace_ ) {
  651. sprintf(pt_->buffer() + offset,
  652. "-Pn sctp -Pnc %d -Pct %c "
  653. "-Ptsn %d -Psid %d -Pssn %d "
  654. "-Pf %d -Po %d ",
  655. sh->NumChunks(),
  656. cChunkType,
  657. sh->SctpTrace()[i].uiTsn,
  658. sh->SctpTrace()[i].usStreamId,
  659. sh->SctpTrace()[i].usStreamSeqNum,
  660. ch->num_forwards(),
  661. ch->opt_num_forwards());
  662. }
  663. else {
  664. sprintf(pt_->buffer() + offset,
  665. "[%d %c %d %d %d] %d %d",
  666. sh->NumChunks(),
  667. cChunkType,
  668. sh->SctpTrace()[i].uiTsn,
  669. sh->SctpTrace()[i].usStreamId,
  670. sh->SctpTrace()[i].usStreamSeqNum,
  671. ch->num_forwards(),
  672. ch->opt_num_forwards());
  673. }
  674. }
  675. }
  677. void
  678. CMUTrace::format_rtp(Packet *p, int offset)
  679. {
  680. struct hdr_cmn *ch = HDR_CMN(p);
  681. struct hdr_rtp *rh = HDR_RTP(p);
  682. struct hdr_ip *ih = HDR_IP(p);
  683.         Node* thisnode = Node::get_node_by_address(src_);
  685. //hacking, needs to change later, 
  686.         int dst = Address::instance().get_nodeaddr(ih->daddr());
  688. if (dst == src_){
  689. // I just received a cbr data packet
  690. if (thisnode->energy_model() && 
  691.     thisnode->energy_model()->powersavingflag()) {
  692. thisnode->energy_model()->set_node_state(EnergyModel::INROUTE);
  693. }
  694.         }
  696. if (pt_->tagged()) {
  697. sprintf(pt_->buffer() + offset,
  698. "-cbr:s %d -cbr:f %d -cbr:o %d ",
  699. rh->seqno_,
  700. ch->num_forwards(),
  701. ch->opt_num_forwards());
  702. } else if (newtrace_) {
  703. sprintf(pt_->buffer() + offset,
  704. "-Pn cbr -Pi %d -Pf %d -Po %d ",
  705. rh->seqno_,
  706. ch->num_forwards(),
  707. ch->opt_num_forwards());
  708. } else {
  709. sprintf(pt_->buffer() + offset,
  710. "[%d] %d %d",
  711. rh->seqno_,
  712. ch->num_forwards(),
  713. ch->opt_num_forwards());
  714. }
  715. }
  717. void
  718. CMUTrace::format_imep(Packet *p, int offset)
  719. {
  720.         struct hdr_imep *im = HDR_IMEP(p);
  722. #define U_INT16_T(x)    *((u_int16_t*) &(x))
  724. if (pt_->tagged()) {
  725.     sprintf(pt_->buffer() + offset,
  726.     "-imep:a %c -imep:h %c -imep:o %c -imep:l %04x ",
  727.     (im->imep_block_flags & BLOCK_FLAG_ACK) ? 'A' : '-',
  728.                     (im->imep_block_flags & BLOCK_FLAG_HELLO) ? 'H' : '-',
  729.                     (im->imep_block_flags & BLOCK_FLAG_OBJECT) ? 'O' : '-',
  730.                     U_INT16_T(im->imep_length));
  731. } else if (newtrace_) {
  732.     sprintf(pt_->buffer() + offset,
  733.                 "-P imep -Pa %c -Ph %c -Po %c -Pl 0x%04x ] ",
  734.                 (im->imep_block_flags & BLOCK_FLAG_ACK) ? 'A' : '-',
  735.                 (im->imep_block_flags & BLOCK_FLAG_HELLO) ? 'H' : '-',
  736.                 (im->imep_block_flags & BLOCK_FLAG_OBJECT) ? 'O' : '-',
  737.                 U_INT16_T(im->imep_length));
  738. } else {
  739.             sprintf(pt_->buffer() + offset,
  740.                 "[%c %c %c 0x%04x] ",
  741.                 (im->imep_block_flags & BLOCK_FLAG_ACK) ? 'A' : '-',
  742.                 (im->imep_block_flags & BLOCK_FLAG_HELLO) ? 'H' : '-',
  743.                 (im->imep_block_flags & BLOCK_FLAG_OBJECT) ? 'O' : '-',
  744.                 U_INT16_T(im->imep_length));
  745. }
  746. #undef U_INT16_T
  747. }
  750. void
  751. CMUTrace::format_tora(Packet *p, int offset)
  752. {
  753.         struct hdr_tora *th = HDR_TORA(p);
  754.         struct hdr_tora_qry *qh = HDR_TORA_QRY(p);
  755.         struct hdr_tora_upd *uh = HDR_TORA_UPD(p);
  756.         struct hdr_tora_clr *ch = HDR_TORA_CLR(p);
  758.         switch(th->th_type) {
  760.         case TORATYPE_QRY:
  762. if (pt_->tagged()) {
  763.     sprintf(pt_->buffer() + offset,
  764.     "-tora:t %x -tora:d %d -tora:c QUERY",
  765.     qh->tq_type, qh->tq_dst);
  766. } else if (newtrace_) {
  767.     sprintf(pt_->buffer() + offset,
  768. "-P tora -Pt 0x%x -Pd %d -Pc QUERY ",
  769.                         qh->tq_type, qh->tq_dst);
  771.                 } else {
  773.                     sprintf(pt_->buffer() + offset, "[0x%x %d] (QUERY)",
  774.                         qh->tq_type, qh->tq_dst);
  775. }
  776.                 break;
  778.         case TORATYPE_UPD:
  780. if (pt_->tagged()) {
  781.     sprintf(pt_->buffer() + offset,
  782.     "-tora:t %x -tora:d %d -tora:a %f -tora:o %d "
  783.     "-tora:r %d -tora:e %d -tora:i %d -tora:c UPDATE",
  784.     uh->tu_type,
  785.                             uh->tu_dst,
  786.                             uh->tu_tau,
  787.                             uh->tu_oid,
  788.                             uh->tu_r,
  789.                             uh->tu_delta,
  790.                             uh->tu_id);
  791. } else if (newtrace_) {
  792.     sprintf(pt_->buffer() + offset,
  793.                         "-P tora -Pt 0x%x -Pd %d (%f %d %d %d %d) -Pc UPDATE ",
  794.                         uh->tu_type,
  795.                         uh->tu_dst,
  796.                         uh->tu_tau,
  797.                         uh->tu_oid,
  798.                         uh->tu_r,
  799.                         uh->tu_delta,
  800.                         uh->tu_id);
  801. } else {
  802.                     sprintf(pt_->buffer() + offset,
  803.                         "-Pt 0x%x -Pd %d -Pa %f -Po %d -Pr %d -Pe %d -Pi %d -Pc UPDATE ",
  804.                         uh->tu_type,
  805.                         uh->tu_dst,
  806.                         uh->tu_tau,
  807.                         uh->tu_oid,
  808.                         uh->tu_r,
  809.                         uh->tu_delta,
  810.                         uh->tu_id);
  811. }
  812.                 break;
  814.         case TORATYPE_CLR:
  815. if (pt_->tagged()) {
  816.     sprintf(pt_->buffer() + offset,
  817.     "-tora:t %x -tora:d %d -tora:a %f -tora:o %d "
  818.     "-tora:c CLEAR ",
  819.     ch->tc_type,
  820.                             ch->tc_dst,
  821.                             ch->tc_tau,
  822.                             ch->tc_oid);
  823. } else if (newtrace_) {
  824.     sprintf(pt_->buffer() + offset, 
  825. "-P tora -Pt 0x%x -Pd %d -Pa %f -Po %d -Pc CLEAR ",
  826.                         ch->tc_type,
  827.                         ch->tc_dst,
  828.                         ch->tc_tau,
  829.                         ch->tc_oid);
  830. } else {
  831.                     sprintf(pt_->buffer() + offset, "[0x%x %d %f %d] (CLEAR)",
  832.                         ch->tc_type,
  833.                         ch->tc_dst,
  834.                         ch->tc_tau,
  835.                         ch->tc_oid);
  836. }
  837.                 break;
  838.         }
  839. }
  841. void
  842. CMUTrace::format_aodv(Packet *p, int offset)
  843. {
  844.         struct hdr_aodv *ah = HDR_AODV(p);
  845.         struct hdr_aodv_request *rq = HDR_AODV_REQUEST(p);
  846.         struct hdr_aodv_reply *rp = HDR_AODV_REPLY(p);
  849.         switch(ah->ah_type) {
  850.         case AODVTYPE_RREQ:
  852. if (pt_->tagged()) {
  853.     sprintf(pt_->buffer() + offset,
  854.     "-aodv:t %x -aodv:h %d -aodv:b %d -aodv:d %d "
  855.     "-aodv:ds %d -aodv:s %d -aodv:ss %d "
  856.     "-aodv:c REQUEST ",
  857.     rq->rq_type,
  858.                             rq->rq_hop_count,
  859.                             rq->rq_bcast_id,
  860.                             rq->rq_dst,
  861.                             rq->rq_dst_seqno,
  862.                             rq->rq_src,
  863.                             rq->rq_src_seqno);
  864. } else if (newtrace_) {
  866.     sprintf(pt_->buffer() + offset,
  867. "-P aodv -Pt 0x%x -Ph %d -Pb %d -Pd %d -Pds %d -Ps %d -Pss %d -Pc REQUEST ",
  868. rq->rq_type,
  869.                         rq->rq_hop_count,
  870.                         rq->rq_bcast_id,
  871.                         rq->rq_dst,
  872.                         rq->rq_dst_seqno,
  873.                         rq->rq_src,
  874.                         rq->rq_src_seqno);
  877. } else {
  879.     sprintf(pt_->buffer() + offset,
  880. "[0x%x %d %d [%d %d] [%d %d]] (REQUEST)",
  881. rq->rq_type,
  882.                         rq->rq_hop_count,
  883.                         rq->rq_bcast_id,
  884.                         rq->rq_dst,
  885.                         rq->rq_dst_seqno,
  886.                         rq->rq_src,
  887.                         rq->rq_src_seqno);
  888. }
  889.                 break;
  891.         case AODVTYPE_RREP:
  892.         case AODVTYPE_HELLO:
  893. case AODVTYPE_RERR:
  895. if (pt_->tagged()) {
  896.     sprintf(pt_->buffer() + offset,
  897.     "-aodv:t %x -aodv:h %d -aodv:d %d -adov:ds %d "
  898.     "-aodv:l %f -aodv:c %s ",
  899.     rp->rp_type,
  900.     rp->rp_hop_count,
  901.     rp->rp_dst,
  902.     rp->rp_dst_seqno,
  903.     rp->rp_lifetime,
  904.     rp->rp_type == AODVTYPE_RREP ? "REPLY" :
  905.     (rp->rp_type == AODVTYPE_RERR ? "ERROR" :
  906.      "HELLO"));
  907. } else if (newtrace_) {
  909. sprintf(pt_->buffer() + offset,
  910.     "-P aodv -Pt 0x%x -Ph %d -Pd %d -Pds %d -Pl %f -Pc %s ",
  911. rp->rp_type,
  912. rp->rp_hop_count,
  913. rp->rp_dst,
  914. rp->rp_dst_seqno,
  915. rp->rp_lifetime,
  916. rp->rp_type == AODVTYPE_RREP ? "REPLY" :
  917. (rp->rp_type == AODVTYPE_RERR ? "ERROR" :
  918.  "HELLO"));
  919.         } else {
  921. sprintf(pt_->buffer() + offset,
  922. "[0x%x %d [%d %d] %f] (%s)",
  923. rp->rp_type,
  924. rp->rp_hop_count,
  925. rp->rp_dst,
  926. rp->rp_dst_seqno,
  927. rp->rp_lifetime,
  928. rp->rp_type == AODVTYPE_RREP ? "REPLY" :
  929. (rp->rp_type == AODVTYPE_RERR ? "ERROR" :
  930.  "HELLO"));
  931. }
  932.                 break;
  934.         default:
  935. #ifdef WIN32
  936.                 fprintf(stderr,
  937.         "CMUTrace::format_aodv: invalid AODV packet typen");
  938. #else
  939. fprintf(stderr,
  940.         "%s: invalid AODV packet typen", __FUNCTION__);
  941. #endif
  942.                 abort();
  943.         }
  944. }
  946. void
  947. CMUTrace::nam_format(Packet *p, int offset)
  948. {
  949. Node* srcnode = 0 ;
  950. Node* dstnode = 0 ;
  951. Node* nextnode = 0 ;
  952.         struct hdr_cmn *ch = HDR_CMN(p);
  953. struct hdr_ip *ih = HDR_IP(p);
  954. char op = (char) type_;
  955. char colors[32];
  956. int next_hop = -1 ;
  958. // change wrt Mike's code
  959. assert(type_ != EOT);
  963. //<zheng: add for 802.15.4>
  965. //Actually we only need to handle MAC layer for nam (but should display dropping for other layers)
  966. //if (strcmp(tracename,"MAC") != 0)
  967. //if ((op != 'D')&&(op != 'd'))
  968. // return;
  970. struct hdr_mac802_11 *mh = HDR_MAC802_11(p);
  971. char ptype[11];
  972. strcpy(ptype,
  973. ((ch->ptype() == PT_MAC) ? (
  974.   (mh->dh_fc.fc_subtype == MAC_Subtype_RTS) ? "RTS"  :
  975.   (mh->dh_fc.fc_subtype == MAC_Subtype_CTS) ? "CTS"  :
  976.   (mh->dh_fc.fc_subtype == MAC_Subtype_ACK) ? "ACK"  :
  977.   (mh->dh_fc.fc_subtype == MAC_Subtype_Beacon) ? "BCN"  : //Beacon
  978.   (mh->dh_fc.fc_subtype == MAC_Subtype_AssocReq) ? "ACRQ"  :
  979.           (mh->dh_fc.fc_subtype == MAC_Subtype_AssocRep) ? "ACRP"  :
  980.   (mh->dh_fc.fc_subtype == MAC_Subtype_Command_AssoReq) ? "CM1"  : //CMD: Association request
  981.   (mh->dh_fc.fc_subtype == MAC_Subtype_Command_AssoRsp) ? "CM2"  : //CMD: Association response
  982.   (mh->dh_fc.fc_subtype == MAC_Subtype_Command_DAssNtf) ? "CM3"  : //CMD: Disassociation notification
  983.   (mh->dh_fc.fc_subtype == MAC_Subtype_Command_DataReq) ? "CM4"  : //CMD: Data request
  984.   (mh->dh_fc.fc_subtype == MAC_Subtype_Command_PIDCNtf) ? "CM5"  : //CMD: PAN ID conflict notification
  985.   (mh->dh_fc.fc_subtype == MAC_Subtype_Command_OrphNtf) ? "CM6"  : //CMD: Orphan notification
  986.   (mh->dh_fc.fc_subtype == MAC_Subtype_Command_BconReq) ? "CM7"  : //CMD: Beacon request
  987.   (mh->dh_fc.fc_subtype == MAC_Subtype_Command_CoorRea) ? "CM8"  : //CMD: Coordinator realignment
  988.   (mh->dh_fc.fc_subtype == MAC_Subtype_Command_GTSReq) ? "CM9"  : //CMD: GTS request
  989.   "UNKN"
  990.   ) : packet_info.name(ch->ptype())));
  991. //</zheng: add for 802.15.4>
  992.         int dst = Address::instance().get_nodeaddr(ih->daddr());
  994. nextnode = Node::get_node_by_address(ch->next_hop_);
  995.         if (nextnode) next_hop = nextnode->nodeid(); 
  997. srcnode = Node::get_node_by_address(src_);
  998. dstnode = Node::get_node_by_address(ch->next_hop_);
  1000. double distance = 0;
  1002.         if ((srcnode) && (dstnode)) {
  1003.    MobileNode* tmnode = (MobileNode*)srcnode;
  1004.    MobileNode* rmnode = (MobileNode*)dstnode;
  1006.    distance = tmnode->propdelay(rmnode) * 300000000 ;
  1007. }
  1009. double energy = -1;
  1010. double initenergy = -1;
  1012. //default value for changing node color with respect to energy depletion
  1013. double l1 = 0.5; 
  1014. double l2 = 0.2;
  1016. if (srcnode) {
  1017.     if (srcnode->energy_model()) {
  1018.     energy = srcnode->energy_model()->energy();
  1019.     initenergy = srcnode->energy_model()->initialenergy();
  1020.     l1 = srcnode->energy_model()->level1();
  1021.     l2 = srcnode->energy_model()->level2();
  1022.     }
  1023. }
  1025.         int energyLevel = 0 ;
  1026.         double energyLeft = (double)(energy/initenergy) ;
  1028.         if ((energyLeft <= 1 ) && (energyLeft >= l1 )) energyLevel = 3;
  1029.         if ((energyLeft >= l2 ) && (energyLeft < l1 )) energyLevel = 2;
  1030.         if ((energyLeft > 0 ) && (energyLeft < l2 )) energyLevel = 1;
  1032. if (energyLevel == 0) 
  1033. strcpy(colors,"-c black -o red");
  1034.         else if (energyLevel == 1) 
  1035. strcpy(colors,"-c red -o yellow");
  1036.         else if (energyLevel == 2) 
  1037. strcpy(colors,"-c yellow -o green");
  1038.         else if (energyLevel == 3) 
  1039. strcpy(colors,"-c green -o black");
  1041. // A simple hack for scadds demo (fernandez's visit) -- Chalermek
  1042. int pkt_color = 0;
  1043. if (ch->ptype()==PT_DIFF) {
  1044. hdr_cdiff *dfh= HDR_CDIFF(p);
  1045. if (dfh->mess_type != DATA) {
  1046. pkt_color = 1;
  1047. }
  1048. }
  1050. //<zheng: add for 802.15.4>
  1051. if (Nam802_15_4::Nam_Status)
  1052. {
  1053. ATTRIBUTELINK *attr;
  1054. int t_src,t_dst;
  1055. if (ch->ptype() == PT_MAC)
  1056. {
  1057. t_src = p802_15_4macSA(p);
  1058. t_dst = p802_15_4macDA(p);;
  1059. }
  1060. else
  1061. {
  1062. t_src = HDR_IP(p)->saddr();
  1063. t_dst = HDR_IP(p)->daddr();
  1064. }
  1065. attr = findAttrLink(HDR_CMN(p)->ptype(),t_src,t_dst);
  1066. if (attr == NULL)
  1067. attr = findAttrLink(HDR_CMN(p)->ptype());
  1068. if (attr != NULL)
  1069. HDR_LRWPAN(p)->attribute = attr->attribute;
  1070. else
  1071. HDR_LRWPAN(p)->attribute = 0;
  1072. if (HDR_LRWPAN(p)->attribute >= 32)
  1073. pkt_color = HDR_LRWPAN(p)->attribute;
  1074. }
  1075. //</zheng: add for 802.15.4>
  1077. // convert to nam format 
  1078. if (op == 's') op = 'h' ;
  1079. if (op == 'D') op = 'd' ;
  1080. if (op == 'h') {
  1081. sprintf(pt_->nbuffer(),
  1082. "+ -t %.9f -s %d -d %d -p %s -e %d -c 2 -a %d -i %d -k %3s ",
  1083. Scheduler::instance().clock(),
  1084. src_,                           // this node
  1085. next_hop,
  1086. ptype, //<zheng: modify for 802.15.4>packet_info.name(ch->ptype()),
  1087. ch->size(),
  1088. pkt_color,   
  1089. ch->uid(),
  1090. tracename);
  1092. offset = strlen(pt_->nbuffer());
  1093. pt_->namdump();
  1094. sprintf(pt_->nbuffer() ,
  1095. "- -t %.9f -s %d -d %d -p %s -e %d -c 2 -a %d -i %d -k %3s",
  1096. Scheduler::instance().clock(),
  1097. src_,                           // this node
  1098. next_hop,
  1099. ptype, //<zheng: modify for 802.15.4>packet_info.name(ch->ptype()),
  1100. ch->size(),
  1101. pkt_color,
  1102. ch->uid(),
  1103. tracename);
  1105. offset = strlen(pt_->nbuffer());
  1106. pt_->namdump();
  1107. }
  1109.         // if nodes are too far from each other
  1110. // nam won't dump SEND event 'cuz it's
  1111. // gonna be dropped later anyway
  1112. // this value 250 is pre-calculated by using 
  1113. // two-ray ground refelction model with fixed
  1114. // transmission power 3.652e-10
  1115. // if ((type_ == SEND)  && (distance > 250 )) return ;
  1117. if(tracetype == TR_ROUTER && type_ == RECV && dst != -1 ) return ;
  1118. if(type_ == RECV && dst == -1 )dst = src_ ; //broadcasting event
  1120.         if (energy != -1) { //energy model being turned on
  1121.    if (src_ >= MAX_NODE) {
  1122.    fprintf (stderr, "node id must be < %dn",
  1123.     MAX_NODE);
  1124.        exit(0);
  1125.    }
  1126.    if (nodeColor[src_] != energyLevel ) { //only dump it when node  
  1127.        sprintf(pt_->nbuffer() ,                    //color change
  1128.           "n -t %.9f -s %d -S COLOR %s",
  1129.            Scheduler::instance().clock(),
  1130.            src_,                           // this node
  1131.            colors);
  1132.                offset = strlen(pt_->nbuffer());
  1133.                pt_->namdump();
  1134.        nodeColor[src_] = energyLevel ;
  1135.     }   
  1136.         }
  1138. sprintf(pt_->nbuffer() ,
  1139. "%c -t %.9f -s %d -d %d -p %s -e %d -c 2 -a %d -i %d -k %3s",
  1140. op,
  1141. Scheduler::instance().clock(),
  1142. src_,                           // this node
  1143. next_hop,
  1144. ptype, //<zheng: modify for 802.15.4>packet_info.name(ch->ptype()),
  1145. ch->size(),
  1146. pkt_color,
  1147. ch->uid(),
  1148. tracename);
  1150. //<zheng: ns 2.27 removed the following part, but we need it to control the broadcast radius>
  1151. if (Nam802_15_4::Nam_Status)
  1152. {
  1153. if ((strcmp(tracename, "AGT") != 0) || ((u_int32_t)(ih->daddr()) == IP_BROADCAST)) //<zheng: add: next_hop info not available at agent level>
  1154. //(doesn't really matter -- seems agent level has no effect on nam)
  1155. if (next_hop == -1 && op == 'h') {
  1156. // print extra fields for broadcast packets
  1158. // bradius is calculated assuming 2-ray ground reflectlon
  1159. // model using default settings of Phy/WirelessPhy and
  1160. // Antenna/OmniAntenna
  1161. if (bradius == 0.0) calculate_broadcast_parameters();
  1163. double radius = bradius*radius_scaling_factor_; 
  1165. // duration is calculated based on the radius and
  1166. // the speed of light (299792458 m/s)
  1167. double duration = (bradius/299792458.0)*duration_scaling_factor_;
  1168. //<zheng: add -- the duration in 802.15.4 could be very small and rounded to 0.0>
  1169. if (Nam802_15_4::Nam_Status)
  1170. if (duration < 0.000000001)
  1171. duration = 0.000000001;
  1172. //</zheng: add>
  1173. sprintf(pt_->nbuffer() + strlen(pt_->nbuffer()),
  1174. " -R %.2f -D %.2f",
  1175. radius,
  1176. duration);
  1177. }
  1178. }
  1179. //</zheng>
  1181. offset = strlen(pt_->nbuffer());
  1182. pt_->namdump();
  1183. }
  1185. void CMUTrace::format(Packet* p, const char *why)
  1186. {
  1187. hdr_cmn *ch = HDR_CMN(p);
  1188. int offset = 0;
  1190. /*
  1191.  * Log the MAC Header
  1192.  */
  1193. format_mac_common(p, why, offset);
  1195. if (pt_->namchannel()) 
  1196. nam_format(p, offset);
  1197. offset = strlen(pt_->buffer());
  1198. switch(ch->ptype()) {
  1199. case PT_MAC:
  1200. case PT_SMAC:
  1201. break;
  1202. case PT_ARP:
  1203. format_arp(p, offset);
  1204. break;
  1205. default:
  1206. format_ip(p, offset);
  1207. offset = strlen(pt_->buffer());
  1208. switch(ch->ptype()) {
  1209. case PT_AODV:
  1210. format_aodv(p, offset);
  1211. break;
  1212. case PT_TORA:
  1213.                         format_tora(p, offset);
  1214.                         break;
  1215.                 case PT_IMEP:
  1216.                         format_imep(p, offset);
  1217.                         break;
  1218. case PT_DSR:
  1219. format_dsr(p, offset);
  1220. break;
  1221. case PT_MESSAGE:
  1222. case PT_UDP:
  1223. format_msg(p, offset);
  1224. break;
  1225. case PT_TCP:
  1226. case PT_ACK:
  1227. format_tcp(p, offset);
  1228. break;
  1229. case PT_SCTP:
  1230. /* Armando L. Caro Jr. <acaro@@cis,udel,edu> 6/5/2002
  1231.  */
  1232. format_sctp(p, offset);
  1233. break;
  1234. case PT_CBR:
  1235. format_rtp(p, offset);
  1236. break;
  1237.         case PT_DIFF:
  1238. break;
  1239. case PT_GAF:
  1240. case PT_PING:
  1241. break;
  1242. default:
  1244. if(pktTrc_ && pktTrc_->format_unknow(p, offset, pt_, newtrace_))
  1245. break;
  1247. /*<zheng: del -- there are many more new packet types added, like PT_EXP (poisson traffic belongs to this type)>
  1248. fprintf(stderr, "%s - invalid packet type (%s).n",
  1249. __PRETTY_FUNCTION__, packet_info.name(ch->ptype()));
  1250. exit(1);
  1251. </zheng: del>*/
  1252. break; //zheng: add
  1253. }
  1254. }
  1255. }
  1257. int
  1258. CMUTrace::command(int argc, const char*const* argv)
  1259. {
  1261.         if(argc == 3) {
  1262.                 if(strcmp(argv[1], "node") == 0) {
  1263.                         node_ = (MobileNode*) TclObject::lookup(argv[2]);
  1264.                         if(node_ == 0)
  1265.                                 return TCL_ERROR;
  1266.                         return TCL_OK;
  1267.                 }
  1268. if (strcmp(argv[1], "newtrace") == 0) {
  1269. newtrace_ = atoi(argv[2]);
  1270.         return TCL_OK;
  1271. }
  1272.         }
  1273. return Trace::command(argc, argv);
  1274. }
  1276. /*ARGSUSED*/
  1277. void
  1278. CMUTrace::recv(Packet *p, Handler *h)
  1279. {
  1280. if (!node_energy()) {
  1281. Packet::free(p);
  1282. return;
  1283. }
  1284.         assert(initialized());
  1285.         /*
  1286.          * Agent Trace "stamp" the packet with the optimal route on
  1287.          * sending.
  1288.          */
  1289.         if (tracetype == TR_AGENT && type_ == SEND) {
  1290.                 God::instance()->stampPacket(p);
  1291.         }
  1292. #if 0
  1293.         /*
  1294.          * When the originator of a packet drops the packet, it may or may
  1295.          * not have been stamped by GOD.  Stamp it before logging the
  1296.          * information.
  1297.          */
  1298.         if(src_ == src && type_ == DROP) {
  1299.                 God::instance()->stampPacket(p);
  1300.         }
  1301. #endif
  1302. format(p, "---");
  1303. pt_->dump();
  1304. //namdump();
  1305. if(target_ == 0)
  1306. Packet::free(p);
  1307. else
  1308. send(p, h);
  1309. }
  1311. void
  1312. CMUTrace::recv(Packet *p, const char* why)
  1313. {
  1314.         assert(initialized() && type_ == DROP);
  1315. if (!node_energy()) {
  1316. Packet::free(p);
  1317. return;
  1318. }
  1319. #if 0
  1320.         /*
  1321.          * When the originator of a packet drops the packet, it may or may
  1322.          * not have been stamped by GOD.  Stamp it before logging the
  1323.          * information.
  1324.          */
  1325.         if(src_ == ih->saddr()) {
  1326.                 God::instance()->stampPacket(p);
  1327.         }
  1328. #endif
  1329. format(p, why);
  1330. pt_->dump();
  1331. //namdump();
  1332. Packet::free(p);
  1333. }
  1335. int CMUTrace::node_energy()
  1336. {
  1337. Node* thisnode = Node::get_node_by_address(src_);
  1338. double energy = 1;
  1339. if (thisnode) {
  1340. if (thisnode->energy_model()) {
  1341. energy = thisnode->energy_model()->energy();
  1342. }
  1343. } 
  1344. if (energy > 0) return 1;
  1345. return 0;
  1346. }
  1348. //<zheng: ns 2.27 removed the following part, but we need it to control the broadcast radius>
  1349. void CMUTrace::calculate_broadcast_parameters() {
  1350. // Calculate the maximum distance at which a packet can be received
  1351. // based on the two-ray reflection model using the current default
  1352. // values for Phy/WirelessPhy and Antenna/OmniAntenna.
  1354. double P_t, P_r, G_t, G_r, h, L;
  1355. Tcl& tcl = Tcl::instance();
  1357. tcl.evalc("Phy/WirelessPhy set Pt_");
  1358. P_t = atof(tcl.result());
  1359. tcl.evalc("Phy/WirelessPhy set RXThresh_");
  1360. P_r = atof(tcl.result());
  1361. tcl.evalc("Phy/WirelessPhy set L_");
  1362. L = atof(tcl.result());
  1363. tcl.evalc("Antenna/OmniAntenna set Gt_");
  1364. G_t = atof(tcl.result());
  1365. tcl.evalc("Antenna/OmniAntenna set Gr_");
  1366. G_r = atof(tcl.result());
  1367. tcl.evalc("Antenna/OmniAntenna set Z_");
  1368. h = atof(tcl.result());
  1369. bradius = pow(P_t*G_r*G_t*pow(h,4.0)/(P_r*L), 0.25);
  1370. //<zheng: add for 802.15.4>
  1371. //the above calculation is not accurate for short distance
  1372. double PI,freq,lambda,crossover_dist;
  1373. PI = 3.14159265359;
  1374. tcl.evalc("Phy/WirelessPhy set freq_");
  1375. freq = atof(tcl.result());
  1376. lambda = 3.0e8/freq;
  1377. crossover_dist = (4 * PI * h * h) / lambda;
  1378. if (bradius < crossover_dist) //need re-calculation
  1379. bradius = pow(P_t * G_r * G_t * pow(lambda, 2.0)/(P_r * L), 0.5)/(4 * PI);
  1380. //</zheng: add for 802.15.4>
  1382. // Also get the scaling factors
  1383. tcl.evalc("CMUTrace set radius_scaling_factor_");
  1384. radius_scaling_factor_ = atof(tcl.result());
  1385. tcl.evalc("CMUTrace set duration_scaling_factor_");
  1386. duration_scaling_factor_ = atof(tcl.result());
  1387. }
  1388. //</zheng>