tcp-full-bay.cc

Go to the documentation of this file.

/*
 * Copyright (c) 1997 The Regents of the University of California.
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed by the Network Research
 *      Group at Lawrence Berkeley National Laboratory.
 * 4. Neither the name of the University nor of the Laboratory may be used
 *    to endorse or promote products derived from this software without
 *    specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

/*
 * This code below was motivated in part by code contributed by
 * Kathie Nichols (nichols@com21.com).  The code below is based primarily
 * on the 4.4BSD TCP implementation. -KF [kfall@ee.lbl.gov]
 *
 * Major revisions, 8/97, kmn (vj)
 *
 * Some Warnings:
 *      this version of TCP will not work correctly if the sequence number
 *      goes above 2147483648 due to sequence number wrap
 *
 *      this version of TCP currently sends data on the 3rd segment of
 *      the initial 3-way handshake.  So, the typical sequence of events is
 *              A   ------> SYN ------> B
 *              A   <----- SYN+ACK ---- B
 *              A   ------> ACK+data -> B
 *      whereas many "real-world" TCPs don't send data until a 4th segment
 *
 *      there is no dynamic receiver's advertised window.   The advertised
 *      window is simulated by simply telling the sender a bound on the window
 *      size (wnd_).
 *
 *      in real TCP, a user process performing a read (via PRU_RCVD)
 *              calls tcp_output each time to (possibly) send a window
 *              update.  Here we don't have a user process, so we simulate
 *              a user process always ready to consume all the receive buffer
 *
 * Notes:
 *      wnd_, wnd_init_, cwnd_, ssthresh_ are in segment units
 *      sequence and ack numbers are in byte units
 *
 * Futures:
 *      there are different existing TCPs with respect to how
 *      ack's are handled on connection startup.  Some delay
 *      the ack for the first segment, which can cause connections
 *      to take longer to start up than if we be sure to ack it quickly.
 */

#ifndef lint
static const char rcsid[] =
    "@(#) $Header: /nfs/jade/vint/CVSROOT/ns-2/baytcp/tcp-full-bay.cc,v 1.4 2001/07/19 17:57:02 haldar Exp $ (LBL)";
#endif

#include "tclcl.h"
#include "ip.h"
#include "tcp-full-bay.h"
#include "flags.h"
#include "random.h"
#include "template.h"

#define TRUE    1
#define FALSE   0

static class BayFullTcpClass : public TclClass { 
public:
    BayFullTcpClass() : TclClass("Agent/TCP/BayFullTcp") {}
    TclObject* create(int, const char*const*) { 
        return (new BayFullTcpAgent());
    }
} class_bayfull;

static class TahoeBayFullTcpClass : public TclClass { 
public:
        TahoeBayFullTcpClass() : TclClass("Agent/TCP/BayFullTcp/Tahoe") {}
  TclObject* create(int, const char*const*) { 
    // tcl lib code
    // sets reno_fastrecov_ to false
    //return (new BayFullTcpAgent());
    fprintf(stderr,"Tahoe, NewReno or Sack flavors are NOT available for BayTCP!! Use BayFullTcp only, which actually implements Reno.\n");

    exit(1);
        }
} class_tahoe_bayfull;

static class NewRenoBayFullTcpClass : public TclClass { 
public:
        NewRenoBayFullTcpClass() : TclClass("Agent/TCP/BayFullTcp/Newreno") {}
        TclObject* create(int, const char*const*) { 
          // tcl lib code
          // sets deflate_on_pack_ to false
          //return (new BayFullTcpAgent());
          fprintf(stderr,"Tahoe, NewReno or Sack flavors are NOT available for BayFullTCP!! Use BayFullTcp only, which actually implements Reno.\n");
          exit(1);
        }
} class_newreno_bayfull;

static class SackBayFullTcpClass : public TclClass { 
public:
        SackBayFullTcpClass() : TclClass("Agent/TCP/BayFullTcp/Sack") {}
        TclObject* create(int, const char*const*) { 
          //return (new BayFullTcpAgent());
          fprintf(stderr,"Tahoe, NewReno or Sack flavors are NOT available for BayFullTCP!! Use BayFullTcp only, which actually implements Reno.\n");
          exit(1);
        }
} class_sack_bayfull;

/*
 * Tcl bound variables:
 *      segsperack: for delayed ACKs, how many to wait before ACKing
 *      segsize: segment size to use when sending
 */
BayFullTcpAgent::BayFullTcpAgent() : flags_(0),
        state_(TCPS_CLOSED), rq_(rcv_nxt_), last_ack_sent_(0), app_(0),
        delack_timer_(this)
{
        bind("segsperack_", &segs_per_ack_);
        bind("segsize_", &maxseg_);
        bind("tcprexmtthresh_", &tcprexmtthresh_);
        bind("iss_", &iss_);
        bind_bool("nodelay_", &nodelay_);
        bind_bool("data_on_syn_",&data_on_syn_);
        bind_bool("dupseg_fix_", &dupseg_fix_);
        bind_bool("dupack_reset_", &dupack_reset_);
        bind("interval_", &delack_interval_);
}

void
BayFullTcpAgent::delay_bind_init_all()
{
        TcpAgent::delay_bind_init_all();
        reset();
}

int
BayFullTcpAgent::delay_bind_dispatch(const char *varName, const char *localName, TclObject *tracer)
{
        return TcpAgent::delay_bind_dispatch(varName, localName, tracer);
}

/*
 * reset to starting point, don't set state_ here,
 * because our starting point might be LISTEN rather
 * than CLOSED if we're a passive opener
 */
void
BayFullTcpAgent::reset()
{
        TcpAgent::reset();
        highest_ack_ = 0;
        last_ack_sent_ = 0;
        rcv_nxt_ = 0;           //kmn
        flags_ = 0;
        t_seqno_ = iss_;
        close_on_empty_ = 0;    //added 7/30/97 by kmn
        switch_spa_thresh_ = 0;
        first_data_ = 0;                //don't open cwnd too early
}

