/*

  * Copyright (c) 1991-1997 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 Computer Systems

  *    Engineering Group at Lawrence Berkeley 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.

  *

  * @(#) $Header: /cvsroot/nsnam/ns-2/tcp/tcp.h,v 1.132 2011/08/26 19:29:57 tom_henderson Exp $ (LBL)

  */

 #ifndef ns_tcp_h

 #define ns_tcp_h

 #include "agent.h"

 #include "packet.h"

 //class EventTrace;

 struct hdr_tcp {

 #define NSA 3

     double ts_;             /* time packet generated (at source) */

     double ts_echo_;        /* the echoed timestamp (originally sent by

                                the peer) */

     int seqno_;             /* sequence number */

     int reason_;            /* reason for a retransmit */

     int sack_area_[NSA+][];    /* sack blocks: start, end of block */

     int sa_length_;         /* Indicate the number of SACKs in this  *

                              * packet.  Adds 2+sack_length*8 bytes   */

     int ackno_;             /* ACK number for FullTcp */

     int hlen_;              /* header len (bytes) for FullTcp */

     int tcp_flags_;         /* TCP flags for FullTcp */

     int last_rtt_;        /* more recent RTT measurement in ms, */

                 /*   for statistics only */

     // Advertised Window, Shigeyuki Osada 2012/01/08

     double wnd_;

     static int offset_;    // offset for this header

     inline static int& offset() { return offset_; }

     inline static hdr_tcp* access(Packet* p) {

         return (hdr_tcp*) p->access(offset_);

     }

     /* per-field member functions */

     double& ts() { return (ts_); }

     double& ts_echo() { return (ts_echo_); }

     int& seqno() { return (seqno_); }

     int& reason() { return (reason_); }

     int& sa_left(int n) { return (sack_area_[n][]); }

     int& sa_right(int n) { return (sack_area_[n][]); }

     int& sa_length() { return (sa_length_); }

     int& hlen() { return (hlen_); }

     int& ackno() { return (ackno_); }

     int& flags() { return (tcp_flags_); }

     int& last_rtt() { return (last_rtt_); }

     double& wnd() {return (wnd_);}  // Shigeyuki Osada

 };

 /* these are used to mark packets as to why we xmitted them */

 #define TCP_REASON_TIMEOUT    0x01

 #define    TCP_REASON_DUPACK    0x02

 #define    TCP_REASON_RBP        0x03   // used only in tcp-rbp.cc

 #define TCP_REASON_PARTIALACK   0x04

 /* these are reasons we adjusted our congestion window */

 #define    CWND_ACTION_DUPACK    1    // dup acks/fast retransmit

 #define    CWND_ACTION_TIMEOUT    2    // retransmission timeout

 #define    CWND_ACTION_ECN        3    // ECN bit [src quench if supported]

 #define CWND_ACTION_EXITED      4       // congestion recovery has ended

                     // (when previously CWND_ACTION_DUPACK)

 /* these are bits for how to change the cwnd and ssthresh values */

 #define    CLOSE_SSTHRESH_HALF    0x00000001

 #define    CLOSE_CWND_HALF        0x00000002

 #define    CLOSE_CWND_RESTART    0x00000004

 #define    CLOSE_CWND_INIT        0x00000008

 #define    CLOSE_CWND_ONE        0x00000010

 #define CLOSE_SSTHRESH_HALVE    0x00000020

 #define CLOSE_CWND_HALVE    0x00000040

 #define THREE_QUARTER_SSTHRESH  0x00000080

 #define CLOSE_CWND_HALF_WAY     0x00000100

 #define CWND_HALF_WITH_MIN    0x00000200

 #define TCP_IDLE        0x00000400

 #define NO_OUTSTANDING_DATA     0x00000800

 /*

  * tcp_tick_:

  * default 0.1,

  * 0.3 for 4.3 BSD,

  * 0.01 for new window algorithms,

  */

 #define NUMDUPACKS 3        /* This is no longer used.  The variable */

                 /* numdupacks_ is used instead. */

 #define TCP_MAXSEQ 1073741824   /* Number that curseq_ is set to for */

                 /* "infinite send" (2^30)            */

 #define TCP_TIMER_RTX        0

 #define TCP_TIMER_DELSND    1

 #define TCP_TIMER_BURSTSND    2

 #define TCP_TIMER_DELACK    3

 #define TCP_TIMER_Q         4

 #define TCP_TIMER_RESET        5 

 class TcpAgent;

 class RtxTimer : public TimerHandler {

 public:

     RtxTimer(TcpAgent *a) : TimerHandler() { a_ = a; }

 protected:

     virtual void expire(Event *e);

     TcpAgent *a_;

 };

 class DelSndTimer : public TimerHandler {

 public:

     DelSndTimer(TcpAgent *a) : TimerHandler() { a_ = a; }

 protected:

     virtual void expire(Event *e);

     TcpAgent *a_;

 };

 class BurstSndTimer : public TimerHandler {

 public:

     BurstSndTimer(TcpAgent *a) : TimerHandler() { a_ = a; }

 protected:

     virtual void expire(Event *e);

     TcpAgent *a_;

 };

 /*

  * Variables for HighSpeed TCP.

  */

 //int *hs_win_;        // array of cwnd values

 //int *hs_increase_;    // array of increase values

 //double *hs_decrease_;    // array of decrease values

 struct hstcp {

     double low_p;  // low_p

     double dec1;    // for computing the decrease parameter

     double dec2;    // for computing the decrease parameter

     double p1;    // for computing p

         double p2;    // for computing p

     /* The next three parameters are for CPU overhead, for computing */

     /*   the HighSpeed parameters less frequently.  A better solution */

      /*   might be just to have a look-up array.  */

     double cwnd_last_;    /* last cwnd for computed parameters */

         double increase_last_;    /* increase param for cwnd_last_ */

     hstcp() : low_p(0.0), dec1(0.0), dec2(0.0), p1(0.0), p2(0.0),

         cwnd_last_(0.0), increase_last_(0.0) { }

 };

 class TcpAgent : public Agent {

     friend class XcpEndsys;

 public:

     TcpAgent();

     virtual ~TcpAgent() {free(tss);}

         virtual void recv(Packet*, Handler*);

     virtual void timeout(int tno);

     virtual void timeout_nonrtx(int tno);

     int command(int argc, const char*const* argv);

     virtual void sendmsg(int nbytes, const char *flags = );

     void trace(TracedVar* v);

     virtual void advanceby(int delta);

     virtual void reset();

     /* These two functions aid Tmix one-way TCP agents */

     int is_closed() {return closed_;}

     void clr_closed() {closed_ = ;}

 protected:

     virtual int window();

     virtual double windowd();

     void print_if_needed(double memb_time);

     void traceAll();

     virtual void traceVar(TracedVar* v);

     virtual int headersize();   // a tcp header

     virtual void delay_bind_init_all();

     virtual int delay_bind_dispatch(const char *varName, const char *localName, TclObject *tracer);

     double boot_time_;    /* where between 'ticks' this sytem came up */

     double overhead_;

     double wnd_;

     double wnd_const_;

     double wnd_th_;        /* window "threshold" */

     double wnd_init_;

     double wnd_restart_;

     double tcp_tick_;    /* clock granularity */

     int wnd_option_;

     int wnd_init_option_;   /* 1 for using wnd_init_ */

                 /* 2 for using large initial windows */

     double decrease_num_;   /* factor for multiplicative decrease */

     double increase_num_;   /* factor for additive increase */

     int tcpip_base_hdr_size_;  /* size of base TCP/IP header */

     int maxcwnd_;        /* max # cwnd can ever be */

         int numdupacks_;    /* dup ACKs before fast retransmit */

     int numdupacksFrac_;    /* for a larger numdupacks_ with large */

                 /* windows */

     /* connection and packet dynamics */

     virtual void output(int seqno, int reason = );

     virtual void send_much(int force, int reason, int maxburst = );

     virtual void newtimer(Packet*);

     virtual void dupack_action();        /* do this on dupacks */

     virtual void send_one();        /* do this on 1-2 dupacks */

     virtual void opencwnd();

     void update_window(Packet*);  // Shigeyuki Osada 2012/01/08

     void slowdown(int how);            /* reduce cwnd/ssthresh */

     void ecn(int seqno);        /* react to quench */

     virtual void set_initial_window();    /* set IW */

     double initial_window();        /* what is IW? */

     void newack(Packet*);

     void finish(); /* called when the connection is terminated */

     int network_limited();    /* Sending limited by network? */

     double limited_slow_start(double cwnd, int max_ssthresh, double increment);

                 /* Limited slow-start for high windows */

     virtual int numdupacks(double cwnd);     /* for getting numdupacks_ */

     /* End of section of connection and packet dynamics.  */

     /* General dynamic state. */

     TracedInt t_seqno_;    /* sequence number */

     TracedInt dupacks_;    /* number of duplicate acks */

     TracedInt curseq_;    /* highest seqno "produced by app" */

     TracedInt highest_ack_;    /* not frozen during Fast Recovery */

     TracedDouble cwnd_;    /* current window */

     TracedInt ssthresh_;    /* slow start threshold */

     TracedInt maxseq_;    /* used for Karn algorithm */

                 /* highest seqno sent so far */

     int last_ack_;        /* largest consecutive ACK, frozen during

                  *        Fast Recovery */

     int recover_;        /* highest pkt sent before dup acks, */

                 /*   timeout, or source quench/ecn */

     int last_cwnd_action_;    /* CWND_ACTION_{TIMEOUT,DUPACK,ECN} */

     int count_;        /* used in window increment algorithms */

     int rtt_active_;    /* 1 if a rtt sample is pending */

     int rtt_seq_;        /* seq # of timed seg if rtt_active_ is 1 */

     double rtt_ts_;        /* time at which rtt_seq_ was sent */

     double firstsent_;    /* When first packet was sent  --Allman */

     double lastreset_;    /* W.N. Last time connection was reset - for */

                 /* detecting pkts from previous incarnations */

     int closed_;            /* whether this connection has closed */

     /* End of general dynamic state. */

     /*

      * State encompassing the round-trip-time estimate.

      * srtt and rttvar are stored as fixed point;

      * srtt has 3 bits to the right of the binary point, rttvar has 2.

      */

     TracedInt t_rtt_;          /* round trip time */

     TracedInt t_srtt_;         /* smoothed round-trip time */

     TracedInt t_rttvar_;       /* variance in round-trip time */

     TracedInt t_backoff_;    /* current multiplier of RTO, */

                 /*   1 if not backed off */

     #define T_RTT_BITS 0

     int T_SRTT_BITS;        /* exponent of weight for updating t_srtt_ */

     int srtt_init_;        /* initial value for computing t_srtt_ */

     int T_RTTVAR_BITS;      /* exponent of weight for updating t_rttvar_ */

     int rttvar_exp_;        /* exponent of multiple for t_rtxcur_ */

     int rttvar_init_;       /* initial value for computing t_rttvar_ */

     double t_rtxcur_;    /* current retransmit value */

     double rtxcur_init_;    /* initial value for t_rtxcur_ */

     virtual void rtt_init();

     virtual double rtt_timeout();    /* provide RTO based on RTT estimates */

     virtual void rtt_update(double tao);    /* update RTT estimate */

     virtual void rtt_backoff();        /* double multiplier */

     /* End of state for the round-trip-time estimate. */

         /* RTOs: */

     double maxrto_;        /* max value of an RTO */

     double minrto_;         /* min value of an RTO */

     int ts_resetRTO_;    /* Un-backoff RTO after any valid RTT, */

                 /*   including from a retransmitted pkt?  */

                 /* The old version was "false". */

                 /* But "true" gives better performance, and */

                                 /* seems conformant with RFC 2988. */

         /* End of section for RTOs. */

     /* Timestamps. */

     double ts_peer_;        /* the most recent timestamp the peer sent */

     double ts_echo_;        /* the most recent timestamp the peer echoed */

     int ts_option_size_;    // header bytes in a ts option

         double *tss;            // To store sent timestamps, with bugfix_ts_

         int tss_size_;          // Current capacity of tss

     int ts_option_;        /* use RFC1323-like timestamps? */

     /* End of timestamps. */

     /* Helper functions.  Used by tcp-asym */

     virtual void output_helper(Packet*) { return; }

     virtual void send_helper(int) { return; }

     virtual void send_idle_helper() { return; }

     virtual void recv_helper(Packet*);

     virtual void recv_frto_helper(Packet*);

     virtual void recv_newack_helper(Packet*);

     virtual void partialnewack_helper(Packet*) {};

     /* End of helper functions. */

     int force_wnd(int num);

     void spurious_timeout();

     /* Timers */

     RtxTimer rtx_timer_;

     DelSndTimer delsnd_timer_;

     BurstSndTimer burstsnd_timer_;

     virtual void cancel_timers() {

         rtx_timer_.force_cancel();

         burstsnd_timer_.force_cancel();

         delsnd_timer_.force_cancel();

     }

     virtual void cancel_rtx_timer() {

         rtx_timer_.force_cancel();

     }

     virtual void set_rtx_timer();

     void reset_rtx_timer(int mild, int backoff = );

     int timerfix_;        /* set to true to update timer *after* */

                 /* update the RTT, instead of before   */

     int rfc2988_;        /* Use updated RFC 2988 timers */

     /* End of timers. */ 

     /* For modeling SYN and SYN/ACK packets. */

     int syn_;        /* 1 for modeling SYN/ACK exchange */

     int delay_growth_;      /* delay opening cwnd until 1st data recv'd */

         int max_connects_;      /* max number of transmits for syn packet */

                 /* -1 to allow infinite number of transmits */

     /* End of modeling SYN and SYN/ACK packets. */

     /* Dynamic state for SYN packet retransmissions. */

     int syn_connects_;    /* number of transmits of syn packet */

     /* End of dynamic state for SYN packet retransmissions. */

     /* F-RTO */

     int frto_enabled_;    /* != 0 to enable F-RTO */

     int sfrto_enabled_;    /* != 0 to enabled SACK-based F-RTO */

     int spurious_response_;    /* Response variant to spurious RTO */

     /* End of R-RTO */

     /* Parameters for backwards compatility with old code. */

     int bug_fix_;        /* 1 for multiple-fast-retransmit fix */

     int less_careful_;    /* 1 for Less Careful variant of bug_fix_, */

                 /*  for illustration only  */

     int exitFastRetrans_;    /* True to clean exits of Fast Retransmit */

                 /* False for buggy old behavior */

     int bugfix_ack_;        // 1 to enable ACK heuristic, to allow

                 //  multiple-fast-retransmits in special cases.

                 // From Andrei Gurtov

     int bugfix_ts_;         // 1 to enable timestamp heuristic, to allow

                 //  multiple-fast-retransmits in special cases.

                 // From Andrei Gurtov

                 // Not implemented yet.

     int old_ecn_;        /* For backwards compatibility with the

                  * old ECN implementation, which never

                  * reduced the congestion window below

                  * one packet. */

     int bugfix_ss_;        // 1 to use window of one when SYN

                 //  packet is dropped

     /* End of parameters for backwards compatility. */

     /* Parameters for alternate congestion control mechanisms. */

     double k_parameter_;     /* k parameter in binomial controls */

     double l_parameter_;     /* l parameter in binomial controls */

     int precision_reduce_;  /* non-integer reduction of cwnd */

     int maxburst_;        /* max # packets can send back-2-back */

     int aggressive_maxburst_;    /* Send on a non-valid ack? */

     /* End of parameters for alternate congestion control mechanisms. */

     FILE *plotfile_;

     /* Dynamic state used for alternate congestion control mechanisms */

     double awnd_;        /* averaged window */

     int first_decrease_;    /* First decrease of congestion window.  */

                 /* Used for decrease_num_ != 0.5. */

     double fcnt_;        /* used in window increment algorithms */

     double base_cwnd_;    /* base window (for experimental purposes) */

     /* End of state for alternate congestion control mechanisms */

     /* Dynamic state only used for monitoring */

     int trace_all_oneline_;    /* TCP tracing vars all in one line or not? */

     int nam_tracevar_;      /* Output nam's variable trace or just plain

                    text variable trace? */

         TracedInt ndatapack_;   /* number of data packets sent */

         TracedInt ndatabytes_;  /* number of data bytes sent */

         TracedInt nackpack_;    /* number of ack packets received */

         TracedInt nrexmit_;     /* number of retransmit timeouts

                    when there was data outstanding */

         TracedInt nrexmitpack_; /* number of retransmited packets */

         TracedInt nrexmitbytes_; /* number of retransmited bytes */

         TracedInt necnresponses_; /* number of times cwnd was reduced

                       in response to an ecn packet -- sylvia */

         TracedInt ncwndcuts_;     /* number of times cwnd was reduced

                    for any reason -- sylvia */

         TracedInt ncwndcuts1_;     /* number of times cwnd was reduced

                                    due to congestion (as opposed to idle

                                    periods */

     /* end of dynamic state for monitoring */

     /* Specifying variants in TCP algorithms.  */

     int slow_start_restart_; /* boolean: re-init cwnd after connection

                     goes idle.  On by default. */

     int restart_bugfix_;    /* ssthresh is cut down because of

                    timeouts during a connection's idle period.

                    Setting this boolean fixes this problem.

                    For now, it is off by default. */

         TracedInt singledup_;   /* Send on a single dup ack.  */

     int LimTransmitFix_;    /* To fix a bug in Limited Transmit. */

     int noFastRetrans_;    /* No Fast Retransmit option.  */

     int oldCode_;        /* Use old code. */

     int useHeaders_;    /* boolean: Add TCP/IP header sizes */

     /* end of specifying variants */

     /* Used for ECN */

     int ecn_;        /* Explicit Congestion Notification */

     int cong_action_;    /* Congestion Action.  True to indicate

                    that the sender responded to congestion. */

         int ecn_burst_;        /* True when the previous ACK packet

                  *  carried ECN-Echo. */

     int ecn_backoff_;    /* True when retransmit timer should begin

                       to be backed off.  */

     int ect_;           /* turn on ect bit now? */

     int SetCWRonRetransmit_;  /* True to allow setting CWR on */

                   /*  retransmitted packets.   Affects */

                   /*  performance for Reno with ECN.  */

     int use_rtt_;         /* Use RTT for timeout for ECN-marked SYN-ACK */

     /* end of ECN */

     /* used for Explicit Loss Notification */

     void tcp_eln(Packet *pkt); /* reaction to ELN (usually wireless) */

         int eln_;               /* Explicit Loss Notification (wireless) */

         int eln_rxmit_thresh_;  /* Threshold for ELN-triggered rxmissions */

         int eln_last_rxmit_;    /* Last packet rxmitted due to ELN info */

     /* end of Explicit Loss Notification */

     /* for High-Speed TCP, RFC 3649 */

     double linear(double x, double x_1, double y_1, double x_2, double y_2);

       /* the "linear" function is for experimental highspeed TCP */

     /* These four parameters define the HighSpeed response function. */

     int low_window_;    /* window for turning on high-speed TCP */

     int high_window_;    /* target window for new response function */

     double high_p_;        /* target drop rate for new response function */

     double high_decrease_;    /* decrease rate at target window */

     /* The next parameter is for Limited Slow-Start. */

     int max_ssthresh_;    /* max value for ssthresh_ */

     /* These two functions are just an easy structuring of the code. */

     double increase_param();  /* get increase parameter for current cwnd */

     double decrease_param();  /* get decrease parameter for current cwnd */

     int cwnd_range_;    /* for determining when to recompute params. */

     hstcp hstcp_;        /* HighSpeed TCP variables */

         /* end of section for experimental high-speed TCP */

     /* for Quick-Start, RFC 4782 */

     virtual void processQuickStart(Packet *pkt);

     virtual void endQuickStart();

     int lossQuickStart();

     int rate_request_;      /* Rate request in KBps, for QuickStart.  */

     int qs_enabled_;        /* to enable QuickStart. */

     int qs_requested_;

     int qs_approved_;

         int qs_window_;  /* >0: there are outstanding non-acked segments

                             from QS window */

         int qs_cwnd_; /* Initial window for Quick-Start */

         int tcp_qs_recovery_; /* != 0 if we apply slow start on packet

                                  losses during QS window */

     int qs_request_mode_;   /* 1 = Try to avoid unnecessary QS requests

                    for short flows. Use qs_rtt_ as the RTT

                    used in window calculation.

                    Other: Always request 'rate_request_' bytes,

                    regardless of flow size */

     int qs_thresh_;         /* Do not use QS if there are less data to send

                    than this. Applies only if

                    qs_request_mode_ == 1 */

     int qs_rtt_;            /* QS needs some assumption of the RTT in

                    in order to be able to determine how much

                    it needs for rate request with given amount

                    of data to send. milliseconds. */

     int print_request_;    /* true to print Quick-Start request */

     int ttl_diff_;

         /* end of section for Quick-Start. */

     /* F-RTO: !=0 when F-RTO recovery is underway, N:th round-trip

      * since RTO. Can have values between 0-2 */

     int frto_;

     int pipe_prev_; /* window size when timeout last occurred */

         /* support for event-tracing */

         //EventTrace *et_;

         void trace_event(char *eventtype);

     /* these function are now obsolete, see other above */

     void closecwnd(int how);

     void quench(int how);

     /* TCP quiescence, reducing cwnd after an idle period */

     void process_qoption_after_send() ;

     void process_qoption_after_ack(int seqno) ;

     void reset_qoption();    /* for QOption with EnblRTTCtr_ */

     void rtt_counting();    /* for QOption with EnblRTTCtr_ */

     int QOption_ ; /* TCP quiescence option */

     int EnblRTTCtr_ ; /* are we using a corase grained timer? */

     int T_full ; /* last time the window was full */

     int T_last ;

     int T_prev ;

     int T_start ;

     int RTT_count ;

     int RTT_prev ;

     int RTT_goodcount ;

     int F_counting ;

     int W_used ;

     int W_timed ;

     int F_full ;

     int Backoffs ;

     int control_increase_ ; /* If true, don't increase cwnd if sender */

                 /*  is not window-limited.  */

     int prev_highest_ack_ ; /* Used to determine if sender is */

                 /*  window-limited.  */

        /* end of TCP quiescence */

 };

 /* TCP Reno */

 class RenoTcpAgent : public virtual TcpAgent {

  public:

     RenoTcpAgent();

     virtual int window();

     virtual double windowd();

     virtual void recv(Packet *pkt, Handler*);

     virtual void timeout(int tno);

     virtual void dupack_action();

  protected:

     int allow_fast_retransmit(int last_cwnd_action_);

     unsigned int dupwnd_;

 };

 /* TCP New Reno */

 class NewRenoTcpAgent : public virtual RenoTcpAgent {

  public:

     NewRenoTcpAgent();

     virtual void recv(Packet *pkt, Handler*);

     virtual void partialnewack_helper(Packet* pkt);

     virtual void dupack_action();

  protected:

     int newreno_changes_;    /* 0 for fixing unnecessary fast retransmits */

                 /* 1 for additional code from Allman, */

                 /* to implement other algorithms from */

                 /* Hoe's paper, including sending a new */

                 /* packet for every two duplicate ACKs. */

                 /* The default is set to 0. */

     int newreno_changes1_;  /* Newreno_changes1_ set to 0 gives the */

                 /* Slow-but-Steady variant of NewReno from */

                 /* RFC 2582, with the retransmit timer reset */

                 /* after each partial new ack. */

                 /* Newreno_changes1_ set to 1 gives the */

                 /* Impatient variant of NewReno from */

                 /* RFC 2582, with the retransmit timer reset */

                 /* only for the first partial new ack. */

                 /* The default is set to 0 */

     void partialnewack(Packet *pkt);

     int allow_fast_retransmit(int last_cwnd_action_);

     int acked_, new_ssthresh_;  /* used if newreno_changes_ == 1 */

     double ack2_, ack3_, basertt_; /* used if newreno_changes_ == 1 */

     int firstpartial_;     /* For the first partial ACK. */

     int partial_window_deflation_; /* 0 if set cwnd to ssthresh upon */

                        /* partial new ack (default) */

                        /* 1 if deflate (cwnd + dupwnd) by */

                        /* amount of data acked */

                        /* "Partial window deflation" is */

                        /* discussed in RFC 2582. */

     int exit_recovery_fix_;     /* 0 for setting cwnd to ssthresh upon */

                  /* leaving fast recovery (default) */

                  /* 1 for setting cwnd to min(ssthresh, */

                  /* amnt. of data in network) when leaving */

 };

 /* TCP vegas (VegasTcpAgent) */

 class VegasTcpAgent : public virtual TcpAgent {

  public:

     VegasTcpAgent();

     ~VegasTcpAgent();

     virtual void recv(Packet *pkt, Handler *);

     virtual void timeout(int tno);

 protected:

     double vegastime() {

         return(Scheduler::instance().clock() - firstsent_);

     }

     virtual void output(int seqno, int reason = );

     virtual void recv_newack_helper(Packet*);

     int vegas_expire(Packet*);

     void reset();

     void vegas_inflate_cwnd(int win, double current_time);

     virtual void delay_bind_init_all();

     virtual int delay_bind_dispatch(const char *varName, const char *localName, TclObject *tracer);

     double t_cwnd_changed_; // last time cwnd changed

     double firstrecv_;    // time recv the 1st ack

     int    v_alpha_;        // vegas thruput thresholds in pkts

     int    v_beta_;              

     int    v_gamma_;        // threshold to change from slow-start to

                 // congestion avoidance, in pkts

     int    v_slowstart_;    // # of pkts to send after slow-start, deflt(2)

     int    v_worried_;      // # of pkts to chk after dup ack (1 or 2)

     double v_timeout_;      // based on fine-grained timer

     double v_rtt_;

     double v_sa_;

     double v_sd_;    

     int    v_cntRTT_;       // # of rtt measured within one rtt

     double v_sumRTT_;       // sum of rtt measured within one rtt

     double v_begtime_;    // tagged pkt sent

     int    v_begseq_;    // tagged pkt seqno

     double* v_sendtime_;    // each unacked pkt's sendtime is recorded.

     int*   v_transmits_;    // # of retx for an unacked pkt

     int    v_maxwnd_;    // maxwnd size for v_sendtime_[]

     double v_newcwnd_;    // record un-inflated cwnd

     double v_baseRTT_;    // min of all rtt

     double v_incr_;        // amount cwnd is increased in the next rtt

     int    v_inc_flag_;    // if cwnd is allowed to incr for this rtt

     double v_actual_;    // actual send rate (pkt/s; needed for tcp-rbp)

     int ns_vegas_fix_level_;   // see comment at end of tcp-vegas.cc for details of fixes

 };

 // Local Variables:

 // mode:c++

 // c-basic-offset: 8

 // End:

 #endif