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

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

通讯编程

开发平台：

Visual C++

tcp-full-bay.cc：源码内容
  1. /*
  2.  * Copyright (c) 1997 The Regents of the University of California.
  3.  * All rights reserved.
  4.  * 
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  * 1. Redistributions of source code must retain the above copyright
  9.  *    notice, this list of conditions and the following disclaimer.
  10.  * 2. Redistributions in binary form must reproduce the above copyright
  11.  *    notice, this list of conditions and the following disclaimer in the
  12.  *    documentation and/or other materials provided with the distribution.
  13.  * 3. All advertising materials mentioning features or use of this software
  14.  *    must display the following acknowledgement:
  15.  *  This product includes software developed by the Network Research
  16.  *  Group at Lawrence Berkeley National Laboratory.
  17.  * 4. Neither the name of the University nor of the Laboratory may be used
  18.  *    to endorse or promote products derived from this software without
  19.  *    specific prior written permission.
  20.  * 
  21.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31.  * SUCH DAMAGE.
  32.  */
  34. /*
  35.  * This code below was motivated in part by code contributed by
  36.  * Kathie Nichols (nichols@com21.com).  The code below is based primarily
  37.  * on the 4.4BSD TCP implementation. -KF [kfall@ee.lbl.gov]
  38.  *
  39.  * Major revisions, 8/97, kmn (vj)
  40.  *
  41.  * Some Warnings:
  42.  * this version of TCP will not work correctly if the sequence number
  43.  * goes above 2147483648 due to sequence number wrap
  44.  *
  45.  * this version of TCP currently sends data on the 3rd segment of
  46.  * the initial 3-way handshake.  So, the typical sequence of events is
  47.  * A   ------> SYN ------> B
  48.  * A   <----- SYN+ACK ---- B
  49.  * A   ------> ACK+data -> B
  50.  * whereas many "real-world" TCPs don't send data until a 4th segment
  51.  *
  52.  * there is no dynamic receiver's advertised window.   The advertised
  53.  * window is simulated by simply telling the sender a bound on the window
  54.  * size (wnd_).
  55.  *
  56.  * in real TCP, a user process performing a read (via PRU_RCVD)
  57.  * calls tcp_output each time to (possibly) send a window
  58.  * update.  Here we don't have a user process, so we simulate
  59.  * a user process always ready to consume all the receive buffer
  60.  *
  61.  * Notes:
  62.  * wnd_, wnd_init_, cwnd_, ssthresh_ are in segment units
  63.  * sequence and ack numbers are in byte units
  64.  *
  65.  * Futures:
  66.  * there are different existing TCPs with respect to how
  67.  * ack's are handled on connection startup.  Some delay
  68.  * the ack for the first segment, which can cause connections
  69.  * to take longer to start up than if we be sure to ack it quickly.
  70.  */
  72. #ifndef lint
  73. static const char rcsid[] =
  74.     "@(#) $Header: /cvsroot/nsnam/ns-2/baytcp/tcp-full-bay.cc,v 1.6 2006/12/17 15:17:01 mweigle Exp $ (LBL)";
  75. #endif
  77. #include "tclcl.h"
  78. #include "ip.h"
  79. #include "tcp-full-bay.h"
  80. #include "flags.h"
  81. #include "random.h"
  82. #include "template.h"
  84. #define TRUE  1
  85. #define FALSE  0
  87. static class BayFullTcpClass : public TclClass { 
  88. public:
  89.     BayFullTcpClass() : TclClass("Agent/TCP/BayFullTcp") {}
  90.     TclObject* create(int, const char*const*) { 
  91.         return (new BayFullTcpAgent());
  92.     }
  93. } class_bayfull;
  95. static class TahoeBayFullTcpClass : public TclClass { 
  96. public:
  97. TahoeBayFullTcpClass() : TclClass("Agent/TCP/BayFullTcp/Tahoe") {}
  98.   TclObject* create(int, const char*const*) { 
  99.     // tcl lib code
  100.     // sets reno_fastrecov_ to false
  101.     //return (new BayFullTcpAgent());
  102.     fprintf(stderr,"Tahoe, NewReno or Sack flavors are NOT available for BayTCP!! Use BayFullTcp only, which actually implements Reno.n");
  104.     exit(1);
  105.     return NULL;
  106. }
  107. } class_tahoe_bayfull;
  109. static class NewRenoBayFullTcpClass : public TclClass { 
  110. public:
  111. NewRenoBayFullTcpClass() : TclClass("Agent/TCP/BayFullTcp/Newreno") {}
  112. TclObject* create(int, const char*const*) { 
  113.   // tcl lib code
  114.   // sets deflate_on_pack_ to false
  115.   //return (new BayFullTcpAgent());
  116.   fprintf(stderr,"Tahoe, NewReno or Sack flavors are NOT available for BayFullTCP!! Use BayFullTcp only, which actually implements Reno.n");
  117.   exit(1);
  118.   return NULL;
  119. }
  120. } class_newreno_bayfull;
  122. static class SackBayFullTcpClass : public TclClass { 
  123. public:
  124. SackBayFullTcpClass() : TclClass("Agent/TCP/BayFullTcp/Sack") {}
  125. TclObject* create(int, const char*const*) { 
  126.   //return (new BayFullTcpAgent());
  127.   fprintf(stderr,"Tahoe, NewReno or Sack flavors are NOT available for BayFullTCP!! Use BayFullTcp only, which actually implements Reno.n");
  128.   exit(1);
  129.   return NULL;
  130. }
  131. } class_sack_bayfull;
  133. /*
  134.  * Tcl bound variables:
  135.  * segsperack: for delayed ACKs, how many to wait before ACKing
  136.  * segsize: segment size to use when sending
  137.  */
  138. BayFullTcpAgent::BayFullTcpAgent() : flags_(0),
  139. state_(TCPS_CLOSED), rq_(rcv_nxt_), last_ack_sent_(0), app_(0),
  140. delack_timer_(this)
  141. {
  142. bind("segsperack_", &segs_per_ack_);
  143. bind("segsize_", &maxseg_);
  144. bind("tcprexmtthresh_", &tcprexmtthresh_);
  145. bind("iss_", &iss_);
  146. bind_bool("nodelay_", &nodelay_);
  147. bind_bool("data_on_syn_",&data_on_syn_);
  148. bind_bool("dupseg_fix_", &dupseg_fix_);
  149. bind_bool("dupack_reset_", &dupack_reset_);
  150. bind("interval_", &delack_interval_);
  151. }
  153. void
  154. BayFullTcpAgent::delay_bind_init_all()
  155. {
  156. TcpAgent::delay_bind_init_all();
  157.        reset();
  158. }
  160. int
  161. BayFullTcpAgent::delay_bind_dispatch(const char *varName, const char *localName, TclObject *tracer)
  162. {
  163.         return TcpAgent::delay_bind_dispatch(varName, localName, tracer);
  164. }
  166. /*
  167.  * reset to starting point, don't set state_ here,
  168.  * because our starting point might be LISTEN rather
  169.  * than CLOSED if we're a passive opener
  170.  */
  171. void
  172. BayFullTcpAgent::reset()
  173. {
  174. TcpAgent::reset();
  175. highest_ack_ = 0;
  176. last_ack_sent_ = 0;
  177. rcv_nxt_ = 0; //kmn
  178. flags_ = 0;
  179. t_seqno_ = iss_;
  180. close_on_empty_ = 0; //added 7/30/97 by kmn
  181. switch_spa_thresh_ = 0;
  182. first_data_ = 0; //don't open cwnd too early
  183. }
  185. void
  186. BayFullTcpAgent::reinit()
  187. {
  188. cancel_rtx_timeout();
  189. rtt_init();
  190. cwnd_ = wnd_init_;
  191. last_ack_ = highest_ack_ = 0;
  192. ssthresh_ = int(wnd_);
  193. awnd_ = wnd_init_ / 2.0;
  194. recover_ = 0;
  195. recover_cause_ = 0;
  197. last_ack_sent_ = 0;
  198. rcv_nxt_ = 0; //kmn
  199. flags_ = 0;
  200. t_seqno_ = maxseq_ = iss_;
  201. switch_spa_thresh_ = 0;
  202. /*
  203. for(int i =0; i < NTIMER; i++) {
  204. cancel(i);
  205. }
  206. */
  207. rq_.clear();
  208. first_data_ = 0; //don't open cwnd too early
  209. }
  211. /*
  212.  * headersize:
  213.  * how big is an IP+TCP header in bytes
  214.  * (for now, is the basic size, but may changes
  215.  *  in the future w/options; fix for sack)
  216.  */
  217. int
  218. BayFullTcpAgent::headersize()
  219. {
  220. return (TCPIP_BASE_PKTSIZE);
  221. }
  223. /*
  224.  * cancel any pending timers
  225.  * free up the reassembly queue if there's anything there
  226.  */
  227. BayFullTcpAgent::~BayFullTcpAgent()
  228. {
  229.   /*
  230.    * not required any more
  231. register i;
  232. for (i = 0; i < NTIMER; i++)
  233. if (pending_[i])
  234. cancel(i);
  235.   */
  236. rq_.clear();
  237. }
  239. /*
  240.  * the 'advance' interface to the regular tcp is in packet
  241.  * units.  Here we scale this to bytes for full tcp.
  242.  *
  243.  * 'advance' is normally called by an "application" (i.e. data source)
  244.  * to signal that there is something to send
  245.  *
  246.  * 'curseq_' is the last byte number provided by the application
  247.  */
  248. void
  249. BayFullTcpAgent::advance(int np)
  250. {
  251. // XXX hack:
  252. // because np is in packets and a data source
  253. // may pass a *huge* number as a way to tell us
  254. // to go forever, just look for the huge number
  255. // and if it's there, pre-divide it
  256. if (np >= 0x10000000)
  257. np /= maxseg_;
  259. curseq_ += (np * maxseg_);
  261. //
  262. // state-specific operations:
  263. // if CLOSED, do an active open/connect
  264. // if ESTABLISHED, just try to send more
  265. // if above ESTABLISHED, we are closing, so don't allow
  266. // if anything else (establishing), do nothing here
  267. //
  268. if (state_ > TCPS_ESTABLISHED) {
  269. fprintf(stderr,
  270.  "%f: BayFullTcpAgent::advance(%s): cannot advance while in state %dn",
  271.  now(), name(), state_);
  272. return;
  273. } else if (state_ == TCPS_CLOSED) {
  274. connect(); // initiate new connection
  275. } else if (state_ == TCPS_ESTABLISHED)
  276. send_much(0, REASON_NORMAL, 0);
  277. return;
  278. }
  279. /*
  280.  * added 7/30/97 by kmn to allow to pass bytes and set close_on_empty_
  281.  */
  282. int
  283. BayFullTcpAgent::advance(int n, int close_flag)
  284. {
  285. close_on_empty_ = close_flag;
  287. //
  288. // state-specific operations:
  289. // if CLOSED, do an active open/connect
  290. // if ESTABLISHED, just try to send more
  291. // if above ESTABLISHED, we are closing, so don't allow
  292. // if anything else (establishing), do nothing here
  293. //
  294. if (state_ > TCPS_ESTABLISHED) {
  295. return 0; //try again later, please
  296. } else if (state_ == TCPS_CLOSED) {
  297. curseq_ = iss_ + n;
  298. reinit();
  299. connect(); // initiate new connection
  300. }
  301. else if (state_ == TCPS_ESTABLISHED)
  302. curseq_ += n;
  303. else
  304. return 0;
  305. return 1;
  306. }
  307. /*
  308.  * flags that are completely dependent on the tcp state
  309.  * (in real TCP, see tcp_fsm.h, the "tcp_outflags" array)
  310.  */
  311. int BayFullTcpAgent::outflags()
  312. {
  313. int flags = 0;
  314. if ((state_ != TCPS_LISTEN) && (state_ != TCPS_SYN_SENT))
  315. flags |= TH_ACK;
  317. if ((state_ == TCPS_SYN_SENT) || (state_ == TCPS_SYN_RECEIVED))
  318. flags |= TH_SYN;
  320. if ((state_ == TCPS_FIN_WAIT_1) || (state_ == TCPS_LAST_ACK))
  321. flags |= TH_FIN;
  323. return (flags);
  324. }
  326. void BayFullTcpAgent::sendpacket(int seqno, int ackno, int pflags, int datalen,
  327.       int reason, Packet *p)
  328. {
  329. if (!p) p = allocpkt();
  330. hdr_tcp *tcph = hdr_tcp::access(p);
  331. hdr_cmn *th = hdr_cmn::access(p);
  332. tcph->seqno() = seqno;
  333. tcph->ackno() = ackno;
  334. tcph->flags() = pflags;
  335. tcph->hlen() = headersize();
  336. tcph->ts() = now();
  337.     /* Open issue:  should tcph->reason map to pkt->flags_ as in ns-1?? */
  338. tcph->reason() |= reason;
  339. th->size() = datalen + headersize();
  340. if (datalen <= 0)
  341. ++nackpack_;
  342. else {
  343. ++ndatapack_;
  344. ndatabytes_ += datalen;
  345. }
  346. if (reason == REASON_TIMEOUT || reason == REASON_DUPACK) {
  347. ++nrexmitpack_;
  348. nrexmitbytes_ += datalen;
  349. }
  350. send(p, 0);
  351. }
  353. /*
  354.  * see if we should send a segment, and if so, send it
  355.  * (may be ACK or data)
  356.  * 'maxseq_' is called 'snd_max' in "real" TCP
  357.  * and is the largest seq number we've sent
  358.  *
  359.  * maxseg_, largest seq# we've sent (snd_max)
  360.  * flags_, flags regarding our internal state (t_state)
  361.  * pflags, a local used to build up the tcp header flags (flags)
  362.  * curseq_, is the highest sequence number given to us by "application"
  363.  * highest_ack_, the highest ACK we've seen for our data (snd_una)
  364.  * seqno, the next seq# we're going to send (snd_nxt), this will
  365.  * update t_seqno_ (the last thing we sent)
  366.  */
  367. void BayFullTcpAgent::output(int seqno, int reason)
  368. {
  369. int is_retransmit = (seqno < maxseq_);
  370. int idle = (highest_ack_ == maxseq_);
  372. //kmn - changing all this for clarity 8/7/97
  373. int buffered_bytes = (curseq_ + iss_) - seqno;
  374. int datalen = min(buffered_bytes, (highest_ack_ + (window() * maxseg_)) - seqno);
  375. int pflags = outflags();
  376. int emptying_buffer = 0;
  378. if((pflags & TH_SYN) || datalen <= 0)
  379. datalen = 0;
  380. else if(datalen > maxseg_) {
  381. datalen = maxseg_;
  382. } else if(datalen == buffered_bytes) {
  383. emptying_buffer = 1;
  384. pflags |= TH_PUSH;
  385. //usrclosed() causes nested calls to output()
  386. if(close_on_empty_) {
  387. pflags |= TH_FIN;
  388. state_ = TCPS_FIN_WAIT_1;
  389. }
  390. }
  392. //end of kmn changes
  394. /* turn off FIN if there's really more to send */
  395. if (datalen > 0 && !emptying_buffer)
  396. pflags &= ~TH_FIN;
  398. /* sender SWS avoidance (Nagle) */
  400. if (datalen > 0) {
  401. // if full-sized segment, ok
  402. if (datalen == maxseg_)
  403. goto send;
  404. // if Nagle disabled and buffer clearing, ok
  405. if ((idle || nodelay_)  && emptying_buffer)
  406. goto send;
  407. // if a retransmission
  408. if (is_retransmit)
  409. goto send;
  410. // if big "enough", ok...
  411. // (this is not a likely case, and would
  412. // only happen for tiny windows)
  413. if (datalen >= ((wnd_ * maxseg_) / 2.0))
  414. goto send;
  415. }
  417. if (need_send())
  418. goto send;
  420. /*
  421.  * send now if a SYN or special flag "TF_ACKNOW" is set.
  422.  * TF_ACKNOW can be set during connection establishment and
  423.  * to generate acks for out-of-order data
  424.  * kmn 8/28 need to send if there's a push
  425.  */
  426. if ((flags_ & TF_ACKNOW) || (pflags & (TH_SYN|TH_FIN|TH_PUSH)))
  427. goto send;
  429. return; // no reason to send now
  431. send:
  432. //these changed by vj and kmn
  433. if (pflags & TH_FIN) {
  434. if (flags_ & TF_SENTFIN) {
  435. // don't allow seqno to advance past fin
  436. // (the ack generated by a discarded duplicate
  437. // may attempt to do this)
  438. if (seqno >= maxseq_)
  439. --seqno;
  440. } else {
  441. flags_ |= TF_SENTFIN;
  442. ++t_seqno_;
  443. }
  444. }
  446. if((pflags & TH_SYN)) {
  447. if ((flags_ & TF_SENTSYN) == 0) {
  448. flags_ |= TF_SENTSYN;
  449. ++t_seqno_;
  450. }
  451. }
  453. /*
  454.  * fill in packet fields.  Agent::allocpkt()
  455.  * has already filled most of the network layer
  456.  * fields for us.   So fill in tcp hdr and adjust
  457.  * the packet size.
  458.  */
  459. sendpacket(seqno, rcv_nxt_, pflags, datalen, reason);
  460. last_ack_sent_ = rcv_nxt_;
  461. flags_ &= ~(TF_ACKNOW|TF_DELACK);
  463. t_seqno_ += datalen; // update snd_nxt (t_seqno_)
  464. if (t_seqno_ > maxseq_) {
  465. maxseq_ = t_seqno_;  // largest seq# we've sent
  466. /*
  467.  * Time this transmission if not a retransmission and
  468.  * not currently timing anything.
  469.  */
  470. if (rtt_active_ == FALSE) {
  471. rtt_active_ = TRUE; // set timer
  472. rtt_seq_ = seqno;  // timed seq #
  473. }
  474. }
  475. /*
  476.  * Set retransmit timer if not currently set,
  477.  * and not doing an ack or a keep-alive probe.
  478.  * Initial value for retransmit timer is smoothed
  479.  * round-trip time + 2 * round-trip time variance.
  480.  * Future values are rtt + 4 * rttvar.
  481.  */
  482. if (!(rtx_timer_.status() == TIMER_PENDING) && (t_seqno_ > highest_ack_)) {
  483. set_rtx_timer();  // no timer pending, schedule one
  484. }
  485. }
  487. /*
  488.  * Try to send as much data as the window will allow.  The link layer will 
  489.  * do the buffering; we ask the application layer for the size of the packets.
  490.  */
  491. void BayFullTcpAgent::send_much(int force, int reason, int maxburst)
  492. {
  494. /*
  495.  * highest_ack is essentially "snd_una" in real TCP
  496.  *
  497.  * loop while we are in-window (seqno <= (highest_ack + win))
  498.  * and there is something to send (t_seqno_ < curseq_+iss_)
  499.  */
  500. int win = window() * maxseg_; // window() in pkts
  501. int npackets = 0;
  502. int topwin = curseq_ + iss_;
  503. if (topwin > highest_ack_ + win)
  504. topwin = highest_ack_ + win;
  506. if (!force && (delsnd_timer_.status() == TIMER_PENDING))
  507. return;
  509. while (force || (t_seqno_ < topwin)) {
  510. if (overhead_ != 0 && !(delsnd_timer_.status() == TIMER_PENDING)) {
  511. delsnd_timer_.resched(Random::uniform(overhead_));
  512. return;
  513. }
  514. output(t_seqno_, reason); // updates seqno for us
  515. force = 0;
  516. if (outflags() & TH_SYN)
  517. break;
  518. if (maxburst && ++npackets >= maxburst)
  519. break;
  520. }
  521. }
  523. void BayFullTcpAgent::cancel_rtx_timeout()
  524. {
  525. if (rtx_timer_.status() == TIMER_PENDING) {
  526. rtx_timer_.cancel();
  527. }
  528. }
  530. /*
  531.  * Process an ACK
  532.  * this version of the routine doesn't necessarily
  533.  * require the ack to be one which advances the ack number
  534.  *
  535.  * if this ACKs a rtt estimate
  536.  * indicate we are not timing
  537.  * reset the exponential timer backoff (gamma)
  538.  * update rtt estimate
  539.  * cancel retrans timer if everything is sent and ACK'd, else set it
  540.  * advance the ack number if appropriate
  541.  * update segment to send next if appropriate
  542.  */
  543. void BayFullTcpAgent::newack(Packet* pkt)
  544. {
  545.     hdr_tcp *tcph = hdr_tcp::access(pkt);
  547. register int ackno = tcph->ackno();
  549. // we were timing the segment and we
  550. // got an ACK for it
  551. if (rtt_active_ && ackno >= rtt_seq_) {
  552. /* got a rtt sample */
  553. rtt_active_ = FALSE; // no longer timing
  554. t_backoff_ = 1; // stop exp backoff
  555. }
  557. /* always with timestamp option */
  558. double tao = now() - tcph->ts();
  559. rtt_update(tao);
  561. if (ackno >= maxseq_)
  562. cancel_rtx_timeout();
  563. else {
  564. if (ackno > highest_ack_) {
  565. set_rtx_timer();
  566. }
  567. }
  569. // advance the ack number if this is for new data
  570. if (ackno > highest_ack_)
  571. highest_ack_ = ackno;
  572. // set up the next packet to send
  573. if (t_seqno_ < highest_ack_)
  574. t_seqno_ = highest_ack_; // thing to send next
  575. }
  577. /*
  578.  * nuked this stuff, but left in method - kmn
  579.  */
  580. int BayFullTcpAgent::predict_ok(Packet* )
  581. {
  582. return 0;
  583. }
  585. /*
  586.  * fast_retransmit using the given seqno
  587.  * perform a fast retransmit
  588.  * kludge t_seqno_ (snd_nxt) so we do the
  589.  * retransmit then continue from where we were
  590.  */
  592. void BayFullTcpAgent::fast_retransmit(int seq)
  593. {       
  594.         rtt_backoff();                  // bug fix by van to avoid spurious rtx
  595. int onxt = t_seqno_; // output() changes t_seqno_
  596. recover_ = maxseq_; // keep a copy of highest sent
  597. recover_cause_ = REASON_DUPACK; // why we started this recovery period
  598. output(seq, REASON_DUPACK); // send one pkt
  599. t_seqno_ = onxt;
  600. }
  602. /*
  603.  * real tcp determines if the remote
  604.  * side should receive a window update/ACK from us, and often
  605.  * results in sending an update every 2 segments, thereby
  606.  * giving the familiar 2-packets-per-ack behavior of TCP.
  607.  * Here, we don't advertise any windows, so we just see if
  608.  * there's at least 'segs_per_ack_' pkts not yet acked
  609.  */
  610.  /* kmn - adding code to switch from one seg per ack to set value
  611.   */
  613. int BayFullTcpAgent::need_send()
  614. {
  615. //first cut, send if anything to ack. Might need maxseg_
  616. if(flags_ & TF_ACKNOW)
  617. return 1;
  618. if(rcv_nxt_ < switch_spa_thresh_)
  619. return ((rcv_nxt_ - last_ack_sent_) >= 1);
  620. return ((rcv_nxt_ - last_ack_sent_) >= (segs_per_ack_ * maxseg_));
  621. }
  623. /*
  624.  * deal with timers going off.
  625.  * 2 types for now:
  626.  * retransmission timer (TCP_TIMER_RTX)
  627.  * delayed send (randomization) timer (TCP_TIMER_DELSND)
  628.  *
  629.  * real TCP initializes the RTO as 6 sec
  630.  * (  ^ 3sec, kmn )
  631.  * (A + 2D, where A=0, D=3), [Stevens p. 305]
  632.  * and thereafter uses
  633.  * (A + 4D, where A and D are dynamic estimates)
  634.  *
  635.  * note that in the simulator t_srtt_, t_rttvar_ and t_rtt_
  636.  * are all measured in 'tcp_tick_'-second units
  637.  */
  638. void BayFullTcpAgent::timeout(int tno)
  639. {
  640. if(state_ == TCPS_CLOSED || state_ == TCPS_LISTEN)
  641. return;
  642.         /* retransmit timer */
  643.         if (tno == TCP_TIMER_RTX) {
  644. ++nrexmit_;
  645. recover_ = maxseq_;
  646. recover_cause_ = REASON_TIMEOUT;
  647.                 slowdown(CLOSE_SSTHRESH_HALF|CLOSE_CWND_RESTART);
  648. //changed 6/10/00 to look at rtx problem -kmn
  649. /* if(highest_ack_ == maxseq_)
  650. reset_rtx_timer(0,0);
  651. else
  652.                  reset_rtx_timer(0,1);
  653. */
  654.                 reset_rtx_timer(1);
  655. t_seqno_ = highest_ack_;
  656. dupacks_ = 0;
  657.                 send_much(1, REASON_TIMEOUT);
  658.         } else if (tno == TCP_TIMER_DELSND) {
  659.                 /*
  660.                  * delayed-send timer, with random overhead
  661.                  * to avoid phase effects
  662.                  */
  663.                 send_much(1, PF_TIMEOUT);
  664.         } else if (tno == TCP_TIMER_DELACK) {
  665. if (flags_ & TF_DELACK) {
  666. flags_ &= ~TF_DELACK;
  667. flags_ |= TF_ACKNOW;
  668. send_much(1, REASON_NORMAL, 0);
  669. }
  670. delack_timer_.resched(delack_interval_);
  671. } else {
  672. fprintf(stderr, "%f: (%s) UNKNOWN TIMEOUT %dn",
  673. now(), name(), tno);
  674. }
  675. }
  677. /*
  678.  * introduced kedar
  679.  */
  681. void BayDelAckTimer::expire(Event *) {
  682. a_->timeout(TCP_TIMER_DELACK);
  683. }
  685. /*
  686.  * main reception path - 
  687.  * called from the agent that handles the data path below in its muxing mode
  688.  * advance() is called when connection is established with size sent from
  689.  * user/application agent
  690.  */
  691. void BayFullTcpAgent::recv(Packet *pkt, Handler*)
  692. {
  693. hdr_tcp *tcph = hdr_tcp::access(pkt);
  694. hdr_cmn *th = hdr_cmn::access(pkt);
  695. hdr_ip *iph = hdr_ip::access(pkt);
  696. int needoutput = 0;
  697. int ourfinisacked = 0;
  698. int todrop = 0;
  699. int dupseg = FALSE;
  701. #ifdef notdef
  702. if (trace_)
  703. plot();
  704. #endif
  706. //
  707. // if no delayed-ACK timer is set, set one
  708. // they are set to fire every 'interval_' secs, starting
  709. // at time t0 = (0.0 + k * interval_) for some k such
  710. // that t0 > now
  711. //
  712. /*
  713. if (!pending_[TCP_TIMER_DELACK]) {
  714. */
  715. if (!(delack_timer_.status() == TIMER_PENDING)) {
  716. double now = Scheduler::instance().clock();
  717. int last = int(now / delack_interval_);
  718. delack_timer_.resched(delack_interval_ * (last + 1.0) - now);
  720. }
  722. int datalen = th->size() - tcph->hlen();
  723. int ackno = tcph->ackno(); // ack # from packet
  725. // nuked header prediction code that was here - kmn 8/5/97
  727. int tiflags = tcph->flags() ; // tcp flags from packet
  729. switch (state_) {
  730. case TCPS_LISTEN: /* awaiting peer's SYN */
  731. if (tiflags & TH_ACK) {
  732. if (tiflags & TH_FIN) {
  733. sendpacket(tcph->ackno(), tcph->seqno()+1,
  734.    TH_ACK, 0, REASON_NORMAL);
  735. goto drop;
  736. }
  737. // ACK shouldn't be on here
  738. // kmn - this can be from previous connection if reusing
  739. // fprintf(stderr,
  740. //     "%f: BayFullTcpAgent::recv(%s): got ACK(%d) while in LISTENn",
  741. // now(), name(), ackno);
  742. goto drop;
  743. }
  744. if ((tiflags & TH_SYN) == 0) {
  745. // we're looking for a SYN in return
  746. fprintf(stderr,
  747.     "%f: BayFullTcpAgent::recv(%s): got a non-SYN while in LISTENn",
  748. now(), name());
  749. goto drop;
  750. }
  751. flags_ |= TF_ACKNOW;
  752. state_ = TCPS_SYN_RECEIVED;
  753. rcv_nxt_ = tcph->seqno() + 1; //kmn
  754. t_seqno_ = iss_;
  755. //kmn - switch from one to set segs per ack
  756. switch_spa_thresh_ = rcv_nxt_ + (16 * 1024);
  757. goto step6;
  758. case TCPS_SYN_SENT: /* we sent SYN, expecting SYN+ACK */
  759. if ((tiflags & TH_ACK) && (ackno > maxseq_)) {
  760. // not an ACK for our SYN, discard
  761. // fprintf(stderr,
  762. //     "%f: BayFullTcpAgent::recv(%s): bad ACK (%d) for our SYN(%d)n",
  763. //         now(), name(), int(ackno), int(maxseq_));
  764. goto drop;
  765. }
  766. if ((tiflags & TH_SYN) == 0) {
  767. // we're looking for a SYN in return
  768. fprintf(stderr,
  769.     "%f: BayFullTcpAgent::recv(%s): no SYN for our SYN(%d)n",
  770.         now(), name(), int(maxseq_));
  771. goto drop;
  772. }
  773. rcv_nxt_ = tcph->seqno()+1; // initial expected seq#
  774. //kmn - switch from one to set segs per ack
  775. switch_spa_thresh_ = rcv_nxt_ + (16 * 1024);
  776. cancel_rtx_timeout(); // cancel timer on our 1st SYN
  777. flags_ |= TF_ACKNOW; // ACK peer's SYN
  778. if (tiflags & TH_ACK) {
  779. // got SYN+ACK (what we're expecting)
  780. // set up to ACK peer's SYN+ACK
  781. newack(pkt);
  782. state_ = TCPS_ESTABLISHED;
  783. } else {
  784. // simultaneous active opens
  785. state_ = TCPS_SYN_RECEIVED;
  786. }
  787. goto step6;
  788. }
  790. // check for redundant data at head/tail of segment
  791. // note that the 4.4bsd [Net/3] code has
  792. // a bug here which can cause us to ignore the
  793. // perfectly good ACKs on duplicate segments.  The
  794. // fix is described in (Stevens, Vol2, p. 959-960).
  795. // This code is based on that correction.
  796. //
  797. // In addition, it has a modification so that duplicate segments
  798. // with dup acks don't trigger a fast retransmit when dupseg_fix_
  799. // is enabled.
  800. //
  801. todrop = rcv_nxt_ - tcph->seqno();  // how much overlap?
  802. if (todrop > 0) {
  803. // segment is something we've seen (perhaps partially)
  804. if (tiflags & TH_SYN) {
  805. t_seqno_ = highest_ack_;
  806. if ((tiflags & TH_ACK) == 0)
  807. goto dropafterack;
  808. tiflags &= ~TH_SYN;
  809. }
  810. if (todrop > datalen ||
  811.     (todrop == datalen && ((tiflags & TH_FIN) == 0))) {
  812. /*
  813.  * Any valid FIN must be to the left of the window.
  814.  * At this point the FIN must be a duplicate or out
  815.  * of sequence; drop it.
  816.  */
  817. tiflags &= ~TH_FIN;
  819. /*
  820.  * Send an ACK to resynchronize and drop any data.
  821.  * But keep on processing for RST or ACK.
  822.  */
  823. flags_ |= TF_ACKNOW;
  824. todrop = datalen;
  825. dupseg = TRUE;
  826. }
  827. tcph->seqno() += todrop;
  828. datalen -= todrop;
  829. }
  831. if (tiflags & TH_SYN) {
  832. fprintf(stderr,
  833.     "%f: %d.%d>%d.%d BayFullTcpAgent::recv(%s) received unexpected SYN (state:%d)n",
  834.         now(),
  835. iph->saddr(), iph->sport(),
  836. iph->daddr(), iph->dport(),
  837.         name(), state_);
  838. goto drop;
  839. }
  841. if ((tiflags & (TH_SYN|TH_ACK)) == 0) {
  842. fprintf(stderr, "%f: %d.%d>%d.%d BayFullTcpAgent::recv(%s) got packet lacking ACK (seq %d)n",
  843. now(),
  844. iph->saddr(), iph->sport(),
  845. iph->daddr(), iph->dport(),
  846. name(), tcph->seqno());
  847. goto drop;
  848. }
  850. /*
  851.  * ACK processing
  852.  */
  854. switch (state_) {
  855. case TCPS_SYN_RECEIVED: /* got ACK for our SYN+ACK */
  856. if (ackno < highest_ack_ || ackno > maxseq_) {
  857. // not in useful range
  858. goto drop;
  859. }
  860. state_ = TCPS_ESTABLISHED;
  861. /* fall into ... */
  863.         /*
  864.          * In ESTABLISHED state: drop duplicate ACKs; ACK out of range
  865.          * ACKs.  If the ack is in the range
  866.          *      tp->snd_una < ti->ti_ack <= tp->snd_max
  867.          * then advance tp->snd_una to ti->ti_ack and drop
  868.          * data from the retransmission queue.
  869.  *
  870.  * note that states CLOSE_WAIT and TIME_WAIT aren't used
  871.  * in the simulator
  872.          */
  874.         case TCPS_ESTABLISHED:
  875.         case TCPS_FIN_WAIT_1:
  876.         case TCPS_FIN_WAIT_2:
  877.         case TCPS_CLOSING:
  878.         case TCPS_LAST_ACK:
  880. // look for dup ACKs (dup ack numbers, no data)
  881. //
  882. // do fast retransmit/recovery if at/past thresh
  883. if (ackno <= highest_ack_) {
  884. // an ACK which doesn't advance highest_ack_
  885. if (datalen == 0 && (!dupseg_fix_ || !dupseg)) {
  886.                                 /*
  887.                                  * If we have outstanding data
  888.                                  * this is a completely
  889.                                  * duplicate ack,
  890.                                  * the ack is the biggest we've
  891.                                  * seen and we've seen exactly our rexmt
  892.                                  * threshhold of them, assume a packet
  893.                                  * has been dropped and retransmit it.
  894.                                  *
  895.                                  * We know we're losing at the current
  896.                                  * window size so do congestion avoidance.
  897.                                  *
  898.                                  * Dup acks mean that packets have left the
  899.                                  * network (they're now cached at the receiver)
  900.                                  * so bump cwnd by the amount in the receiver
  901.                                  * to keep a constant cwnd packets in the
  902.                                  * network.
  903.                                  */
  905.         if (!(rtx_timer_.status() == TIMER_PENDING) ||
  906.     ackno != highest_ack_) {
  907. // not timed, or re-ordered ACK
  908. dupacks_ = 0;
  909. } else if (bug_fix_ &&
  910.      highest_ack_ == recover_ &&
  911.      recover_cause_ == REASON_TIMEOUT) {
  912.   // doing timeout recovery not fastrxmit
  913.   dupacks_ = 0;
  914.    } else if (++dupacks_ == tcprexmtthresh_) {
  915. slowdown(CLOSE_SSTHRESH_HALF|CLOSE_CWND_HALF);
  916. cancel_rtx_timeout();
  917. rtt_active_ = FALSE;
  918. fast_retransmit(ackno);
  919. // we measure cwnd in packets,
  920. // so don't scale by maxseg_
  921. // as real TCP does
  922. cwnd_ = ssthresh_ + dupacks_;
  923. goto drop;
  924. } else if (dupacks_ > tcprexmtthresh_) {
  925. // we just measure cwnd in packets,
  926. // so don't scale by maxset_ as real
  927. // tcp does
  928. cwnd_++; // fast recovery
  929. send_much(0, REASON_NORMAL, 0);
  930. goto drop;
  931. }
  932. } else {
  933. // non-zero length segment
  934. // (or window changed in real TCP).
  935. if (dupack_reset_)
  936. dupacks_ = 0;
  937. }
  938. break; /* take us to "step6" */
  939. }
  941. /*
  942.  * we've finished the fast retransmit/recovery period
  943.  * (i.e. received an ACK which advances highest_ack_)
  944.  */
  946.                 /*
  947.                  * If the congestion window was inflated to account
  948.                  * for the other side's cached packets, retract it.
  949.                  */
  950. if (dupacks_ >= tcprexmtthresh_ && cwnd_ > ssthresh_) {
  951. /*
  952.  * make sure we send at most 2 packets due to this ack
  953.  */
  954. cwnd_ = (maxseq_ - ackno + maxseg_ - 1)
  955.   / maxseg_ + 2;
  956. }
  957. dupacks_ = 0;
  958. if (ackno > maxseq_) {
  959. // ack more than we sent(!?)
  960. fprintf(stderr,
  961.     "%f: BayFullTcpAgent::recv(%s) too-big ACK (ack: %d, maxseq:%d)n",
  962. now(), name(), int(ackno), int(maxseq_));
  963. goto dropafterack;
  964. }
  966.                 /*
  967.                  * If we have a timestamp reply, update smoothed
  968.                  * round trip time.  If no timestamp is present but
  969.                  * transmit timer is running and timed sequence
  970.                  * number was acked, update smoothed round trip time.
  971.                  * Since we now have an rtt measurement, cancel the
  972.                  * timer backoff (cf., Phil Karn's retransmit alg.).
  973.                  * Recompute the initial retransmit timer.
  974.  *
  975.                  * If all outstanding data is acked, stop retransmit
  976.                  * If there is more data to be acked, restart retransmit
  977.                  * timer, using current (possibly backed-off) value.
  978.                  */
  979. newack(pkt);
  980. if (state_ == TCPS_ESTABLISHED && ackno < maxseq_)
  981. needoutput = 1;
  982. /* kmn - 8/12/97: don't want to do this on first
  983.  * data send, especially to compare IWs
  984.  * So added test.
  985.  */
  986. if(first_data_)
  987. opencwnd();
  988. // kmn - 8/15 added second test that is acking fin
  989. if ((state_ == TCPS_FIN_WAIT_1 || state_ == TCPS_FIN_WAIT_2
  990. || state_ == TCPS_LAST_ACK || state_ == TCPS_CLOSING)
  991. && ackno >= (curseq_ + iss_)) // && ackno == maxseq_)
  992. ourfinisacked = 1;
  993. else
  994. ourfinisacked = 0;
  995. // additional processing when we're in special states
  997. switch (state_) {
  998.                 /*
  999.                  * In FIN_WAIT_1 STATE in addition to the processing
  1000.                  * for the ESTABLISHED state if our FIN is now acknowledged
  1001.                  * then enter FIN_WAIT_2.
  1002.                  */
  1003. case TCPS_FIN_WAIT_1: /* doing active close */
  1004. if (ourfinisacked)
  1005. state_ = TCPS_FIN_WAIT_2;
  1006. break;
  1008.                 /*
  1009.                  * In CLOSING STATE in addition to the processing for
  1010.                  * the ESTABLISHED state if the ACK acknowledges our FIN
  1011.                  * then enter the TIME-WAIT state, otherwise ignore
  1012.                  * the segment.
  1013.                  */
  1014. case TCPS_CLOSING: /* simultaneous active close */;
  1015. if (ourfinisacked)
  1016. state_ = TCPS_CLOSED;
  1017. break;
  1018.                 /*
  1019.                  * In LAST_ACK, we may still be waiting for data to drain
  1020.                  * and/or to be acked, as well as for the ack of our FIN.
  1021.                  * If our FIN is now acknowledged,
  1022.                  * enter the closed state and return.
  1023.                  */
  1024. case TCPS_LAST_ACK: /* passive close */
  1025. if (ourfinisacked) {
  1026. state_ = TCPS_CLOSED; //kmn added 2 lines
  1027. /*
  1028. for(int i =0; i < NTIMER; i++) {
  1029. cancel(i);
  1030. }
  1031. */
  1032. goto drop;
  1033. } else { //should be a FIN we've seen
  1034. fprintf(stderr,
  1035.      "%f: %d.%d>%d.%d BayFullTcpAgent::recv(%s) received non-ACK (state:%d)n",
  1036.          now(),
  1037. iph->saddr(), iph->sport(),
  1038. iph->daddr(), iph->dport(),
  1039.          name(), state_);
  1040. }
  1042. /* no case for TIME_WAIT in simulator */
  1043. } // inner switch
  1044. } // outer switch
  1046. step6:
  1047. /* real TCP handles window updates and URG data here */
  1048. /* dodata: this label is in the "real" code.. here only for reference */
  1049. /*
  1050.  * DATA processing
  1051.  * kmn - several changes here to talk to application agent
  1052.  */
  1054. if (datalen > 0 || (tiflags & TH_FIN)) {
  1055. first_data_ = 1; //now seen first data
  1056. // see the "TCP_REASS" macro for this code
  1057. if (tcph->seqno() == rcv_nxt_ && rq_.empty()) {
  1058. // got the in-order packet we were looking
  1059. // for, nobody is in the reassembly queue,
  1060. // so this is the common case...
  1061. // note: in "real" TCP we must also be in
  1062. // ESTABLISHED state to come here, because
  1063. // data arriving before ESTABLISHED is
  1064. // queued in the reassembly queue.  Since we
  1065. // don't really have a process anyhow, just
  1066. // accept the data here as-is (i.e. don't
  1067. // require being in ESTABLISHED state)
  1068. tiflags &= TH_FIN;
  1069. if (tiflags) {
  1070. ++rcv_nxt_;
  1071. }
  1072. flags_ |= TF_DELACK;
  1073. rcv_nxt_ += datalen;
  1074. // give to "application" here
  1075. // added 7/30/97 by kmn to call application with
  1076. // number of bytes since last push (if any)
  1077. // the server is going to call advance before this
  1078. // completes, so changed advance to not call
  1079. // send_much if ESTABLISHED. curseq gets
  1080. // checked below.
  1081. //
  1082. if(datalen && app_ && (tcph->flags() & TH_PUSH)) {
  1083. //rcv_nxt_ - last_upcalled_bytes_;
  1084. app_->recv(pkt,this,DATA_PUSH);
  1085. //last_upcalled_bytes_ = rcv_nxt_;
  1086. }
  1087. needoutput = need_send();
  1088. } else {
  1089. // not the one we want next (or it
  1090. // is but there's stuff on the reass queue);
  1091. // do whatever we need to do for out-of-order
  1092. // segments or hole-fills.  Also,
  1093. // send an ACK to the other side right now.
  1094. tiflags = rq_.add(pkt);
  1095. if (tiflags & TH_PUSH) {
  1096.   if (app_ != NULL )
  1097.     app_->recv(pkt,this,DATA_PUSH);
  1098.   needoutput = need_send();
  1099. } else
  1100. flags_ |= TF_ACKNOW;
  1101. //reset for losses
  1102. switch_spa_thresh_ = rcv_nxt_ + (16 * 1024);
  1103. }
  1104. }
  1106. /*
  1107.  * if FIN is received, ACK the FIN
  1108.  * (let user know if we could do so)
  1109.  */
  1111. if (tiflags & TH_FIN) {
  1112. flags_ |= TF_ACKNOW;
  1113. rq_.clear(); // other side shutting down
  1114. switch (state_) {
  1115.                 /*
  1116.                  * In SYN_RECEIVED and ESTABLISHED STATES
  1117.                  * enter the CLOSE_WAIT state.
  1118.  * (in the simulator, go to LAST_ACK)
  1119.  * (passive close)
  1120.                  */
  1121.                 case TCPS_SYN_RECEIVED:
  1122.                 case TCPS_ESTABLISHED:
  1123.                         state_ = TCPS_LAST_ACK;
  1124.                         break;
  1126.                 /*
  1127.                  * If still in FIN_WAIT_1 STATE FIN has not been acked so
  1128.                  * enter the CLOSING state.
  1129.  * (simultaneous close)
  1130.                  */
  1131.                 case TCPS_FIN_WAIT_1:
  1132.                         state_ = TCPS_CLOSING;
  1133.                         break;
  1134.                 /*
  1135.                  * In FIN_WAIT_2 state enter the TIME_WAIT state,
  1136.                  * starting the time-wait timer, turning off the other
  1137.                  * standard timers.
  1138.  * (in the simulator, just go to CLOSED)
  1139.  * (active close)
  1140.                  */
  1141.                 case TCPS_FIN_WAIT_2:
  1142.                         state_ = TCPS_CLOSED;
  1143. cancel_rtx_timeout();
  1144.                         break;
  1145. }
  1146. }
  1148. if (needoutput || (flags_ & TF_ACKNOW))
  1149. send_much(1, REASON_NORMAL, 0);
  1150. else if ((curseq_ + iss_) > highest_ack_)
  1151. send_much(0, REASON_NORMAL, 0);
  1153. /* kmn -  ugh, egregious hack. Can tell it's a server
  1154.  * so it goes to listen state. Do something
  1155.  * else if this becomes more stable
  1156.  */
  1157.         if(state_ == TCPS_CLOSED) {
  1158. if(close_on_empty_) {
  1159. reinit();
  1160. curseq_ = iss_;
  1161. state_ = TCPS_LISTEN;
  1162. } else { /*"something else" - kmn 6/00 */
  1163.   if (app_ != NULL )
  1164.     app_->recv(pkt,this,CONNECTION_END);
  1165. }
  1166. }
  1167. Packet::free(pkt);
  1168. return;
  1170. dropafterack:
  1171. flags_ |= TF_ACKNOW;
  1172. send_much(1, REASON_NORMAL, 0);
  1173. drop:
  1174.     Packet::free(pkt);
  1175. return;
  1176. }
  1178. void BayFullTcpAgent::reset_rtx_timer(int )
  1179. {
  1180. // cancel old timer,
  1181. // set a new one
  1182.         rtt_backoff(); // double current timeout
  1183.         set_rtx_timer(); // set new timer
  1184.         rtt_active_ = FALSE;
  1185. }
  1188. /*
  1189.  * do an active open
  1190.  * (in real TCP, see tcp_usrreq, case PRU_CONNECT)
  1191.  */
  1192. void BayFullTcpAgent::connect()
  1193. {
  1194. state_ = TCPS_SYN_SENT; // sending a SYN now
  1196. if (!data_on_syn_) {
  1197. // force no data in this segment
  1198. int cur = curseq_;
  1199. curseq_ = iss_;
  1200. output(iss_, REASON_NORMAL);
  1201. curseq_ = cur + 1; //think I have to add in the syn here
  1202. return;
  1203. }
  1204. output(iss_, REASON_NORMAL);
  1205. return;
  1206. }
  1208. /*
  1209.  * be a passive opener
  1210.  * (in real TCP, see tcp_usrreq, case PRU_LISTEN)
  1211.  * (for simulation, make this peer's ptype ACKs)
  1212.  */
  1213. void BayFullTcpAgent::listen()
  1214. {
  1215. state_ = TCPS_LISTEN;
  1216. type_ = PT_TCP; //  changed by kmn 8/6/97
  1217. //type_ = PT_ACK; // instead of PT_TCP
  1218. }
  1220. /*
  1221.  * called when user/application performs 'close'
  1222.  */
  1224. void BayFullTcpAgent::usrclosed()
  1225. {
  1227. switch (state_) {
  1228. case TCPS_CLOSED:
  1229. case TCPS_LISTEN:
  1230. case TCPS_SYN_SENT:
  1231. state_ = TCPS_CLOSED;
  1232. break;
  1233. case TCPS_SYN_RECEIVED:
  1234. case TCPS_ESTABLISHED:
  1235. state_ = TCPS_FIN_WAIT_1;
  1236. send_much(1, REASON_NORMAL, 0);
  1237. break;
  1238. }
  1239. return;
  1240. }
  1242. int BayFullTcpAgent::command(int argc, const char*const* argv)
  1243. {
  1244. // would like to have some "connect" primitive
  1245. // here, but the problem is that we get called before
  1246. // the simulation is running and we want to send a SYN.
  1247. // Because no routing exists yet, this fails.
  1248. // Instead, see code in advance() above.
  1249. //
  1250. // listen can happen any time because it just changes state_
  1251. //
  1252. // close is designed to happen at some point after the
  1253. // simulation is running (using an ns 'at' command)
  1255.  Tcl& tcl = Tcl::instance();
  1257. if (argc == 2) {
  1258. if (strcmp(argv[1], "listen") == 0) {
  1259. // just a state transition
  1260. listen();
  1261. return (TCL_OK);
  1262. }
  1263. if (strcmp(argv[1], "close") == 0) {
  1264. usrclosed();
  1265. return (TCL_OK);
  1266. }
  1267. }
  1268. if (argc == 3) {
  1269. if (strcmp(argv[1], "advance") == 0) {
  1270. advance(atoi(argv[2]));
  1271. return (TCL_OK);
  1272. }
  1273. //added 7/31/97 by kmn to work with apps, specifically www
  1274. // probably should use a special type of agent...
  1275. if (strcmp(argv[1], "attach-application") == 0) { 
  1276. app_ = (BayTcpAppAgent *)TclObject::lookup(argv[2]); 
  1277. if (app_ == 0) {
  1278. tcl.resultf("no such agent %s", argv[2]);
  1279. return(TCL_ERROR);
  1280. }
  1281. return(TCL_OK);
  1282. }
  1283. //added by kmn 8/12/97
  1284. if (strcmp(argv[1], "initial-window") == 0) { 
  1285. wnd_init_ = atoi(argv[2]); 
  1286. cwnd_ = wnd_init_;
  1287. awnd_ = wnd_init_ /2.0;
  1288. return(TCL_OK);
  1289. }
  1291. }
  1292. return (TcpAgent::command(argc, argv));
  1293. }
  1294. /*
  1295.  * clear out reassembly queue
  1296.  */
  1297. void BayReassemblyQueue::clear()
  1298. {
  1299. seginfo* p;
  1300. seginfo* n;
  1301. for (p = head_; p != NULL; p = n) {
  1302. n = p->next_;
  1303. delete p;
  1304. }
  1305. head_ = tail_ = NULL;
  1306. return;
  1307. }
  1309. /*
  1310.  * add a packet to the reassembly queue..
  1311.  * will update BayFullTcpAgent::rcv_nxt_ by way of the
  1312.  * BayReassemblyQueue::rcv_nxt_ integer reference (an alias)
  1313.  */
  1314. int BayReassemblyQueue::add(Packet* pkt)
  1315. {
  1316.     hdr_tcp *tcph = hdr_tcp::access(pkt);
  1317.     hdr_cmn *th = hdr_cmn::access(pkt);
  1319. int start = tcph->seqno();
  1320. int end = start + th->size() - tcph->hlen();
  1321. int tiflags = tcph->flags();
  1322. seginfo *q, *p, *n;
  1324. if (head_ == NULL) {
  1325. // nobody there, just insert
  1326. tail_ = head_ = new seginfo;
  1327. head_->prev_ = NULL;
  1328. head_->next_ = NULL;
  1329. head_->startseq_ = start;
  1330. head_->endseq_ = end;
  1331. head_->flags_ = tiflags;
  1332. } else {
  1333. p = NULL;
  1334. n = new seginfo;
  1335. n->startseq_ = start;
  1336. n->endseq_ = end;
  1337. n->flags_ = tiflags;
  1338. if (tail_->endseq_ <= start) {
  1339. // common case of end of reass queue
  1340. p = tail_;
  1341. goto endfast;
  1342. }
  1344. q = head_;
  1345. // look for the segment after this one
  1346. while (q != NULL && (end > q->startseq_))
  1347. q = q->next_;
  1348. // set p to the segment before this one
  1349. if (q == NULL)
  1350. p = tail_;
  1351. else
  1352. p = q->prev_;
  1354. if (p == NULL) {
  1355. // insert at head
  1356. n->next_ = head_;
  1357. n->prev_ = NULL;
  1358. head_->prev_ = n;
  1359. head_ = n;
  1360. } else {
  1361. endfast:
  1362. // insert in the middle or end
  1363. n->next_ = p->next_;
  1364. if (p->next_)
  1365. p->next_->prev_ = n;
  1366. p->next_ = n;
  1367. n->prev_ = p;
  1368. if (p == tail_)
  1369. tail_ = n;
  1370. }
  1371. }
  1372. //
  1373. // look for a sequence of in-order segments and
  1374. // set rcv_nxt if we can
  1375. //
  1377. if (head_->startseq_ > rcv_nxt_)
  1378. return 0; // still awaiting a hole-fill
  1380. tiflags = 0;
  1381. p = head_;
  1382. while (p != NULL) {
  1383. // update rcv_nxt_ to highest in-seq thing
  1384. // and delete the entry from the reass queue
  1385. rcv_nxt_ = p->endseq_;
  1386. tiflags |= p->flags_;
  1387. q = p;
  1388. if (q->prev_)
  1389. q->prev_->next_ = q->next_;
  1390. else
  1391. head_ = q->next_;
  1392. if (q->next_)
  1393. q->next_->prev_ = q->prev_;
  1394. else
  1395. tail_ = q->prev_;
  1396. if (q->next_ && (q->endseq_ < q->next_->startseq_)) {
  1397. delete q;
  1398. break; // only the in-seq stuff
  1399. }
  1400. p = p->next_;
  1401. delete q;
  1402. }
  1403. return (tiflags);
  1404. }