void
BayFullTcpAgent::reinit()
{
        cancel_rtx_timeout();
        rtt_init();
        cwnd_ = wnd_init_;
        last_ack_ = highest_ack_ = 0;
        ssthresh_ = int(wnd_);
        awnd_ = wnd_init_ / 2.0;
        recover_ = 0;
        recover_cause_ = 0;

        last_ack_sent_ = 0;
        rcv_nxt_ = 0;           //kmn
        flags_ = 0;
        t_seqno_ = maxseq_ = iss_;
        switch_spa_thresh_ = 0;
        /*
        for(int i =0; i < NTIMER; i++)  {
                cancel(i);
        }
        */
        rq_.clear();
        first_data_ = 0;                //don't open cwnd too early
}

/*
 * headersize:
 *      how big is an IP+TCP header in bytes
 *      (for now, is the basic size, but may changes
 *       in the future w/options; fix for sack)
 */
int
BayFullTcpAgent::headersize()
{
        return (TCPIP_BASE_PKTSIZE);
}

/*
 * cancel any pending timers
 * free up the reassembly queue if there's anything there
 */
BayFullTcpAgent::~BayFullTcpAgent()
{
  /*
   * not required any more
        register i;
        for (i = 0; i < NTIMER; i++)
                if (pending_[i])
                        cancel(i);
  */
        rq_.clear();
}

/*
 * the 'advance' interface to the regular tcp is in packet
 * units.  Here we scale this to bytes for full tcp.
 *
 * 'advance' is normally called by an "application" (i.e. data source)
 * to signal that there is something to send
 *
 * 'curseq_' is the last byte number provided by the application
 */
void
BayFullTcpAgent::advance(int np)
{
        // XXX hack:
        //      because np is in packets and a data source
        //      may pass a *huge* number as a way to tell us
        //      to go forever, just look for the huge number
        //      and if it's there, pre-divide it
        if (np >= 0x10000000)
                np /= maxseg_;

        curseq_ += (np * maxseg_);

        //
        // state-specific operations:
        //      if CLOSED, do an active open/connect
        //      if ESTABLISHED, just try to send more
        //      if above ESTABLISHED, we are closing, so don't allow
        //      if anything else (establishing), do nothing here
        //
        if (state_ > TCPS_ESTABLISHED) {
                fprintf(stderr,
                 "%f: BayFullTcpAgent::advance(%s): cannot advance while in state %d\n",
                 now(), name(), state_);
                return;
        } else if (state_ == TCPS_CLOSED)       {
                connect();              // initiate new connection
        } else if (state_ == TCPS_ESTABLISHED)
                send_much(0, REASON_NORMAL, 0);
        return;
}
/*
 * added 7/30/97 by kmn to allow to pass bytes and set close_on_empty_
 */
int
BayFullTcpAgent::advance(int n, int close_flag)
{
        close_on_empty_ = close_flag;

        //
        // state-specific operations:
        //      if CLOSED, do an active open/connect
        //      if ESTABLISHED, just try to send more
        //      if above ESTABLISHED, we are closing, so don't allow
        //      if anything else (establishing), do nothing here
        //
        if (state_ > TCPS_ESTABLISHED) {
                return 0;       //try again later, please
        } else if (state_ == TCPS_CLOSED)       {
                curseq_ = iss_ + n;
                reinit();
                connect();              // initiate new connection
        }
        else if (state_ == TCPS_ESTABLISHED)
                curseq_ += n;   
        else
                return 0;
        return 1;
}
/*
 * flags that are completely dependent on the tcp state
 * (in real TCP, see tcp_fsm.h, the "tcp_outflags" array)
 */
int BayFullTcpAgent::outflags()
{
        int flags = 0;
        if ((state_ != TCPS_LISTEN) && (state_ != TCPS_SYN_SENT))
                flags |= TH_ACK;

        if ((state_ == TCPS_SYN_SENT) || (state_ == TCPS_SYN_RECEIVED))
                flags |= TH_SYN;

        if ((state_ == TCPS_FIN_WAIT_1) || (state_ == TCPS_LAST_ACK))
                flags |= TH_FIN;

        return (flags);
}

void BayFullTcpAgent::sendpacket(int seqno, int ackno, int pflags, int datalen,
                              int reason)
{
        Packet* p = allocpkt();
        hdr_tcp *tcph = hdr_tcp::access(p);
        hdr_cmn *th = hdr_cmn::access(p);
        tcph->seqno() = seqno;
        tcph->ackno() = ackno;
        tcph->flags() = pflags;
        tcph->hlen() = headersize();
        tcph->ts() = now();
    /* Open issue:  should tcph->reason map to pkt->flags_ as in ns-1?? */
        tcph->reason() |= reason;
        th->size() = datalen + headersize();
        if (datalen <= 0)
                ++nackpack_;
        else {
                ++ndatapack_;
                ndatabytes_ += datalen;
        }
        if (reason == REASON_TIMEOUT || reason == REASON_DUPACK) {
                ++nrexmitpack_;
                nrexmitbytes_ += datalen;
        }
        send(p, 0);
}

/*
 * see if we should send a segment, and if so, send it
 * (may be ACK or data)
 *      'maxseq_' is called 'snd_max' in "real" TCP
 *      and is the largest seq number we've sent
 *
 * maxseg_, largest seq# we've sent (snd_max)
 * flags_, flags regarding our internal state (t_state)
 * pflags, a local used to build up the tcp header flags (flags)
 * curseq_, is the highest sequence number given to us by "application"
 * highest_ack_, the highest ACK we've seen for our data (snd_una)
 * seqno, the next seq# we're going to send (snd_nxt), this will
 *      update t_seqno_ (the last thing we sent)
 */
