tcp-full.cc

ns2--tcp-full.cc

   1 /* -*-    Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */
   2 
   3 /*
   4  * Copyright (c) Intel Corporation 2001. All rights reserved.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *   http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17 
  18 /*
  19  * Copyright (c) 1997, 1998 The Regents of the University of California.
  20  * All rights reserved.
  21  * 
  22  * Redistribution and use in source and binary forms, with or without
  23  * modification, are permitted provided that the following conditions
  24  * are met:
  25  * 1. Redistributions of source code must retain the above copyright
  26  *    notice, this list of conditions and the following disclaimer.
  27  * 2. Redistributions in binary form must reproduce the above copyright
  28  *    notice, this list of conditions and the following disclaimer in the
  29  *    documentation and/or other materials provided with the distribution.
  30  * 3. All advertising materials mentioning features or use of this software
  31  *    must display the following acknowledgement:
  32  *     This product includes software developed by the Network Research
  33  *     Group at Lawrence Berkeley National Laboratory.
  34  * 4. Neither the name of the University nor of the Laboratory may be used
  35  *    to endorse or promote products derived from this software without
  36  *    specific prior written permission.
  37  * 
  38  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  39  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  40  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  41  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  42  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  43  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  44  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  45  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  46  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  47  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  48  * SUCH DAMAGE.
  49  */
  50 
  51 /*
  52  *
  53  * Full-TCP : A two-way TCP very similar to the 4.4BSD version of Reno TCP.
  54  * This version also includes variants Tahoe, NewReno, and SACK.
  55  *
  56  * This code below has received a fairly major restructuring (Aug. 2001).
  57  * The ReassemblyQueue structure is now removed to a separate module and
  58  * entirely re-written.
  59  * Also, the SACK functionality has been re-written (almost) entirely.
  60  * -KF [[email protected]]
  61  *
  62  * This code below was motivated in part by code contributed by
  63  * Kathie Nichols ([email protected]).  The code below is based primarily
  64  * on the 4.4BSD TCP implementation. -KF [[email protected]]
  65  *
  66  * Kathie Nichols and Van Jacobson have contributed significant bug fixes,
  67  * especially with respect to the the handling of sequence numbers during
  68  * connection establishment/clearin.  Additional fixes have followed
  69  * theirs.
  70  *
  71  * Fixes for gensack() and ReassemblyQueue::add() contributed by Richard 
  72  * Mortier 
  73  *
  74  * Some warnings and comments:
  75  *    this version of TCP will not work correctly if the sequence number
  76  *    goes above 2147483648 due to sequence number wrap
  77  *
  78  *    this version of TCP by default sends data at the beginning of a
  79  *    connection in the "typical" way... That is,
  80  *        A   ------> SYN ------> B
  81  *        A   <----- SYN+ACK ---- B
  82  *        A   ------> ACK ------> B
  83  *        A   ------> data -----> B
  84  *
  85  *    there is no dynamic receiver's advertised window.   The advertised
  86  *    window is simulated by simply telling the sender a bound on the window
  87  *    size (wnd_).
  88  *
  89  *    in real TCP, a user process performing a read (via PRU_RCVD)
  90  *        calls tcp_output each time to (possibly) send a window
  91  *        update.  Here we don't have a user process, so we simulate
  92  *        a user process always ready to consume all the receive buffer
  93  *
  94  * Notes:
  95  *    wnd_, wnd_init_, cwnd_, ssthresh_ are in segment units
  96  *    sequence and ack numbers are in byte units
  97  *
  98  * Futures:
  99  *      there are different existing TCPs with respect to how
 100  *      ack's are handled on connection startup.  Some delay
 101  *      the ack for the first segment, which can cause connections
 102  *      to take longer to start up than if we be sure to ack it quickly.
 103  *
 104  *      some TCPs arrange for immediate ACK generation if the incoming segment
 105  *      contains the PUSH bit
 106  *
 107  *
 108  */
 109 
 110 #ifndef lint
 111 static const char rcsid[] =
 112     "@(#) $Header: /cvsroot/nsnam/ns-2/tcp/tcp-full.cc,v 1.130 2010/03/08 05:54:54 tom_henderson Exp $ (LBL)";
 113 #endif
 114 
 115 #include "ip.h"
 116 #include "tcp-full.h"
 117 #include "flags.h"
 118 #include "random.h"
 119 #include "template.h"
 120 
 121 #ifndef TRUE
 122 #define    TRUE     1
 123 #endif
 124 
 125 #ifndef FALSE
 126 #define    FALSE     0
 127 #endif
 128 
 129 /*
 130  * Tcl Linkage for the following:
 131  *    Agent/TCP/FullTcp, Agent/TCP/FullTcp/Tahoe,
 132  *    Agent/TCP/FullTcp/Newreno, Agent/TCP/FullTcp/Sack
 133  *
 134  * See tcl/lib/ns-default.tcl for init methods for
 135  *    Tahoe, Newreno, and Sack
 136  */
 137 
 138 static class FullTcpClass : public TclClass { 
 139 public:
 140     FullTcpClass() : TclClass("Agent/TCP/FullTcp") {}
 141     TclObject* create(int, const char*const*) { 
 142         return (new FullTcpAgent());
 143     }
 144 } class_full;
 145 
 146 static class TahoeFullTcpClass : public TclClass { 
 147 public:
 148     TahoeFullTcpClass() : TclClass("Agent/TCP/FullTcp/Tahoe") {}
 149     TclObject* create(int, const char*const*) { 
 150         // ns-default sets reno_fastrecov_ to false
 151         return (new TahoeFullTcpAgent());
 152     }
 153 } class_tahoe_full;
 154 
 155 static class NewRenoFullTcpClass : public TclClass { 
 156 public:
 157     NewRenoFullTcpClass() : TclClass("Agent/TCP/FullTcp/Newreno") {}
 158     TclObject* create(int, const char*const*) { 
 159         // ns-default sets open_cwnd_on_pack_ to false
 160         return (new NewRenoFullTcpAgent());
 161     }
 162 } class_newreno_full;
 163 
 164 static class SackFullTcpClass : public TclClass { 
 165 public:
 166     SackFullTcpClass() : TclClass("Agent/TCP/FullTcp/Sack") {}
 167     TclObject* create(int, const char*const*) { 
 168         // ns-default sets reno_fastrecov_ to false
 169         // ns-default sets open_cwnd_on_pack_ to false
 170         return (new SackFullTcpAgent());
 171     }
 172 } class_sack_full;
 173 
 174 /*
 175  * Delayed-binding variable linkage
 176  */
 177 
 178 void
 179 FullTcpAgent::delay_bind_init_all()
 180 {
 181         delay_bind_init_one("segsperack_");
 182         delay_bind_init_one("segsize_");
 183         delay_bind_init_one("tcprexmtthresh_");
 184         delay_bind_init_one("iss_");
 185         delay_bind_init_one("nodelay_");
 186         delay_bind_init_one("data_on_syn_");
 187         delay_bind_init_one("dupseg_fix_");
 188         delay_bind_init_one("dupack_reset_");
 189         delay_bind_init_one("close_on_empty_");
 190         delay_bind_init_one("signal_on_empty_");
 191         delay_bind_init_one("interval_");
 192         delay_bind_init_one("ts_option_size_");
 193         delay_bind_init_one("reno_fastrecov_");
 194         delay_bind_init_one("pipectrl_");
 195         delay_bind_init_one("open_cwnd_on_pack_");
 196         delay_bind_init_one("halfclose_");
 197         delay_bind_init_one("nopredict_");
 198         delay_bind_init_one("ecn_syn_");
 199         delay_bind_init_one("ecn_syn_wait_");
 200         delay_bind_init_one("debug_");
 201         delay_bind_init_one("spa_thresh_");
 202 
 203     TcpAgent::delay_bind_init_all();
 204        
 205           reset();
 206 }
 207 
 208 int
 209 FullTcpAgent::delay_bind_dispatch(const char *varName, const char *localName, TclObject *tracer)
 210 {
 211         if (delay_bind(varName, localName, "segsperack_", &segs_per_ack_, tracer)) return TCL_OK;
 212         if (delay_bind(varName, localName, "segsize_", &maxseg_, tracer)) return TCL_OK;
 213         if (delay_bind(varName, localName, "tcprexmtthresh_", &tcprexmtthresh_, tracer)) return TCL_OK;
 214         if (delay_bind(varName, localName, "iss_", &iss_, tracer)) return TCL_OK;
 215         if (delay_bind(varName, localName, "spa_thresh_", &spa_thresh_, tracer)) return TCL_OK;
 216         if (delay_bind_bool(varName, localName, "nodelay_", &nodelay_, tracer)) return TCL_OK;
 217         if (delay_bind_bool(varName, localName, "data_on_syn_", &data_on_syn_, tracer)) return TCL_OK;
 218         if (delay_bind_bool(varName, localName, "dupseg_fix_", &dupseg_fix_, tracer)) return TCL_OK;
 219         if (delay_bind_bool(varName, localName, "dupack_reset_", &dupack_reset_, tracer)) return TCL_OK;
 220         if (delay_bind_bool(varName, localName, "close_on_empty_", &close_on_empty_, tracer)) return TCL_OK;
 221         if (delay_bind_bool(varName, localName, "signal_on_empty_", &signal_on_empty_, tracer)) return TCL_OK;
 222         if (delay_bind_time(varName, localName, "interval_", &delack_interval_, tracer)) return TCL_OK;
 223         if (delay_bind(varName, localName, "ts_option_size_", &ts_option_size_, tracer)) return TCL_OK;
 224         if (delay_bind_bool(varName, localName, "reno_fastrecov_", &reno_fastrecov_, tracer)) return TCL_OK;
 225         if (delay_bind_bool(varName, localName, "pipectrl_", &pipectrl_, tracer)) return TCL_OK;
 226         if (delay_bind_bool(varName, localName, "open_cwnd_on_pack_", &open_cwnd_on_pack_, tracer)) return TCL_OK;
 227         if (delay_bind_bool(varName, localName, "halfclose_", &halfclose_, tracer)) return TCL_OK;
 228         if (delay_bind_bool(varName, localName, "nopredict_", &nopredict_, tracer)) return TCL_OK;
 229         if (delay_bind_bool(varName, localName, "ecn_syn_", &ecn_syn_, tracer)) return TCL_OK;
 230         if (delay_bind(varName, localName, "ecn_syn_wait_", &ecn_syn_wait_, tracer)) return TCL_OK;
 231         if (delay_bind_bool(varName, localName, "debug_", &debug_, tracer)) return TCL_OK;
 232 
 233         return TcpAgent::delay_bind_dispatch(varName, localName, tracer);
 234 }
 235 
 236 void
 237 SackFullTcpAgent::delay_bind_init_all()
 238 {
 239         delay_bind_init_one("clear_on_timeout_");
 240         delay_bind_init_one("sack_rtx_cthresh_");
 241         delay_bind_init_one("sack_rtx_bthresh_");
 242         delay_bind_init_one("sack_block_size_");
 243         delay_bind_init_one("sack_option_size_");
 244         delay_bind_init_one("max_sack_blocks_");
 245         delay_bind_init_one("sack_rtx_threshmode_");
 246     FullTcpAgent::delay_bind_init_all();
 247 }
 248 
 249 int
 250 SackFullTcpAgent::delay_bind_dispatch(const char *varName, const char *localName, TclObject *tracer)
 251 {
 252         if (delay_bind_bool(varName, localName, "clear_on_timeout_", &clear_on_timeout_, tracer)) return TCL_OK;
 253         if (delay_bind(varName, localName, "sack_rtx_cthresh_", &sack_rtx_cthresh_, tracer)) return TCL_OK;
 254         if (delay_bind(varName, localName, "sack_rtx_bthresh_", &sack_rtx_bthresh_, tracer)) return TCL_OK;
 255         if (delay_bind(varName, localName, "sack_rtx_threshmode_", &sack_rtx_threshmode_, tracer)) return TCL_OK;
 256         if (delay_bind(varName, localName, "sack_block_size_", &sack_block_size_, tracer)) return TCL_OK;
 257         if (delay_bind(varName, localName, "sack_option_size_", &sack_option_size_, tracer)) return TCL_OK;
 258         if (delay_bind(varName, localName, "max_sack_blocks_", &max_sack_blocks_, tracer)) return TCL_OK;
 259         return FullTcpAgent::delay_bind_dispatch(varName, localName, tracer);
 260 }
 261 
 262 int
 263 FullTcpAgent::command(int argc, const char*const* argv)
 264 {
 265     // would like to have some "connect" primitive
 266     // here, but the problem is that we get called before
 267     // the simulation is running and we want to send a SYN.
 268     // Because no routing exists yet, this fails.
 269     // Instead, see code in advance().
 270     //
 271     // listen can happen any time because it just changes state_
 272     //
 273     // close is designed to happen at some point after the
 274     // simulation is running (using an ns 'at' command)
 275 
 276     if (argc == 2) {
 277         if (strcmp(argv[1], "listen") == 0) {
 278             // just a state transition
 279             listen();
 280             return (TCL_OK);
 281         }
 282         if (strcmp(argv[1], "close") == 0) {
 283             usrclosed();
 284             return (TCL_OK);
 285         }
 286     }
 287     if (argc == 3) {
 288         if (strcmp(argv[1], "advance") == 0) {
 289             advanceby(atoi(argv[2]));
 290             return (TCL_OK);
 291         }
 292         if (strcmp(argv[1], "advanceby") == 0) {
 293             advanceby(atoi(argv[2]));
 294             return (TCL_OK);
 295         }
 296         if (strcmp(argv[1], "advance-bytes") == 0) {
 297             advance_bytes(atoi(argv[2]));
 298             return (TCL_OK);
 299         }
 300     }
 301     if (argc == 4) {
 302         if (strcmp(argv[1], "sendmsg") == 0) {
 303             sendmsg(atoi(argv[2]), argv[3]);
 304             return (TCL_OK);
 305         }
 306     }
 307     return (TcpAgent::command(argc, argv));
 308 }
 309 
 310 /*
 311  * "User Interface" Functions for Full TCP
 312  *    advanceby(number of packets)
 313  *    advance_bytes(number of bytes)
 314  *    sendmsg(int bytes, char* buf)
 315  *    listen
 316  *    close
 317  */
 318 
 319 /*
 320  * the 'advance' interface to the regular tcp is in packet
 321  * units.  Here we scale this to bytes for full tcp.
 322  *
 323  * 'advance' is normally called by an "application" (i.e. data source)
 324  * to signal that there is something to send
 325  *
 326  * 'curseq_' is the sequence number of the last byte provided
 327  * by the application.  In the case where no data has been supplied
 328  * by the application, curseq_ is the iss_.
 329  */
 330 void
 331 FullTcpAgent::advanceby(int np)
 332 {
 333     // XXX hack:
 334     //    because np is in packets and a data source
 335     //    may pass a *huge* number as a way to tell us
 336     //    to go forever, just look for the huge number
 337     //    and if it's there, pre-divide it
 338     if (np >= 0x10000000)
 339         np /= maxseg_;
 340 
 341     advance_bytes(np * maxseg_);
 342     return;
 343 }
 344 
 345 /*
 346  * the byte-oriented interface: advance_bytes(int nbytes)
 347  */
 348 
 349 void
 350 FullTcpAgent::advance_bytes(int nb)
 351 {
 352 
 353     //
 354     // state-specific operations:
 355     //    if CLOSED or LISTEN, reset and try a new active open/connect
 356     //    if ESTABLISHED, queue and try to send more
 357     //    if SYN_SENT or SYN_RCVD, just queue
 358     //    if above ESTABLISHED, we are closing, so don't allow
 359     //
 360 
 361     switch (state_) {
 362 
 363     case TCPS_CLOSED:
 364     case TCPS_LISTEN:
 365                 reset();
 366                 curseq_ = iss_ + nb;
 367                 connect();              // initiate new connection
 368         break;
 369 
 370     case TCPS_ESTABLISHED:
 371     case TCPS_SYN_SENT:
 372     case TCPS_SYN_RECEIVED:
 373                 if (curseq_ < iss_) 
 374                         curseq_ = iss_; 
 375                 curseq_ += nb;
 376         break;
 377 
 378     default:
 379             if (debug_) 
 380                 fprintf(stderr, "%f: FullTcpAgent::advance(%s): cannot advance while in state %s\n",
 381                  now(), name(), statestr(state_));
 382 
 383     }
 384 
 385     if (state_ == TCPS_ESTABLISHED)
 386         send_much(0, REASON_NORMAL, maxburst_);
 387 
 388       return;
 389 }
 390 
 391 /*
 392  * If MSG_EOF is set, by setting close_on_empty_ to TRUE, we ensure that
 393  * a FIN will be sent when the send buffer emptys.
 394  * If DAT_EOF is set, the callback function done_data is called
 395  * when the send buffer empty
 396  * 
 397  * When (in the future?) FullTcpAgent implements T/TCP, avoidance of 3-way 
 398  * handshake can be handled in this function.
 399  */
 400 void
 401 FullTcpAgent::sendmsg(int nbytes, const char *flags)
 402 {
 403     if (flags && strcmp(flags, "MSG_EOF") == 0) 
 404         close_on_empty_ = TRUE;    
 405     if (flags && strcmp(flags, "DAT_EOF") == 0) 
 406         signal_on_empty_ = TRUE;    
 407 
 408     if (nbytes == -1) {
 409         infinite_send_ = TRUE;
 410         advance_bytes(0);
 411     } else
 412         advance_bytes(nbytes);
 413 }
 414 
 415 /*
 416  * do an active open
 417  * (in real TCP, see tcp_usrreq, case PRU_CONNECT)
 418  */
 419 void
 420 FullTcpAgent::connect()
 421 {
 422     newstate(TCPS_SYN_SENT);    // sending a SYN now
 423     sent(iss_, foutput(iss_, REASON_NORMAL));
 424     return;
 425 }
 426 
 427 /*
 428  * be a passive opener
 429  * (in real TCP, see tcp_usrreq, case PRU_LISTEN)
 430  * (for simulation, make this peer's ptype ACKs)
 431  */
 432 void
 433 FullTcpAgent::listen()
 434 {
 435     newstate(TCPS_LISTEN);
 436     type_ = PT_ACK;    // instead of PT_TCP
 437 }
 438 
 439 
 440 /*
 441 * This function is invoked when the sender buffer is empty. It in turn
 442 * invokes the Tcl done_data procedure that was registered with TCP.
 443 */
 444  
 445 void
 446 FullTcpAgent::bufferempty()
 447 {
 448        signal_on_empty_=FALSE;
 449     Tcl::instance().evalf("%s done_data", this->name());
 450 }
 451 
 452 
 453 /*
 454  * called when user/application performs 'close'
 455  */
 456 
 457 void
 458 FullTcpAgent::usrclosed()
 459 {
 460     curseq_ = maxseq_ - 1;    // now, no more data
 461     infinite_send_ = FALSE;    // stop infinite send
 462 
 463     switch (state_) {
 464     case TCPS_CLOSED:
 465     case TCPS_LISTEN:
 466         cancel_timers();
 467         newstate(TCPS_CLOSED);
 468         finish();
 469         break;
 470     case TCPS_SYN_SENT:
 471         newstate(TCPS_CLOSED);
 472         /* fall through */
 473     case TCPS_LAST_ACK:
 474         flags_ |= TF_NEEDFIN;
 475         send_much(1, REASON_NORMAL, maxburst_);
 476         break;
 477     case TCPS_SYN_RECEIVED:
 478     case TCPS_ESTABLISHED:
 479         newstate(TCPS_FIN_WAIT_1);
 480         flags_ |= TF_NEEDFIN;
 481         send_much(1, REASON_NORMAL, maxburst_);
 482         break;
 483     case TCPS_CLOSE_WAIT:
 484         newstate(TCPS_LAST_ACK);
 485         flags_ |= TF_NEEDFIN;
 486         send_much(1, REASON_NORMAL, maxburst_);
 487         break;
 488     case TCPS_FIN_WAIT_1:
 489     case TCPS_FIN_WAIT_2:
 490     case TCPS_CLOSING:
 491         /* usr asked for a close more than once [?] */
 492                 if (debug_)
 493                  fprintf(stderr,
 494                    "%f FullTcpAgent(%s): app close in bad state %s\n",
 495                    now(), name(), statestr(state_));
 496         break;
 497     default:
 498                 if (debug_)
 499                 fprintf(stderr,
 500                 "%f FullTcpAgent(%s): app close in unknown state %s\n",
 501                 now(), name(), statestr(state_));
 502     }
 503 
 504     return;
 505 }
 506 
 507 /*
 508  * Utility type functions
 509  */
 510 
 511 void
 512 FullTcpAgent::cancel_timers()
 513 {
 514 
 515     // cancel: rtx, burstsend, delsnd
 516     TcpAgent::cancel_timers();      
 517     // cancel: delack
 518     delack_timer_.force_cancel();
 519 }
 520 
 521 void
 522 FullTcpAgent::newstate(int state)
 523 {
 524 //printf("%f(%s): state changed from %s to %s\n",
 525 //now(), name(), statestr(state_), statestr(state));
 526 
 527     state_ = state;
 528 }
 529 
 530 void
 531 FullTcpAgent::prpkt(Packet *pkt)
 532 {
 533     hdr_tcp *tcph = hdr_tcp::access(pkt);    // TCP header
 534     hdr_cmn *th = hdr_cmn::access(pkt);    // common header (size, etc)
 535     //hdr_flags *fh = hdr_flags::access(pkt);    // flags (CWR, CE, bits)
 536     hdr_ip* iph = hdr_ip::access(pkt);
 537     int datalen = th->size() - tcph->hlen(); // # payload bytes
 538 
 539     fprintf(stdout, " [%d:%d.%d>%d.%d] (hlen:%d, dlen:%d, seq:%d, ack:%d, flags:0x%x (%s), salen:%d, reason:0x%x)\n",
 540         th->uid(),
 541         iph->saddr(), iph->sport(),
 542         iph->daddr(), iph->dport(),
 543         tcph->hlen(),
 544         datalen,
 545         tcph->seqno(),
 546         tcph->ackno(),
 547         tcph->flags(), flagstr(tcph->flags()),
 548         tcph->sa_length(),
 549         tcph->reason());
 550 }
 551 
 552 char *
 553 FullTcpAgent::flagstr(int hflags)
 554 {
 555     // update this if tcp header flags change
 556     static char *flagstrs[28] = {
 557         "", "", "", "",    // 0-3
 558         "", "", "", "",    // 4-7
 559         "", "", "", "", // 0x08-0x0b
 560         /* do not use */
 561         "", "", "", "",        // 0x0c-0x0f
 562         "", "", "", "", // 0x10-0x13
 563         "", "", "", "", // 0x14-0x17
 564         "", "", "", "", // 0x18-0x1b
 565     };
 566     if (hflags < 0 || (hflags > 28)) {
 567         /* Added strings for CWR and ECE  -M. Weigle 6/27/02 */
 568         if (hflags == 72) 
 569              return ("");
 570          else if (hflags == 80)
 571              return ("");
 572          else if (hflags == 88) 
 573              return ("");
 574          else if (hflags == 152) 
 575              return ("");
 576         else if (hflags == 153)
 577             return ("");
 578         else
 579             return ("");
 580     }
 581     return (flagstrs[hflags]);
 582 }
 583 
 584 char *
 585 FullTcpAgent::statestr(int state)
 586 {
 587     static char *statestrs[TCP_NSTATES] = {
 588         "CLOSED", "LISTEN", "SYN_SENT", "SYN_RCVD",
 589         "ESTABLISHED", "CLOSE_WAIT", "FIN_WAIT_1", "CLOSING",
 590         "LAST_ACK", "FIN_WAIT_2"
 591     };
 592     if (state < 0 || (state >= TCP_NSTATES))
 593         return ("INVALID");
 594     return (statestrs[state]);
 595 }
 596 
 597 void
 598 DelAckTimer::expire(Event *) {
 599         a_->timeout(TCP_TIMER_DELACK);
 600 }
 601 
 602 /*
 603  * reset to starting point, don't set state_ here,
 604  * because our starting point might be LISTEN rather
 605  * than CLOSED if we're a passive opener
 606  */
 607 void
 608 FullTcpAgent::reset()
 609 {
 610     cancel_timers();    // cancel timers first
 611           TcpAgent::reset();    // resets most variables
 612     rq_.clear();        // clear reassembly queue
 613     rtt_init();        // zero rtt, srtt, backoff
 614 
 615     last_ack_sent_ = -1;
 616     rcv_nxt_ = -1;
 617     pipe_ = 0;
 618     rtxbytes_ = 0;
 619     flags_ = 0;
 620     t_seqno_ = iss_;
 621     maxseq_ = -1;
 622     irs_ = -1;
 623     last_send_time_ = -1.0;
 624     if (ts_option_)
 625         recent_ = recent_age_ = 0.0;
 626     else
 627         recent_ = recent_age_ = -1.0;
 628 
 629     fastrecov_ = FALSE;
 630 
 631     closed_ = 0;
 632     close_on_empty_ = FALSE;
 633 
 634         if (ecn_syn_)
 635                 ecn_syn_next_ = 1;
 636         else
 637                 ecn_syn_next_ = 0;
 638 
 639 }
 640 
 641 /*
 642  * This function is invoked when the connection is done. It in turn
 643  * invokes the Tcl finish procedure that was registered with TCP.
 644  * This function mimics tcp_close()
 645  */
 646 
 647 void
 648 FullTcpAgent::finish()
 649 {
 650     Tcl::instance().evalf("%s done", this->name());
 651 }
 652 /*
 653  * headersize:
 654  *    how big is an IP+TCP header in bytes; include options such as ts
 655  * this function should be virtual so others (e.g. SACK) can override
 656  */
 657 int
 658 FullTcpAgent::headersize()
 659 {
 660     int total = tcpip_base_hdr_size_;
 661     if (total < 1) {
 662         fprintf(stderr,
 663             "%f: FullTcpAgent(%s): warning: tcpip hdr size is only %d bytes\n",
 664             now(), name(), tcpip_base_hdr_size_);
 665     }
 666 
 667     if (ts_option_)
 668         total += ts_option_size_;
 669 
 670     return (total);
 671 }
 672 
 673 /*
 674  * flags that are completely dependent on the tcp state
 675  * these are used for the next outgoing packet in foutput()
 676  * (in real TCP, see tcp_fsm.h, the "tcp_outflags" array)
 677  */
 678 int
 679 FullTcpAgent::outflags()
 680 {
 681     // in real TCP an RST is added in the CLOSED state
 682     static int tcp_outflags[TCP_NSTATES] = {
 683         TH_ACK,              /* 0, CLOSED */  
 684         0,                      /* 1, LISTEN */ 
 685         TH_SYN,                 /* 2, SYN_SENT */
 686         TH_SYN|TH_ACK,          /* 3, SYN_RECEIVED */
 687         TH_ACK,                 /* 4, ESTABLISHED */
 688         TH_ACK,                 /* 5, CLOSE_WAIT */
 689         TH_FIN|TH_ACK,          /* 6, FIN_WAIT_1 */
 690         TH_FIN|TH_ACK,          /* 7, CLOSING */
 691         TH_FIN|TH_ACK,          /* 8, LAST_ACK */
 692         TH_ACK,                 /* 9, FIN_WAIT_2 */
 693         /* 10, TIME_WAIT --- not used in simulator */
 694     };
 695 
 696     if (state_ < 0 || (state_ >= TCP_NSTATES)) {
 697         fprintf(stderr, "%f FullTcpAgent(%s): invalid state %d\n",
 698             now(), name(), state_);
 699         return (0x0);
 700     }
 701 
 702     return (tcp_outflags[state_]);
 703 }
 704 
 705 /*
 706  * reaass() -- extract the appropriate fields from the packet
 707  *    and pass this info the ReassemblyQueue add routine
 708  *
 709  * returns the TCP header flags representing the "or" of
 710  *    the flags contained in the adjacent sequence # blocks
 711  */
 712 
 713 int
 714 FullTcpAgent::reass(Packet* pkt)
 715 {  
 716         hdr_tcp *tcph =  hdr_tcp::access(pkt);
 717         hdr_cmn *th = hdr_cmn::access(pkt);
 718    
 719         int start = tcph->seqno();
 720         int end = start + th->size() - tcph->hlen();
 721         int tiflags = tcph->flags();
 722     int fillshole = (start == rcv_nxt_);
 723     int flags;
 724    
 725     // end contains the seq of the last byte of
 726     // in the packet plus one
 727 
 728     if (start == end && (tiflags & TH_FIN) == 0) {
 729         fprintf(stderr, "%f: FullTcpAgent(%s)::reass() -- bad condition - adding non-FIN zero-len seg\n",
 730             now(), name());
 731         abort();
 732     }
 733 
 734     flags = rq_.add(start, end, tiflags, 0);
 735 
 736     //present:
 737     //
 738     // If we've never received a SYN (unlikely)
 739     // or this is an out of order addition, no reason to coalesce
 740     //
 741 
 742     if (TCPS_HAVERCVDSYN(state_) == 0 || !fillshole) {
 743          return (0x00);
 744     }
 745     //
 746     // If we get some data in SYN_RECVD, no need to present to user yet
 747     //
 748     if (state_ == TCPS_SYN_RECEIVED && (end > start))
 749         return (0x00);
 750 
 751     // clear out data that has been passed, up to rcv_nxt_,
 752     // collects flags
 753 
 754     flags |= rq_.cleartonxt();
 755 
 756         return (flags);
 757 }
 758 
 759 /*
 760  * utility function to set rcv_next_ during inital exchange of seq #s
 761  */
 762 
 763 int
 764 FullTcpAgent::rcvseqinit(int seq, int dlen)
 765 {
 766     return (seq + dlen + 1);
 767 }
 768 
 769 /*
 770  * build a header with the timestamp option if asked
 771  */
 772 int
 773 FullTcpAgent::build_options(hdr_tcp* tcph)
 774 {
 775     int total = 0;
 776     if (ts_option_) {
 777         tcph->ts() = now();
 778         tcph->ts_echo() = recent_;
 779         total += ts_option_size_;
 780     } else {
 781         tcph->ts() = tcph->ts_echo() = -1.0;
 782     }
 783     return (total);
 784 }
 785 
 786 /*
 787  * pack() -- is the ACK a partial ACK? (not past recover_)
 788  */
 789 
 790 int
 791 FullTcpAgent::pack(Packet *pkt)
 792 {
 793     hdr_tcp *tcph = hdr_tcp::access(pkt);
 794     /* Added check for fast recovery.  -M. Weigle 5/2/02 */
 795     return (fastrecov_ && tcph->ackno() >= highest_ack_ &&
 796         tcph->ackno() < recover_);
 797 }
 798 
 799 /*
 800  * baseline reno TCP exists fast recovery on a partial ACK
 801  */
 802 
 803 void
 804 FullTcpAgent::pack_action(Packet*)
 805 {
 806     if (reno_fastrecov_ && fastrecov_ && cwnd_ > double(ssthresh_)) {
 807         cwnd_ = double(ssthresh_); // retract window if inflated
 808     }
 809     fastrecov_ = FALSE;
 810 //printf("%f: EXITED FAST RECOVERY\n", now());
 811     dupacks_ = 0;
 812 }
 813 
 814 /*
 815  * ack_action -- same as partial ACK action for base Reno TCP
 816  */
 817 
 818 void
 819 FullTcpAgent::ack_action(Packet* p)
 820 {
 821     FullTcpAgent::pack_action(p);
 822 }
 823 
 824 
 825 /*
 826  * sendpacket: 
 827  *    allocate a packet, fill in header fields, and send
 828  *    also keeps stats on # of data pkts, acks, re-xmits, etc
 829  *
 830  * fill in packet fields.  Agent::allocpkt() fills
 831  * in most of the network layer fields for us.
 832  * So fill in tcp hdr and adjust the packet size.
 833  *
 834  * Also, set the size of the tcp header.
 835  */
 836 void
 837 FullTcpAgent::sendpacket(int seqno, int ackno, int pflags, int datalen, int reason, Packet *p)
 838 {
 839         if (!p) p = allocpkt();
 840         hdr_tcp *tcph = hdr_tcp::access(p);
 841     hdr_flags *fh = hdr_flags::access(p);
 842 
 843     /* build basic header w/options */
 844 
 845         tcph->seqno() = seqno;
 846         tcph->ackno() = ackno;
 847         tcph->flags() = pflags;
 848         tcph->reason() |= reason; // make tcph->reason look like ns1 pkt->flags?
 849     tcph->sa_length() = 0;    // may be increased by build_options()
 850         tcph->hlen() = tcpip_base_hdr_size_;
 851     tcph->hlen() += build_options(tcph);
 852 
 853     /*
 854      * Explicit Congestion Notification (ECN) related:
 855      * Bits in header:
 856      *     ECT (EC Capable Transport),
 857      *     ECNECHO (ECHO of ECN Notification generated at router),
 858      *     CWR (Congestion Window Reduced from RFC 2481)
 859      * States in TCP:
 860      *    ecn_: I am supposed to do ECN if my peer does
 861      *    ect_: I am doing ECN (ecn_ should be T and peer does ECN)
 862      */
 863     
 864     if (datalen > 0 && ecn_ ){
 865             // set ect on data packets 
 866         fh->ect() = ect_;    // on after mutual agreement on ECT
 867         } else if (ecn_ && ecn_syn_ && ecn_syn_next_ && (pflags & TH_SYN) && (pflags & TH_ACK)) {
 868                 // set ect on syn/ack packet, if syn packet was negotiating ECT
 869                    fh->ect() = ect_;
 870     } else {
 871         /* Set ect() to 0.  -M. Weigle 1/19/05 */
 872         fh->ect() = 0;
 873     }
 874     if (ecn_ && ect_ && recent_ce_ ) { 
 875         // This is needed here for the ACK in a SYN, SYN/ACK, ACK
 876         // sequence.
 877         pflags |= TH_ECE;
 878     }
 879         // fill in CWR and ECE bits which don't actually sit in
 880         // the tcp_flags but in hdr_flags
 881         if ( pflags & TH_ECE) {
 882                 fh->ecnecho() = 1;
 883         } else {
 884                 fh->ecnecho() = 0;
 885         }
 886         if ( pflags & TH_CWR ) {
 887                 fh->cong_action() = 1;
 888         }
 889     else {
 890         /* Set cong_action() to 0  -M. Weigle 1/19/05 */
 891         fh->cong_action() = 0;
 892     }
 893 
 894     /* actual size is data length plus header length */
 895 
 896         hdr_cmn *ch = hdr_cmn::access(p);
 897         ch->size() = datalen + tcph->hlen();
 898 
 899         if (datalen <= 0)
 900                 ++nackpack_;
 901         else {
 902                 ++ndatapack_;
 903                 ndatabytes_ += datalen;
 904         last_send_time_ = now();    // time of last data
 905         }
 906         if (reason == REASON_TIMEOUT || reason == REASON_DUPACK || reason == REASON_SACK) {
 907                 ++nrexmitpack_;
 908                 nrexmitbytes_ += datalen;
 909         }
 910 
 911     last_ack_sent_ = ackno;
 912 
 913 //if (state_ != TCPS_ESTABLISHED) {
 914 //printf("%f(%s)[state:%s]: sending pkt ", now(), name(), statestr(state_));
 915 //prpkt(p);
 916 //}
 917 
 918     send(p, 0);
 919 
 920     return;
 921 }
 922 
 923 //
 924 // reset_rtx_timer: called during a retransmission timeout
 925 // to perform exponential backoff.  Also, note that because
 926 // we have performed a retransmission, our rtt timer is now
 927 // invalidated (indicate this by setting rtt_active_ false)
 928 //
 929 void
 930 FullTcpAgent::reset_rtx_timer(int /* mild */)
 931 {
 932     // cancel old timer, set a new one
 933     /* if there is no outstanding data, don't back off rtx timer *
 934      * (Fix from T. Kelly.) */
 935     if (!(highest_ack_ == maxseq_ && restart_bugfix_)) {
 936             rtt_backoff();        // double current timeout
 937     }
 938         set_rtx_timer();    // set new timer
 939         rtt_active_ = FALSE;    // no timing during this window
 940 }
 941 
 942 /*
 943  * see if we should send a segment, and if so, send it
 944  *     (may be ACK or data)
 945  * return the number of data bytes sent (count a SYN or FIN as 1 each)
 946  *
 947  * simulator var, desc (name in real TCP)
 948  * --------------------------------------
 949  * maxseq_, largest seq# we've sent plus one (snd_max)
 950  * flags_, flags regarding our internal state (t_state)
 951  * pflags, a local used to build up the tcp header flags (flags)
 952  * curseq_, is the highest sequence number given to us by "application"
 953  * highest_ack_, the highest ACK we've seen for our data (snd_una-1)
 954  * seqno, the next seq# we're going to send (snd_nxt)
 955  */
 956 int
 957 FullTcpAgent::foutput(int seqno, int reason)
 958 {
 959     // if maxseg_ not set, set it appropriately
 960     // Q: how can this happen?
 961 
 962     if (maxseg_ == 0) 
 963            maxseg_ = size_ - headersize();
 964     else
 965         size_ =  maxseg_ + headersize();
 966 
 967     int is_retransmit = (seqno < maxseq_);
 968     int quiet = (highest_ack_ == maxseq_);
 969     int pflags = outflags();
 970     int syn = (seqno == iss_);
 971     int emptying_buffer = FALSE;
 972     int buffered_bytes = (infinite_send_) ? TCP_MAXSEQ :
 973                 curseq_ - highest_ack_ + 1;
 974 
 975     int win = window() * maxseg_;    // window (in bytes)
 976     int off = seqno - highest_ack_;    // offset of seg in window
 977     int datalen;
 978     //int amtsent = 0;
 979 
 980     // be careful if we have not received any ACK yet
 981     if (highest_ack_ < 0) {
 982         if (!infinite_send_)
 983             buffered_bytes = curseq_ - iss_;;
 984         off = seqno - iss_;
 985     }
 986 
 987     if (syn && !data_on_syn_)
 988         datalen = 0;
 989     else if (pipectrl_)
 990         datalen = buffered_bytes - off;
 991     else
 992         datalen = min(buffered_bytes, win) - off;
 993 
 994         if ((signal_on_empty_) && (!buffered_bytes) && (!syn))
 995                     bufferempty();
 996 
 997     //
 998     // in real TCP datalen (len) could be < 0 if there was window
 999     // shrinkage, or if a FIN has been sent and neither ACKd nor
1000     // retransmitted.  Only this 2nd case concerns us here...
1001     //
1002     if (datalen < 0) {
1003         datalen = 0;
1004     } else if (datalen > maxseg_) {
1005         datalen = maxseg_;
1006     }
1007 
1008     //
1009     // this is an option that causes us to slow-start if we've
1010     // been idle for a "long" time, where long means a rto or longer
1011     // the slow-start is a sort that does not set ssthresh
1012     //
1013 
1014     if (slow_start_restart_ && quiet && datalen > 0) {
1015         if (idle_restart()) {
1016             slowdown(CLOSE_CWND_INIT);
1017         }
1018     }
1019 
1020     //
1021     // see if sending this packet will empty the send buffer
1022     // a dataless SYN packet counts also
1023     //
1024 
1025     if (!infinite_send_ && ((seqno + datalen) > curseq_ || 
1026         (syn && datalen == 0))) {
1027         emptying_buffer = TRUE;
1028         //
1029         // if not a retransmission, notify application that 
1030         // everything has been sent out at least once.
1031         //
1032         if (!syn) {
1033             idle();
1034             if (close_on_empty_ && quiet) {
1035                 flags_ |= TF_NEEDCLOSE;
1036             }
1037         }
1038         pflags |= TH_PUSH;
1039         //
1040         // if close_on_empty set, we are finished
1041         // with this connection; close it
1042         //
1043     } else  {
1044         /* not emptying buffer, so can't be FIN */
1045         pflags &= ~TH_FIN;
1046     }
1047     if (infinite_send_ && (syn && datalen == 0))
1048         pflags |= TH_PUSH;  // set PUSH for dataless SYN
1049 
1050     /* sender SWS avoidance (Nagle) */
1051 
1052     if (datalen > 0) {
1053         // if full-sized segment, ok
1054         if (datalen == maxseg_)
1055             goto send;
1056         // if Nagle disabled and buffer clearing, ok
1057         if ((quiet || nodelay_)  && emptying_buffer)
1058             goto send;
1059         // if a retransmission
1060         if (is_retransmit)
1061             goto send;
1062         // if big "enough", ok...
1063         //    (this is not a likely case, and would
1064         //    only happen for tiny windows)
1065         if (datalen >= ((wnd_ * maxseg_) / 2.0))
1066             goto send;
1067     }
1068 
1069     if (need_send())
1070         goto send;
1071 
1072     /*
1073      * send now if a control packet or we owe peer an ACK
1074      * TF_ACKNOW can be set during connection establishment and
1075      * to generate acks for out-of-order data
1076      */
1077 
1078     if ((flags_ & (TF_ACKNOW|TF_NEEDCLOSE)) ||
1079         (pflags & (TH_SYN|TH_FIN))) {
1080         goto send;
1081     }
1082 
1083         /*      
1084          * No reason to send a segment, just return.
1085          */      
1086     return 0;
1087 
1088 send:
1089 
1090     // is a syn or fin?
1091 
1092     syn = (pflags & TH_SYN) ? 1 : 0;
1093     int fin = (pflags & TH_FIN) ? 1 : 0;
1094 
1095         /* setup ECN syn and ECN SYN+ACK packet headers */
1096         if (ecn_ && syn && !(pflags & TH_ACK)){
1097                 pflags |= TH_ECE;
1098                 pflags |= TH_CWR;
1099         }
1100         if (ecn_ && syn && (pflags & TH_ACK)){
1101                 pflags |= TH_ECE;
1102                 pflags &= ~TH_CWR;
1103         }
1104     else if (ecn_ && ect_ && cong_action_ && 
1105                  (!is_retransmit || SetCWRonRetransmit_)) {
1106         /* 
1107          * Don't set CWR for a retranmitted SYN+ACK (has ecn_ 
1108          * and cong_action_ set).
1109          * -M. Weigle 6/19/02
1110                  *
1111                  * SetCWRonRetransmit_ was changed to true,
1112                  * allowing CWR on retransmitted data packets.  
1113                  * See test ecn_burstyEcn_reno_full 
1114                  * in test-suite-ecn-full.tcl.
1115          * - Sally Floyd, 6/5/08.
1116          */
1117         /* set CWR if necessary */
1118         pflags |= TH_CWR;
1119         /* Turn cong_action_ off: Added 6/5/08, Sally Floyd. */
1120         cong_action_ = FALSE;
1121     }
1122 
1123     /* moved from sendpacket()  -M. Weigle 6/19/02 */
1124     //
1125     // although CWR bit is ordinarily associated with ECN,
1126     // it has utility within the simulator for traces. Thus, set
1127     // it even if we aren't doing ECN
1128     //
1129     if (datalen > 0 && cong_action_ && !is_retransmit) {
1130         pflags |= TH_CWR;
1131     }
1132   
1133         /* set ECE if necessary */
1134         if (ecn_ && ect_ && recent_ce_ ) {
1135         pflags |= TH_ECE;
1136     }
1137 
1138         /* 
1139          * Tack on the FIN flag to the data segment if close_on_empty_
1140          * was previously set-- avoids sending a separate FIN
1141          */ 
1142         if (flags_ & TF_NEEDCLOSE) {
1143                 flags_ &= ~TF_NEEDCLOSE;
1144                 if (state_ <= TCPS_ESTABLISHED && state_ != TCPS_CLOSED)
1145                 {
1146                     pflags |=TH_FIN;
1147                     fin = 1;  /* FIN consumes sequence number */
1148                     newstate(TCPS_FIN_WAIT_1);
1149                 }
1150         }
1151     sendpacket(seqno, rcv_nxt_, pflags, datalen, reason);
1152 
1153         /*      
1154          * Data sent (as far as we can tell).
1155          * Any pending ACK has now been sent.
1156          */      
1157     flags_ &= ~(TF_ACKNOW|TF_DELACK);
1158 
1159     /*
1160      * if we have reacted to congestion recently, the
1161      * slowdown() procedure will have set cong_action_ and
1162      * sendpacket will have copied that to the outgoing pkt
1163      * CWR field. If that packet contains data, then
1164      * it will be reliably delivered, so we are free to turn off the
1165      * cong_action_ state now  If only a pure ACK, we keep the state
1166      * around until we actually send a segment
1167      */
1168 
1169     int reliable = datalen + syn + fin; // seq #'s reliably sent
1170     /* 
1171      * Don't reset cong_action_ until we send new data.
1172      * -M. Weigle 6/19/02
1173      */
1174     if (cong_action_ && reliable > 0 && !is_retransmit)
1175         cong_action_ = FALSE;
1176 
1177     // highest: greatest sequence number sent + 1
1178     //    and adjusted for SYNs and FINs which use up one number
1179 
1180     int highest = seqno + reliable;
1181     if (highest > maxseq_) {
1182         maxseq_ = highest;
1183         //
1184         // if we are using conventional RTT estimation,
1185         // establish timing on this segment
1186         //
1187         if (!ts_option_ && rtt_active_ == FALSE) {
1188             rtt_active_ = TRUE;    // set timer
1189             rtt_seq_ = seqno;     // timed seq #
1190             rtt_ts_ = now();    // when set
1191         }
1192     }
1193 
1194     /*
1195      * Set retransmit timer if not currently set,
1196      * and not doing an ack or a keep-alive probe.
1197      * Initial value for retransmit timer is smoothed
1198      * round-trip time + 2 * round-trip time variance.
1199      * Future values are rtt + 4 * rttvar.
1200      */
1201     if (rtx_timer_.status() != TIMER_PENDING && reliable) {
1202         set_rtx_timer();  // no timer pending, schedule one
1203     }
1204 
1205     return (reliable);
1206 }
1207 
1208 /*
1209  *
1210  * send_much: send as much data as we are allowed to.  This is
1211  * controlled by the "pipectrl_" variable.  If pipectrl_ is set
1212  * to FALSE, then we are working as a normal window-based TCP and
1213  * we are allowed to send whatever the window allows.
1214  * If pipectrl_ is set to TRUE, then we are allowed to send whatever
1215  * pipe_ allows us to send.  One tricky part is to make sure we
1216  * do not overshoot the receiver's advertised window if we are
1217  * in (pipectrl_ == TRUE) mode.
1218  */
1219   
1220 void
1221 FullTcpAgent::send_much(int force, int reason, int maxburst)
1222 {
1223     int npackets = 0;    // sent so far
1224 
1225 //if ((int(t_seqno_)) > 1)
1226 //printf("%f: send_much(f:%d, win:%d, pipectrl:%d, pipe:%d, t_seqno:%d, topwin:%d, maxseq_:%d\n",
1227 //now(), force, win, pipectrl_, pipe_, int(t_seqno_), topwin, int(maxseq_));
1228 
1229     if (!force && (delsnd_timer_.status() == TIMER_PENDING))
1230         return;
1231 
1232     while (1) {
1233 
1234         /*
1235          * note that if output decides to not actually send
1236          * (e.g. because of Nagle), then if we don't break out
1237          * of this loop, we can loop forever at the same
1238          * simulated time instant
1239          */
1240         int amt;
1241         int seq = nxt_tseq();
1242         if (!force && !send_allowed(seq))
1243             break;
1244         // Q: does this need to be here too?
1245         if (!force && overhead_ != 0 &&
1246             (delsnd_timer_.status() != TIMER_PENDING)) {
1247             delsnd_timer_.resched(Random::uniform(overhead_));
1248             return;
1249         }
1250         if ((amt = foutput(seq, reason)) <= 0)
1251             break;
1252         if ((outflags() & TH_FIN))
1253             --amt;    // don't count FINs
1254         sent(seq, amt);
1255         force = 0;
1256 
1257         if ((outflags() & (TH_SYN|TH_FIN)) ||
1258             (maxburst && ++npackets >= maxburst))
1259             break;
1260     }
1261     return;
1262 }
1263 
1264 /*
1265  * base TCP: we are allowed to send a sequence number if it
1266  * is in the window
1267  */
1268 int
1269 FullTcpAgent::send_allowed(int seq)
1270 {
1271         int win = window() * maxseg_;
1272         int topwin = curseq_; // 1 seq number past the last byte we can send
1273 
1274         if ((topwin > highest_ack_ + win) || infinite_send_)
1275                 topwin = highest_ack_ + win; 
1276 
1277     return (seq < topwin);
1278 }
1279 /*
1280  * Process an ACK
1281  *    this version of the routine doesn't necessarily
1282  *    require the ack to be one which advances the ack number
1283  *
1284  * if this ACKs a rtt estimate
1285  *    indicate we are not timing
1286  *    reset the exponential timer backoff (gamma)
1287  * update rtt estimate
1288  * cancel retrans timer if everything is sent and ACK'd, else set it
1289  * advance the ack number if appropriate
1290  * update segment to send next if appropriate
1291  */
1292 void
1293 FullTcpAgent::newack(Packet* pkt)
1294 {
1295     hdr_tcp *tcph = hdr_tcp::access(pkt);
1296 
1297     register int ackno = tcph->ackno();
1298     int progress = (ackno > highest_ack_);
1299 
1300     if (ackno == maxseq_) {
1301         cancel_rtx_timer();    // all data ACKd
1302     } else if (progress) {
1303         set_rtx_timer();
1304     }
1305 
1306     // advance the ack number if this is for new data
1307     if (progress)
1308         highest_ack_ = ackno;
1309 
1310     // if we have suffered a retransmit timeout, t_seqno_
1311     // will have been reset to highest_ ack.  If the
1312     // receiver has cached some data above t_seqno_, the
1313     // new-ack value could (should) jump forward.  We must
1314     // update t_seqno_ here, otherwise we would be doing
1315     // go-back-n.
1316 
1317     if (t_seqno_ < highest_ack_)
1318         t_seqno_ = highest_ack_; // seq# to send next
1319 
1320         /*
1321          * Update RTT only if it's OK to do so from info in the flags header.
1322          * This is needed for protocols in which intermediate agents
1323 
1324          * in the network intersperse acks (e.g., ack-reconstructors) for
1325          * various reasons (without violating e2e semantics).
1326          */
1327         hdr_flags *fh = hdr_flags::access(pkt);
1328 
1329     if (!fh->no_ts_) {
1330                 if (ts_option_) {
1331             recent_age_ = now();
1332             recent_ = tcph->ts();
1333             rtt_update(now() - tcph->ts_echo());
1334             if (ts_resetRTO_ && (!ect_ || !ecn_backoff_ ||
1335                    !hdr_flags::access(pkt)->ecnecho())) { 
1336                 // From Andrei Gurtov
1337                 //
1338                              // Don't end backoff if still in ECN-Echo with
1339                              // a congestion window of 1 packet.
1340                 t_backoff_ = 1;
1341             }
1342         } else if (rtt_active_ && ackno > rtt_seq_) {
1343             // got an RTT sample, record it
1344             // "t_backoff_ = 1;" deleted by T. Kelly.
1345             rtt_active_ = FALSE;
1346             rtt_update(now() - rtt_ts_);
1347                 }
1348         if (!ect_ || !ecn_backoff_ ||
1349             !hdr_flags::access(pkt)->ecnecho()) {
1350             /*
1351              * Don't end backoff if still in ECN-Echo with
1352              * a congestion window of 1 packet.
1353              * Fix from T. Kelly.
1354              */
1355             t_backoff_ = 1;
1356             ecn_backoff_ = 0;
1357         }
1358 
1359         }
1360     return;
1361 }
1362 
1363 /*
1364  * this is the simulated form of the header prediction
1365  * predicate.  While not really necessary for a simulation, it
1366  * follows the code base more closely and can sometimes help to reveal
1367  * odd behavior caused by the implementation structure..
1368  *
1369  * Here's the comment from the real TCP:
1370  *
1371  * Header prediction: check for the two common cases
1372  * of a uni-directional data xfer.  If the packet has
1373  * no control flags, is in-sequence, the window didn't
1374  * change and we're not retransmitting, it's a
1375  * candidate.  If the length is zero and the ack moved
1376  * forward, we're the sender side of the xfer.  Just
1377  * free the data acked & wake any higher level process
1378  * that was blocked waiting for space.  If the length
1379  * is non-zero and the ack didn't move, we're the
1380  * receiver side.  If we're getting packets in-order
1381  * (the reassembly queue is empty), add the data to
1382  * the socket buffer and note that we need a delayed ack.
1383  * Make sure that the hidden state-flags are also off.
1384  * Since we check for TCPS_ESTABLISHED above, it can only
1385  * be TF_NEEDSYN.
1386  */
1387 
1388 int
1389 FullTcpAgent::predict_ok(Packet* pkt)
1390 {
1391     hdr_tcp *tcph = hdr_tcp::access(pkt);
1392         hdr_flags *fh = hdr_flags::access(pkt);
1393 
1394     /* not the fastest way to do this, but perhaps clearest */
1395 
1396     int p1 = (state_ == TCPS_ESTABLISHED);        // ready
1397     int p2 = ((tcph->flags() & (TH_SYN|TH_FIN|TH_ACK)) == TH_ACK); // ACK
1398     int p3 = ((flags_ & TF_NEEDFIN) == 0);        // don't need fin
1399     int p4 = (!ts_option_ || fh->no_ts_ || (tcph->ts() >= recent_)); // tsok
1400     int p5 = (tcph->seqno() == rcv_nxt_);        // in-order data
1401     int p6 = (t_seqno_ == maxseq_);            // not re-xmit
1402     int p7 = (!ecn_ || fh->ecnecho() == 0);        // no ECN
1403     int p8 = (tcph->sa_length() == 0);        // no SACK info
1404 
1405     return (p1 && p2 && p3 && p4 && p5 && p6 && p7 && p8);
1406 }
1407 
1408 /*
1409  * fast_retransmit using the given seqno
1410  *    perform fast RTX, set recover_, set last_cwnd_action
1411  */
1412 
1413 int
1414 FullTcpAgent::fast_retransmit(int seq)
1415 {
1416     // we are now going to fast-retransmit and willtrace that event
1417     trace_event("FAST_RETX");
1418     
1419     recover_ = maxseq_;    // recovery target
1420     last_cwnd_action_ = CWND_ACTION_DUPACK;
1421     return(foutput(seq, REASON_DUPACK));    // send one pkt
1422 }
1423 
1424 /*
1425  * real tcp determines if the remote
1426  * side should receive a window update/ACK from us, and often
1427  * results in sending an update every 2 segments, thereby
1428  * giving the familiar 2-packets-per-ack behavior of TCP.
1429  * Here, we don't advertise any windows, so we just see if
1430  * there's at least 'segs_per_ack_' pkts not yet acked
1431  *
1432  * also, provide for a segs-per-ack "threshold" where
1433  * we generate 1-ack-per-seg until enough stuff
1434  * (spa_thresh_ bytes) has been received from the other side
1435  * This idea came from vj/kmn in BayTcp.  Added 8/21/01.
1436  */
1437 
1438 int
1439 FullTcpAgent::need_send()
1440 {
1441     if (flags_ & TF_ACKNOW)
1442         return TRUE;
1443 
1444     int spa = (spa_thresh_ > 0 && ((rcv_nxt_ - irs_)  < spa_thresh_)) ?
1445         1 : segs_per_ack_;
1446         
1447     return ((rcv_nxt_ - last_ack_sent_) >= (spa * maxseg_));
1448 }
1449 
1450 /*
1451  * determine whether enough time has elapsed in order to
1452  * conclude a "restart" is necessary (e.g. a slow-start)
1453  *
1454  * for now, keep track of this similarly to how rtt_update() does
1455  */
1456 
1457 int
1458 FullTcpAgent::idle_restart()
1459 {
1460     if (last_send_time_ < 0.0) {
1461         // last_send_time_ isn't set up yet, we shouldn't
1462         // do the idle_restart
1463         return (0);
1464     }
1465 
1466     double tao = now() - last_send_time_;
1467     if (!ts_option_) {
1468                 double tickoff = fmod(last_send_time_ + boot_time_,
1469             tcp_tick_);
1470                 tao = int((tao + tickoff) / tcp_tick_) * tcp_tick_;
1471     }
1472 
1473     return (tao > t_rtxcur_);  // verify this CHECKME
1474 }
1475 
1476 /*
1477  * tcp-full's version of set_initial_window()... over-rides
1478  * the one in tcp.cc
1479  */
1480 void
1481 FullTcpAgent::set_initial_window()
1482 {
1483     syn_ = TRUE;    // full-tcp always models SYN exchange
1484     TcpAgent::set_initial_window();
1485 }       
1486 
1487 /*
1488  * main reception path - 
1489  * called from the agent that handles the data path below in its muxing mode
1490  * advance() is called when connection is established with size sent from
1491  * user/application agent
1492  *
1493  * This is a fairly complex function.  It operates generally as follows:
1494  *    do header prediction for simple cases (pure ACKS or data)
1495  *    if in LISTEN and we get a SYN, begin initializing connection
1496  *    if in SYN_SENT and we get an ACK, complete connection init
1497  *    trim any redundant data from received dataful segment
1498  *    deal with ACKS:
1499  *        if in SYN_RCVD, complete connection init then go on
1500  *        see if ACK is old or at the current highest_ack
1501  *        if at current high, is the threshold reached or not
1502  *        if so, maybe do fast rtx... otherwise drop or inflate win
1503  *    deal with incoming data
1504  *    deal with FIN bit on in arriving packet
1505  */
1506 void
1507 FullTcpAgent::recv(Packet *pkt, Handler*)
1508 {
1509     hdr_tcp *tcph = hdr_tcp::access(pkt);    // TCP header
1510     hdr_cmn *th = hdr_cmn::access(pkt);    // common header (size, etc)
1511     hdr_flags *fh = hdr_flags::access(pkt);    // flags (CWR, CE, bits)
1512 
1513     int needoutput = FALSE;
1514     int ourfinisacked = FALSE;
1515     int dupseg = FALSE;            // recv'd dup data segment
1516     int todrop = 0;                // duplicate DATA cnt in seg
1517 
1518     last_state_ = state_;
1519 
1520     int datalen = th->size() - tcph->hlen(); // # payload bytes
1521     int ackno = tcph->ackno();         // ack # from packet
1522     int tiflags = tcph->flags() ;          // tcp flags from packet
1523 
1524 //if (state_ != TCPS_ESTABLISHED || (tiflags&(TH_SYN|TH_FIN))) {
1525 //fprintf(stdout, "%f(%s)in state %s recv'd this packet: ", now(), name(), statestr(state_));
1526 //prpkt(pkt);
1527 //}
1528 
1529     /* 
1530      * Acknowledge FIN from passive closer even in TCPS_CLOSED state
1531      * (since we lack TIME_WAIT state and RST packets,
1532      * the loss of the FIN packet from the passive closer will make that
1533      * endpoint retransmit the FIN forever)
1534      * -F. Hernandez-Campos 8/6/00
1535      */
1536     if ( (state_ == TCPS_CLOSED) && (tiflags & TH_FIN) ) {
1537         goto dropafterack;
1538     }
1539 
1540     /*
1541      * Don't expect to see anything while closed
1542      */
1543 
1544     if (state_ == TCPS_CLOSED) {
1545                 if (debug_) {
1546                 fprintf(stderr, "%f: FullTcp(%s): recv'd pkt in CLOSED state: ",
1547                 now(), name());
1548                 prpkt(pkt);
1549                 }
1550         goto drop;
1551     }
1552 
1553         /*
1554          * Process options if not in LISTEN state,
1555          * else do it below
1556          */
1557     if (state_ != TCPS_LISTEN)
1558         dooptions(pkt);
1559 
1560     /*
1561      * if we are using delayed-ACK timers and
1562      * no delayed-ACK timer is set, set one.
1563      * They are set to fire every 'interval_' secs, starting
1564      * at time t0 = (0.0 + k * interval_) for some k such
1565      * that t0 > now
1566      */
1567     if (delack_interval_ > 0.0 &&
1568         (delack_timer_.status() != TIMER_PENDING)) {
1569         int last = int(now() / delack_interval_);
1570         delack_timer_.resched(delack_interval_ * (last + 1.0) - now());
1571     }
1572 
1573     /*
1574      * Try header prediction: in seq data or in seq pure ACK
1575      *    with no funny business
1576      */
1577     if (!nopredict_ && predict_ok(pkt)) {
1578                 /*
1579                  * If last ACK falls within this segment's sequence numbers,
1580                  * record the timestamp.
1581          * See RFC1323 (now RFC1323 bis)
1582                  */
1583                 if (ts_option_ && !fh->no_ts_ &&
1584             tcph->seqno() <= last_ack_sent_) {
1585             /*
1586              * this is the case where the ts value is newer than
1587              * the last one we've seen, and the seq # is the one
1588              * we expect [seqno == last_ack_sent_] or older
1589              */
1590             recent_age_ = now();
1591             recent_ = tcph->ts();
1592                 }
1593 
1594         //
1595         // generate a stream of ecnecho bits until we see a true
1596         // cong_action bit
1597         //
1598 
1599             if (ecn_) {
1600                 if (fh->ce() && fh->ect()) {
1601                     // no CWR from peer yet... arrange to
1602                     // keep sending ECNECHO
1603                     recent_ce_ = TRUE;
1604                 } else if (fh->cwr()) {
1605                     // got CWR response from peer.. stop
1606                     // sending ECNECHO bits
1607                     recent_ce_ = FALSE;
1608                 }
1609             }
1610 
1611         // Header predication basically looks to see
1612         // if the incoming packet is an expected pure ACK
1613         // or an expected data segment
1614 
1615         if (datalen == 0) {
1616             // check for a received pure ACK in the correct range..
1617             // also checks to see if we are wnd_ limited
1618             // (we don't change cwnd at all below), plus
1619             // not being in fast recovery and not a partial ack.
1620             // If we are in fast
1621             // recovery, go below so we can remember to deflate
1622             // the window if we need to
1623             if (ackno > highest_ack_ && ackno < maxseq_ &&
1624                 cwnd_ >= wnd_ && !fastrecov_) {
1625                 newack(pkt);    // update timers,  highest_ack_
1626                 send_much(0, REASON_NORMAL, maxburst_);
1627                 Packet::free(pkt);
1628                 return;
1629             }
1630         } else if (ackno == highest_ack_ && rq_.empty()) {
1631             // check for pure incoming segment
1632             // the next data segment we're awaiting, and
1633             // that there's nothing sitting in the reassem-
1634             // bly queue
1635             //     give to "application" here
1636             //    note: DELACK is inspected only by
1637             //    tcp_fasttimo() in real tcp.  Every 200 ms
1638             //    this routine scans all tcpcb's looking for
1639             //    DELACK segments and when it finds them
1640             //    changes DELACK to ACKNOW and calls tcp_output()
1641             rcv_nxt_ += datalen;
1642             flags_ |= TF_DELACK;
1643             recvBytes(datalen); // notify application of "delivery"
1644             //
1645             // special code here to simulate the operation
1646             // of a receiver who always consumes data,
1647             // resulting in a call to tcp_output
1648             Packet::free(pkt);
1649             if (need_send())
1650                 send_much(1, REASON_NORMAL, maxburst_);
1651             return;
1652         }
1653     } /* header prediction */
1654 
1655 
1656     //
1657     // header prediction failed
1658     // (e.g. pure ACK out of valid range, SACK present, etc)...
1659     // do slow path processing
1660 
1661     //
1662     // the following switch does special things for these states:
1663     //    TCPS_LISTEN, TCPS_SYN_SENT
1664     //
1665 
1666     switch (state_) {
1667 
1668         /*
1669          * If the segment contains an ACK then it is bad and do reset.
1670          * If it does not contain a SYN then it is not interesting; drop it.
1671          * Otherwise initialize tp->rcv_nxt, and tp->irs, iss is already
1672      * selected, and send a segment:
1673          *     
1674          * Initialize tp->snd_nxt to tp->iss.
1675          * Enter SYN_RECEIVED state, and process any other fields of this
1676          * segment in this state.
1677          */
1678 
1679     case TCPS_LISTEN:    /* awaiting peer's SYN */
1680 
1681         if (tiflags & TH_ACK) {
1682                         if (debug_) {
1683                         fprintf(stderr,
1684                     "%f: FullTcpAgent(%s): warning: recv'd ACK while in LISTEN: ",
1685                     now(), name());
1686                     prpkt(pkt);
1687                         }
1688             // don't want ACKs in LISTEN
1689             goto dropwithreset;
1690         }
1691         if ((tiflags & TH_SYN) == 0) {
1692                         if (debug_) {
1693                         fprintf(stderr, "%f: FullTcpAgent(%s): warning: recv'd NON-SYN while in LISTEN\n",
1694                 now(), name());
1695                     prpkt(pkt);
1696                         }
1697             // any non-SYN is discarded
1698             goto drop;
1699         }
1700 
1701         /*
1702          * must by a SYN (no ACK) at this point...
1703          * in real tcp we would bump the iss counter here also
1704          */
1705         dooptions(pkt);
1706         irs_ = tcph->seqno();
1707         t_seqno_ = iss_; /* tcp_sendseqinit() macro in real tcp */
1708         rcv_nxt_ = rcvseqinit(irs_, datalen);
1709         flags_ |= TF_ACKNOW;
1710 
1711         // check for a ECN-SYN with ECE|CWR
1712         if (ecn_ && fh->ecnecho() && fh->cong_action()) {
1713             ect_ = TRUE;
1714         }
1715 
1716 
1717         if (fid_ == 0) {
1718             // XXX: sort of hack... If we do not
1719             // have a special flow ID, pick up that
1720             // of the sender (active opener)
1721             hdr_ip* iph = hdr_ip::access(pkt);
1722             fid_ = iph->flowid();
1723         }
1724 
1725         newstate(TCPS_SYN_RECEIVED);
1726         goto trimthenstep6;
1727 
1728         /*
1729          * If the state is SYN_SENT:
1730          *      if seg contains an ACK, but not for our SYN, drop the input.
1731          *      if seg does not contain SYN, then drop it.
1732          * Otherwise this is an acceptable SYN segment
1733          *      initialize tp->rcv_nxt and tp->irs
1734          *      if seg contains ack then advance tp->snd_una
1735          *      if SYN has been acked change to ESTABLISHED else SYN_RCVD state
1736          *      arrange for segment to be acked (eventually)
1737          *      continue processing rest of data/controls, beginning with URG
1738          */
1739 
1740     case TCPS_SYN_SENT:    /* we sent SYN, expecting SYN+ACK (or SYN) */
1741 
1742         /* drop if it's a SYN+ACK and the ack field is bad */
1743         if ((tiflags & TH_ACK) &&
1744             ((ackno <= iss_) || (ackno > maxseq_))) {
1745             // not an ACK for our SYN, discard
1746                         if (debug_) {
1747                    fprintf(stderr, "%f: FullTcpAgent::recv(%s): bad ACK for our SYN: ",
1748                     now(), name());
1749                     prpkt(pkt);
1750                         }
1751             goto dropwithreset;
1752         }
1753 
1754         if ((tiflags & TH_SYN) == 0) {
1755                         if (debug_) {
1756                     fprintf(stderr, "%f: FullTcpAgent::recv(%s): no SYN for our SYN: ",
1757                     now(), name());
1758                     prpkt(pkt);
1759                         }
1760             goto drop;
1761         }
1762 
1763         /* looks like an ok SYN or SYN+ACK */
1764                 // If ecn_syn_wait is set to 2:
1765         // Check if CE-marked SYN/ACK packet, then just send an ACK
1766                 //  packet with ECE set, and drop the SYN/ACK packet.
1767                 //  Don't update TCP state. 
1768         if (tiflags & TH_ACK) 
1769         {
1770                         if (ecn_ && fh->ecnecho() && !fh->cong_action() && ecn_syn_wait_ == 2) 
1771                         // if SYN/ACK packet and ecn_syn_wait_ == 2
1772             {
1773                         if ( fh->ce() ) 
1774                                 // If SYN/ACK packet is CE-marked
1775                 {
1776                     //cancel_rtx_timer();
1777                     //newack(pkt);
1778                     set_rtx_timer();
1779                     sendpacket(t_seqno_, rcv_nxt_, TH_ACK|TH_ECE, 0, 0);
1780                     goto drop;
1781                 }
1782                 }
1783         }
1784 
1785 
1786 #ifdef notdef
1787 cancel_rtx_timer();    // cancel timer on our 1st SYN [does this belong!?]
1788 #endif
1789         irs_ = tcph->seqno();    // get initial recv'd seq #
1790         rcv_nxt_ = rcvseqinit(irs_, datalen);
1791 
1792         if (tiflags & TH_ACK) {
1793             // SYN+ACK (our SYN was acked)
1794                         if (ecn_ && fh->ecnecho() && !fh->cong_action()) {
1795                                 ect_ = TRUE;
1796                         if ( fh->ce() ) 
1797                         recent_ce_ = TRUE;
1798                 }
1799             highest_ack_ = ackno;
1800             cwnd_ = initial_window();
1801 
1802 #ifdef notdef
1803 /*
1804  * if we didn't have to retransmit the SYN,
1805  * use its rtt as our initial srtt & rtt var.
1806  */
1807 if (t_rtt_) {
1808     double tao = now() - tcph->ts();
1809     rtt_update(tao);
1810 }
1811 #endif
1812 
1813             /*
1814              * if there's data, delay ACK; if there's also a FIN
1815              * ACKNOW will be turned on later.
1816              */
1817             if (datalen > 0) {
1818                 flags_ |= TF_DELACK;    // data there: wait
1819             } else {
1820                 flags_ |= TF_ACKNOW;    // ACK peer's SYN
1821             }
1822 
1823                         /*
1824                          * Received  in SYN_SENT[*] state.
1825                          * Transitions:
1826                          *      SYN_SENT  --> ESTABLISHED
1827                          *      SYN_SENT* --> FIN_WAIT_1
1828                          */
1829 
1830             if (flags_ & TF_NEEDFIN) {
1831                 newstate(TCPS_FIN_WAIT_1);
1832                 flags_ &= ~TF_NEEDFIN;
1833                 tiflags &= ~TH_SYN;
1834             } else {
1835                 newstate(TCPS_ESTABLISHED);
1836             }
1837 
1838             // special to ns:
1839             //  generate pure ACK here.
1840             //  this simulates the ordinary connection establishment
1841             //  where the ACK of the peer's SYN+ACK contains
1842             //  no data.  This is typically caused by the way
1843             //  the connect() socket call works in which the
1844             //  entire 3-way handshake occurs prior to the app
1845             //  being able to issue a write() [which actually
1846             //  causes the segment to be sent].
1847             sendpacket(t_seqno_, rcv_nxt_, TH_ACK, 0, 0);
1848         } else {
1849             // Check ECN-SYN packet
1850                         if (ecn_ && fh->ecnecho() && fh->cong_action())
1851                                 ect_ = TRUE;
1852 
1853             // SYN (no ACK) (simultaneous active opens)
1854             flags_ |= TF_ACKNOW;
1855             cancel_rtx_timer();
1856             newstate(TCPS_SYN_RECEIVED);
1857             /*
1858              * decrement t_seqno_: we are sending a
1859              * 2nd SYN (this time in the form of a
1860              * SYN+ACK, so t_seqno_ will have been
1861              * advanced to 2... reduce this
1862              */
1863             t_seqno_--;    // CHECKME
1864         }
1865 
1866 trimthenstep6:
1867         /*
1868          * advance the seq# to correspond to first data byte
1869          */
1870         tcph->seqno()++;
1871 
1872         if (tiflags & TH_ACK)
1873             goto process_ACK;
1874 
1875         goto step6;
1876 
1877     case TCPS_LAST_ACK:
1878         /* 
1879          * The only way we're in LAST_ACK is if we've already
1880          * received a FIN, so ignore all retranmitted FINS.
1881          * -M. Weigle 7/23/02
1882          */
1883         if (tiflags & TH_FIN) {
1884             goto drop;
1885         }
1886         break;
1887     case TCPS_CLOSING:
1888         break;
1889     } /* end switch(state_) */
1890 
1891         /*
1892          * States other than LISTEN or SYN_SENT.
1893          * First check timestamp, if present.
1894          * Then check that at least some bytes of segment are within
1895          * receive window.  If segment begins before rcv_nxt,
1896          * drop leading data (and SYN); if nothing left, just ack.
1897          *
1898          * RFC 1323 PAWS: If we have a timestamp reply on this segment
1899          * and it's less than ts_recent, drop it.
1900          */
1901 
1902     if (ts_option_ && !fh->no_ts_ && recent_ && tcph->ts() < recent_) {
1903         if ((now() - recent_age_) > TCP_PAWS_IDLE) {
1904             /*
1905              * this is basically impossible in the simulator,
1906              * but here it is...
1907              */
1908                         /*
1909                          * Invalidate ts_recent.  If this segment updates
1910                          * ts_recent, the age will be reset later and ts_recent
1911                          * will get a valid value.  If it does not, setting
1912                          * ts_recent to zero will at least satisfy the
1913                          * requirement that zero be placed in the timestamp
1914                          * echo reply when ts_recent isn't valid.  The
1915                          * age isn't reset until we get a valid ts_recent
1916                          * because we don't want out-of-order segments to be
1917                          * dropped when ts_recent is old.
1918                          */
1919             recent_ = 0.0;
1920         } else {
1921             fprintf(stderr, "%f: FullTcpAgent(%s): dropped pkt due to bad ts\n",
1922                 now(), name());
1923             goto dropafterack;
1924         }
1925     }
1926 
1927     // check for redundant data at head/tail of segment
1928     //    note that the 4.4bsd [Net/3] code has
1929     //    a bug here which can cause us to ignore the
1930     //    perfectly good ACKs on duplicate segments.  The
1931     //    fix is described in (Stevens, Vol2, p. 959-960).
1932     //    This code is based on that correction.
1933     //
1934     // In addition, it has a modification so that duplicate segments
1935     // with dup acks don't trigger a fast retransmit when dupseg_fix_
1936     // is enabled.
1937     //
1938     // Yet one more modification: make sure that if the received
1939     //    segment had datalen=0 and wasn't a SYN or FIN that
1940     //    we don't turn on the ACKNOW status bit.  If we were to
1941     //    allow ACKNOW to be turned on, normal pure ACKs that happen
1942     //    to have seq #s below rcv_nxt can trigger an ACK war by
1943     //    forcing us to ACK the pure ACKs
1944     //
1945     // Update: if we have a dataless FIN, don't really want to
1946     // do anything with it.  In particular, would like to
1947     // avoid ACKing an incoming FIN+ACK while in CLOSING
1948     //
1949     todrop = rcv_nxt_ - tcph->seqno();  // how much overlap?
1950 
1951     if (todrop > 0 && ((tiflags & (TH_SYN)) || datalen > 0)) {
1952 //printf("%f(%s): trim 1..todrop:%d, dlen:%d\n",now(), name(), todrop, datalen);
1953         if (tiflags & TH_SYN) {
1954             tiflags &= ~TH_SYN;
1955             tcph->seqno()++;
1956             th->size()--;    // XXX Must decrease packet size too!!
1957                     // Q: Why?.. this is only a SYN
1958             todrop--;
1959         }
1960         //
1961         // see Stevens, vol 2, p. 960 for this check;
1962         // this check is to see if we are dropping
1963         // more than this segment (i.e. the whole pkt + a FIN),
1964         // or just the whole packet (no FIN)
1965         //
1966         if ((todrop > datalen) ||
1967             (todrop == datalen && ((tiflags & TH_FIN) == 0))) {
1968 //printf("%f(%s): trim 2..todrop:%d, dlen:%d\n",now(), name(), todrop, datalen);
1969                         /*
1970                          * Any valid FIN must be to the left of the window.
1971                          * At this point the FIN must be a duplicate or out
1972                          * of sequence; drop it.
1973                          */
1974 
1975             tiflags &= ~TH_FIN;
1976 
1977             /*
1978              * Send an ACK to resynchronize and drop any data.
1979              * But keep on processing for RST or ACK.
1980              */
1981 
1982             flags_ |= TF_ACKNOW;
1983             todrop = datalen;
1984             dupseg = TRUE;    // *completely* duplicate
1985 
1986         }
1987 
1988         /*
1989          * Trim duplicate data from the front of the packet
1990          */
1991 
1992         tcph->seqno() += todrop;
1993         th->size() -= todrop;    // XXX Must decrease size too!!
1994                     // why? [kf]..prob when put in RQ
1995         datalen -= todrop;
1996 
1997     } /* data trim */
1998 
1999     /*
2000      * If we are doing timstamps and this packet has one, and
2001      * If last ACK falls within this segment's sequence numbers,
2002      * record the timestamp.
2003      * See RFC1323 (now RFC1323 bis)
2004      */
2005     if (ts_option_ && !fh->no_ts_ && tcph->seqno() <= last_ack_sent_) {
2006         /*
2007          * this is the case where the ts value is newer than
2008          * the last one we've seen, and the seq # is the one we expect
2009          * [seqno == last_ack_sent_] or older
2010          */
2011         recent_age_ = now();
2012         recent_ = tcph->ts();
2013     }
2014 
2015     if (tiflags & TH_SYN) {
2016                 if (debug_) {
2017                 fprintf(stderr, "%f: FullTcpAgent::recv(%s) received unexpected SYN (state:%d): ",
2018                 now(), name(), state_);
2019                 prpkt(pkt);
2020                 }
2021         goto dropwithreset;
2022     }
2023 
2024     if ((tiflags & TH_ACK) == 0) {
2025         /*
2026          * Added check for state != SYN_RECEIVED.  We will receive a 
2027          * duplicate SYN in SYN_RECEIVED when our SYN/ACK was dropped.
2028          * We should just ignore the duplicate SYN (our timeout for 
2029          * resending the SYN/ACK is about the same as the client's 
2030          * timeout for resending the SYN), but give no error message. 
2031          * -M. Weigle 07/24/01
2032          */
2033         if (state_ != TCPS_SYN_RECEIVED) {
2034                         if (debug_) {
2035                     fprintf(stderr, "%f: FullTcpAgent::recv(%s) got packet lacking ACK (state:%d): ",
2036                 now(), name(), state_);
2037                     prpkt(pkt);
2038                         }
2039         }
2040         goto drop;
2041     }
2042 
2043     /*
2044      * Ack processing.
2045      */
2046 
2047     switch (state_) {
2048     case TCPS_SYN_RECEIVED:    /* want ACK for our SYN+ACK */
2049         if (ackno < highest_ack_ || ackno > maxseq_) {
2050             // not in useful range
2051                         if (debug_) {
2052                         fprintf(stderr, "%f: FullTcpAgent(%s): ack(%d) not in range while in SYN_RECEIVED: ",
2053                  now(), name(), ackno);
2054                     prpkt(pkt);
2055                         }
2056             goto dropwithreset;
2057         }
2058 
2059         if (ecn_ && ect_ && ecn_syn_ && fh->ecnecho() && ecn_syn_wait_ == 2) 
2060         {
2061         // The SYN/ACK packet was ECN-marked.
2062         // Reset the rtx timer, send another SYN/ACK packet
2063                 //  immediately, and drop the ACK packet.
2064                 // Do not move to TCPS_ESTB state or update TCP variables.
2065             cancel_rtx_timer();
2066             ecn_syn_next_ = 0;
2067             foutput(iss_, REASON_NORMAL);
2068             wnd_init_option_ = 1;
2069                         wnd_init_ = 1;
2070             goto drop;
2071         } 
2072         if (ecn_ && ect_ && ecn_syn_ && fh->ecnecho() && ecn_syn_wait_ < 2) {
2073         // The SYN/ACK packet was ECN-marked.
2074             if (ecn_syn_wait_ == 1) {
2075                 // A timer will be called in ecn().
2076                 cwnd_ = 1;
2077                 use_rtt_ = 1; //KK, wait for timeout() period
2078             } else {
2079                     // Congestion window will be halved in ecn().
2080                 cwnd_ = 2;
2081             }
2082         } else  {
2083             cwnd_ = initial_window();
2084         }
2085     
2086                 /*
2087                  * Make transitions:
2088                  *      SYN-RECEIVED  -> ESTABLISHED
2089                  *      SYN-RECEIVED* -> FIN-WAIT-1
2090                  */
2091                 if (flags_ & TF_NEEDFIN) {
2092             newstate(TCPS_FIN_WAIT_1);
2093                         flags_ &= ~TF_NEEDFIN;
2094                 } else {
2095                         newstate(TCPS_ESTABLISHED);
2096                 }
2097 
2098         /* fall into ... */
2099 
2100 
2101         /*
2102          * In ESTABLISHED state: drop duplicate ACKs; ACK out of range
2103          * ACKs.  If the ack is in the range
2104          *      tp->snd_una < ti->ti_ack <= tp->snd_max
2105          * then advance tp->snd_una to ti->ti_ack and drop
2106          * data from the retransmission queue.
2107      *
2108      * note that state TIME_WAIT isn't used
2109      * in the simulator
2110          */
2111 
2112         case TCPS_ESTABLISHED:
2113         case TCPS_FIN_WAIT_1:
2114         case TCPS_FIN_WAIT_2:
2115     case TCPS_CLOSE_WAIT:
2116         case TCPS_CLOSING:
2117         case TCPS_LAST_ACK:
2118 
2119         //
2120         // look for ECNs in ACKs, react as necessary
2121         //
2122 
2123         if (fh->ecnecho() && (!ecn_ || !ect_)) {
2124             fprintf(stderr,
2125                 "%f: FullTcp(%s): warning, recvd ecnecho but I am not ECN capable!\n",
2126                 now(), name());
2127         }
2128 
2129                 //
2130                 // generate a stream of ecnecho bits until we see a true
2131                 // cong_action bit
2132                 // 
2133                 if (ecn_) {
2134                         if (fh->ce() && fh->ect())
2135                                 recent_ce_ = TRUE;
2136                         else if (fh->cwr()) 
2137                                 recent_ce_ = FALSE;
2138                 }
2139 
2140         //
2141         // If ESTABLISHED or starting to close, process SACKS
2142         //
2143 
2144         if (state_ >= TCPS_ESTABLISHED && tcph->sa_length() > 0) {
2145             process_sack(tcph);
2146         }
2147 
2148         //
2149         // ACK indicates packet left the network
2150         //    try not to be fooled by data
2151         //
2152 
2153         if (fastrecov_ && (datalen == 0 || ackno > highest_ack_))
2154             pipe_ -= maxseg_;
2155 
2156         // look for dup ACKs (dup ack numbers, no data)
2157         //
2158         // do fast retransmit/recovery if at/past thresh
2159         if (ackno <= highest_ack_) {
2160             // a pure ACK which doesn't advance highest_ack_
2161             if (datalen == 0 && (!dupseg_fix_ || !dupseg)) {
2162 
2163                                 /*
2164                                  * If we have outstanding data
2165                                  * this is a completely
2166                                  * duplicate ack,
2167                                  * the ack is the biggest we've
2168                                  * seen and we've seen exactly our rexmt
2169                                  * threshhold of them, assume a packet
2170                                  * has been dropped and retransmit it.
2171                                  *
2172                                  * We know we're losing at the current
2173                                  * window size so do congestion avoidance.
2174                                  *
2175                                  * Dup acks mean that packets have left the
2176                                  * network (they're now cached at the receiver)
2177                                  * so bump cwnd by the amount in the receiver
2178                                  * to keep a constant cwnd packets in the
2179                                  * network.
2180                                  */
2181 
2182                 if ((rtx_timer_.status() != TIMER_PENDING) ||
2183                     ackno < highest_ack_) {
2184                     // Q: significance of timer not pending?
2185                     // ACK below highest_ack_
2186                     oldack();
2187                 } else if (++dupacks_ == tcprexmtthresh_) {
2188                     // ACK at highest_ack_ AND meets threshold
2189                     //trace_event("FAST_RECOVERY");
2190                     dupack_action(); // maybe fast rexmt
2191                     goto drop;
2192 
2193                 } else if (dupacks_ > tcprexmtthresh_) {
2194                     // ACK at highest_ack_ AND above threshole
2195                     //trace_event("FAST_RECOVERY");
2196                     extra_ack();
2197 
2198                     // send whatever window allows
2199                     send_much(0, REASON_DUPACK, maxburst_);
2200                     goto drop;
2201                 }
2202             } else {
2203                 // non zero-length [dataful] segment
2204                 // with a dup ack (normal for dataful segs)
2205                 // (or window changed in real TCP).
2206                 if (dupack_reset_) {
2207                     dupacks_ = 0;
2208                     fastrecov_ = FALSE;
2209                 }
2210             }
2211             break;    /* take us to "step6" */
2212         } /* end of dup/old acks */
2213 
2214         /*
2215          * we've finished the fast retransmit/recovery period
2216          * (i.e. received an ACK which advances highest_ack_)
2217          * The ACK may be "good" or "partial"
2218          */
2219 
2220 process_ACK:
2221 
2222         if (ackno > maxseq_) {
2223             // ack more than we sent(!?)
2224                         if (debug_) {
2225                     fprintf(stderr, "%f: FullTcpAgent::recv(%s) too-big ACK (maxseq:%d): ",
2226                 now(), name(), int(maxseq_));
2227                     prpkt(pkt);
2228                         }
2229             goto dropafterack;
2230         }
2231 
2232                 /*
2233                  * If we have a timestamp reply, update smoothed
2234                  * round trip time.  If no timestamp is present but
2235                  * transmit timer is running and timed sequence
2236                  * number was acked, update smoothed round trip time.
2237                  * Since we now have an rtt measurement, cancel the
2238                  * timer backoff (cf., Phil Karn's retransmit alg.).
2239                  * Recompute the initial retransmit timer.
2240          *
2241                  * If all outstanding data is acked, stop retransmit
2242                  * If there is more data to be acked, restart retransmit
2243                  * timer, using current (possibly backed-off) value.
2244                  */
2245         newack(pkt);    // handle timers, update highest_ack_
2246 
2247         /*
2248          * if this is a partial ACK, invoke whatever we should
2249          * note that newack() must be called before the action
2250          * functions, as some of them depend on side-effects
2251          * of newack()
2252          */
2253 
2254         int partial = pack(pkt);
2255 
2256         if (partial)
2257             pack_action(pkt);
2258         else
2259             ack_action(pkt);
2260 
2261         /*
2262          * if this is an ACK with an ECN indication, handle this
2263          * but not if it is a syn packet
2264          */
2265         if (fh->ecnecho() && !(tiflags&TH_SYN) )
2266         if (fh->ecnecho()) {
2267             // Note from Sally: In one-way TCP,
2268             // ecn() is called before newack()...
2269             ecn(highest_ack_);  // updated by newack(), above
2270             // "set_rtx_timer();" from T. Kelly.
2271             if (cwnd_ < 1)
2272                  set_rtx_timer();
2273         }
2274         // CHECKME: handling of rtx timer
2275         if (ackno == maxseq_) {
2276             needoutput = TRUE;
2277         }
2278 
2279         /*
2280          * If no data (only SYN) was ACK'd,
2281          *    skip rest of ACK processing.
2282          */
2283         if (ackno == (highest_ack_ + 1))
2284             goto step6;
2285 
2286         // if we are delaying initial cwnd growth (probably due to
2287         // large initial windows), then only open cwnd if data has
2288         // been received
2289         // Q: check when this happens
2290                 /*
2291                  * When new data is acked, open the congestion window.
2292                  * If the window gives us less than ssthresh packets
2293                  * in flight, open exponentially (maxseg per packet).
2294                  * Otherwise open about linearly: maxseg per window
2295                  * (maxseg^2 / cwnd per packet).
2296                  */
2297         if ((!delay_growth_ || (rcv_nxt_ > 0)) &&
2298             last_state_ == TCPS_ESTABLISHED) {
2299             if (!partial || open_cwnd_on_pack_) {
2300                            if (!ect_ || !hdr_flags::access(pkt)->ecnecho())
2301                 opencwnd();
2302                         }
2303         }
2304 
2305         if ((state_ >= TCPS_FIN_WAIT_1) && (ackno == maxseq_)) {
2306             ourfinisacked = TRUE;
2307         }
2308 
2309         //
2310         // special additional processing when our state
2311         // is one of the closing states:
2312         //    FIN_WAIT_1, CLOSING, LAST_ACK
2313 
2314         switch (state_) {
2315                 /*
2316                  * In FIN_WAIT_1 STATE in addition to the processing
2317                  * for the ESTABLISHED state if our FIN is now acknowledged
2318                  * then enter FIN_WAIT_2.
2319                  */
2320         case TCPS_FIN_WAIT_1:    /* doing active close */
2321             if (ourfinisacked) {
2322                 // got the ACK, now await incoming FIN
2323                 newstate(TCPS_FIN_WAIT_2);
2324                 cancel_timers();
2325                 needoutput = FALSE;
2326             }
2327             break;
2328 
2329                 /*
2330                  * In CLOSING STATE in addition to the processing for
2331                  * the ESTABLISHED state if the ACK acknowledges our FIN
2332                  * then enter the TIME-WAIT state, otherwise ignore
2333                  * the segment.
2334                  */
2335         case TCPS_CLOSING:    /* simultaneous active close */;
2336             if (ourfinisacked) {
2337                 newstate(TCPS_CLOSED);
2338                 cancel_timers();
2339             }
2340             break;
2341                 /*
2342                  * In LAST_ACK, we may still be waiting for data to drain
2343                  * and/or to be acked, as well as for the ack of our FIN.
2344                  * If our FIN is now acknowledged,
2345                  * enter the closed state and return.
2346                  */
2347         case TCPS_LAST_ACK:    /* passive close */
2348             // K: added state change here
2349             if (ourfinisacked) {
2350                 newstate(TCPS_CLOSED);
2351                 finish(); // cancels timers, erc
2352                 reset(); // for connection re-use (bug fix from ns-users list)
2353                 goto drop;
2354             } else {
2355                 // should be a FIN we've seen
2356                                 if (debug_) {
2357                                         fprintf(stderr, "%f: FullTcpAgent(%s)::received non-ACK (state:%d): ",
2358                                         now(), name(), state_);
2359                         prpkt(pkt);
2360                                 }
2361                         }
2362             break;
2363 
2364         /* no case for TIME_WAIT in simulator */
2365         }  // inner state_ switch (closing states)
2366     } // outer state_ switch (ack processing)
2367 
2368 step6:
2369 
2370     /*
2371      * Processing of incoming DATAful segments.
2372      *     Code above has already trimmed redundant data.
2373      *
2374      * real TCP handles window updates and URG data here also
2375      */
2376 
2377 /* dodata: this label is in the "real" code.. here only for reference */
2378 
2379     if ((datalen > 0 || (tiflags & TH_FIN)) &&
2380         TCPS_HAVERCVDFIN(state_) == 0) {
2381 
2382         //
2383         // the following 'if' implements the "real" TCP
2384         // TCP_REASS macro
2385         //
2386 
2387         if (tcph->seqno() == rcv_nxt_ && rq_.empty()) {
2388             // got the in-order packet we were looking
2389             // for, nobody is in the reassembly queue,
2390             // so this is the common case...
2391             // note: in "real" TCP we must also be in
2392             // ESTABLISHED state to come here, because
2393             // data arriving before ESTABLISHED is
2394             // queued in the reassembly queue.  Since we
2395             // don't really have a process anyhow, just
2396             // accept the data here as-is (i.e. don't
2397             // require being in ESTABLISHED state)
2398             flags_ |= TF_DELACK;
2399             rcv_nxt_ += datalen;
2400             tiflags = tcph->flags() & TH_FIN;
2401 
2402             // give to "application" here
2403             // in "real" TCP, this is sbappend() + sorwakeup()
2404             if (datalen)
2405                 recvBytes(datalen); // notify app. of "delivery"
2406             needoutput = need_send();
2407         } else {
2408             // see the "tcp_reass" function:
2409             // not the one we want next (or it
2410             // is but there's stuff on the reass queue);
2411             // do whatever we need to do for out-of-order
2412             // segments or hole-fills.  Also,
2413             // send an ACK (or SACK) to the other side right now.
2414             // Note that we may have just a FIN here (datalen = 0)
2415             int rcv_nxt_old_ = rcv_nxt_; // notify app. if changes
2416             tiflags = reass(pkt);
2417             if (rcv_nxt_ > rcv_nxt_old_) {
2418                 // if rcv_nxt_ has advanced, must have
2419                 // been a hole fill.  In this case, there
2420                 // is something to give to application
2421                 recvBytes(rcv_nxt_ - rcv_nxt_old_);
2422             }
2423             flags_ |= TF_ACKNOW;
2424 
2425             if (tiflags & TH_PUSH) {
2426                 //
2427                 // ???: does this belong here
2428                 // K: APPLICATION recv
2429                 needoutput = need_send();
2430             }
2431         }
2432     } else {
2433         /*
2434          * we're closing down or this is a pure ACK that
2435          * wasn't handled by the header prediction part above
2436          * (e.g. because cwnd < wnd)
2437          */
2438         // K: this is deleted
2439         tiflags &= ~TH_FIN;
2440     }
2441 
2442     /*
2443      * if FIN is received, ACK the FIN
2444      * (let user know if we could do so)
2445      */
2446 
2447     if (tiflags & TH_FIN) {
2448         if (TCPS_HAVERCVDFIN(state_) == 0) {
2449             flags_ |= TF_ACKNOW;
2450              rcv_nxt_++;
2451         }
2452         switch (state_) {
2453                 /*
2454                  * In SYN_RECEIVED and ESTABLISHED STATES
2455                  * enter the CLOSE_WAIT state.
2456          * (passive close)
2457                  */
2458                 case TCPS_SYN_RECEIVED:
2459                 case TCPS_ESTABLISHED:
2460             newstate(TCPS_CLOSE_WAIT);
2461                         break;
2462 
2463                 /*
2464                  * If still in FIN_WAIT_1 STATE FIN has not been acked so
2465                  * enter the CLOSING state.
2466          * (simultaneous close)
2467                  */
2468                 case TCPS_FIN_WAIT_1:
2469             newstate(TCPS_CLOSING);
2470                         break;
2471                 /*
2472                  * In FIN_WAIT_2 state enter the TIME_WAIT state,
2473                  * starting the time-wait timer, turning off the other
2474                  * standard timers.
2475          * (in the simulator, just go to CLOSED)
2476          * (completion of active close)
2477                  */
2478                 case TCPS_FIN_WAIT_2:
2479                         newstate(TCPS_CLOSED);
2480             cancel_timers();
2481                         break;
2482         }
2483     } /* end of if FIN bit on */
2484 
2485     if (needoutput || (flags_ & TF_ACKNOW))
2486         send_much(1, REASON_NORMAL, maxburst_);
2487     else if (curseq_ >= highest_ack_ || infinite_send_)
2488         send_much(0, REASON_NORMAL, maxburst_);
2489     // K: which state to return to when nothing left?
2490 
2491     if (!halfclose_ && state_ == TCPS_CLOSE_WAIT && highest_ack_ == maxseq_)
2492         usrclosed();
2493 
2494     Packet::free(pkt);
2495 
2496     // haoboy: Is here the place for done{} of active close? 
2497     // It cannot be put in the switch above because we might need to do
2498     // send_much() (an ACK)
2499     if (state_ == TCPS_CLOSED) 
2500         Tcl::instance().evalf("%s done", this->name());
2501 
2502     return;
2503 
2504     //
2505     // various ways of dropping (some also ACK, some also RST)
2506     //
2507 
2508 dropafterack:
2509     flags_ |= TF_ACKNOW;
2510     send_much(1, REASON_NORMAL, maxburst_);
2511     goto drop;
2512 
2513 dropwithreset:
2514     /* we should be sending an RST here, but can't in simulator */
2515     if (tiflags & TH_ACK) {
2516         sendpacket(ackno, 0, 0x0, 0, REASON_NORMAL);
2517     } else {
2518         int ack = tcph->seqno() + datalen;
2519         if (tiflags & TH_SYN)
2520             ack--;
2521         sendpacket(0, ack, TH_ACK, 0, REASON_NORMAL);
2522     }
2523 drop:
2524        Packet::free(pkt);
2525     return;
2526 }
2527 
2528 /*  
2529  * Dupack-action: what to do on a DUP ACK.  After the initial check
2530  * of 'recover' below, this function implements the following truth
2531  * table:
2532  *  
2533  *      bugfix  ecn     last-cwnd == ecn        action  
2534  *  
2535  *      0       0       0                       full_reno_action
2536  *      0       0       1                       full_reno_action [impossible]
2537  *      0       1       0                       full_reno_action
2538  *      0       1       1                       1/2 window, return 
2539  *      1       0       0                       nothing 
2540  *      1       0       1                       nothing         [impossible]
2541  *      1       1       0                       nothing 
2542  *      1       1       1                       1/2 window, return
2543  */ 
2544     
2545 void
2546 FullTcpAgent::dupack_action()
2547 {   
2548 
2549         int recovered = (highest_ack_ > recover_);
2550 
2551     fastrecov_ = TRUE;
2552     rtxbytes_ = 0;
2553 
2554         if (recovered || (!bug_fix_ && !ecn_) 
2555             || (last_cwnd_action_ == CWND_ACTION_DUPACK)
2556             || ( highest_ack_ == 0)) {
2557                 goto full_reno_action;
2558         }       
2559     
2560         if (ecn_ && last_cwnd_action_ == CWND_ACTION_ECN) {
2561                 slowdown(CLOSE_CWND_HALF);
2562         cancel_rtx_timer();
2563         rtt_active_ = FALSE;
2564         (void)fast_retransmit(highest_ack_);
2565                 return; 
2566         }      
2567     
2568         if (bug_fix_) {
2569                 /*
2570                  * The line below, for "bug_fix_" true, avoids
2571                  * problems with multiple fast retransmits in one
2572                  * window of data.
2573                  */      
2574                 return;  
2575         }
2576     
2577 full_reno_action:    
2578         slowdown(CLOSE_SSTHRESH_HALF|CLOSE_CWND_HALF);
2579     cancel_rtx_timer();
2580     rtt_active_ = FALSE;
2581     recover_ = maxseq_;
2582     (void)fast_retransmit(highest_ack_);
2583     // we measure cwnd in packets,
2584     // so don't scale by maxseg_
2585     // as real TCP does
2586     cwnd_ = double(ssthresh_) + double(dupacks_);
2587         return;
2588 }
2589 
2590 void
2591 FullTcpAgent::timeout_action()
2592 {
2593     recover_ = maxseq_;
2594 
2595     if (cwnd_ < 1.0) {
2596                 if (debug_) {
2597                 fprintf(stderr, "%f: FullTcpAgent(%s):: resetting cwnd from %f to 1\n",
2598             now(), name(), double(cwnd_));
2599                 }
2600         cwnd_ = 1.0;
2601     }
2602 
2603     if (last_cwnd_action_ == CWND_ACTION_ECN) {
2604         slowdown(CLOSE_CWND_ONE);
2605     } else {
2606         slowdown(CLOSE_SSTHRESH_HALF|CLOSE_CWND_RESTART);
2607         last_cwnd_action_ = CWND_ACTION_TIMEOUT;
2608     }
2609     reset_rtx_timer(1);
2610     t_seqno_ = (highest_ack_ < 0) ? iss_ : int(highest_ack_);
2611     fastrecov_ = FALSE;
2612     dupacks_ = 0;
2613 }
2614 /*
2615  * deal with timers going off.
2616  * 2 types for now:
2617  *    retransmission timer (rtx_timer_)
2618  *  delayed ack timer (delack_timer_)
2619  *    delayed send (randomization) timer (delsnd_timer_)
2620  *
2621  * real TCP initializes the RTO as 6 sec
2622  *    (A + 2D, where A=0, D=3), [Stevens p. 305]
2623  * and thereafter uses
2624  *    (A + 4D, where A and D are dynamic estimates)
2625  *
2626  * note that in the simulator t_srtt_, t_rttvar_ and t_rtt_
2627  * are all measured in 'tcp_tick_'-second units
2628  */
2629 
2630 void
2631 FullTcpAgent::timeout(int tno)
2632 {
2633 
2634     /*
2635      * Due to F. Hernandez-Campos' fix in recv(), we may send an ACK
2636      * while in the CLOSED state.  -M. Weigle 7/24/01
2637      */
2638     if (state_ == TCPS_LISTEN) {
2639          // shouldn't be getting timeouts here
2640                 if (debug_) {
2641                 fprintf(stderr, "%f: FullTcpAgent(%s): unexpected timeout %d in state %s\n",
2642             now(), name(), tno, statestr(state_));
2643                 }
2644         return;
2645     }
2646 
2647     switch (tno) {
2648 
2649     case TCP_TIMER_RTX:
2650                 /* retransmit timer */
2651                 ++nrexmit_;
2652                 timeout_action();
2653         /* fall thru */
2654     case TCP_TIMER_DELSND:
2655         /* for phase effects */
2656                 send_much(1, PF_TIMEOUT, maxburst_);
2657         break;
2658 
2659     case TCP_TIMER_DELACK:
2660                 if (flags_ & TF_DELACK) {
2661                         flags_ &= ~TF_DELACK;
2662                         flags_ |= TF_ACKNOW;
2663                         send_much(1, REASON_NORMAL, 0);
2664                 }
2665                 delack_timer_.resched(delack_interval_);
2666         break;
2667     default:
2668         fprintf(stderr, "%f: FullTcpAgent(%s) Unknown Timeout type %d\n",
2669             now(), name(), tno);
2670     }
2671     return;
2672 }
2673 
2674 void
2675 FullTcpAgent::dooptions(Packet* pkt)
2676 {
2677     // interesting options: timestamps (here),
2678     //    CC, CCNEW, CCECHO (future work perhaps?)
2679 
2680         hdr_flags *fh = hdr_flags::access(pkt);
2681     hdr_tcp *tcph = hdr_tcp::access(pkt);
2682 
2683     if (ts_option_ && !fh->no_ts_) {
2684         if (tcph->ts() < 0.0) {
2685             fprintf(stderr,
2686                 "%f: FullTcpAgent(%s) warning: ts_option enabled in this TCP, but appears to be disabled in peer\n",
2687                 now(), name());
2688         } else if (tcph->flags() & TH_SYN) {
2689             flags_ |= TF_RCVD_TSTMP;
2690             recent_ = tcph->ts();
2691             recent_age_ = now();
2692         }
2693     }
2694 
2695     return;
2696 }
2697 
2698 //
2699 // this shouldn't ever happen
2700 //
2701 void
2702 FullTcpAgent::process_sack(hdr_tcp*)
2703 {
2704     fprintf(stderr, "%f: FullTcpAgent(%s) Non-SACK capable FullTcpAgent received a SACK\n",
2705         now(), name());
2706     return;
2707 }
2708 
2709 
2710 /*
2711  * ****** Tahoe ******
2712  *
2713  * for TCP Tahoe, we force a slow-start as the dup ack
2714  * action.  Also, no window inflation due to multiple dup
2715  * acks.  The latter is arranged by setting reno_fastrecov_
2716  * false [which is performed by the Tcl init function for Tahoe in
2717  * ns-default.tcl].
2718  */
2719 
2720 /* 
2721  * Tahoe
2722  * Dupack-action: what to do on a DUP ACK.  After the initial check
2723  * of 'recover' below, this function implements the following truth
2724  * table:
2725  * 
2726  *      bugfix  ecn     last-cwnd == ecn        action  
2727  * 
2728  *      0       0       0                       full_tahoe_action
2729  *      0       0       1                       full_tahoe_action [impossible]
2730  *      0       1       0                       full_tahoe_action
2731  *      0       1       1                       1/2 window, return
2732  *      1       0       0                       nothing 
2733  *      1       0       1                       nothing         [impossible]
2734  *      1       1       0                       nothing 
2735  *      1       1       1                       1/2 window, return
2736  */
2737 
2738 void
2739 TahoeFullTcpAgent::dupack_action()
2740 {  
2741         int recovered = (highest_ack_ > recover_);
2742 
2743     fastrecov_ = TRUE;
2744     rtxbytes_ = 0;
2745 
2746         if (recovered || (!bug_fix_ && !ecn_) || highest_ack_ == 0) {
2747                 goto full_tahoe_action;
2748         }
2749    
2750         if (ecn_ && last_cwnd_action_ == CWND_ACTION_ECN) {
2751         // slow start on ECN
2752         last_cwnd_action_ = CWND_ACTION_DUPACK;
2753                 slowdown(CLOSE_CWND_ONE);
2754         set_rtx_timer();
2755                 rtt_active_ = FALSE;
2756         t_seqno_ = highest_ack_;
2757                 return; 
2758         }
2759    
2760         if (bug_fix_) {
2761                 /*
2762                  * The line below, for "bug_fix_" true, avoids
2763                  * problems with multiple fast retransmits in one
2764                  * window of data.
2765                  */      
2766                 return;  
2767         }
2768    
2769 full_tahoe_action:
2770     // slow-start and reset ssthresh
2771     trace_event("FAST_RETX");
2772     recover_ = maxseq_;
2773     last_cwnd_action_ = CWND_ACTION_DUPACK;
2774         slowdown(CLOSE_SSTHRESH_HALF|CLOSE_CWND_ONE);    // cwnd->1
2775     set_rtx_timer();
2776         rtt_active_ = FALSE;
2777     t_seqno_ = highest_ack_;
2778     send_much(0, REASON_NORMAL, 0);
2779         return; 
2780 }  
2781 
2782 /*
2783  * ****** Newreno ******
2784  *
2785  * for NewReno, a partial ACK does not exit fast recovery,
2786  * and does not reset the dup ACK counter (which might trigger fast
2787  * retransmits we don't want).  In addition, the number of packets
2788  * sent in response to an ACK is limited to recov_maxburst_ during
2789  * recovery periods.
2790  */
2791 
2792 NewRenoFullTcpAgent::NewRenoFullTcpAgent() : save_maxburst_(-1)
2793 {
2794     bind("recov_maxburst_", &recov_maxburst_);
2795 }
2796 
2797 void
2798 NewRenoFullTcpAgent::pack_action(Packet*)
2799 {
2800     (void)fast_retransmit(highest_ack_);
2801     cwnd_ = double(ssthresh_);
2802     if (save_maxburst_ < 0) {
2803         save_maxburst_ = maxburst_;
2804         maxburst_ = recov_maxburst_;
2805     }
2806     return;
2807 }
2808 
2809 void
2810 NewRenoFullTcpAgent::ack_action(Packet* p)
2811 {
2812     if (save_maxburst_ >= 0) {
2813         maxburst_ = save_maxburst_;
2814         save_maxburst_ = -1;
2815     }
2816     FullTcpAgent::ack_action(p);
2817     return;
2818 }
2819 
2820 /*
2821  *
2822  * ****** SACK ******
2823  *
2824  * for Sack, receiver part must report SACK data
2825  * sender part maintains a 'scoreboard' (sq_) that
2826  * records what it hears from receiver
2827  * sender fills holes during recovery and obeys
2828  * "pipe" style control until recovery is complete
2829  */
2830 
2831 void
2832 SackFullTcpAgent::reset()
2833 {
2834     sq_.clear();            // no SACK blocks
2835     /* Fixed typo.  -M. Weigle 6/17/02 */
2836     sack_min_ = h_seqno_ = -1;    // no left edge of SACK blocks
2837     FullTcpAgent::reset();
2838 }
2839 
2840 
2841 int
2842 SackFullTcpAgent::hdrsize(int nsackblocks)
2843 {
2844     int total = FullTcpAgent::headersize();
2845     // use base header size plus SACK option size
2846         if (nsackblocks > 0) {
2847                 total += ((nsackblocks * sack_block_size_)
2848                         + sack_option_size_);
2849     }
2850     return (total);
2851 }
2852 
2853 void
2854 SackFullTcpAgent::dupack_action()
2855 {
2856 
2857         int recovered = (highest_ack_ > recover_);
2858 
2859     fastrecov_ = TRUE;
2860     rtxbytes_ = 0;
2861     pipe_ = maxseq_ - highest_ack_ - sq_.total();
2862 
2863 //printf("%f: SACK DUPACK-ACTION:pipe_:%d, sq-total:%d, bugfix:%d, cwnd:%d, highest_ack:%d, recover_:%d\n",
2864 //now(), pipe_, sq_.total(), bug_fix_, int(cwnd_), int(highest_ack_), recover_);
2865 
2866         if (recovered || (!bug_fix_ && !ecn_)) {
2867                 goto full_sack_action;
2868         }           
2869 
2870         if (ecn_ && last_cwnd_action_ == CWND_ACTION_ECN) {
2871         /* 
2872          * Received ECN notification and 3 DUPACKs in same 
2873          * window. Don't cut cwnd again, but retransmit lost
2874          * packet.   -M. Weigle  6/19/02
2875          */
2876         last_cwnd_action_ = CWND_ACTION_DUPACK;
2877         cancel_rtx_timer();
2878         rtt_active_ = FALSE;
2879         int amt = fast_retransmit(highest_ack_);
2880         pipectrl_ = TRUE;
2881         h_seqno_ = highest_ack_ + amt;
2882         send_much(0, REASON_DUPACK, maxburst_);
2883         return; 
2884     }
2885    
2886         if (bug_fix_) {
2887                 /*                              
2888                  * The line below, for "bug_fix_" true, avoids
2889                  * problems with multiple fast retransmits in one
2890                  * window of data.
2891                  */      
2892 
2893 //printf("%f: SACK DUPACK-ACTION BUGFIX RETURN:pipe_:%d, sq-total:%d, bugfix:%d, cwnd:%d\n",
2894 //now(), pipe_, sq_.total(), bug_fix_, int(cwnd_));
2895                 return;  
2896         }
2897    
2898 full_sack_action:                               
2899     trace_event("FAST_RECOVERY");
2900         slowdown(CLOSE_SSTHRESH_HALF|CLOSE_CWND_HALF);
2901         cancel_rtx_timer();
2902         rtt_active_ = FALSE;
2903 
2904     // these initiate SACK-style "pipe" recovery
2905     pipectrl_ = TRUE;
2906     recover_ = maxseq_;    // where I am when recovery starts
2907 
2908     int amt = fast_retransmit(highest_ack_);
2909     h_seqno_ = highest_ack_ + amt;
2910 
2911 //printf("%f: FAST-RTX seq:%d, h_seqno_ is now:%d, pipe:%d, cwnd:%d, recover:%d\n",
2912 //now(), int(highest_ack_), h_seqno_, pipe_, int(cwnd_), recover_);
2913 
2914     send_much(0, REASON_DUPACK, maxburst_);
2915 
2916         return;
2917 }
2918 
2919 void
2920 SackFullTcpAgent::pack_action(Packet*)
2921 {
2922     if (!sq_.empty() && sack_min_ < highest_ack_) {
2923         sack_min_ = highest_ack_;
2924         sq_.cleartonxt();
2925     }
2926     pipe_ -= maxseg_;    // see comment in tcp-sack1.cc
2927     if (h_seqno_ < highest_ack_)
2928         h_seqno_ = highest_ack_;
2929 }
2930 
2931 void
2932 SackFullTcpAgent::ack_action(Packet*)
2933 {
2934 //printf("%f: EXITING fast recovery, recover:%d\n",
2935 //now(), recover_);
2936     fastrecov_ = pipectrl_ = FALSE;
2937         if (!sq_.empty() && sack_min_ < highest_ack_) {
2938                 sack_min_ = highest_ack_;
2939                 sq_.cleartonxt();
2940         }
2941     dupacks_ = 0;
2942 
2943     /* 
2944      * Update h_seqno_ on new ACK (same as for partial ACKS)
2945      * -M. Weigle 6/3/05
2946      */
2947     if (h_seqno_ < highest_ack_)
2948         h_seqno_ = highest_ack_;
2949 }
2950 
2951 //
2952 // receiver side: if there are things in the reassembly queue,
2953 // build the appropriate SACK blocks to carry in the SACK
2954 //
2955 int
2956 SackFullTcpAgent::build_options(hdr_tcp* tcph)
2957 {
2958     int total = FullTcpAgent::build_options(tcph);
2959 
2960         if (!rq_.empty()) {
2961                 int nblk = rq_.gensack(&tcph->sa_left(0), max_sack_blocks_);
2962                 tcph->sa_length() = nblk;
2963         total += (nblk * sack_block_size_) + sack_option_size_;
2964         } else {
2965                 tcph->sa_length() = 0;
2966         }
2967     return (total);
2968 }
2969 
2970 void
2971 SackFullTcpAgent::timeout_action()
2972 {
2973     FullTcpAgent::timeout_action();
2974 
2975     //
2976     // original SACK spec says the sender is
2977     // supposed to clear out its knowledge of what
2978     // the receiver has in the case of a timeout
2979     // (on the chance the receiver has renig'd).
2980     // Here, this happens when clear_on_timeout_ is
2981     // enabled.
2982     //
2983 
2984     if (clear_on_timeout_) {
2985         sq_.clear();
2986         sack_min_ = highest_ack_;
2987     }
2988 
2989     return;
2990 }
2991 
2992 void
2993 SackFullTcpAgent::process_sack(hdr_tcp* tcph)
2994 {
2995     //
2996     // Figure out how many sack blocks are
2997     // in the pkt.  Insert each block range
2998     // into the scoreboard
2999     //
3000 
3001     if (max_sack_blocks_ <= 0) {
3002         fprintf(stderr,
3003             "%f: FullTcpAgent(%s) warning: received SACK block but I am not SACK enabled\n",
3004             now(), name());
3005         return;
3006     }    
3007 
3008     int slen = tcph->sa_length(), i;
3009     for (i = 0; i < slen; ++i) {
3010         /* Added check for FIN   -M. Weigle 5/21/02 */
3011         if (((tcph->flags() & TH_FIN) == 0) && 
3012             tcph->sa_left(i) >= tcph->sa_right(i)) {
3013             fprintf(stderr,
3014                 "%f: FullTcpAgent(%s) warning: received illegal SACK block [%d,%d]\n",
3015                 now(), name(), tcph->sa_left(i), tcph->sa_right(i));
3016             continue;
3017         }
3018         sq_.add(tcph->sa_left(i), tcph->sa_right(i), 0);  
3019     }
3020 
3021     return;
3022 }
3023 
3024 int
3025 SackFullTcpAgent::send_allowed(int seq)
3026 {
3027     // not in pipe control, so use regular control
3028     if (!pipectrl_)
3029         return (FullTcpAgent::send_allowed(seq));
3030 
3031     // don't overshoot receiver's advertised window
3032     int topawin = highest_ack_ + int(wnd_) * maxseg_;
3033     if (seq >= topawin) {
3034 //printf("%f: SEND(%d) NOT ALLOWED DUE TO AWIN:%d, pipe:%d, cwnd:%d\n",
3035 //now(), seq, topawin, pipe_, int(cwnd_));
3036         return FALSE;
3037     }
3038 
3039     /*
3040      * If not in ESTABLISHED, don't send anything we don't have
3041      *   -M. Weigle 7/18/02
3042      */
3043     if (state_ != TCPS_ESTABLISHED && seq > curseq_)
3044         return FALSE;
3045 
3046     // don't overshoot cwnd_
3047     int cwin = int(cwnd_) * maxseg_;
3048     return (pipe_ < cwin);
3049 }
3050 
3051 
3052 //
3053 // Calculate the next seq# to send by send_much.  If we are recovering and
3054 // we have learned about data cached at the receiver via a SACK,
3055 // we may want something other than new data (t_seqno)
3056 //
3057 
3058 int
3059 SackFullTcpAgent::nxt_tseq()
3060 {
3061 
3062     int in_recovery = (highest_ack_ < recover_);
3063     int seq = h_seqno_;
3064 
3065     if (!in_recovery) {
3066 //if (int(t_seqno_) > 1)
3067 //printf("%f: non-recovery nxt_tseq called w/t_seqno:%d\n",
3068 //now(), int(t_seqno_));
3069 //sq_.dumplist();
3070         return (t_seqno_);
3071     }
3072 
3073     int fcnt;    // following count-- the
3074             // count field in the block
3075             // after the seq# we are about
3076             // to send
3077     int fbytes;    // fcnt in bytes
3078 
3079 //if (int(t_seqno_) > 1)
3080 //printf("%f: recovery nxt_tseq called w/t_seqno:%d, seq:%d, mode:%d\n",
3081 //now(), int(t_seqno_), seq, sack_rtx_threshmode_);
3082 //sq_.dumplist();
3083 
3084     while ((seq = sq_.nexthole(seq, fcnt, fbytes)) > 0) {
3085         // if we have a following block
3086         // with a large enough count
3087         // we should use the seq# we get
3088         // from nexthole()
3089         if (sack_rtx_threshmode_ == 0 ||
3090             (sack_rtx_threshmode_ == 1 && fcnt >= sack_rtx_cthresh_) ||
3091             (sack_rtx_threshmode_ == 2 && fbytes >= sack_rtx_bthresh_) ||
3092             (sack_rtx_threshmode_ == 3 && (fcnt >= sack_rtx_cthresh_ || fbytes >= sack_rtx_bthresh_)) ||
3093             (sack_rtx_threshmode_ == 4 && (fcnt >= sack_rtx_cthresh_ && fbytes >= sack_rtx_bthresh_))) {
3094 
3095 //if (int(t_seqno_) > 1)
3096 //printf("%f: nxt_tseq returning %d\n",
3097 //now(), int(seq));
3098             // adjust h_seqno, as we may have
3099             // been "jumped ahead" by learning
3100             // about a filled hole
3101             if (seq > h_seqno_)
3102                 h_seqno_ = seq;
3103             return (seq);
3104         } else if (fcnt <= 0)
3105             break;
3106         else {
3107             seq += maxseg_;
3108         }
3109     }
3110 //if (int(t_seqno_) > 1)
3111 //printf("%f: nxt_tseq returning %d\n",
3112 //now(), int(t_seqno_));
3113     return (t_seqno_);
3114 }

 

转载于:https://www.cnblogs.com/forcheryl/p/4191026.html