MdeModulePkg/Universal/Network/Tcp4Dxe/Tcp4Proto.h

   1 /** @file
   2
   3 Copyright (c) 2005 - 2006, Intel Corporation<BR>
   4 All rights reserved. This program and the accompanying materials
   5 are licensed and made available under the terms and conditions of the BSD License
   6 which accompanies this distribution.  The full text of the license may be found at
   7 http://opensource.org/licenses/bsd-license.php<BR>
   8
   9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  11
  12 **/
  13
  14 #ifndef _TCP4_PROTO_H_
  15 #define _TCP4_PROTO_H_
  16
  17 typedef struct _TCP_CB  TCP_CB;
  18
  19 #include "Tcp4Driver.h"
  20 #include "Socket.h"
  21 #include "Tcp4Option.h"
  22
  23
  24
  25 ///
  26 /// Tcp states, Don't change their order, it is used as
  27 /// index to mTcpOutFlag and other macros
  28 ///
  29 typedef enum {
  30   TCP_CLOSED      = 0,
  31   TCP_LISTEN,
  32   TCP_SYN_SENT,
  33   TCP_SYN_RCVD,
  34   TCP_ESTABLISHED,
  35   TCP_FIN_WAIT_1,
  36   TCP_FIN_WAIT_2,
  37   TCP_CLOSING,
  38   TCP_TIME_WAIT,
  39   TCP_CLOSE_WAIT,
  40   TCP_LAST_ACK
  41 } TCP_STATES;
  42
  43 ///
  44 /// Flags in the TCP header
  45 ///
  46 typedef enum {
  47
  48   TCP_FLG_FIN     = 0x01,
  49   TCP_FLG_SYN     = 0x02,
  50   TCP_FLG_RST     = 0x04,
  51   TCP_FLG_PSH     = 0x08,
  52   TCP_FLG_ACK     = 0x10,
  53   TCP_FLG_URG     = 0x20,
  54
  55   //
  56   // mask for all the flags
  57   //
  58   TCP_FLG_FLAG    = 0x3F
  59 } TCP_HEADER_FLAG;
  60
  61 typedef enum {
  62
  63   TCP_CONNECT_REFUSED     = -1, ///< TCP error status
  64   TCP_CONNECT_RESET       = -2, ///< TCP error status
  65   TCP_CONNECT_CLOSED      = -3, ///< TCP error status
  66
  67   //
  68   // Current congestion status as suggested by RFC3782.
  69   //
  70   TCP_CONGEST_RECOVER     = 1,  ///< During the NewReno fast recovery
  71   TCP_CONGEST_LOSS        = 2,  ///< Retxmit because of retxmit time out
  72   TCP_CONGEST_OPEN        = 3,  ///< TCP is opening its congestion window
  73
  74   //
  75   // TCP control flags
  76   //
  77   TCP_CTRL_NO_NAGLE       = 0x0001, ///< Disable Nagle algorithm
  78   TCP_CTRL_NO_KEEPALIVE   = 0x0002, ///< Disable keepalive timer
  79   TCP_CTRL_NO_WS          = 0x0004, ///< Disable window scale option
  80   TCP_CTRL_RCVD_WS        = 0x0008, ///< Received a wnd scale option in syn
  81   TCP_CTRL_NO_TS          = 0x0010, ///< Disable Timestamp option
  82   TCP_CTRL_RCVD_TS        = 0x0020, ///< Received a Timestamp option in syn
  83   TCP_CTRL_SND_TS         = 0x0040, ///< Send Timestamp option to remote
  84   TCP_CTRL_SND_URG        = 0x0080, ///< In urgent send mode
  85   TCP_CTRL_RCVD_URG       = 0x0100, ///< In urgent receive mode
  86   TCP_CTRL_SND_PSH        = 0x0200, ///< In PUSH send mode
  87   TCP_CTRL_FIN_SENT       = 0x0400, ///< FIN is sent
  88   TCP_CTRL_FIN_ACKED      = 0x0800, ///< FIN is ACKed.
  89   TCP_CTRL_TIMER_ON       = 0x1000, ///< At least one of the timer is on
  90   TCP_CTRL_RTT_ON         = 0x2000, ///< The RTT measurement is on
  91   TCP_CTRL_ACK_NOW        = 0x4000, ///< Send the ACK now, don't delay
  92
  93   //
  94   // Timer related values
  95   //
  96   TCP_TIMER_CONNECT       = 0,                  ///< Connection establishment timer
  97   TCP_TIMER_REXMIT        = 1,                  ///< Retransmit timer
  98   TCP_TIMER_PROBE         = 2,                  ///< Window probe timer
  99   TCP_TIMER_KEEPALIVE     = 3,                  ///< Keepalive timer
 100   TCP_TIMER_FINWAIT2      = 4,                  ///< FIN_WAIT_2 timer
 101   TCP_TIMER_2MSL          = 5,                  ///< TIME_WAIT tiemr
 102   TCP_TIMER_NUMBER        = 6,                  ///< The total number of TCP timer.
 103   TCP_TICK                = 200,                ///< Every TCP tick is 200ms
 104   TCP_TICK_HZ             = 5,                  ///< The frequence of TCP tick
 105   TCP_RTT_SHIFT           = 3,                  ///< SRTT & RTTVAR scaled by 8
 106   TCP_RTO_MIN             = TCP_TICK_HZ,        ///< The minium value of RTO
 107   TCP_RTO_MAX             = (TCP_TICK_HZ * 60), ///< The maxium value of RTO
 108   TCP_FOLD_RTT            = 4,                  ///< Timeout threshod to fold RTT
 109
 110   //
 111   // Default values for some timers
 112   //
 113   TCP_MAX_LOSS            = 12,                          ///< Default max times to retxmit
 114   TCP_KEEPALIVE_IDLE_MIN  = (TCP_TICK_HZ * 60 * 60 * 2), ///< First keep alive
 115   TCP_KEEPALIVE_PERIOD    = (TCP_TICK_HZ * 60),
 116   TCP_MAX_KEEPALIVE       = 8,
 117   TCP_FIN_WAIT2_TIME      = (2 * TCP_TICK_HZ),
 118   TCP_TIME_WAIT_TIME      = (2 * TCP_TICK_HZ),
 119   TCP_PAWS_24DAY          = (24 * 24 * 60 * 60 * TCP_TICK_HZ),
 120   TCP_CONNECT_TIME        = (75 * TCP_TICK_HZ),
 121
 122   //
 123   // The header space to be reserved before TCP data to accomodate :
 124   // 60byte IP head + 60byte TCP head + link layer head
 125   //
 126   TCP_MAX_HEAD            = 192,
 127
 128   //
 129   // Value ranges for some control option
 130   //
 131   TCP_RCV_BUF_SIZE        = (2 * 1024 * 1024),
 132   TCP_RCV_BUF_SIZE_MIN    = (8 * 1024),
 133   TCP_SND_BUF_SIZE        = (2 * 1024 * 1024),
 134   TCP_SND_BUF_SIZE_MIN    = (8 * 1024),
 135   TCP_BACKLOG             = 10,
 136   TCP_BACKLOG_MIN         = 5,
 137   TCP_MAX_LOSS_MIN        = 6,
 138   TCP_CONNECT_TIME_MIN    = (60 * TCP_TICK_HZ),
 139   TCP_MAX_KEEPALIVE_MIN   = 4,
 140   TCP_KEEPALIVE_IDLE_MAX  = (TCP_TICK_HZ * 60 * 60 * 4),
 141   TCP_KEEPALIVE_PERIOD_MIN= (TCP_TICK_HZ * 30),
 142   TCP_FIN_WAIT2_TIME_MAX  = (4 * TCP_TICK_HZ),
 143   TCP_TIME_WAIT_TIME_MAX  = (60 * TCP_TICK_HZ)
 144 } TCP_MISC_VALUES;
 145
 146 ///
 147 /// TCP segmentation data
 148 ///
 149 typedef struct _TCP_SEG {
 150   TCP_SEQNO Seq;  ///< Starting sequence number
 151   TCP_SEQNO End;  ///< The sequence of the last byte + 1, include SYN/FIN. End-Seq = SEG.LEN
 152   TCP_SEQNO Ack;  ///< ACK field in the segment
 153   UINT8     Flag; ///< TCP header flags
 154   UINT16    Urg;  ///< Valid if URG flag is set.
 155   UINT32    Wnd;  ///< TCP window size field
 156 } TCP_SEG;
 157
 158 ///
 159 /// Network endpoint, IP+Port structure
 160 ///
 161 typedef struct _TCP_PEER {
 162   UINT32      Ip;   ///< IP address, network byte order
 163   TCP_PORTNO  Port; ///< Port number, network byte order
 164 } TCP_PEER;
 165
 166 ///
 167 /// TCP control block, it includes various states
 168 ///
 169 struct _TCP_CB {
 170   LIST_ENTRY        List;     ///< Back and forward link entry
 171   TCP_CB            *Parent;  ///< The parent TCP_CB structure
 172
 173   SOCKET            *Sk;      ///< The socket it controled.
 174   TCP_PEER          LocalEnd; ///< Local endpoint
 175   TCP_PEER          RemoteEnd;///< Remote endpoint
 176
 177   LIST_ENTRY        SndQue;   ///< Retxmission queue
 178   LIST_ENTRY        RcvQue;   ///< Reassemble queue
 179   UINT32            CtrlFlag; ///< Control flags, such as NO_NAGLE
 180   INT32             Error;    ///< Soft error status, such as TCP_CONNECT_RESET
 181
 182   //
 183   // RFC793 and RFC1122 defined variables
 184   //
 185   UINT8             State;      ///< TCP state, such as SYN_SENT, LISTEN
 186   UINT8             DelayedAck; ///< Number of delayed ACKs
 187   UINT16            HeadSum;    ///< Checksum of the fixed parts of pesudo
 188                                 ///< header: Src IP, Dst IP, 0, Protocol,
 189                                 ///< not include the TCP length.
 190
 191   TCP_SEQNO         Iss;        ///< Initial Sending Sequence
 192   TCP_SEQNO         SndUna;     ///< First unacknowledged data
 193   TCP_SEQNO         SndNxt;     ///< Next data sequence to send.
 194   TCP_SEQNO         SndPsh;     ///< Send PUSH point
 195   TCP_SEQNO         SndUp;      ///< Send urgent point
 196   UINT32            SndWnd;     ///< Window advertised by the remote peer
 197   UINT32            SndWndMax;  ///< Max send window advertised by the peer
 198   TCP_SEQNO         SndWl1;     ///< Seq number used for last window update
 199   TCP_SEQNO         SndWl2;     ///< Ack no of last window update
 200   UINT16            SndMss;     ///< Max send segment size
 201   TCP_SEQNO         RcvNxt;     ///< Next sequence no to receive
 202   UINT32            RcvWnd;     ///< Window advertised by the local peer
 203   TCP_SEQNO         RcvWl2;     ///< The RcvNxt (or ACK) of last window update.
 204                                 ///< It is necessary because of delayed ACK
 205
 206   TCP_SEQNO         RcvUp;                   ///< Urgent point;
 207   TCP_SEQNO         Irs;                     ///< Initial Receiving Sequence
 208   UINT16            RcvMss;                  ///< Max receive segment size
 209   UINT16            EnabledTimer;            ///< Which timer is currently enabled
 210   UINT32            Timer[TCP_TIMER_NUMBER]; ///< When the timer will expire
 211   INT32             NextExpire;  ///< Count down offset for the nearest timer
 212   UINT32            Idle;        ///< How long the connection is in idle
 213   UINT32            ProbeTime;   ///< The time out value for current window prober
 214
 215   //
 216   // RFC1323 defined variables, about window scale,
 217   // timestamp and PAWS
 218   //
 219   UINT8             SndWndScale;  ///< Wndscale received from the peer
 220   UINT8             RcvWndScale;  ///< Wndscale used to scale local buffer
 221   UINT32            TsRecent;     ///< TsRecent to echo to the remote peer
 222   UINT32            TsRecentAge;  ///< When this TsRecent is updated
 223
 224   //
 225   // RFC2988 defined variables. about RTT measurement
 226   //
 227   TCP_SEQNO         RttSeq;     ///< The seq of measured segment now
 228   UINT32            RttMeasure; ///< Currently measured RTT in heart beats
 229   UINT32            SRtt;       ///< Smoothed RTT, scaled by 8
 230   UINT32            RttVar;     ///< RTT variance, scaled by 8
 231   UINT32            Rto;        ///< Current RTO, not scaled
 232
 233   //
 234   // RFC2581, and 3782 variables.
 235   // Congestion control + NewReno fast recovery.
 236   //
 237   UINT32            CWnd;         ///< Sender's congestion window
 238   UINT32            Ssthresh;     ///< Slow start threshold.
 239   TCP_SEQNO         Recover;      ///< Recover point for NewReno
 240   UINT16            DupAck;       ///< Number of duplicate ACKs
 241   UINT8             CongestState; ///< The current congestion state(RFC3782)
 242   UINT8             LossTimes;    ///< Number of retxmit timeouts in a row
 243   TCP_SEQNO         LossRecover;  ///< Recover point for retxmit
 244
 245   //
 246   // configuration parameters, for EFI_TCP4_PROTOCOL specification
 247   //
 248   UINT32            KeepAliveIdle;   ///< Idle time before sending first probe
 249   UINT32            KeepAlivePeriod; ///< Interval for subsequent keep alive probe
 250   UINT8             MaxKeepAlive;    ///< Maxium keep alive probe times.
 251   UINT8             KeepAliveProbes; ///< The number of keep alive probe.
 252   UINT16            MaxRexmit;       ///< The maxium number of retxmit before abort
 253   UINT32            FinWait2Timeout; ///< The FIN_WAIT_2 time out
 254   UINT32            TimeWaitTimeout; ///< The TIME_WAIT time out
 255   UINT32            ConnectTimeout;  ///< The connect establishment time out
 256
 257   //
 258   // configuration for tcp provided by user
 259   //
 260   BOOLEAN           UseDefaultAddr;
 261   UINT8             TOS;
 262   UINT8             TTL;
 263   EFI_IPv4_ADDRESS  SubnetMask;
 264
 265   IP_IO_IP_INFO     *IpInfo;        ///<pointer reference to Ip used to send pkt
 266 };
 267
 268 extern LIST_ENTRY     mTcpRunQue;
 269 extern LIST_ENTRY     mTcpListenQue;
 270 extern TCP_SEQNO      mTcpGlobalIss;
 271 extern UINT32         mTcpTick;
 272
 273 ///
 274 /// TCP_CONNECTED: both ends have synchronized their ISN.
 275 ///
 276 #define TCP_CONNECTED(state)  ((state) > TCP_SYN_RCVD)
 277
 278 #define TCP_FIN_RCVD(State) \
 279     (((State) == TCP_CLOSE_WAIT) || \
 280     ((State) == TCP_LAST_ACK) || \
 281     ((State) == TCP_CLOSING) || \
 282     ((State) == TCP_TIME_WAIT))
 283
 284 #define TCP_LOCAL_CLOSED(State) \
 285       (((State) == TCP_FIN_WAIT_1) || \
 286       ((State) == TCP_FIN_WAIT_2) || \
 287       ((State) == TCP_CLOSING) || \
 288       ((State) == TCP_TIME_WAIT) || \
 289       ((State) == TCP_LAST_ACK))
 290
 291 //
 292 // Get the TCP_SEG point from a net buffer's ProtoData
 293 //
 294 #define TCPSEG_NETBUF(NBuf) ((TCP_SEG *) ((NBuf)->ProtoData))
 295
 296 //
 297 // macros to compare sequence no
 298 //
 299 #define TCP_SEQ_LT(SeqA, SeqB)  ((INT32) ((SeqA) - (SeqB)) < 0)
 300 #define TCP_SEQ_LEQ(SeqA, SeqB) ((INT32) ((SeqA) - (SeqB)) <= 0)
 301 #define TCP_SEQ_GT(SeqA, SeqB)  ((INT32) ((SeqB) - (SeqA)) < 0)
 302 #define TCP_SEQ_GEQ(SeqA, SeqB) ((INT32) ((SeqB) - (SeqA)) <= 0)
 303
 304 //
 305 // TCP_SEQ_BETWEEN return whether b <= m <= e
 306 //
 307 #define TCP_SEQ_BETWEEN(b, m, e)  ((e) - (b) >= (m) - (b))
 308
 309 //
 310 // TCP_SUB_SEQ returns Seq1 - Seq2. Make sure Seq1 >= Seq2
 311 //
 312 #define TCP_SUB_SEQ(Seq1, Seq2)     ((UINT32) ((Seq1) - (Seq2)))
 313
 314 #define TCP_FLG_ON(Value, Flag)     ((BOOLEAN) (((Value) & (Flag)) != 0))
 315 #define TCP_SET_FLG(Value, Flag)    ((Value) |= (Flag))
 316 #define TCP_CLEAR_FLG(Value, Flag)  ((Value) &= ~(Flag))
 317
 318 //
 319 // test whether two peers are equal
 320 //
 321 #define TCP_PEER_EQUAL(Pa, Pb) \
 322   (((Pa)->Ip == (Pb)->Ip) && ((Pa)->Port == (Pb)->Port))
 323
 324 //
 325 // test whether Pa matches Pb, or Pa is more specific
 326 // than pb. Zero means wildcard.
 327 //
 328 #define TCP_PEER_MATCH(Pa, Pb) \
 329     ((((Pb)->Ip == 0) || ((Pb)->Ip == (Pa)->Ip)) && \
 330     (((Pb)->Port == 0) || ((Pb)->Port == (Pa)->Port)))
 331
 332 #define TCP_TIMER_ON(Flag, Timer)     ((Flag) & (1 << (Timer)))
 333 #define TCP_SET_TIMER(Flag, Timer)    ((Flag) = (UINT16) ((Flag) | (1 << (Timer))))
 334 #define TCP_CLEAR_TIMER(Flag, Timer)  ((Flag) = (UINT16) ((Flag) & (~(1 << (Timer)))))
 335
 336 #define TCP_TIME_LT(Ta, Tb)           ((INT32) ((Ta) - (Tb)) < 0)
 337 #define TCP_TIME_LEQ(Ta, Tb)          ((INT32) ((Ta) - (Tb)) <= 0)
 338 #define TCP_SUB_TIME(Ta, Tb)          ((UINT32) ((Ta) - (Tb)))
 339
 340 #define TCP_MAX_WIN                   0xFFFFU
 341
 342 typedef
 343 VOID
 344 (*TCP_TIMER_HANDLER) (
 345   IN TCP_CB *Tcb
 346   );
 347
 348 #include "Tcp4Func.h"
 349 #endif