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

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

通讯编程

开发平台：

Visual C++

trace.cc：源码内容
  1. /* -*- Mode:C++; c-basic-offset:8; tab-width:8 -*- */
  2. /*
  3.  * Copyright (c) 1990-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.  * @(#) $Header: /cvsroot/nsnam/ns-2/trace/trace.cc,v 1.81 2005/07/13 03:51:33 tomh Exp $ (LBL)
  35.  */
  37. #include <stdio.h>
  38. #include <stdlib.h>
  39. #include "packet.h"
  40. #include "ip.h"
  41. #include "tcp.h"
  42. #include "sctp.h"
  43. #include "rtp.h"
  44. #include "srm.h"
  45. #include "tfrc.h"
  46. #include "flags.h"
  47. #include "address.h"
  48. #include "trace.h"
  49. #include "rap/rap.h"
  52. //const double Trace::PRECISION = 1.0e+6; 
  54. class TraceClass : public TclClass {
  55. public:
  56. TraceClass() : TclClass("Trace") { }
  57. TclObject* create(int argc, const char*const* argv) {
  58. if (argc >= 5)
  59. return (new Trace(*argv[4]));
  60. return 0;
  61. }
  62. } trace_class;
  65. Trace::Trace(int type)
  66. : Connector(), callback_(0), pt_(0), type_(type)
  67. {
  68. bind("src_", (int*)&src_);
  69. bind("dst_", (int*)&dst_);
  70. bind("callback_", &callback_);
  71. bind("show_tcphdr_", &show_tcphdr_);
  72. bind("show_sctphdr_", &show_sctphdr_);
  73. pt_ = new BaseTrace;
  74. }
  76. Trace::~Trace()
  77. {
  78. }
  80. /*
  81.  * $trace detach
  82.  * $trace flush
  83.  * $trace attach $fileID
  84.  */
  85. int Trace::command(int argc, const char*const* argv)
  86. {
  87. Tcl& tcl = Tcl::instance();
  88. if (argc == 2) {
  89. if (strcmp(argv[1], "detach") == 0) {
  90. pt_->channel(0) ;
  91. pt_->namchannel(0) ;
  92. return (TCL_OK);
  93. }
  94. if (strcmp(argv[1], "flush") == 0) {
  95. Tcl_Channel ch = pt_->channel();
  96. Tcl_Channel namch = pt_->namchannel();
  97. if (ch != 0) 
  98. pt_->flush(ch);
  99. //Tcl_Flush(pt_.channel());
  100. if (namch != 0)
  101. //Tcl_Flush(pt_->namchannel());
  102. pt_->flush(namch);
  103. return (TCL_OK);
  104. }
  105.                 if (strcmp(argv[1], "tagged") == 0) {
  106. tcl.resultf("%d", pt_->tagged());
  107.                         return (TCL_OK);
  108.                 }
  109. } else if (argc == 3) {
  110. if (strcmp(argv[1], "annotate") == 0) {
  111. if (pt_->channel() != 0)
  112. annotate(argv[2]);
  113. return (TCL_OK);
  114. }
  115. if (strcmp(argv[1], "attach") == 0) {
  116. int mode;
  117. const char* id = argv[2];
  118. Tcl_Channel ch = Tcl_GetChannel(tcl.interp(), (char*)id,
  119.   &mode);
  120. pt_->channel(ch); 
  121. if (pt_->channel() == 0) {
  122. tcl.resultf("trace: can't attach %s for writing", id);
  123. return (TCL_ERROR);
  124. }
  125. return (TCL_OK);
  126. }
  127. if (strcmp(argv[1], "namattach") == 0) {
  128. int mode;
  129. const char* id = argv[2];
  130. Tcl_Channel namch = Tcl_GetChannel(tcl.interp(), 
  131.    (char*)id, &mode);
  132. pt_->namchannel(namch); 
  133. if (pt_->namchannel() == 0) {
  134. tcl.resultf("trace: can't attach %s for writing", id);
  135. return (TCL_ERROR);
  136. }
  137. return (TCL_OK);
  138. }
  139. if (strcmp(argv[1], "ntrace") == 0) {
  140. if (pt_->namchannel() != 0) 
  141. write_nam_trace(argv[2]);
  142. return (TCL_OK);
  143. }
  144. if (strcmp(argv[1], "tagged") == 0) {
  145.                         int tag;
  146. if (Tcl_GetBoolean(tcl.interp(),
  147.    (char*)argv[2], &tag) == TCL_OK) {
  148. pt_->tagged(tag);
  149. return (TCL_OK);
  150. } else return (TCL_ERROR);
  151.                 }
  152. }
  153. return (Connector::command(argc, argv));
  154. }
  156. void Trace::write_nam_trace(const char *s)
  157. {
  158. sprintf(pt_->nbuffer(), "%s", s);
  159. pt_->namdump();
  160. }
  162. void Trace::annotate(const char* s)
  163. {
  164. if (pt_->tagged()) {
  165. sprintf(pt_->buffer(),
  166. "v "TIME_FORMAT" -e {sim_annotation %g %s}",
  167. Scheduler::instance().clock(), 
  168. Scheduler::instance().clock(), s);
  169. } else {
  170. sprintf(pt_->buffer(),
  171. "v "TIME_FORMAT" eval {set sim_annotation {%s}}", 
  172. pt_->round(Scheduler::instance().clock()), s);
  173. }
  174. pt_->dump();
  175. callback();
  176. sprintf(pt_->nbuffer(), "v -t "TIME_FORMAT" -e sim_annotation %g %s", 
  177. Scheduler::instance().clock(), 
  178. Scheduler::instance().clock(), s);
  179. pt_->namdump();
  180. }
  183. char* srm_names[] = {
  184.         SRM_NAMES
  185. };
  187. int
  188. Trace::get_seqno(Packet* p)
  189. {
  190. hdr_cmn *th = hdr_cmn::access(p);
  191. hdr_tcp *tcph = hdr_tcp::access(p);
  192. hdr_rtp *rh = hdr_rtp::access(p);
  193.         hdr_rap *raph = hdr_rap::access(p);
  194. hdr_tfrc *tfrch = hdr_tfrc::access(p);
  195. hdr_tfrc_ack *tfrch_ack = hdr_tfrc_ack::access(p);
  196. packet_t t = th->ptype();
  197. int seqno;
  199. /* UDP's now have seqno's too */
  200. if (t == PT_RTP || t == PT_CBR || t == PT_UDP || t == PT_EXP ||
  201.     t == PT_PARETO)
  202. seqno = rh->seqno();
  203.         else if (t == PT_RAP_DATA || t == PT_RAP_ACK)
  204.                 seqno = raph->seqno();
  205. else if (t == PT_TCP || t == PT_ACK || t == PT_HTTP || t == PT_FTP ||
  206.     t == PT_TELNET || t == PT_XCP)
  207. seqno = tcph->seqno();
  208. else if (t == PT_TFRC)
  209. seqno = tfrch->seqno;
  210. else if (t == PT_TFRC_ACK)
  211.                 seqno = tfrch_ack->seqno;
  212. else
  213. seqno = -1;
  214.   return seqno;
  215. }
  217. // this function should retain some backward-compatibility, so that
  218. // scripts don't break.
  219. void Trace::format(int tt, int s, int d, Packet* p)
  220. {
  221. hdr_cmn *th = hdr_cmn::access(p);
  222. hdr_ip *iph = hdr_ip::access(p);
  223. hdr_tcp *tcph = hdr_tcp::access(p);
  224. hdr_sctp *sctph = hdr_sctp::access(p);
  225. hdr_srm *sh = hdr_srm::access(p); 
  227. const char* sname = "null";
  229. packet_t t = th->ptype();
  230. const char* name = packet_info.name(t);
  232.         /* SRM-specific */
  233. if (strcmp(name,"SRM") == 0 || strcmp(name,"cbr") == 0 || strcmp(name,"udp") == 0) {
  234.             if ( sh->type() < 5 && sh->type() > 0 ) {
  235.         sname = srm_names[sh->type()];
  236.     }
  237. }
  239. if (name == 0)
  240. abort();
  242. int seqno = get_seqno(p);
  243.         /* 
  244.          * When new flags are added, make sure to change NUMFLAGS
  245.          * in trace.h
  246.          */
  247.         char flags[NUMFLAGS+1];
  248.         for (int i = 0; i < NUMFLAGS; i++)
  249. flags[i] = '-';
  250.         flags[NUMFLAGS] = 0;
  252. hdr_flags* hf = hdr_flags::access(p);
  253. flags[0] = hf->ecn_ ? 'C' : '-';          // Ecn Echo
  254. flags[1] = hf->pri_ ? 'P' : '-'; 
  255. flags[2] = '-';
  256. flags[3] = hf->cong_action_ ? 'A' : '-';   // Congestion Action
  257. flags[4] = hf->ecn_to_echo_ ? 'E' : '-';   // Congestion Experienced
  258. flags[5] = hf->fs_ ? 'F' : '-';    // Fast start: see tcp-fs and tcp-int
  259. flags[6] = hf->ecn_capable_ ? 'N' : '-';
  260. flags[7] = 0; // only for SCTP
  262. #ifdef notdef
  263. flags[1] = (iph->flags() & PF_PRI) ? 'P' : '-';
  264. flags[2] = (iph->flags() & PF_USR1) ? '1' : '-';
  265. flags[3] = (iph->flags() & PF_USR2) ? '2' : '-';
  266. flags[5] = 0;
  267. #endif
  268. char *src_nodeaddr = Address::instance().print_nodeaddr(iph->saddr());
  269. char *src_portaddr = Address::instance().print_portaddr(iph->sport());
  270. char *dst_nodeaddr = Address::instance().print_nodeaddr(iph->daddr());
  271. char *dst_portaddr = Address::instance().print_portaddr(iph->dport());
  273. if (pt_->tagged()) {
  274. sprintf(pt_->buffer(), 
  275. "%c "TIME_FORMAT" -s %d -d %d -p %s -e %d -c %d -i %d -a %d -x {%s.%s %s.%s %d %s %s}",
  276. tt,
  277. Scheduler::instance().clock(),
  278. s,
  279.   d,
  280. name,
  281. th->size(),
  282. iph->flowid(),
  283. th->uid(),
  284. iph->flowid(),
  285. src_nodeaddr,
  286. src_portaddr,
  287. dst_nodeaddr,
  288. dst_portaddr,
  289. seqno,flags,sname);
  290. } else if (show_sctphdr_ && t == PT_SCTP) {
  291. double timestamp;
  292. timestamp = Scheduler::instance().clock();
  294. for(unsigned int i = 0; i < sctph->NumChunks(); i++) {
  295. switch(sctph->SctpTrace()[i].eType) {
  296. case SCTP_CHUNK_INIT:
  297. case SCTP_CHUNK_INIT_ACK:
  298. case SCTP_CHUNK_COOKIE_ECHO:
  299. case SCTP_CHUNK_COOKIE_ACK:
  300. flags[7] = 'I';     // connection initialization
  301. break;
  303. case SCTP_CHUNK_DATA:
  304. flags[7] = 'D';
  305. break;
  307. case SCTP_CHUNK_SACK:
  308. flags[7] = 'S';
  309. break;
  311. case SCTP_CHUNK_FORWARD_TSN:
  312. flags[7] = 'R';
  313. break;
  315. case SCTP_CHUNK_HB:
  316. flags[7] = 'H';
  317. break;
  319. case SCTP_CHUNK_HB_ACK:
  320. flags[7] = 'B';
  321. break;
  322. default:
  323. assert (false);
  324. }
  325. sprintf(pt_->buffer(),
  326. "%c "TIME_FORMAT" %d %d %s %d %s %d %s.%s %s.%s %d %d %d %d %d",
  327. tt,
  328. pt_->round(timestamp),
  329. s,
  330. d,
  331. name,
  332. th->size(),
  333. flags,
  334. iph->flowid(), /* was p->class_ */
  335. src_nodeaddr,
  336. src_portaddr,
  337. dst_nodeaddr,
  338. dst_portaddr,
  339. sctph->NumChunks(),
  340. sctph->SctpTrace()[i].uiTsn,
  341. th->uid(), /* was p->uid_ */
  342. sctph->SctpTrace()[i].usStreamId,
  343. sctph->SctpTrace()[i].usStreamSeqNum);      
  345. /* The caller already calls pt_->dump() for us,
  346.  * but since SCTP needs to dump once per chunk, we
  347.  * call dump ourselves for all but the last chunk.
  348.  */
  349. assert (sctph->NumChunks() >= 1);
  350. if(i < sctph->NumChunks() - 1)
  351. pt_->dump();
  352. }
  353. } else if (!show_tcphdr_) {
  354. sprintf(pt_->buffer(), "%c "TIME_FORMAT" %d %d %s %d %s %d %s.%s %s.%s %d %d",
  355. tt,
  356. pt_->round(Scheduler::instance().clock()),
  357. s,
  358. d,
  359. name,
  360. th->size(),
  361. flags,
  362. iph->flowid() /* was p->class_ */,
  363. // iph->src() >> (Address::instance().NodeShift_[1]), 
  364.                         // iph->src() & (Address::instance().PortMask_), 
  365.                         // iph->dst() >> (Address::instance().NodeShift_[1]), 
  366.                         // iph->dst() & (Address::instance().PortMask_),
  367. src_nodeaddr,
  368. src_portaddr,
  369. dst_nodeaddr,
  370. dst_portaddr,
  371. seqno,
  372. th->uid() /* was p->uid_ */);
  373. } else {
  374. sprintf(pt_->buffer(), 
  375. "%c "TIME_FORMAT" %d %d %s %d %s %d %s.%s %s.%s %d %d %d 0x%x %d %d",
  376. tt,
  377. pt_->round(Scheduler::instance().clock()),
  378. s,
  379. d,
  380. name,
  381. th->size(),
  382. flags,
  383. iph->flowid(), /* was p->class_ */
  384.         // iph->src() >> (Address::instance().NodeShift_[1]), 
  385. // iph->src() & (Address::instance().PortMask_), 
  386.            // iph->dst() >> (Address::instance().NodeShift_[1]), 
  387.            // iph->dst() & (Address::instance().PortMask_),
  388. src_nodeaddr,
  389. src_portaddr,
  390. dst_nodeaddr,
  391. dst_portaddr,
  392. seqno,
  393. th->uid(), /* was p->uid_ */
  394. tcph->ackno(),
  395. tcph->flags(),
  396. tcph->hlen(),
  397. tcph->sa_length());
  398. }
  399. if (pt_->namchannel() != 0)
  400. sprintf(pt_->nbuffer(), 
  401. "%c -t "TIME_FORMAT" -s %d -d %d -p %s -e %d -c %d -i %d -a %d -x {%s.%s %s.%s %d %s %s}",
  402. tt,
  403. Scheduler::instance().clock(),
  404. s,
  405.   d,
  406. name,
  407. th->size(),
  408. iph->flowid(),
  409. th->uid(),
  410. iph->flowid(),
  411. src_nodeaddr,
  412. src_portaddr,
  413. dst_nodeaddr,
  414. dst_portaddr,
  415. seqno,flags,sname);
  416. delete [] src_nodeaddr;
  417.    delete [] src_portaddr;
  418.    delete [] dst_nodeaddr;
  419.     delete [] dst_portaddr;
  420. }
  422. void Trace::recv(Packet* p, Handler* h)
  423. {
  424. format(type_, src_, dst_, p);
  425. pt_->dump();
  426. callback();
  427. pt_->namdump();
  428. /* hack: if trace object not attached to anything free packet */
  429. if (target_ == 0)
  430. Packet::free(p);
  431. else
  432. send(p, h);
  433. }
  435. void Trace::recvOnly(Packet *p)
  436. {
  437. format(type_, src_, dst_, p);
  438. pt_->dump();
  439. callback();
  440. pt_->namdump();
  441. target_->recvOnly(p);
  442. }
  444. void Trace::trace(TracedVar* var)
  445. {
  446. char tmp[256] = "";
  447. Scheduler& s = Scheduler::instance();
  448. if (&s == 0)
  449. return;
  451. if (pt_->tagged()) {
  452. sprintf(pt_->buffer(), "%c "TIME_FORMAT" -a %s -n %s -v %s",
  453. type_,
  454. pt_->round(s.clock()),
  455. var->owner()->name(),
  456. var->name(),
  457. var->value(tmp, 256));
  458. } else {
  459. // format: use Mark's nam feature code without the '-' prefix
  460. sprintf(pt_->buffer(), "%c t"TIME_FORMAT" a%s n%s v%s",
  461. type_,
  462. pt_->round(s.clock()),
  463. var->owner()->name(),
  464. var->name(),
  465. var->value(tmp, 256));
  466. }
  467. pt_->dump();
  468. callback();
  469. }
  471. void Trace::callback() 
  472. {
  473. if (callback_) {
  474. Tcl& tcl = Tcl::instance();
  475. tcl.evalf("%s handle { %s }", name(), pt_->buffer());
  476. }
  477. }
  479. //
  480. // we need a DequeTraceClass here because a 'h' event need to go together
  481. // with the '-' event. It's possible to use a postprocessing script, but 
  482. // seems that's inconvient.
  483. //
  484. static class DequeTraceClass : public TclClass {
  485. public:
  486. DequeTraceClass() : TclClass("Trace/Deque") { }
  487. TclObject* create(int args, const char*const* argv) {
  488. if (args >= 5)
  489. return (new DequeTrace(*argv[4]));
  490. return NULL;
  491. }
  492. } dequetrace_class;
  495. DequeTrace::~DequeTrace()
  496. {
  497. }
  499. void 
  500. DequeTrace::recv(Packet* p, Handler* h)
  501. {
  502. // write the '-' event first
  503. format(type_, src_, dst_, p);
  504. pt_->dump();
  505. callback();
  506. pt_->namdump();
  508. if (pt_->namchannel() != 0 ||
  509.     (pt_->tagged() && pt_->channel() !=0)) {
  510. hdr_cmn *th = hdr_cmn::access(p);
  511. hdr_ip *iph = hdr_ip::access(p);
  512. hdr_srm *sh = hdr_srm::access(p);
  513. const char* sname = "null";   
  515. packet_t t = th->ptype();
  516. const char* name = packet_info.name(t);
  518. if (strcmp(name,"SRM") == 0 || strcmp(name,"cbr") == 0 || strcmp(name,"udp") == 0) {
  519.     if ( sh->type() < 5 && sh->type() > 0  ) {
  520.         sname = srm_names[sh->type()];
  521.     }
  522. }   
  524. char *src_nodeaddr = Address::instance().print_nodeaddr(iph->saddr());
  525. char *src_portaddr = Address::instance().print_portaddr(iph->sport());
  526. char *dst_nodeaddr = Address::instance().print_nodeaddr(iph->daddr());
  527. char *dst_portaddr = Address::instance().print_portaddr(iph->dport());
  529. char flags[NUMFLAGS+1];
  530. for (int i = 0; i < NUMFLAGS; i++)
  531. flags[i] = '-';
  532. flags[NUMFLAGS] = 0;
  534. hdr_flags* hf = hdr_flags::access(p);
  535. flags[0] = hf->ecn_ ? 'C' : '-';          // Ecn Echo
  536. flags[1] = hf->pri_ ? 'P' : '-'; 
  537. flags[2] = '-';
  538. flags[3] = hf->cong_action_ ? 'A' : '-';   // Congestion Action
  539. flags[4] = hf->ecn_to_echo_ ? 'E' : '-';   // Congestion Experienced
  540. flags[5] = hf->fs_ ? 'F' : '-';
  541. flags[6] = hf->ecn_capable_ ? 'N' : '-';
  542. flags[7] = 0; // only for SCTP
  544. #ifdef notdef
  545. flags[1] = (iph->flags() & PF_PRI) ? 'P' : '-';
  546. flags[2] = (iph->flags() & PF_USR1) ? '1' : '-';
  547. flags[3] = (iph->flags() & PF_USR2) ? '2' : '-';
  548. flags[5] = 0;
  549. #endif
  551. if (pt_->nbuffer() != 0) {
  552. sprintf(pt_->nbuffer(), 
  553. "%c -t "TIME_FORMAT" -s %d -d %d -p %s -e %d -c %d -i %d -a %d -x {%s.%s %s.%s %d %s %s}",
  554. 'h',
  555. Scheduler::instance().clock(),
  556. src_,
  557.    dst_,
  558. name,
  559. th->size(),
  560. iph->flowid(),
  561. th->uid(),
  562. iph->flowid(),
  563. src_nodeaddr,
  564. src_portaddr,
  565. dst_nodeaddr,
  566. dst_portaddr,
  567. -1, flags, sname);
  568. pt_->namdump();
  569. }
  570. if (pt_->tagged() && pt_->buffer() != 0) {
  571. sprintf(pt_->buffer(), 
  572. "%c "TIME_FORMAT" -s %d -d %d -p %s -e %d -c %d -i %d -a %d -x {%s.%s %s.%s %d %s %s}",
  573. 'h',
  574. Scheduler::instance().clock(),
  575. src_,
  576.    dst_,
  577. name,
  578. th->size(),
  579. iph->flowid(),
  580. th->uid(),
  581. iph->flowid(),
  582. src_nodeaddr,
  583. src_portaddr,
  584. dst_nodeaddr,
  585. dst_portaddr,
  586. -1, flags, sname);
  587. pt_->dump();
  588. }
  590. delete [] src_nodeaddr;
  591. delete [] src_portaddr;
  592. delete [] dst_nodeaddr;
  593. delete [] dst_portaddr;
  594. }
  596. /* hack: if trace object not attached to anything free packet */
  597. if (target_ == 0)
  598. Packet::free(p);
  599. else
  600. send(p, h);
  601. }