void BayFullTcpAgent::output(int seqno, int reason)
{
        int is_retransmit = (seqno < maxseq_);
        int idle = (highest_ack_ == maxseq_);

        //kmn - changing all this for clarity 8/7/97
        int buffered_bytes = (curseq_ + iss_) - seqno;
        int datalen = min(buffered_bytes, (highest_ack_ + (window() * maxseg_)) - seqno);
        int pflags = outflags();
        int emptying_buffer = 0;

        if((pflags & TH_SYN) || datalen <= 0)
                datalen = 0;
        else if(datalen > maxseg_)      {
                datalen = maxseg_;
        } else if(datalen == buffered_bytes)    {
                emptying_buffer = 1;
                pflags |= TH_PUSH;
                //usrclosed() causes nested calls to output()
                if(close_on_empty_)     {
                        pflags |= TH_FIN;
                        state_ = TCPS_FIN_WAIT_1;
                }
        }

        //end of kmn changes

        /* turn off FIN if there's really more to send */
        if (datalen > 0 && !emptying_buffer)
                pflags &= ~TH_FIN;

        /* sender SWS avoidance (Nagle) */

        if (datalen > 0) {
                // if full-sized segment, ok
                if (datalen == maxseg_)
                        goto send;
                // if Nagle disabled and buffer clearing, ok
                if ((idle || nodelay_)  && emptying_buffer)
                        goto send;
                // if a retransmission
                if (is_retransmit)
                        goto send;
                // if big "enough", ok...
                //      (this is not a likely case, and would
                //      only happen for tiny windows)
                if (datalen >= ((wnd_ * maxseg_) / 2.0))
                        goto send;
        }

        if (need_send())
                goto send;

        /*
         * send now if a SYN or special flag "TF_ACKNOW" is set.
         * TF_ACKNOW can be set during connection establishment and
         * to generate acks for out-of-order data
         * kmn 8/28 need to send if there's a push
         */
        if ((flags_ & TF_ACKNOW) || (pflags & (TH_SYN|TH_FIN|TH_PUSH)))
                goto send;

        return;         // no reason to send now

send:
        //these changed by vj and kmn
        if (pflags & TH_FIN) {
                if (flags_ & TF_SENTFIN) {
                        // don't allow seqno to advance past fin
                        // (the ack generated by a discarded duplicate
                        // may attempt to do this)
                        if (seqno >= maxseq_)
                                --seqno;
                } else {
                        flags_ |= TF_SENTFIN;
                        ++t_seqno_;
                }
        }

        if((pflags & TH_SYN))   {
                if ((flags_ & TF_SENTSYN) == 0) {
                        flags_ |= TF_SENTSYN;
                        ++t_seqno_;
                }
        }

        /*
         * fill in packet fields.  Agent::allocpkt()
         * has already filled most of the network layer
         * fields for us.   So fill in tcp hdr and adjust
         * the packet size.
         */
        sendpacket(seqno, rcv_nxt_, pflags, datalen, reason);
        last_ack_sent_ = rcv_nxt_;
        flags_ &= ~(TF_ACKNOW|TF_DELACK);

        t_seqno_ += datalen;            // update snd_nxt (t_seqno_)
        if (t_seqno_ > maxseq_) {
                maxseq_ = t_seqno_;     // largest seq# we've sent
                /*
                 * Time this transmission if not a retransmission and
                 * not currently timing anything.
                 */
                if (rtt_active_ == FALSE) {
                        rtt_active_ = TRUE;     // set timer
                        rtt_seq_ = seqno;       // timed seq #
                }
        }
        /*
         * Set retransmit timer if not currently set,
         * and not doing an ack or a keep-alive probe.
         * Initial value for retransmit timer is smoothed
         * round-trip time + 2 * round-trip time variance.
         * Future values are rtt + 4 * rttvar.
         */
        if (!(rtx_timer_.status() == TIMER_PENDING) && (t_seqno_ > highest_ack_)) {
                set_rtx_timer();  // no timer pending, schedule one
        }
}

/*
 * Try to send as much data as the window will allow.  The link layer will 
 * do the buffering; we ask the application layer for the size of the packets.
 */
void BayFullTcpAgent::send_much(int force, int reason, int maxburst)
{

        /*
         * highest_ack is essentially "snd_una" in real TCP
         *
         * loop while we are in-window (seqno <= (highest_ack + win))
         * and there is something to send (t_seqno_ < curseq_+iss_)
         */
        int win = window() * maxseg_;   // window() in pkts
        int npackets = 0;
        int topwin = curseq_ + iss_;
        if (topwin > highest_ack_ + win)
                topwin = highest_ack_ + win;

        if (!force && (delsnd_timer_.status() == TIMER_PENDING))
                return;

        while (force || (t_seqno_ < topwin)) {
                if (overhead_ != 0 && !(delsnd_timer_.status() == TIMER_PENDING)) {
                        delsnd_timer_.resched(Random::uniform(overhead_));
                        return;
                }
                output(t_seqno_, reason);       // updates seqno for us
                force = 0;
                if (outflags() & TH_SYN)
                        break;
                if (maxburst && ++npackets >= maxburst)
                        break;
        }
}

void BayFullTcpAgent::cancel_rtx_timeout()
{
        if (rtx_timer_.status() == TIMER_PENDING) {
                rtx_timer_.cancel();
        }
}

/*
 * Process an ACK
 *      this version of the routine doesn't necessarily
 *      require the ack to be one which advances the ack number
 *
 * if this ACKs a rtt estimate
 *      indicate we are not timing
 *      reset the exponential timer backoff (gamma)
 * update rtt estimate
 * cancel retrans timer if everything is sent and ACK'd, else set it
 * advance the ack number if appropriate
 * update segment to send next if appropriate
 */
