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

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

通讯编程

开发平台：

Visual C++

tcp.h：源码内容
  1. /* -*- Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */ /*
  2.  * Copyright (c) 1991-1997 Regents of the University of California.
  3.  * All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  * 1. Redistributions of source code must retain the above copyright
  9.  *    notice, this list of conditions and the following disclaimer.
  10.  * 2. Redistributions in binary form must reproduce the above copyright
  11.  *    notice, this list of conditions and the following disclaimer in the
  12.  *    documentation and/or other materials provided with the distribution.
  13.  * 3. All advertising materials mentioning features or use of this software
  14.  *    must display the following acknowledgement:
  15.  * This product includes software developed by the Computer Systems
  16.  * Engineering Group at Lawrence Berkeley Laboratory.
  17.  * 4. Neither the name of the University nor of the Laboratory may be used
  18.  *    to endorse or promote products derived from this software without
  19.  *    specific prior written permission.
  20.  *
  21.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31.  * SUCH DAMAGE.
  32.  *
  33.  * @(#) $Header: /cvsroot/nsnam/ns-2/tcp/tcp.h,v 1.130 2007/09/29 01:07:22 sallyfloyd Exp $ (LBL)
  34.  */
  35. #ifndef ns_tcp_h
  36. #define ns_tcp_h
  38. #include "agent.h"
  39. #include "packet.h"
  41. //class EventTrace;
  43. struct hdr_tcp {
  44. #define NSA 3
  45. double ts_;             /* time packet generated (at source) */
  46. double ts_echo_;        /* the echoed timestamp (originally sent by
  47.                            the peer) */
  48. int seqno_;             /* sequence number */
  49. int reason_;            /* reason for a retransmit */
  50. int sack_area_[NSA+1][2]; /* sack blocks: start, end of block */
  51. int sa_length_;         /* Indicate the number of SACKs in this  *
  52.                          * packet.  Adds 2+sack_length*8 bytes   */ 
  53. int ackno_;             /* ACK number for FullTcp */
  54. int hlen_;              /* header len (bytes) for FullTcp */
  55. int tcp_flags_;         /* TCP flags for FullTcp */
  56. int last_rtt_; /* more recent RTT measurement in ms, */
  57. /*   for statistics only */
  59. static int offset_; // offset for this header
  60. inline static int& offset() { return offset_; }
  61. inline static hdr_tcp* access(Packet* p) {
  62. return (hdr_tcp*) p->access(offset_);
  63. }
  65. /* per-field member functions */
  66. double& ts() { return (ts_); }
  67. double& ts_echo() { return (ts_echo_); }
  68. int& seqno() { return (seqno_); }
  69. int& reason() { return (reason_); }
  70. int& sa_left(int n) { return (sack_area_[n][0]); }
  71. int& sa_right(int n) { return (sack_area_[n][1]); }
  72. int& sa_length() { return (sa_length_); }
  73. int& hlen() { return (hlen_); }
  74. int& ackno() { return (ackno_); }  
  75. int& flags() { return (tcp_flags_); }
  76. int& last_rtt() { return (last_rtt_); }
  77. };
  79. /* these are used to mark packets as to why we xmitted them */
  80. #define TCP_REASON_TIMEOUT 0x01
  81. #define TCP_REASON_DUPACK 0x02
  82. #define TCP_REASON_RBP 0x03   // used only in tcp-rbp.cc
  83. #define TCP_REASON_PARTIALACK   0x04
  85. /* these are reasons we adjusted our congestion window */
  87. #define CWND_ACTION_DUPACK 1 // dup acks/fast retransmit
  88. #define CWND_ACTION_TIMEOUT 2 // retransmission timeout
  89. #define CWND_ACTION_ECN 3 // ECN bit [src quench if supported]
  90. #define CWND_ACTION_EXITED      4       // congestion recovery has ended
  91. // (when previously CWND_ACTION_DUPACK)
  93. /* these are bits for how to change the cwnd and ssthresh values */
  95. #define CLOSE_SSTHRESH_HALF 0x00000001
  96. #define CLOSE_CWND_HALF 0x00000002
  97. #define CLOSE_CWND_RESTART 0x00000004
  98. #define CLOSE_CWND_INIT 0x00000008
  99. #define CLOSE_CWND_ONE 0x00000010
  100. #define CLOSE_SSTHRESH_HALVE 0x00000020
  101. #define CLOSE_CWND_HALVE 0x00000040
  102. #define THREE_QUARTER_SSTHRESH  0x00000080
  103. #define CLOSE_CWND_HALF_WAY  0x00000100
  104. #define CWND_HALF_WITH_MIN 0x00000200
  105. #define TCP_IDLE 0x00000400
  106. #define NO_OUTSTANDING_DATA     0x00000800
  108. /*
  109.  * tcp_tick_:
  110.  * default 0.1,
  111.  * 0.3 for 4.3 BSD, 
  112.  * 0.01 for new window algorithms,
  113.  */
  115. #define NUMDUPACKS 3 /* This is no longer used.  The variable */
  116. /* numdupacks_ is used instead. */
  117. #define TCP_MAXSEQ 1073741824   /* Number that curseq_ is set to for */
  118. /* "infinite send" (2^30)            */
  120. #define TCP_TIMER_RTX 0
  121. #define TCP_TIMER_DELSND 1
  122. #define TCP_TIMER_BURSTSND 2
  123. #define TCP_TIMER_DELACK 3
  124. #define TCP_TIMER_Q         4
  125. #define TCP_TIMER_RESET        5 
  127. class TcpAgent;
  129. class RtxTimer : public TimerHandler {
  130. public: 
  131. RtxTimer(TcpAgent *a) : TimerHandler() { a_ = a; }
  132. protected:
  133. virtual void expire(Event *e);
  134. TcpAgent *a_;
  135. };
  137. class DelSndTimer : public TimerHandler {
  138. public: 
  139. DelSndTimer(TcpAgent *a) : TimerHandler() { a_ = a; }
  140. protected:
  141. virtual void expire(Event *e);
  142. TcpAgent *a_;
  143. };
  145. class BurstSndTimer : public TimerHandler {
  146. public: 
  147. BurstSndTimer(TcpAgent *a) : TimerHandler() { a_ = a; }
  148. protected:
  149. virtual void expire(Event *e);
  150. TcpAgent *a_;
  151. };
  153. /*
  154.  * Variables for HighSpeed TCP.
  155.  */
  156. //int *hs_win_; // array of cwnd values
  157. //int *hs_increase_; // array of increase values
  158. //double *hs_decrease_; // array of decrease values
  159. struct hstcp {
  160. double low_p;  // low_p
  161. double dec1; // for computing the decrease parameter
  162. double dec2;    // for computing the decrease parameter
  163. double p1; // for computing p
  164.         double p2; // for computing p
  165. /* The next three parameters are for CPU overhead, for computing */
  166. /*   the HighSpeed parameters less frequently.  A better solution */
  167.   /*   might be just to have a look-up array.  */
  168. double cwnd_last_; /* last cwnd for computed parameters */
  169.         double increase_last_; /* increase param for cwnd_last_ */
  170. hstcp() : low_p(0.0), dec1(0.0), dec2(0.0), p1(0.0), p2(0.0),
  171.     cwnd_last_(0.0), increase_last_(0.0) { }
  172. };
  174. class TcpAgent : public Agent {
  175. friend class XcpEndsys;
  176. public:
  177. TcpAgent();
  178. virtual ~TcpAgent() {free(tss);}
  179.         virtual void recv(Packet*, Handler*);
  180. virtual void timeout(int tno);
  181. virtual void timeout_nonrtx(int tno);
  182. int command(int argc, const char*const* argv);
  183. virtual void sendmsg(int nbytes, const char *flags = 0);
  185. void trace(TracedVar* v);
  186. virtual void advanceby(int delta);
  187. protected:
  188. virtual int window();
  189. virtual double windowd();
  190. void print_if_needed(double memb_time);
  191. void traceAll();
  192. virtual void traceVar(TracedVar* v);
  193. virtual int headersize();   // a tcp header
  195. virtual void delay_bind_init_all();
  196. virtual int delay_bind_dispatch(const char *varName, const char *localName, TclObject *tracer);
  198. double boot_time_; /* where between 'ticks' this sytem came up */
  199. double overhead_;
  200. double wnd_;
  201. double wnd_const_;
  202. double wnd_th_; /* window "threshold" */
  203. double wnd_init_;
  204. double wnd_restart_;
  205. double tcp_tick_; /* clock granularity */
  206. int wnd_option_;
  207. int wnd_init_option_;   /* 1 for using wnd_init_ */
  208. /* 2 for using large initial windows */
  209. double decrease_num_;   /* factor for multiplicative decrease */
  210. double increase_num_;   /* factor for additive increase */
  211. int tcpip_base_hdr_size_;  /* size of base TCP/IP header */
  212. int maxcwnd_; /* max # cwnd can ever be */
  213.         int numdupacks_; /* dup ACKs before fast retransmit */
  214. int numdupacksFrac_; /* for a larger numdupacks_ with large */
  215. /* windows */
  217. /* connection and packet dynamics */
  218. virtual void output(int seqno, int reason = 0);
  219. virtual void send_much(int force, int reason, int maxburst = 0);
  220. virtual void newtimer(Packet*);
  221. virtual void dupack_action(); /* do this on dupacks */
  222. virtual void send_one(); /* do this on 1-2 dupacks */
  223. virtual void opencwnd();
  225. void slowdown(int how); /* reduce cwnd/ssthresh */
  226. void ecn(int seqno); /* react to quench */
  227. virtual void set_initial_window(); /* set IW */
  228. double initial_window(); /* what is IW? */
  229. void reset();
  230. void newack(Packet*);
  231. void finish(); /* called when the connection is terminated */
  232. int network_limited(); /* Sending limited by network? */
  233. double limited_slow_start(double cwnd, int max_ssthresh, double increment);
  234. /* Limited slow-start for high windows */
  235. virtual int numdupacks(double cwnd);  /* for getting numdupacks_ */
  236. /* End of section of connection and packet dynamics.  */
  238. /* General dynamic state. */
  239. TracedInt t_seqno_; /* sequence number */
  240. TracedInt dupacks_; /* number of duplicate acks */
  241. TracedInt curseq_; /* highest seqno "produced by app" */
  242. TracedInt highest_ack_; /* not frozen during Fast Recovery */
  243. TracedDouble cwnd_; /* current window */
  244. TracedInt ssthresh_; /* slow start threshold */
  245. TracedInt maxseq_; /* used for Karn algorithm */
  246. /* highest seqno sent so far */
  247. int last_ack_; /* largest consecutive ACK, frozen during
  248.  * Fast Recovery */
  249. int recover_; /* highest pkt sent before dup acks, */
  250. /*   timeout, or source quench/ecn */
  251. int last_cwnd_action_; /* CWND_ACTION_{TIMEOUT,DUPACK,ECN} */
  252. int count_; /* used in window increment algorithms */
  253. int rtt_active_; /* 1 if a rtt sample is pending */
  254. int rtt_seq_; /* seq # of timed seg if rtt_active_ is 1 */
  255. double rtt_ts_; /* time at which rtt_seq_ was sent */
  256. double firstsent_; /* When first packet was sent  --Allman */
  257. double lastreset_; /* W.N. Last time connection was reset - for */
  258. /* detecting pkts from previous incarnations */
  259. int closed_;            /* whether this connection has closed */
  260. /* End of general dynamic state. */
  262. /*
  263.  * State encompassing the round-trip-time estimate.
  264.  * srtt and rttvar are stored as fixed point;
  265.  * srtt has 3 bits to the right of the binary point, rttvar has 2.
  266.  */
  267. TracedInt t_rtt_;       /* round trip time */
  268. TracedInt t_srtt_;      /* smoothed round-trip time */
  269. TracedInt t_rttvar_;    /* variance in round-trip time */
  270. TracedInt t_backoff_; /* current multiplier of RTO, */
  271. /*   1 if not backed off */
  272. #define T_RTT_BITS 0
  273. int T_SRTT_BITS;        /* exponent of weight for updating t_srtt_ */
  274. int srtt_init_; /* initial value for computing t_srtt_ */
  275. int T_RTTVAR_BITS;      /* exponent of weight for updating t_rttvar_ */ 
  276. int rttvar_exp_;        /* exponent of multiple for t_rtxcur_ */
  277. int rttvar_init_;       /* initial value for computing t_rttvar_ */
  278. double t_rtxcur_; /* current retransmit value */
  279. double rtxcur_init_;    /* initial value for t_rtxcur_ */
  280. virtual void rtt_init();
  281. virtual double rtt_timeout(); /* provide RTO based on RTT estimates */
  282. virtual void rtt_update(double tao); /* update RTT estimate */
  283. virtual void rtt_backoff(); /* double multiplier */
  284. /* End of state for the round-trip-time estimate. */
  286.         /* RTOs: */
  287. double maxrto_; /* max value of an RTO */
  288. double minrto_;         /* min value of an RTO */
  289. int ts_resetRTO_; /* Un-backoff RTO after any valid RTT, */
  290. /*   including from a retransmitted pkt?  */
  291. /* The old version was "false". */
  292. /* But "true" gives better performance, and */
  293.                                 /* seems conformant with RFC 2988. */
  294.         /* End of section for RTOs. */
  296. /* Timestamps. */
  297. double ts_peer_;        /* the most recent timestamp the peer sent */
  298. double ts_echo_;        /* the most recent timestamp the peer echoed */
  299. int ts_option_size_;    // header bytes in a ts option
  300.         double *tss;            // To store sent timestamps, with bugfix_ts_
  301.         int tss_size_;          // Current capacity of tss
  302. int ts_option_; /* use RFC1323-like timestamps? */
  303. /* End of timestamps. */
  305. /* Helper functions.  Used by tcp-asym */
  306. virtual void output_helper(Packet*) { return; }
  307. virtual void send_helper(int) { return; }
  308. virtual void send_idle_helper() { return; }
  309. virtual void recv_helper(Packet*) { return; }
  310. virtual void recv_frto_helper(Packet*);
  311. virtual void recv_newack_helper(Packet*);
  312. virtual void partialnewack_helper(Packet*) {};
  313. /* End of helper functions. */
  315. int force_wnd(int num);
  316. void spurious_timeout();
  318. /* Timers */
  319. RtxTimer rtx_timer_;
  320. DelSndTimer delsnd_timer_;
  321. BurstSndTimer burstsnd_timer_;
  322. virtual void cancel_timers() {
  323. rtx_timer_.force_cancel();
  324. burstsnd_timer_.force_cancel();
  325. delsnd_timer_.force_cancel();
  326. }
  327. virtual void cancel_rtx_timer() {
  328. rtx_timer_.force_cancel();
  329. }
  330. virtual void set_rtx_timer();
  331. void reset_rtx_timer(int mild, int backoff = 1);
  332. int timerfix_; /* set to true to update timer *after* */
  333. /* update the RTT, instead of before   */
  334. int rfc2988_; /* Use updated RFC 2988 timers */
  335. /* End of timers. */ 
  338. /* For modeling SYN and SYN/ACK packets. */
  339. int syn_; /* 1 for modeling SYN/ACK exchange */
  340. int delay_growth_;   /* delay opening cwnd until 1st data recv'd */
  341.         int max_connects_;   /* max number of transmits for syn packet */
  342. /* -1 to allow infinite number of transmits */
  343. /* End of modeling SYN and SYN/ACK packets. */
  345. /* Dynamic state for SYN packet retransmissions. */
  346. int syn_connects_; /* number of transmits of syn packet */
  347. /* End of dynamic state for SYN packet retransmissions. */
  349. /* F-RTO */
  350. int frto_enabled_; /* != 0 to enable F-RTO */
  351. int sfrto_enabled_; /* != 0 to enabled SACK-based F-RTO */
  352. int spurious_response_; /* Response variant to spurious RTO */
  353. /* End of R-RTO */
  355. /* Parameters for backwards compatility with old code. */ 
  356. int bug_fix_; /* 1 for multiple-fast-retransmit fix */
  357. int less_careful_; /* 1 for Less Careful variant of bug_fix_, */
  358. /*  for illustration only  */
  359. int exitFastRetrans_; /* True to clean exits of Fast Retransmit */ 
  360. /* False for buggy old behavior */
  361. int bugfix_ack_;        // 1 to enable ACK heuristic, to allow
  362. //  multiple-fast-retransmits in special cases.
  363. // From Andrei Gurtov
  364. int bugfix_ts_;         // 1 to enable timestamp heuristic, to allow
  365. //  multiple-fast-retransmits in special cases.
  366. // From Andrei Gurtov
  367. // Not implemented yet.
  368. int old_ecn_; /* For backwards compatibility with the 
  369.  * old ECN implementation, which never
  370.  * reduced the congestion window below
  371.  * one packet. */ 
  372. int bugfix_ss_; // 1 to use window of one when SYN
  373. //  packet is dropped
  374. /* End of parameters for backwards compatility. */
  376. /* Parameters for alternate congestion control mechanisms. */
  377. double k_parameter_;     /* k parameter in binomial controls */
  378. double l_parameter_;     /* l parameter in binomial controls */
  379. int precision_reduce_;  /* non-integer reduction of cwnd */
  380. int maxburst_; /* max # packets can send back-2-back */
  381. int aggressive_maxburst_; /* Send on a non-valid ack? */
  382. /* End of parameters for alternate congestion control mechanisms. */
  384. FILE *plotfile_;
  386. /* Dynamic state used for alternate congestion control mechanisms */
  387. double awnd_; /* averaged window */
  388. int first_decrease_; /* First decrease of congestion window.  */
  389. /* Used for decrease_num_ != 0.5. */
  390. double fcnt_; /* used in window increment algorithms */
  391. double base_cwnd_; /* base window (for experimental purposes) */
  392. /* End of state for alternate congestion control mechanisms */
  394. /* Dynamic state only used for monitoring */
  395. int trace_all_oneline_; /* TCP tracing vars all in one line or not? */
  396. int nam_tracevar_;      /* Output nam's variable trace or just plain 
  397.    text variable trace? */
  398.         TracedInt ndatapack_;   /* number of data packets sent */
  399.         TracedInt ndatabytes_;  /* number of data bytes sent */
  400.         TracedInt nackpack_;    /* number of ack packets received */
  401.         TracedInt nrexmit_;     /* number of retransmit timeouts 
  402.    when there was data outstanding */
  403.         TracedInt nrexmitpack_; /* number of retransmited packets */
  404.         TracedInt nrexmitbytes_; /* number of retransmited bytes */
  405.         TracedInt necnresponses_; /* number of times cwnd was reduced
  406.        in response to an ecn packet -- sylvia */
  407.         TracedInt ncwndcuts_;  /* number of times cwnd was reduced 
  408.    for any reason -- sylvia */
  409.         TracedInt ncwndcuts1_;     /* number of times cwnd was reduced 
  410.                                    due to congestion (as opposed to idle
  411.                                    periods */
  412. /* end of dynamic state for monitoring */
  414. /* Specifying variants in TCP algorithms.  */
  415. int slow_start_restart_; /* boolean: re-init cwnd after connection 
  416.     goes idle.  On by default. */
  417. int restart_bugfix_;    /* ssthresh is cut down because of
  418.    timeouts during a connection's idle period.
  419.    Setting this boolean fixes this problem.
  420.    For now, it is off by default. */ 
  421.         TracedInt singledup_;   /* Send on a single dup ack.  */
  422. int LimTransmitFix_; /* To fix a bug in Limited Transmit. */
  423. int noFastRetrans_; /* No Fast Retransmit option.  */
  424. int oldCode_; /* Use old code. */
  425. int useHeaders_; /* boolean: Add TCP/IP header sizes */
  426. /* end of specifying variants */
  428. /* Used for ECN */
  429. int ecn_; /* Explicit Congestion Notification */
  430. int cong_action_; /* Congestion Action.  True to indicate
  431.    that the sender responded to congestion. */
  432.         int ecn_burst_; /* True when the previous ACK packet
  433.  *  carried ECN-Echo. */
  434. int ecn_backoff_; /* True when retransmit timer should begin
  435.        to be backed off.  */
  436. int ect_;        /* turn on ect bit now? */
  437. int SetCWRonRetransmit_;  /* True to allow setting CWR on */
  438.   /*  retransmitted packets.   Affects */
  439.   /*  performance for Reno with ECN.  */
  440. int use_rtt_;      /* Use RTT for timeout for ECN-marked SYN-ACK */
  441. /* end of ECN */
  443. /* used for Explicit Loss Notification */
  444. void tcp_eln(Packet *pkt); /* reaction to ELN (usually wireless) */
  445.         int eln_;               /* Explicit Loss Notification (wireless) */
  446.         int eln_rxmit_thresh_;  /* Threshold for ELN-triggered rxmissions */
  447.         int eln_last_rxmit_;    /* Last packet rxmitted due to ELN info */
  448. /* end of Explicit Loss Notification */
  450. /* for High-Speed TCP, RFC 3649 */
  451. double linear(double x, double x_1, double y_1, double x_2, double y_2);
  452.   /* the "linear" function is for experimental highspeed TCP */
  453. /* These four parameters define the HighSpeed response function. */
  454. int low_window_; /* window for turning on high-speed TCP */
  455. int high_window_; /* target window for new response function */
  456. double high_p_; /* target drop rate for new response function */
  457. double high_decrease_; /* decrease rate at target window */
  458. /* The next parameter is for Limited Slow-Start. */
  459. int max_ssthresh_; /* max value for ssthresh_ */
  461. /* These two functions are just an easy structuring of the code. */ 
  462. double increase_param();  /* get increase parameter for current cwnd */
  463. double decrease_param();  /* get decrease parameter for current cwnd */
  464. int cwnd_range_; /* for determining when to recompute params. */
  465. hstcp hstcp_; /* HighSpeed TCP variables */
  466.         /* end of section for experimental high-speed TCP */
  468. /* for Quick-Start, RFC 4782 */
  469. virtual void processQuickStart(Packet *pkt);
  470. virtual void endQuickStart();
  471. int lossQuickStart();
  472. int rate_request_;      /* Rate request in KBps, for QuickStart.  */
  473. int qs_enabled_;        /* to enable QuickStart. */
  474. int qs_requested_;
  475. int qs_approved_;
  476.         int qs_window_;  /* >0: there are outstanding non-acked segments
  477.                             from QS window */
  478.         int qs_cwnd_; /* Initial window for Quick-Start */
  479.         int tcp_qs_recovery_; /* != 0 if we apply slow start on packet
  480.                                  losses during QS window */
  481. int qs_request_mode_;   /* 1 = Try to avoid unnecessary QS requests
  482.    for short flows. Use qs_rtt_ as the RTT
  483.    used in window calculation.
  484.    Other: Always request 'rate_request_' bytes,
  485.    regardless of flow size */
  486. int qs_thresh_;         /* Do not use QS if there are less data to send
  487.    than this. Applies only if
  488.    qs_request_mode_ == 1 */
  489. int qs_rtt_;            /* QS needs some assumption of the RTT in
  490.    in order to be able to determine how much
  491.    it needs for rate request with given amount
  492.    of data to send. milliseconds. */
  493. int print_request_; /* true to print Quick-Start request */
  494. int ttl_diff_;
  495.         /* end of section for Quick-Start. */
  497. /* F-RTO: !=0 when F-RTO recovery is underway, N:th round-trip
  498.  * since RTO. Can have values between 0-2 */
  499. int frto_;
  500. int pipe_prev_; /* window size when timeout last occurred */
  502.         /* support for event-tracing */
  503.         //EventTrace *et_;
  504.         void trace_event(char *eventtype);
  506. /* these function are now obsolete, see other above */
  507. void closecwnd(int how);
  508. void quench(int how);
  509.         
  510. /* TCP quiescence, reducing cwnd after an idle period */
  511. void process_qoption_after_send() ;
  512. void process_qoption_after_ack(int seqno) ;
  513. void reset_qoption(); /* for QOption with EnblRTTCtr_ */
  514. void rtt_counting(); /* for QOption with EnblRTTCtr_ */
  515. int QOption_ ; /* TCP quiescence option */
  516. int EnblRTTCtr_ ; /* are we using a corase grained timer? */
  517. int T_full ; /* last time the window was full */
  518. int T_last ;
  519. int T_prev ;
  520. int T_start ;
  521. int RTT_count ;
  522. int RTT_prev ;
  523. int RTT_goodcount ;
  524. int F_counting ;
  525. int W_used ; 
  526. int W_timed ;
  527. int F_full ; 
  528. int Backoffs ;
  529. int control_increase_ ; /* If true, don't increase cwnd if sender */
  530. /*  is not window-limited.  */
  531. int prev_highest_ack_ ; /* Used to determine if sender is */
  532. /*  window-limited.  */
  533.     /* end of TCP quiescence */
  534. };
  536. /* TCP Reno */
  537. class RenoTcpAgent : public virtual TcpAgent {
  538.  public:
  539. RenoTcpAgent();
  540. virtual int window();
  541. virtual double windowd();
  542. virtual void recv(Packet *pkt, Handler*);
  543. virtual void timeout(int tno);
  544. virtual void dupack_action();
  545.  protected:
  546. int allow_fast_retransmit(int last_cwnd_action_);
  547. unsigned int dupwnd_;
  548. };
  550. /* TCP New Reno */
  551. class NewRenoTcpAgent : public virtual RenoTcpAgent {
  552.  public:
  553. NewRenoTcpAgent();
  554. virtual void recv(Packet *pkt, Handler*);
  555. virtual void partialnewack_helper(Packet* pkt);
  556. virtual void dupack_action();
  557.  protected:
  558. int newreno_changes_; /* 0 for fixing unnecessary fast retransmits */
  559. /* 1 for additional code from Allman, */
  560. /* to implement other algorithms from */
  561. /* Hoe's paper, including sending a new */
  562. /* packet for every two duplicate ACKs. */
  563. /* The default is set to 0. */
  564. int newreno_changes1_;  /* Newreno_changes1_ set to 0 gives the */
  565. /* Slow-but-Steady variant of NewReno from */
  566. /* RFC 2582, with the retransmit timer reset */
  567. /* after each partial new ack. */  
  568. /* Newreno_changes1_ set to 1 gives the */
  569. /* Impatient variant of NewReno from */
  570. /* RFC 2582, with the retransmit timer reset */
  571. /* only for the first partial new ack. */
  572. /* The default is set to 0 */
  573. void partialnewack(Packet *pkt);
  574. int allow_fast_retransmit(int last_cwnd_action_);
  575. int acked_, new_ssthresh_;  /* used if newreno_changes_ == 1 */
  576. double ack2_, ack3_, basertt_; /* used if newreno_changes_ == 1 */
  577. int firstpartial_;  /* For the first partial ACK. */ 
  578. int partial_window_deflation_; /* 0 if set cwnd to ssthresh upon */
  579.        /* partial new ack (default) */
  580.        /* 1 if deflate (cwnd + dupwnd) by */
  581.        /* amount of data acked */
  582.        /* "Partial window deflation" is */
  583.        /* discussed in RFC 2582. */
  584. int exit_recovery_fix_;  /* 0 for setting cwnd to ssthresh upon */
  585.  /* leaving fast recovery (default) */
  586.  /* 1 for setting cwnd to min(ssthresh, */
  587.  /* amnt. of data in network) when leaving */
  588. };
  590. /* TCP vegas (VegasTcpAgent) */
  591. class VegasTcpAgent : public virtual TcpAgent {
  592.  public:
  593. VegasTcpAgent();
  594. ~VegasTcpAgent();
  595. virtual void recv(Packet *pkt, Handler *);
  596. virtual void timeout(int tno);
  597. protected:
  598. double vegastime() {
  599. return(Scheduler::instance().clock() - firstsent_);
  600. }
  601. virtual void output(int seqno, int reason = 0);
  602. virtual void recv_newack_helper(Packet*);
  603. int vegas_expire(Packet*); 
  604. void reset();
  605. void vegas_inflate_cwnd(int win, double current_time);
  607. virtual void delay_bind_init_all();
  608. virtual int delay_bind_dispatch(const char *varName, const char *localName, TclObject *tracer);
  610. double t_cwnd_changed_; // last time cwnd changed
  611. double firstrecv_; // time recv the 1st ack
  613. int    v_alpha_;     // vegas thruput thresholds in pkts
  614. int    v_beta_;       
  616. int    v_gamma_;     // threshold to change from slow-start to
  617. // congestion avoidance, in pkts
  619. int    v_slowstart_;    // # of pkts to send after slow-start, deflt(2)
  620. int    v_worried_;      // # of pkts to chk after dup ack (1 or 2)
  622. double v_timeout_;      // based on fine-grained timer
  623. double v_rtt_;
  624. double v_sa_;
  625. double v_sd_;
  627. int    v_cntRTT_;       // # of rtt measured within one rtt
  628. double v_sumRTT_;       // sum of rtt measured within one rtt
  630. double v_begtime_; // tagged pkt sent
  631. int    v_begseq_; // tagged pkt seqno
  633. double* v_sendtime_; // each unacked pkt's sendtime is recorded.
  634. int*   v_transmits_; // # of retx for an unacked pkt
  636. int    v_maxwnd_; // maxwnd size for v_sendtime_[]
  637. double v_newcwnd_; // record un-inflated cwnd
  639. double v_baseRTT_; // min of all rtt
  641. double v_incr_; // amount cwnd is increased in the next rtt
  642. int    v_inc_flag_; // if cwnd is allowed to incr for this rtt
  644. double v_actual_; // actual send rate (pkt/s; needed for tcp-rbp)
  646. int ns_vegas_fix_level_;   // see comment at end of tcp-vegas.cc for details of fixes
  647. };
  649. // Local Variables:
  650. // mode:c++
  651. // c-basic-offset: 8
  652. // End:
  654. #endif