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

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

通讯编程

开发平台：

Visual C++

snoop.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 Daedalus Research
  17.  *  Group at the University of California Berkeley.
  18.  * 4. Neither the name of the University nor of the Research Group may be
  19.  *    used 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.  */
  35. #ifndef lint
  36. static const char rcsid[] =
  37.     "@(#) $Header: /cvsroot/nsnam/ns-2/tcp/snoop.cc,v 1.25 2003/01/28 23:31:03 sfloyd Exp $ (UCB)";
  38. #endif
  40. #include "snoop.h"
  42. int hdr_snoop::offset_;
  44. class SnoopHeaderClass : public PacketHeaderClass {
  45. public:
  46.         SnoopHeaderClass() : PacketHeaderClass("PacketHeader/Snoop",
  47. sizeof(hdr_snoop)) {
  48. bind_offset(&hdr_snoop::offset_);
  49. }
  50. } class_snoophdr;
  52. static class LLSnoopClass : public TclClass {
  53. public:
  54. LLSnoopClass() : TclClass("LL/LLSnoop") {}
  55. TclObject* create(int, const char*const*) {
  56. return (new LLSnoop());
  57. }
  58. } llsnoop_class;
  60. static class SnoopClass : public TclClass {
  61. public:
  62. SnoopClass() : TclClass("Snoop") {}
  63. TclObject* create(int, const char*const*) {
  64. return (new Snoop());
  65. }
  66. } snoop_class;
  68. Snoop::Snoop() : NsObject(),
  69. fstate_(0), lastSeen_(-1), lastAck_(-1), 
  70. expNextAck_(0), expDupacks_(0), bufhead_(0), 
  71. toutPending_(0), buftail_(0),
  72. wl_state_(SNOOP_WLEMPTY), wl_lastSeen_(-1), wl_lastAck_(-1), 
  73. wl_bufhead_(0), wl_buftail_(0)
  74. {
  75. bind("snoopDisable_", &snoopDisable_);
  76. bind_time("srtt_", &srtt_);
  77. bind_time("rttvar_", &rttvar_);
  78. bind("maxbufs_", &maxbufs_);
  79. bind("snoopTick_", &snoopTick_);
  80. bind("g_", &g_);
  81. bind("tailTime_", &tailTime_);
  82. bind("rxmitStatus_", &rxmitStatus_);
  83. bind("lru_", &lru_);
  85. rxmitHandler_ = new SnoopRxmitHandler(this);
  87. int i;
  88. for (i = 0; i < SNOOP_MAXWIND; i++) /* data from wired->wireless */
  89. pkts_[i] = 0;
  90. for (i = 0; i < SNOOP_WLSEQS; i++) {/* data from wireless->wired */
  91. wlseqs_[i] = (hdr_seq *) malloc(sizeof(hdr_seq));
  92. wlseqs_[i]->seq = wlseqs_[i]->num = 0;
  93. }
  94. if (maxbufs_ == 0)
  95. maxbufs_ = SNOOP_MAXWIND;
  96. }
  98. void
  99. Snoop::reset()
  100. {
  101. // printf("%x resettingn", this);
  102. fstate_ = 0;
  103. lastSeen_ = -1;
  104. lastAck_ = -1;
  105. expNextAck_ = 0;
  106. expDupacks_ = 0;
  107. bufhead_ = buftail_ = 0;
  108. if (toutPending_) {
  109. Scheduler::instance().cancel(toutPending_);
  110. // xxx: I think that toutPending_ doesn't need to be freed because snoop didn't allocate it (but I'm not sure).
  111. toutPending_ = 0;
  112. };
  113. for (int i = 0; i < SNOOP_MAXWIND; i++) {
  114. if (pkts_[i]) {
  115. Packet::free(pkts_[i]);
  116. pkts_[i] = 0;
  117. }
  118. }
  119. }
  121. void 
  122. Snoop::wlreset()
  123. {
  124. wl_state_ = SNOOP_WLEMPTY;
  125. wl_bufhead_ = wl_buftail_ = 0;
  126. for (int i = 0; i < SNOOP_WLSEQS; i++) {
  127. wlseqs_[i]->seq = wlseqs_[i]->num = 0;
  128. }
  129. }
  132. int 
  133. Snoop::command(int argc, const char*const* argv)
  134. {
  135. //Tcl& tcl = Tcl::instance();
  137. if (argc == 3) {
  138. if (strcmp(argv[1], "llsnoop") == 0) {
  139. parent_ = (LLSnoop *) TclObject::lookup(argv[2]);
  140. if (parent_)
  141. recvtarget_ = parent_->uptarget();
  142. return (TCL_OK);
  143. }
  145. if (strcmp(argv[1], "check-rxmit") == 0) {
  146. if (empty_()) {
  147. rxmitStatus_ = SNOOP_PROPAGATE;
  148. return (TCL_OK);
  149. }
  151. Packet *p = pkts_[buftail_];
  152. hdr_snoop *sh = hdr_snoop::access(p);
  154. if (sh->sndTime()!=-1 && sh->sndTime()<atoi(argv[2]) &&
  155.     sh->numRxmit() == 0)
  156. /* candidate for retransmission */
  157. rxmitStatus_ = snoop_rxmit(p);
  158. else
  159. rxmitStatus_ = SNOOP_PROPAGATE;
  160. return (TCL_OK);
  161. }
  162. }
  163. return NsObject::command(argc, argv);
  164. }
  166. void LLSnoop::recv(Packet *p, Handler *h)
  167. {
  168. Tcl &tcl = Tcl::instance();
  169. hdr_ip *iph = hdr_ip::access(p);
  171. /* get-snoop creates a snoop object if none currently exists */
  172. hdr_cmn *ch = HDR_CMN(p);
  173. if(ch->direction() == hdr_cmn::UP) 
  174. /* get-snoop creates a snoop object if none currently exists */
  175. /* In ns, addresses have ports embedded in them. */
  176. tcl.evalf("%s get-snoop %d %d", name(), iph->daddr(),
  177.   iph->saddr()); 
  178.        
  179. else  
  180. tcl.evalf("%s get-snoop %d %d", name(), iph->saddr(),
  181.   iph->daddr());
  183. Snoop *snoop = (Snoop *) TclObject::lookup(tcl.result());
  185. snoop->recv(p, h);
  187. if (integrate_)
  188. tcl.evalf("%s integrate %d %d", name(), iph->saddr(),
  189.   iph->daddr());
  190. if (h) /* resume higher layer (queue) */
  191. Scheduler::instance().schedule(h, &intr_, 0.000001);
  192. return;
  193. }
  195. /*
  196.  * Receive a packet from higher layer or from the network.
  197.  * Call snoop_data() if TCP packet and forward it on if it's an ack.
  198.  */
  199. void
  200. Snoop::recv(Packet* p, Handler* h )
  201. {
  203. hdr_cmn *ch = HDR_CMN(p);
  204. if(ch->direction() == hdr_cmn::UP) {
  205. handle((Event *) p);
  206. return;
  207. }
  209. packet_t type = hdr_cmn::access(p)->ptype();
  210. /* Put packet (if not ack) in cache after checking, and send it on */
  212. if (type == PT_TCP) 
  213. snoop_data(p);
  215. else if (type == PT_ACK)
  216. snoop_wired_ack(p);
  218. ch->direction() = hdr_cmn::DOWN;  // Ben added
  219. parent_->sendDown(p); /* vector to LLSnoop's sendto() */
  220. }
  222. /*
  223.  * Handle a packet received from peer across wireless link.  Check first
  224.  * for packet errors, then call snoop_ack() or pass it up as necessary.
  225.  */
  226. void
  227. Snoop::handle(Event *e)
  228. {
  230. Packet *p = (Packet *) e;
  231. packet_t type = hdr_cmn::access(p)->ptype();
  232. //int seq = hdr_tcp::access(p)->seqno();
  233. int prop = SNOOP_PROPAGATE; // by default;  propagate ack or packet
  234. Scheduler& s = Scheduler::instance();
  236. //hdr_ll *llh = hdr_ll::access(p);
  237. if (hdr_cmn::access(p)->error()) {
  238. parent_->drop(p); // drop packet if it's been corrupted
  239. return;
  240. }
  242. if (type == PT_ACK) 
  243. prop = snoop_ack(p); 
  245. else if (type == PT_TCP) /* XXX what about TELNET? */
  246. snoop_wless_data(p);
  248. if (prop == SNOOP_PROPAGATE)
  249. s.schedule(recvtarget_, e, parent_->delay());
  250. else { // suppress ack
  251. /* printf("---- %f suppressing ack %dn", s.clock(), seq);*/
  252. Packet::free(p);
  253. }
  254. }
  256. /*
  257.  * Data packet processing.  p is guaranteed to be of type PT_TCP when 
  258.  * this function is called.
  259.  */
  260. void
  261. Snoop::snoop_data(Packet *p)
  262. {
  263. Scheduler &s = Scheduler::instance();
  264. int seq = hdr_tcp::access(p)->seqno();
  265. int resetPending = 0;
  267. // printf("%x snoop_data: %f sending packet %dn", this, s.clock(), seq);
  268. if (fstate_ & SNOOP_ALIVE && seq == 0)
  269. reset();
  270. fstate_ |= SNOOP_ALIVE;
  271. if ((fstate_ & SNOOP_FULL) && !lru_) {
  272. // printf("snoop full, fwd'ingn t %d h %d", buftail_, bufhead_);
  273. if (seq > lastSeen_)
  274. lastSeen_ = seq;
  275. return;
  276. }
  277. /* 
  278.  * Only if the ifq is NOT full do we insert, since otherwise we want
  279.  * congestion control to kick in.
  280.  */
  282. if (parent_->ifq()->length() < parent_->ifq()->limit()-1)
  283. resetPending = snoop_insert(p);
  284. if (toutPending_ && resetPending == SNOOP_TAIL) {
  285. s.cancel(toutPending_);
  286. // xxx: I think that toutPending_ doesn't need to be freed because snoop didn't allocate it (but I'm not sure).
  287. toutPending_ = 0;
  288. }
  289. if (!toutPending_ && !empty_()) {
  290. toutPending_ = (Event *) (pkts_[buftail_]);
  291. s.schedule(rxmitHandler_, toutPending_, timeout());
  292. }
  293. return;
  294. }
  296. /* 
  297.  * snoop_insert() does all the hard work for snoop_data(). It traverses the 
  298.  * snoop cache and looks for the right place to insert this packet (or
  299.  * determines if its already been cached). It then decides whether
  300.  * this is a packet in the normal increasing sequence, whether it
  301.  * is a sender-rexmitted-but-lost-due-to-congestion (or network 
  302.  * out-of-order) packet, or if it is a sender-rexmitted packet that
  303.  * was buffered by us before.
  304.  */
  305. int
  306. Snoop::snoop_insert(Packet *p)
  307. {
  311. int i, seq = hdr_tcp::access(p)->seqno(), retval=0;
  313. if (seq <= lastAck_) 
  314. return retval;
  316. if (fstate_ & SNOOP_FULL) {
  317. /* free tail and go on */
  318. printf("snoop full, making roomn");
  319. Packet::free(pkts_[buftail_]);
  320. pkts_[buftail_] = 0;
  321. buftail_ = next(buftail_);
  322. fstate_ |= ~SNOOP_FULL;
  323. }
  325. if (seq > lastSeen_ || pkts_[buftail_] == 0) { // in-seq or empty cache
  326. i = bufhead_;
  327. bufhead_ = next(bufhead_);
  328. } else if (seq < hdr_snoop::access(pkts_[buftail_])->seqno()) {
  329. buftail_ = prev(buftail_);
  330. i = buftail_;
  331. } else {
  332. for (i = buftail_; i != bufhead_; i = next(i)) {
  333. hdr_snoop *sh = hdr_snoop::access(pkts_[i]);
  334. if (sh->seqno() == seq) {  // cached before
  336. sh->numRxmit() = 0;
  337. sh->senderRxmit() = 1; //must be a sender retr
  338. sh->sndTime() = Scheduler::instance().clock();
  339. return SNOOP_TAIL;
  340. } else if (sh->seqno() > seq) { 
  342. //not cached before, should insert in the middle
  343. // find the position it should be: prev(i)
  344.  
  345. Packet *temp = pkts_[prev(buftail_)];
  346. for (int j = buftail_; j != i; j = next(j)) 
  347. pkts_[prev(j)] = pkts_[j];
  348. i = prev(i);
  349. pkts_[i] = temp;   // seems not necessary. Ben comments
  350. buftail_ = prev(buftail_);
  351. break;
  352. }
  353. }
  355. // This should not happen, since seq must be > lastSeen, which is 
  356. // handled before in the first if.   Ben comments
  357. if (i == bufhead_)
  358. bufhead_ = next(bufhead_);
  359. }
  361. // save in the buffer
  362. savepkt_(p, seq, i);
  364. if (bufhead_ == buftail_)
  365. fstate_ |= SNOOP_FULL;
  366. /* 
  367.  * If we have one of the following packets:
  368.  * 1. a network-out-of-order packet, or
  369.  * 2. a fast rxmit packet, or 3. a sender retransmission 
  370.  * AND it hasn't already been buffered, 
  371.  * then seq will be < lastSeen_. 
  372.  * We mark this packet as having been due to a sender rexmit 
  373.  * and use this information in snoop_ack(). We let the dupacks
  374.  * for this packet go through according to expDupacks_.
  375.  */
  376. if (seq < lastSeen_) { /* not in-order -- XXX should it be <= ? */
  377. if (buftail_ == i) {
  378. hdr_snoop *sh = hdr_snoop::access(pkts_[i]);
  379. sh->senderRxmit() = 1;
  380. sh->numRxmit() = 0;
  381. }
  382. expNextAck_ = buftail_;
  383. retval = SNOOP_TAIL;
  384. } else
  385. lastSeen_ = seq;
  387. return retval;
  388. }
  390. void
  391. Snoop::savepkt_(Packet *p, int seq, int i)
  392. {
  393. pkts_[i] = p->copy();
  394. Packet *pkt = pkts_[i];
  395. hdr_snoop *sh = hdr_snoop::access(pkt);
  396. sh->seqno() = seq;
  397. sh->numRxmit() = 0;
  398. sh->senderRxmit() = 0;
  399. sh->sndTime() = Scheduler::instance().clock();
  400. }
  402. /*
  403.  * Ack processing in snoop protocol.  We know for sure that this is an ack.
  404.  * Return SNOOP_SUPPRESS if ack is to be suppressed and SNOOP_PROPAGATE o.w.
  405.  */
  406. int
  407. Snoop::snoop_ack(Packet *p)
  408. {
  409. Packet *pkt;
  411. int ack = hdr_tcp::access(p)->seqno();
  413. /*
  414.  * There are 3 cases:
  415.  * 1. lastAck_ > ack.  In this case what has happened is
  416.  *    that the acks have come out of order, so we don't
  417.  *    do any local processing but forward it on.
  418.  * 2. lastAck_ == ack.  This is a duplicate ack. If we have
  419.  *    the packet we resend it, and drop the dupack.
  420.  *    Otherwise we never got it from the fixed host, so we
  421.  *    need to let the dupack get through.
  422.  *    Set expDupacks_ to number of packets already sent
  423.  *    This is the number of dup acks to ignore.
  424.  * 3. lastAck_ < ack.  Set lastAck_ = ack, and update
  425.  *    the head of the buffer queue. Also clean up ack'd packets.
  426.  */
  427. if (fstate_ & SNOOP_CLOSED || lastAck_ > ack) 
  428. return SNOOP_PROPAGATE; // send ack onward
  430. if (lastAck_ == ack) {
  431. /* A duplicate ack; pure window updates don't occur in ns. */
  433. pkt = pkts_[buftail_];
  435. if (pkt == 0) 
  436. return SNOOP_PROPAGATE;
  438. hdr_snoop *sh = hdr_snoop::access(pkt);
  440. if (pkt == 0 || sh->seqno() > ack + 1) 
  441. /* don't have packet, letting thru' */
  442.         return SNOOP_PROPAGATE;
  444. /* 
  445.  * We have the packet: one of 3 possibilities:
  446.  * 1. We are not expecting any dupacks (expDupacks_ == 0)
  447.  * 2. We are expecting dupacks (expDupacks_ > 0)
  448.  * 3. We are in an inconsistent state (expDupacks_ == -1)
  449.  */
  452. if (expDupacks_ == 0) { // not expecting it
  453. #define RTX_THRESH 1
  455. static int thresh = 0;
  456. if (thresh++ < RTX_THRESH) 
  457. /* no action if under RTX_THRESH */
  458. return SNOOP_PROPAGATE;
  460. thresh = 0;
  462. // if the packet is a sender retransmission, pass on
  463. if (sh->senderRxmit()) 
  464. return SNOOP_PROPAGATE;
  466. /*
  467.  * Otherwise, not triggered by sender.  If this is
  468.  * the first dupack recd., we must determine how many
  469.  * dupacks will arrive that must be ignored, and also
  470.  * rexmit the desired packet.  Note that expDupacks_
  471.  * will be -1 if we miscount for some reason.
  472.  */
  475. expDupacks_ = bufhead_ - expNextAck_;
  476. if (expDupacks_ < 0)
  477. expDupacks_ += SNOOP_MAXWIND;
  478. expDupacks_ -= RTX_THRESH + 1;
  479. expNextAck_ = next(buftail_);
  481. if (sh->numRxmit() == 0) 
  482. return snoop_rxmit(pkt);
  483. } else if (expDupacks_ > 0) {
  484. expDupacks_--;
  485. return SNOOP_SUPPRESS;
  486. } else if (expDupacks_ == -1) {
  487. if (sh->numRxmit() < 2) {
  488. return snoop_rxmit(pkt);
  489. }
  490. } else // let sender deal with it
  491. return SNOOP_PROPAGATE;
  492. } else { // a new ack
  494. fstate_ &= ~SNOOP_NOACK; // have seen at least 1 new ack
  496. /* free buffers */
  497. double sndTime = snoop_cleanbufs_(ack);
  499. if (sndTime != -1)
  500. snoop_rtt(sndTime);
  502. expDupacks_ = 0;
  503. expNextAck_ = buftail_;
  504. lastAck_ = ack;
  505. }
  506. return SNOOP_PROPAGATE;
  507. }
  509. /* 
  510.  * Handle data packets that arrive from a wireless link, and we're not
  511.  * the end recipient.  See if there are any holes in the transmission, and
  512.  * if there are, mark them as candidates for wireless loss.  Then, when
  513.  * (dup)acks troop back for this loss, set the ELN bit in their header, to
  514.  * help the sender (or a snoop agent downstream) retransmit.
  515.  */
  516. void
  517. Snoop::snoop_wless_data(Packet *p)
  518. {
  519. hdr_tcp *th = hdr_tcp::access(p);
  520. int i, seq = th->seqno();
  522. if (wl_state_ & SNOOP_WLALIVE && seq == 0)
  523. wlreset();
  524. wl_state_ |= SNOOP_WLALIVE;
  526. if (wl_state_ & SNOOP_WLEMPTY && seq >= wl_lastAck_) {
  527. wlseqs_[wl_bufhead_]->seq = seq;
  528. wlseqs_[wl_bufhead_]->num = 1;
  529. wl_buftail_ = wl_bufhead_;
  530. wl_bufhead_ = wl_next(wl_bufhead_);
  531. wl_lastSeen_ = seq;
  532. wl_state_ &= ~SNOOP_WLEMPTY;
  533. return;
  534. }
  535. /* WL data list definitely not empty at this point. */
  536. if (seq >= wl_lastSeen_) {
  537. wl_lastSeen_ = seq;
  538. i = wl_prev(wl_bufhead_);
  539. if (wlseqs_[i]->seq + wlseqs_[i]->num == seq) {
  540. wlseqs_[i]->num++;
  541. return;
  542. }
  543. i = wl_bufhead_;
  544. wl_bufhead_ = wl_next(wl_bufhead_);
  545. } else if (seq == wlseqs_[i = wl_buftail_]->seq - 1) {
  546. } else
  547. return;
  549. wlseqs_[i]->seq = seq;
  550. wlseqs_[i]->num++;
  552. /* Ignore network out-of-ordering and retransmissions for now */
  553. return;
  554. }
  556. /*
  557.  * Ack from wired side (for sender on "other" side of wireless link.
  558.  */
  559. void 
  560. Snoop::snoop_wired_ack(Packet *p)
  561. {
  562. hdr_tcp *th = hdr_tcp::access(p);
  563. int ack = th->seqno();
  564. int i;
  566. if (ack == wl_lastAck_ && snoop_wlessloss(ack)) {
  567. hdr_flags::access(p)->eln_ = 1;
  568. } else if (ack > wl_lastAck_) {
  569. /* update info about unack'd data */
  570. for (i = wl_buftail_; i != wl_bufhead_; i = wl_next(i)) {
  571. hdr_seq *t = wlseqs_[i];
  572. if (t->seq + t->num - 1 <= ack) {
  573. t->seq = t->num = 0;
  574. } else if (ack < t->seq) {
  575. break;
  576. } else if (ack < t->seq + t->num - 1) {
  577. /* ack for part of a block */
  578. t->num -= ack - t->seq +1;
  579. t->seq = ack + 1;
  580. break;
  581. }
  582. }
  583. wl_buftail_ = i;
  584. if (wl_buftail_ == wl_bufhead_)
  585. wl_state_ |= SNOOP_WLEMPTY;
  586. wl_lastAck_ = ack;
  587. /* Even a new ack could cause an ELN to be set. */
  588. if (wl_bufhead_ != wl_buftail_ && snoop_wlessloss(ack))
  589. hdr_flags::access(p)->eln_ = 1;
  590. }
  591. }
  593. /* 
  594.  * Return 1 if we think this packet loss was not congestion-related, and 
  595.  * 0 otherwise.  This function simply implements the lookup into the table
  596.  * that maintains this info; most of the hard work is done in 
  597.  * snoop_wless_data() and snoop_wired_ack().
  598.  */
  599. int
  600. Snoop::snoop_wlessloss(int ack)
  601. {
  602. if ((wl_bufhead_ == wl_buftail_) || wlseqs_[wl_buftail_]->seq > ack+1)
  603. return 1;
  604. return 0;
  605. }
  607. /*
  608.  * clean snoop cache of packets that have been acked.
  609.  */
  610. double
  611. Snoop::snoop_cleanbufs_(int ack)
  612. {
  613. Scheduler &s = Scheduler::instance();
  614. double sndTime = -1;
  616. if (toutPending_) {
  617. s.cancel(toutPending_);
  618. // xxx: I think that toutPending_ doesn't need to be freed because snoop didn't allocate it (but I'm not sure).
  619. toutPending_ = 0;
  620. };
  622. if (empty_())
  623. return sndTime;
  625. int i = buftail_;
  626. do {
  627. hdr_snoop *sh = hdr_snoop::access(pkts_[i]);
  628. int seq = hdr_tcp::access(pkts_[i])->seqno();
  630. if (seq <= ack) {
  631. sndTime = sh->sndTime();
  632. Packet::free(pkts_[i]);
  633. pkts_[i] = 0;
  634. fstate_ &= ~SNOOP_FULL; /* XXX redundant? */
  635. } else if (seq > ack)
  636. break;
  637. i = next(i);
  638. } while (i != bufhead_);
  640. if ((i != buftail_) || (bufhead_ != buftail_)) {
  641. fstate_ &= ~SNOOP_FULL;
  642. buftail_ = i;
  643. }
  644. if (!empty_()) {
  645. toutPending_ = (Event *) (pkts_[buftail_]);
  646. s.schedule(rxmitHandler_, toutPending_, timeout());
  647. hdr_snoop *sh = hdr_snoop::access(pkts_[buftail_]);
  648. tailTime_ = sh->sndTime();
  649. }
  651. return sndTime;
  652. }
  654. /* 
  655.  * Calculate smoothed rtt estimate and linear deviation.
  656.  */
  657. void
  658. Snoop::snoop_rtt(double sndTime)
  659. {
  660. double rtt = Scheduler::instance().clock() - sndTime;
  662. if (parent_->integrate()) {
  663. parent_->snoop_rtt(sndTime);
  664. return;
  665. }
  667. if (rtt > 0) {
  668. srtt_ = g_*srtt_ + (1-g_)*rtt;
  669. double delta = rtt - srtt_;
  670. if (delta < 0)
  671. delta = -delta;
  672. if (rttvar_ != 0)
  673. rttvar_ = g_*delta + (1-g_)*rttvar_;
  674. else 
  675. rttvar_ = delta;
  676. }
  677. }
  680. /* 
  681.  * Calculate smoothed rtt estimate and linear deviation.
  682.  */
  683. void
  684. LLSnoop::snoop_rtt(double sndTime)
  685. {
  686. double rtt = Scheduler::instance().clock() - sndTime;
  687. if (rtt > 0) {
  688. srtt_ = g_*srtt_ + (1-g_)*rtt;
  689. double delta = rtt - srtt_;
  690. if (delta < 0)
  691. delta = -delta;
  692. if (rttvar_ != 0)
  693. rttvar_ = g_*delta + (1-g_)*rttvar_;
  694. else 
  695. rttvar_ = delta;
  696. }
  697. }
  699. /*
  700.  * Returns 1 if recent queue length is <= half the maximum and 0 otherwise.
  701.  */
  702. int 
  703. Snoop::snoop_qlong()
  704. {
  705. /* For now only instantaneous lengths */
  706. // if (parent_->ifq()->length() <= 3*parent_->ifq()->limit()/4)
  708. return 1;
  709. // return 0;
  710. }
  712. /*
  713.  * Ideally, would like to schedule snoop retransmissions at higher priority.
  714.  */
  715. int
  716. Snoop::snoop_rxmit(Packet *pkt)
  717. {
  718. Scheduler& s = Scheduler::instance();
  719. if (pkt != 0) {
  720. hdr_snoop *sh = hdr_snoop::access(pkt);
  721. if (sh->numRxmit() < SNOOP_MAX_RXMIT && snoop_qlong()) {
  722. /* && sh->seqno() == lastAck_+1)  */
  724. #if 0
  725. printf("%f Rxmitting packet %dn", s.clock(), 
  726.        hdr_tcp::access(pkt)->seqno());
  727. #endif
  729. // need to specify direction, in this case, down
  730. hdr_cmn *ch = HDR_CMN(pkt);       
  731. ch->direction() = hdr_cmn::DOWN;  // Ben added
  733. sh->sndTime() = s.clock();
  734. sh->numRxmit() = sh->numRxmit() + 1;
  735. Packet *p = pkt->copy();
  736. parent_->sendDown(p);
  737. } else 
  738. return SNOOP_PROPAGATE;
  739. }
  740. /* Reset timeout for later time. */
  741. if (toutPending_) {
  742. s.cancel(toutPending_);
  743. // xxx: I think that toutPending_ doesn't need to be freed because snoop didn't allocate it (but I'm not sure).
  744. };
  745. toutPending_ = (Event *)pkt;
  746. s.schedule(rxmitHandler_, toutPending_, timeout());
  747. return SNOOP_SUPPRESS;
  748. }
  750. void 
  751. Snoop::snoop_cleanup()
  752. {
  753. }
  755. void
  756. SnoopRxmitHandler::handle(Event *)
  757. {
  758. Packet *p = snoop_->pkts_[snoop_->buftail_];
  759. snoop_->toutPending_ = 0;
  760. if (p == 0)
  761. return;
  762. hdr_snoop *sh = hdr_snoop::access(p);
  763. if (sh->seqno() != snoop_->lastAck_ + 1)
  764. return;
  765. if ((snoop_->bufhead_ != snoop_->buftail_) || 
  766.     (snoop_->fstate_ & SNOOP_FULL)) {
  767. // printf("%f Snoop timeoutn", Scheduler::instance().clock());
  768. if (snoop_->snoop_rxmit(p) == SNOOP_SUPPRESS)
  769. snoop_->expNextAck_ = snoop_->next(snoop_->buftail_);
  770. }
  771. }