void BayFullTcpAgent::newack(Packet* pkt)
{
    hdr_tcp *tcph = hdr_tcp::access(pkt);

        register int ackno = tcph->ackno();

        // we were timing the segment and we
        // got an ACK for it
        if (rtt_active_ && ackno >= rtt_seq_) {
                /* got a rtt sample */
                rtt_active_ = FALSE;    // no longer timing
                t_backoff_ = 1;         // stop exp backoff
        }

        /* always with timestamp option */
        double tao = now() - tcph->ts();
        rtt_update(tao);

        if (ackno >= maxseq_)
                cancel_rtx_timeout();
        else {
                if (ackno > highest_ack_) {
                        set_rtx_timer();
                }
        }

        // advance the ack number if this is for new data
        if (ackno > highest_ack_)
                highest_ack_ = ackno;
        // set up the next packet to send
        if (t_seqno_ < highest_ack_)
                t_seqno_ = highest_ack_;        // thing to send next
}

/*
 * nuked this stuff, but left in method - kmn
 */
int BayFullTcpAgent::predict_ok(Packet* )
{
        return 0;
}

/*
 * fast_retransmit using the given seqno
 *      perform a fast retransmit
 *      kludge t_seqno_ (snd_nxt) so we do the
 *      retransmit then continue from where we were
 */

void BayFullTcpAgent::fast_retransmit(int seq)
{       
        rtt_backoff();                  // bug fix by van to avoid spurious rtx
        int onxt = t_seqno_;            // output() changes t_seqno_
        recover_ = maxseq_;             // keep a copy of highest sent
        recover_cause_ = REASON_DUPACK; // why we started this recovery period
        output(seq, REASON_DUPACK);     // send one pkt
        t_seqno_ = onxt;
}

/*
 * real tcp determines if the remote
 * side should receive a window update/ACK from us, and often
 * results in sending an update every 2 segments, thereby
 * giving the familiar 2-packets-per-ack behavior of TCP.
 * Here, we don't advertise any windows, so we just see if
 * there's at least 'segs_per_ack_' pkts not yet acked
 */
 /* kmn - adding code to switch from one seg per ack to set value
  */

int BayFullTcpAgent::need_send()
{
        //first cut, send if anything to ack. Might need maxseg_
        if(flags_ & TF_ACKNOW)
                return 1;
        if(rcv_nxt_ < switch_spa_thresh_)
                return ((rcv_nxt_ - last_ack_sent_) >= 1);
        return ((rcv_nxt_ - last_ack_sent_) >= (segs_per_ack_ * maxseg_));
}

/*
 * deal with timers going off.
 * 2 types for now:
 *      retransmission timer (TCP_TIMER_RTX)
 *      delayed send (randomization) timer (TCP_TIMER_DELSND)
 *
 * real TCP initializes the RTO as 6 sec
 *                              (  ^ 3sec, kmn )
 *      (A + 2D, where A=0, D=3), [Stevens p. 305]
 * and thereafter uses
 *      (A + 4D, where A and D are dynamic estimates)
 *
 * note that in the simulator t_srtt_, t_rttvar_ and t_rtt_
 * are all measured in 'tcp_tick_'-second units
 */
void BayFullTcpAgent::timeout(int tno)
{
        if(state_ == TCPS_CLOSED || state_ == TCPS_LISTEN)
                return;
        /* retransmit timer */
        if (tno == TCP_TIMER_RTX) {
                ++nrexmit_;
                recover_ = maxseq_;
                recover_cause_ = REASON_TIMEOUT;
                slowdown(CLOSE_SSTHRESH_HALF|CLOSE_CWND_RESTART);
                //changed 6/10/00 to look at rtx problem -kmn
/*              if(highest_ack_ == maxseq_)
                        reset_rtx_timer(0,0);
                else
                        reset_rtx_timer(0,1);
*/
                reset_rtx_timer(1);
                t_seqno_ = highest_ack_;
                dupacks_ = 0;
                send_much(1, REASON_TIMEOUT);
        } else if (tno == TCP_TIMER_DELSND) {
                /*
                 * delayed-send timer, with random overhead
                 * to avoid phase effects
                 */
                send_much(1, PF_TIMEOUT);
        } else if (tno == TCP_TIMER_DELACK) {
                if (flags_ & TF_DELACK) {
                        flags_ &= ~TF_DELACK;
                        flags_ |= TF_ACKNOW;
                        send_much(1, REASON_NORMAL, 0);
                }
                delack_timer_.resched(delack_interval_);
        } else {
                fprintf(stderr, "%f: (%s) UNKNOWN TIMEOUT %d\n",
                        now(), name(), tno);
        }
}

/*
 * introduced kedar
 */

void BayDelAckTimer::expire(Event *) {
        a_->timeout(TCP_TIMER_DELACK);
}

/*
 * main reception path - 
 * called from the agent that handles the data path below in its muxing mode
 * advance() is called when connection is established with size sent from
 * user/application agent
 */
void BayFullTcpAgent::recv(Packet *pkt, Handler*)
{
        hdr_tcp *tcph = hdr_tcp::access(pkt);
        hdr_cmn *th = hdr_cmn::access(pkt);
        hdr_ip *iph = hdr_ip::access(pkt);
        int needoutput = 0;
        int ourfinisacked = 0;
        int todrop = 0;
        int dupseg = FALSE;

#ifdef notdef
        if (trace_)
                plot();
#endif

        //
        // if no delayed-ACK timer is set, set one
        // they are set to fire every 'interval_' secs, starting
        // at time t0 = (0.0 + k * interval_) for some k such
        // that t0 > now
        //
        /*
        if (!pending_[TCP_TIMER_DELACK]) {
        */
        if (!(delack_timer_.status() == TIMER_PENDING)) {
                double now = Scheduler::instance().clock();
                int last = int(now / delack_interval_);
                delack_timer_.resched(delack_interval_ * (last + 1.0) - now);

        }

        int datalen = th->size() - tcph->hlen();
        int ackno = tcph->ackno();      // ack # from packet

        // nuked header prediction code that was here - kmn 8/5/97

        int tiflags = tcph->flags() ; // tcp flags from packet

        switch (state_) {
        case TCPS_LISTEN:       /* awaiting peer's SYN */
                if (tiflags & TH_ACK) {
                        if (tiflags & TH_FIN) {
                                sendpacket(tcph->ackno(), tcph->seqno()+1,
                                           TH_ACK, 0, REASON_NORMAL);
                                goto drop;
                        }
                        // ACK shouldn't be on here
        // kmn - this can be from previous connection if reusing
        //              fprintf(stderr,
        //                  "%f: BayFullTcpAgent::recv(%s): got ACK(%d) while in LISTEN\n",
        //                      now(), name(), ackno);
                        goto drop;
                }
                if ((tiflags & TH_SYN) == 0) {
                        // we're looking for a SYN in return
                        fprintf(stderr,
                            "%f: BayFullTcpAgent::recv(%s): got a non-SYN while in LISTEN\n",
                                now(), name());
                        goto drop;
                }
                flags_ |= TF_ACKNOW;
                state_ = TCPS_SYN_RECEIVED;
                rcv_nxt_ = tcph->seqno() + 1;   //kmn
                t_seqno_ = iss_;
                //kmn - switch from one to set segs per ack
                switch_spa_thresh_ = rcv_nxt_ + (16 * 1024);
                goto step6;
        case TCPS_SYN_SENT:     /* we sent SYN, expecting SYN+ACK */
                if ((tiflags & TH_ACK) && (ackno > maxseq_)) {
                        // not an ACK for our SYN, discard
//                      fprintf(stderr,
//                          "%f: BayFullTcpAgent::recv(%s): bad ACK (%d) for our SYN(%d)\n",
//                              now(), name(), int(ackno), int(maxseq_));
                        goto drop;
                }
                if ((tiflags & TH_SYN) == 0) {
                        // we're looking for a SYN in return
                        fprintf(stderr,
                            "%f: BayFullTcpAgent::recv(%s): no SYN for our SYN(%d)\n",
                                now(), name(), int(maxseq_));
                        goto drop;
                }
                rcv_nxt_ = tcph->seqno()+1;     // initial expected seq#
                //kmn - switch from one to set segs per ack
                switch_spa_thresh_ = rcv_nxt_ + (16 * 1024);
                cancel_rtx_timeout();   // cancel timer on our 1st SYN
                flags_ |= TF_ACKNOW;    // ACK peer's SYN
                if (tiflags & TH_ACK) {
                        // got SYN+ACK (what we're expecting)
                        // set up to ACK peer's SYN+ACK
                        newack(pkt);
                        state_ = TCPS_ESTABLISHED;
                } else {
                        // simultaneous active opens
                        state_ = TCPS_SYN_RECEIVED;
                }
                goto step6;
        }

        // check for redundant data at head/tail of segment
        //      note that the 4.4bsd [Net/3] code has
        //      a bug here which can cause us to ignore the
        //      perfectly good ACKs on duplicate segments.  The
        //      fix is described in (Stevens, Vol2, p. 959-960).
        //      This code is based on that correction.
        //
        // In addition, it has a modification so that duplicate segments
        // with dup acks don't trigger a fast retransmit when dupseg_fix_
        // is enabled.
        //
        todrop = rcv_nxt_ - tcph->seqno();  // how much overlap?
        if (todrop > 0) {
                // segment is something we've seen (perhaps partially)
                if (tiflags & TH_SYN) {
                        t_seqno_ = highest_ack_;
                        if ((tiflags & TH_ACK) == 0)
                                goto dropafterack;
                        tiflags &= ~TH_SYN;
                }
                if (todrop > datalen ||
                    (todrop == datalen && ((tiflags & TH_FIN) == 0))) {
                        /*
                         * Any valid FIN must be to the left of the window.
                         * At this point the FIN must be a duplicate or out
                         * of sequence; drop it.
                         */
                        tiflags &= ~TH_FIN;

                        /*
                         * Send an ACK to resynchronize and drop any data.
                         * But keep on processing for RST or ACK.
                         */
                        flags_ |= TF_ACKNOW;
                        todrop = datalen;
                        dupseg = TRUE;
                }
                tcph->seqno() += todrop;
                datalen -= todrop;
        }

        if (tiflags & TH_SYN) {
                fprintf(stderr,
                    "%f: %d.%d>%d.%d BayFullTcpAgent::recv(%s) received unexpected SYN (state:%d)\n",
                        now(),
                        iph->saddr(), iph->sport(),
                        iph->daddr(), iph->dport(),
                        name(), state_);
                goto drop;
        }

        if ((tiflags & (TH_SYN|TH_ACK)) == 0) {
                fprintf(stderr, "%f: %d.%d>%d.%d BayFullTcpAgent::recv(%s) got packet lacking ACK (seq %d)\n",
                        now(),
                        iph->saddr(), iph->sport(),
                        iph->daddr(), iph->dport(),
                        name(), tcph->seqno());
                goto drop;
        }

        /*
         * ACK processing
         */

        switch (state_) {
        case TCPS_SYN_RECEIVED: /* got ACK for our SYN+ACK */
                if (ackno < highest_ack_ || ackno > maxseq_) {
                        // not in useful range
                        goto drop;
                }
                state_ = TCPS_ESTABLISHED;
                /* fall into ... */

        /*
         * In ESTABLISHED state: drop duplicate ACKs; ACK out of range
         * ACKs.  If the ack is in the range
         *      tp->snd_una < ti->ti_ack <= tp->snd_max
         * then advance tp->snd_una to ti->ti_ack and drop
         * data from the retransmission queue.
         *
         * note that states CLOSE_WAIT and TIME_WAIT aren't used
         * in the simulator
         */

        case TCPS_ESTABLISHED:
        case TCPS_FIN_WAIT_1:
        case TCPS_FIN_WAIT_2:
        case TCPS_CLOSING:
        case TCPS_LAST_ACK:

                // look for dup ACKs (dup ack numbers, no data)
                //
                // do fast retransmit/recovery if at/past thresh
                if (ackno <= highest_ack_) {
                        // an ACK which doesn't advance highest_ack_
                        if (datalen == 0 && (!dupseg_fix_ || !dupseg)) {
                                /*
                                 * If we have outstanding data
                                 * this is a completely
                                 * duplicate ack,
                                 * the ack is the biggest we've
                                 * seen and we've seen exactly our rexmt
                                 * threshhold of them, assume a packet
                                 * has been dropped and retransmit it.
                                 *
                                 * We know we're losing at the current
                                 * window size so do congestion avoidance.
                                 *
                                 * Dup acks mean that packets have left the
                                 * network (they're now cached at the receiver)
                                 * so bump cwnd by the amount in the receiver
                                 * to keep a constant cwnd packets in the
                                 * network.
                                 */

                                if (!(rtx_timer_.status() == TIMER_PENDING) ||
                                    ackno != highest_ack_) {
                                        // not timed, or re-ordered ACK
                                        dupacks_ = 0;
                                } else if (bug_fix_ &&
                                           highest_ack_ == recover_ &&
                                           recover_cause_ == REASON_TIMEOUT) {
                                        // doing timeout recovery not fastrxmit
                                        dupacks_ = 0;
                                } else if (++dupacks_ == tcprexmtthresh_) {
                                                slowdown(CLOSE_SSTHRESH_HALF|CLOSE_CWND_HALF);
                                                cancel_rtx_timeout();
                                                rtt_active_ = FALSE;
                                                fast_retransmit(ackno);
                                                // we measure cwnd in packets,
                                                // so don't scale by maxseg_
                                                // as real TCP does
                                                cwnd_ = ssthresh_ + dupacks_;
                                                goto drop;
                                } else if (dupacks_ > tcprexmtthresh_) {
                                        // we just measure cwnd in packets,
                                        // so don't scale by maxset_ as real
                                        // tcp does
                                        cwnd_++;        // fast recovery
                                        send_much(0, REASON_NORMAL, 0);
                                        goto drop;
                                }
                        } else {
                                // non-zero length segment
                                // (or window changed in real TCP).
                                if (dupack_reset_)
                                        dupacks_ = 0;
                        }
                        break;  /* take us to "step6" */
                }

                /*
                 * we've finished the fast retransmit/recovery period
                 * (i.e. received an ACK which advances highest_ack_)
                 */

                /*
                 * If the congestion window was inflated to account
                 * for the other side's cached packets, retract it.
                 */
                if (dupacks_ >= tcprexmtthresh_ && cwnd_ > ssthresh_) {
                        /*
                         * make sure we send at most 2 packets due to this ack
                         */
                        cwnd_ = (maxseq_ - ackno + maxseg_ - 1)
                                  / maxseg_ + 2;
                }
                dupacks_ = 0;
                if (ackno > maxseq_) {
                        // ack more than we sent(!?)
                        fprintf(stderr,
                            "%f: BayFullTcpAgent::recv(%s) too-big ACK (ack: %d, maxseq:%d)\n",
                                now(), name(), int(ackno), int(maxseq_));
                        goto dropafterack;
                }

                /*
                 * If we have a timestamp reply, update smoothed
                 * round trip time.  If no timestamp is present but
                 * transmit timer is running and timed sequence
                 * number was acked, update smoothed round trip time.
                 * Since we now have an rtt measurement, cancel the
                 * timer backoff (cf., Phil Karn's retransmit alg.).
                 * Recompute the initial retransmit timer.
                 *
                 * If all outstanding data is acked, stop retransmit
                 * If there is more data to be acked, restart retransmit
                 * timer, using current (possibly backed-off) value.
                 */
                newack(pkt);
                if (state_ == TCPS_ESTABLISHED && ackno < maxseq_)
                        needoutput = 1;
                /* kmn - 8/12/97: don't want to do this on first
                 * data send, especially to compare IWs
                 * So added test.
                 */
                if(first_data_)
                        opencwnd();
                // kmn - 8/15 added second test that is acking fin
                if ((state_ == TCPS_FIN_WAIT_1 || state_ == TCPS_FIN_WAIT_2
                        || state_ == TCPS_LAST_ACK || state_ == TCPS_CLOSING)
                        && ackno >= (curseq_ + iss_)) // && ackno == maxseq_)
                        ourfinisacked = 1;
                else
                        ourfinisacked = 0;
                // additional processing when we're in special states

                switch (state_) {
                /*
                 * In FIN_WAIT_1 STATE in addition to the processing
                 * for the ESTABLISHED state if our FIN is now acknowledged
                 * then enter FIN_WAIT_2.
                 */
                case TCPS_FIN_WAIT_1:   /* doing active close */
                        if (ourfinisacked)
                                state_ = TCPS_FIN_WAIT_2;
                        break;

                /*
                 * In CLOSING STATE in addition to the processing for
                 * the ESTABLISHED state if the ACK acknowledges our FIN
                 * then enter the TIME-WAIT state, otherwise ignore
                 * the segment.
                 */
                case TCPS_CLOSING:      /* simultaneous active close */;
                        if (ourfinisacked)
                                state_ = TCPS_CLOSED;
                        break;
                /*
                 * In LAST_ACK, we may still be waiting for data to drain
                 * and/or to be acked, as well as for the ack of our FIN.
                 * If our FIN is now acknowledged,
                 * enter the closed state and return.
                 */
                case TCPS_LAST_ACK:     /* passive close */
                        if (ourfinisacked)      {
                                state_ = TCPS_CLOSED;   //kmn added 2 lines
                                /*
                                for(int i =0; i < NTIMER; i++)  {
                                        cancel(i);
                                }
                                */
                                goto drop;
                        } else {                //should be a FIN we've seen
                                fprintf(stderr,
                                "%f: %d.%d>%d.%d BayFullTcpAgent::recv(%s) received non-ACK (state:%d)\n",
                                        now(),
                                        iph->saddr(), iph->sport(),
                                        iph->daddr(), iph->dport(),
                                        name(), state_);
                        }

                /* no case for TIME_WAIT in simulator */
                } // inner switch
        } // outer switch

step6:
        /* real TCP handles window updates and URG data here */
/* dodata: this label is in the "real" code.. here only for reference */
        /*
         * DATA processing
         * kmn - several changes here to talk to application agent
         */

        if (datalen > 0 || (tiflags & TH_FIN)) {
                first_data_ = 1;        //now seen first data
                // see the "TCP_REASS" macro for this code
                if (tcph->seqno() == rcv_nxt_ && rq_.empty()) {
                        // got the in-order packet we were looking
                        // for, nobody is in the reassembly queue,
                        // so this is the common case...
                        // note: in "real" TCP we must also be in
                        // ESTABLISHED state to come here, because
                        // data arriving before ESTABLISHED is
                        // queued in the reassembly queue.  Since we
                        // don't really have a process anyhow, just
                        // accept the data here as-is (i.e. don't
                        // require being in ESTABLISHED state)
                        tiflags &= TH_FIN;
                        if (tiflags) {
                                ++rcv_nxt_;
                        }
                        flags_ |= TF_DELACK;
                        rcv_nxt_ += datalen;
                        // give to "application" here
                        // added 7/30/97 by kmn to call application with
                        //      number of bytes since last push (if any)
                        // the server is going to call advance before this
                        //      completes, so changed advance to not call
                        //      send_much if ESTABLISHED. curseq gets
                        //      checked below.
                        //
                        if(datalen && app_ && (tcph->flags() & TH_PUSH)) {
                                //rcv_nxt_ - last_upcalled_bytes_;
                                app_->recv(pkt,this,DATA_PUSH);
                                //last_upcalled_bytes_ = rcv_nxt_;
                        }
                        needoutput = need_send();
                } else {
                        // not the one we want next (or it
                        // is but there's stuff on the reass queue);
                        // do whatever we need to do for out-of-order
                        // segments or hole-fills.  Also,
                        // send an ACK to the other side right now.
                        tiflags = rq_.add(pkt);
                        if (tiflags & TH_PUSH) {
                          if (app_ != NULL )
                            app_->recv(pkt,this,DATA_PUSH);
                          needoutput = need_send();
                        } else
                                flags_ |= TF_ACKNOW;
                        //reset for losses
                        switch_spa_thresh_ = rcv_nxt_ + (16 * 1024);
                }
        }

        /*
         * if FIN is received, ACK the FIN
         * (let user know if we could do so)
         */

        if (tiflags & TH_FIN) {
                flags_ |= TF_ACKNOW;
                rq_.clear();    // other side shutting down
                switch (state_) {
                /*
                 * In SYN_RECEIVED and ESTABLISHED STATES
                 * enter the CLOSE_WAIT state.
                 * (in the simulator, go to LAST_ACK)
                 * (passive close)
                 */
                case TCPS_SYN_RECEIVED:
                case TCPS_ESTABLISHED:
                        state_ = TCPS_LAST_ACK;
                        break;

                /*
                 * If still in FIN_WAIT_1 STATE FIN has not been acked so
                 * enter the CLOSING state.
                 * (simultaneous close)
                 */
                case TCPS_FIN_WAIT_1:
                        state_ = TCPS_CLOSING;
                        break;
                /*
                 * In FIN_WAIT_2 state enter the TIME_WAIT state,
                 * starting the time-wait timer, turning off the other
                 * standard timers.
                 * (in the simulator, just go to CLOSED)
                 * (active close)
                 */
                case TCPS_FIN_WAIT_2:
                        state_ = TCPS_CLOSED;
                        cancel_rtx_timeout();
                        break;
                }
        }

        if (needoutput || (flags_ & TF_ACKNOW))
                send_much(1, REASON_NORMAL, 0);
        else if ((curseq_ + iss_) > highest_ack_)
                send_much(0, REASON_NORMAL, 0);

        /* kmn -  ugh, egregious hack. Can tell it's a server
         * so it goes to listen state. Do something
         * else if this becomes more stable
         */
        if(state_ == TCPS_CLOSED)       {
                if(close_on_empty_) {
                        reinit();
                        curseq_ = iss_;
                        state_ = TCPS_LISTEN;
                } else {        /*"something else" - kmn 6/00 */
                  if (app_ != NULL )
                    app_->recv(pkt,this,CONNECTION_END);
                }
        }
        Packet::free(pkt);
        return;

dropafterack:
        flags_ |= TF_ACKNOW;
        send_much(1, REASON_NORMAL, 0);
drop:
        Packet::free(pkt);
        return;
}

void BayFullTcpAgent::reset_rtx_timer(int )
{
        // cancel old timer,
        // set a new one
        rtt_backoff();          // double current timeout
        set_rtx_timer();        // set new timer
        rtt_active_ = FALSE;
}


/*
 * do an active open
 * (in real TCP, see tcp_usrreq, case PRU_CONNECT)
 */
void BayFullTcpAgent::connect()
{
        state_ = TCPS_SYN_SENT; // sending a SYN now

        if (!data_on_syn_) {
                // force no data in this segment
                int cur = curseq_;
                curseq_ = iss_;
                output(iss_, REASON_NORMAL);
                curseq_ = cur + 1;      //think I have to add in the syn here
                return;
        }
        output(iss_, REASON_NORMAL);
        return;
}

/*
 * be a passive opener
 * (in real TCP, see tcp_usrreq, case PRU_LISTEN)
 * (for simulation, make this peer's ptype ACKs)
 */
void BayFullTcpAgent::listen()
{
        state_ = TCPS_LISTEN;
        type_ = PT_TCP; //  changed by kmn 8/6/97
        //type_ = PT_ACK;       // instead of PT_TCP
}

/*
 * called when user/application performs 'close'
 */

void BayFullTcpAgent::usrclosed()
{

        switch (state_) {
        case TCPS_CLOSED:
        case TCPS_LISTEN:
        case TCPS_SYN_SENT:
                state_ = TCPS_CLOSED;
                break;
        case TCPS_SYN_RECEIVED:
        case TCPS_ESTABLISHED:
                state_ = TCPS_FIN_WAIT_1;
                send_much(1, REASON_NORMAL, 0);
                break;
        }
        return;
}

int BayFullTcpAgent::command(int argc, const char*const* argv)
{
        // would like to have some "connect" primitive
        // here, but the problem is that we get called before
        // the simulation is running and we want to send a SYN.
        // Because no routing exists yet, this fails.
        // Instead, see code in advance() above.
        //
        // listen can happen any time because it just changes state_
        //
        // close is designed to happen at some point after the
        // simulation is running (using an ns 'at' command)

         Tcl& tcl = Tcl::instance();

        if (argc == 2) {
                if (strcmp(argv[1], "listen") == 0) {
                        // just a state transition
                        listen();
                        return (TCL_OK);
                }
                if (strcmp(argv[1], "close") == 0) {
                        usrclosed();
                        return (TCL_OK);
                }
        }
        if (argc == 3) {
                if (strcmp(argv[1], "advance") == 0) {
                        advance(atoi(argv[2]));
                        return (TCL_OK);
                }
                //added 7/31/97 by kmn to work with apps, specifically www
                //      probably should use a special type of agent...
                if (strcmp(argv[1], "attach-application") == 0) { 
                        app_ = (BayTcpAppAgent *)TclObject::lookup(argv[2]); 
                        if (app_ == 0) {
                                tcl.resultf("no such agent %s", argv[2]);
                                return(TCL_ERROR);
                        }
                        return(TCL_OK);
                }
                //added by kmn 8/12/97
                if (strcmp(argv[1], "initial-window") == 0) { 
                        wnd_init_ = atoi(argv[2]); 
                        cwnd_ = wnd_init_;
                        awnd_ = wnd_init_ /2.0;
                        return(TCL_OK);
                }

        }
        return (TcpAgent::command(argc, argv));
}
/*
 * clear out reassembly queue
 */
void BayReassemblyQueue::clear()
{
        seginfo* p;
        seginfo* n;
        for (p = head_; p != NULL; p = n) {
                n = p->next_;
                delete p;
        }
        head_ = tail_ = NULL;
        return;
}

/*
 * add a packet to the reassembly queue..
 * will update BayFullTcpAgent::rcv_nxt_ by way of the
 * BayReassemblyQueue::rcv_nxt_ integer reference (an alias)
 */
int BayReassemblyQueue::add(Packet* pkt)
{
    hdr_tcp *tcph = hdr_tcp::access(pkt);
    hdr_cmn *th = hdr_cmn::access(pkt);

        int start = tcph->seqno();
        int end = start + th->size() - tcph->hlen();
        int tiflags = tcph->flags();
        seginfo *q, *p, *n;

        if (head_ == NULL) {
                // nobody there, just insert
                tail_ = head_ = new seginfo;
                head_->prev_ = NULL;
                head_->next_ = NULL;
                head_->startseq_ = start;
                head_->endseq_ = end;
                head_->flags_ = tiflags;
        } else {
                p = NULL;
                n = new seginfo;
                n->startseq_ = start;
                n->endseq_ = end;
                n->flags_ = tiflags;
                if (tail_->endseq_ <= start) {
                        // common case of end of reass queue
                        p = tail_;
                        goto endfast;
                }

                q = head_;
                // look for the segment after this one
                while (q != NULL && (end > q->startseq_))
                        q = q->next_;
                // set p to the segment before this one
                if (q == NULL)
                        p = tail_;
                else
                        p = q->prev_;

                if (p == NULL) {
                        // insert at head
                        n->next_ = head_;
                        n->prev_ = NULL;
                        head_->prev_ = n;
                        head_ = n;
                } else {
endfast:
                        // insert in the middle or end
                        n->next_ = p->next_;
                        if (p->next_)
                                p->next_->prev_ = n;
                        p->next_ = n;
                        n->prev_ = p;
                        if (p == tail_)
                                tail_ = n;
                }
        }
        //
        // look for a sequence of in-order segments and
        // set rcv_nxt if we can
        //

        if (head_->startseq_ > rcv_nxt_)
                return 0;       // still awaiting a hole-fill

        tiflags = 0;
        p = head_;
        while (p != NULL) {
                // update rcv_nxt_ to highest in-seq thing
                // and delete the entry from the reass queue
                rcv_nxt_ = p->endseq_;
                tiflags |= p->flags_;
                q = p;
                if (q->prev_)
                        q->prev_->next_ = q->next_;
                else
                        head_ = q->next_;
                if (q->next_)
                        q->next_->prev_ = q->prev_;
                else
                        tail_ = q->prev_;
                if (q->next_ && (q->endseq_ < q->next_->startseq_)) {
                        delete q;
                        break;          // only the in-seq stuff
                }
                p = p->next_;
                delete q;
        }
        return (tiflags);
}

---