[mirror_edk2.git] / MdeModulePkg / Universal / Network / Tcp4Dxe / Tcp4Proto.h

/** @file

Copyright (c) 2005 - 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution.  The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php

THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

Module Name:

  Tcp4Proto.h

Abstract:


**/

#ifndef _TCP4_PROTO_H_
#define _TCP4_PROTO_H_

typedef struct _TCP_CB  TCP_CB;

#include "Tcp4Driver.h"
#include "Socket.h"
#include "Tcp4Option.h"

//
// tcp states, Don't change their order, it is used as
// index to mTcpOutFlag and other macros
//
enum {
  TCP_CLOSED      = 0,
  TCP_LISTEN,
  TCP_SYN_SENT,
  TCP_SYN_RCVD,
  TCP_ESTABLISHED,
  TCP_FIN_WAIT_1,
  TCP_FIN_WAIT_2,
  TCP_CLOSING,
  TCP_TIME_WAIT,
  TCP_CLOSE_WAIT,
  TCP_LAST_ACK
};

//
// flags in the TCP header
//
enum {

  TCP_FLG_FIN     = 0x01,
  TCP_FLG_SYN     = 0x02,
  TCP_FLG_RST     = 0x04,
  TCP_FLG_PSH     = 0x08,
  TCP_FLG_ACK     = 0x10,
  TCP_FLG_URG     = 0x20,
  TCP_FLG_FLAG    = 0x3F  // mask for all the flags
};

enum {

  //
  // TCP error status
  //
  TCP_CONNECT_REFUSED     = -1,
  TCP_CONNECT_RESET       = -2,
  TCP_CONNECT_CLOSED      = -3,

  //
  // Current congestion status as suggested by RFC3782.
  //
  TCP_CONGEST_RECOVER     = 1,  // during the NewReno fast recovery
  TCP_CONGEST_LOSS        = 2,  // retxmit because of retxmit time out
  TCP_CONGEST_OPEN        = 3,  // TCP is opening its congestion window

  //
  // TCP control flags
  //
  TCP_CTRL_NO_NAGLE       = 0x0001, // disable Nagle algorithm
  TCP_CTRL_NO_KEEPALIVE   = 0x0002, // disable keepalive timer
  TCP_CTRL_NO_WS          = 0x0004, // disable window scale option
  TCP_CTRL_RCVD_WS        = 0x0008, // rcvd a wnd scale option in syn
  TCP_CTRL_NO_TS          = 0x0010, // disable Timestamp option
  TCP_CTRL_RCVD_TS        = 0x0020, // rcvd a Timestamp option in syn
  TCP_CTRL_SND_TS         = 0x0040, // Send Timestamp option to remote
  TCP_CTRL_SND_URG        = 0x0080, // in urgent send mode
  TCP_CTRL_RCVD_URG       = 0x0100, // in urgent receive mode
  TCP_CTRL_SND_PSH        = 0x0200, // in PUSH send mode
  TCP_CTRL_FIN_SENT       = 0x0400, // FIN is sent
  TCP_CTRL_FIN_ACKED      = 0x0800, // FIN is ACKed.
  TCP_CTRL_TIMER_ON       = 0x1000, // At least one of the timer is on
  TCP_CTRL_RTT_ON         = 0x2000, // The RTT measurement is on
  TCP_CTRL_ACK_NOW        = 0x4000, // Send the ACK now, don't delay

  //
  // Timer related values
  //
  TCP_TIMER_CONNECT       = 0,                // Connection establishment timer
  TCP_TIMER_REXMIT        = 1,                // retransmit timer
  TCP_TIMER_PROBE         = 2,                // Window probe timer
  TCP_TIMER_KEEPALIVE     = 3,                // Keepalive timer
  TCP_TIMER_FINWAIT2      = 4,                // FIN_WAIT_2 timer
  TCP_TIMER_2MSL          = 5,                // TIME_WAIT tiemr
  TCP_TIMER_NUMBER        = 6,                // the total number of TCP timer.
  TCP_TICK                = 200,              // every TCP tick is 200ms
  TCP_TICK_HZ             = 5,                // the frequence of TCP tick
  TCP_RTT_SHIFT           = 3,                // SRTT & RTTVAR scaled by 8
  TCP_RTO_MIN             = TCP_TICK_HZ,      // the minium value of RTO
  TCP_RTO_MAX             = TCP_TICK_HZ *60,  // the maxium value of RTO
  TCP_FOLD_RTT            = 4,                // timeout threshod to fold RTT

  //
  // default values for some timers
  //
  TCP_MAX_LOSS            = 12,                  // default max times to retxmit
  TCP_KEEPALIVE_IDLE_MIN  = TCP_TICK_HZ *60 *60 *2, // First keep alive
  TCP_KEEPALIVE_PERIOD    = TCP_TICK_HZ *60,
  TCP_MAX_KEEPALIVE       = 8,
  TCP_FIN_WAIT2_TIME      = 2 *TCP_TICK_HZ,         // * 60,
  TCP_TIME_WAIT_TIME      = 2 *TCP_TICK_HZ,
  TCP_PAWS_24DAY          = 24 *24 *60 *60 *TCP_TICK_HZ,
  TCP_CONNECT_TIME        = 75 *TCP_TICK_HZ,

  //
  // The header space to be reserved before TCP data to accomodate :
  // 60byte IP head + 60byte TCP head + link layer head
  //
  TCP_MAX_HEAD            = 192,

  //
  // value ranges for some control option
  //
  TCP_RCV_BUF_SIZE        = 2 *1024 *1024,
  TCP_RCV_BUF_SIZE_MIN    = 8 *1024,
  TCP_SND_BUF_SIZE        = 2 *1024 *1024,
  TCP_SND_BUF_SIZE_MIN    = 8 *1024,
  TCP_BACKLOG             = 10,
  TCP_BACKLOG_MIN         = 5,
  TCP_MAX_LOSS_MIN        = 6,
  TCP_CONNECT_TIME_MIN    = 60 *TCP_TICK_HZ,
  TCP_MAX_KEEPALIVE_MIN   = 4,
  TCP_KEEPALIVE_IDLE_MAX  = TCP_TICK_HZ *60 *60 *4,
  TCP_KEEPALIVE_PERIOD_MIN= TCP_TICK_HZ *30,
  TCP_FIN_WAIT2_TIME_MAX  = 4 *TCP_TICK_HZ,
  TCP_TIME_WAIT_TIME_MAX  = 60 *TCP_TICK_HZ
};

typedef struct _TCP_SEG {
  TCP_SEQNO Seq;  // Starting sequence number
  TCP_SEQNO End;  // The sequence of the last byte + 1,
                  // include SYN/FIN. End-Seq = SEG.LEN
  TCP_SEQNO Ack;  // ACK fild in the segment
  UINT8     Flag; // TCP header flags
  UINT16    Urg;  // Valid if URG flag is set.
  UINT32    Wnd;  // TCP window size field
} TCP_SEG;

typedef struct _TCP_PEER {
  UINT32      Ip;   // Network byte order
  TCP_PORTNO  Port; // Network byte order
} TCP_PEER;

//
// tcp control block, it includes various states
//
struct _TCP_CB {
  NET_LIST_ENTRY    List;
  TCP_CB            *Parent;

  SOCKET            *Sk;
  TCP_PEER          LocalEnd;
  TCP_PEER          RemoteEnd;

  NET_LIST_ENTRY    SndQue;   // retxmission queue
  NET_LIST_ENTRY    RcvQue;   // reassemble queue
  UINT32            CtrlFlag; // control flags, such as NO_NAGLE
  INT32             Error;    // soft error status,TCP_CONNECT_RESET...

  //
  // RFC793 and RFC1122 defined variables
  //
  UINT8             State;      // TCP state, such as SYN_SENT, LISTEN
  UINT8             DelayedAck; // number of delayed ACKs
  UINT16            HeadSum;    // checksum of the fixed parts of pesudo
                                // header: Src IP, Dst IP, 0, Protocol,
                                // not include the TCP length.

  TCP_SEQNO         Iss;        // Initial Sending Sequence
  TCP_SEQNO         SndUna;     // first unacknowledged data
  TCP_SEQNO         SndNxt;     // next data sequence to send.
  TCP_SEQNO         SndPsh;     // Send PUSH point
  TCP_SEQNO         SndUp;      // Send urgent point
  UINT32            SndWnd;     // Window advertised by the remote peer
  UINT32            SndWndMax;  // max send window advertised by the peer
  TCP_SEQNO         SndWl1;     // Seq number used for last window update
  TCP_SEQNO         SndWl2;     // ack no of last window update
  UINT16            SndMss;     // Max send segment size
  TCP_SEQNO         RcvNxt;     // Next sequence no to receive
  UINT32            RcvWnd;     // Window advertised by the local peer
  TCP_SEQNO         RcvWl2;     // The RcvNxt (or ACK) of last window update.
                                // It is necessary because of delayed ACK

  TCP_SEQNO         RcvUp;                   // urgent point;
  TCP_SEQNO         Irs;                     // Initial Receiving Sequence
  UINT16            RcvMss;                  // Max receive segment size
  UINT16            EnabledTimer;            // which timer is currently enabled
  UINT32            Timer[TCP_TIMER_NUMBER]; // when the timer will expire
  INT32             NextExpire;  // count down offset for the nearest timer
  UINT32            Idle;        // How long the connection is in idle
  UINT32            ProbeTime;   // the time out value for current window prober

  //
  // RFC1323 defined variables, about window scale,
  // timestamp and PAWS
  //
  UINT8             SndWndScale;  // Wndscale received from the peer
  UINT8             RcvWndScale;  // Wndscale used to scale local buffer
  UINT32            TsRecent;     // TsRecent to echo to the remote peer
  UINT32            TsRecentAge;  // When this TsRecent is updated

  // TCP_SEQNO  LastAckSent;
  // It isn't necessary to add LastAckSent here,
  // since it is the same as RcvWl2

  //
  // RFC2988 defined variables. about RTT measurement
  //
  TCP_SEQNO         RttSeq;     // the seq of measured segment now
  UINT32            RttMeasure; // currently measured RTT in heart beats
  UINT32            SRtt;       // Smoothed RTT, scaled by 8
  UINT32            RttVar;     // RTT variance, scaled by 8
  UINT32            Rto;        // Current RTO, not scaled

  //
  // RFC2581, and 3782 variables.
  // Congestion control + NewReno fast recovery.
  //
  UINT32            CWnd;         // Sender's congestion window
  UINT32            Ssthresh;     // Slow start threshold.
  TCP_SEQNO         Recover;      // recover point for NewReno
  UINT16            DupAck;       // number of duplicate ACKs
  UINT8             CongestState; // the current congestion state(RFC3782)
  UINT8             LossTimes;    // number of retxmit timeouts in a row
  TCP_SEQNO         LossRecover;  // recover point for retxmit

  //
  // configuration parameters, for EFI_TCP4_PROTOCOL specification
  //
  UINT32            KeepAliveIdle;   // idle time before sending first probe
  UINT32            KeepAlivePeriod; // interval for subsequent keep alive probe
  UINT8             MaxKeepAlive;    // Maxium keep alive probe times.
  UINT8             KeepAliveProbes; // the number of keep alive probe.
  UINT16            MaxRexmit;      // The maxium number of retxmit before abort
  UINT32            FinWait2Timeout; // The FIN_WAIT_2 time out
  UINT32            TimeWaitTimeout; // The TIME_WAIT time out
  UINT32            ConnectTimeout;

  //
  // configuration for tcp provided by user
  //
  BOOLEAN           UseDefaultAddr;
  UINT8             TOS;
  UINT8             TTL;
  EFI_IPv4_ADDRESS  SubnetMask;

  //
  // pointer reference to Ip used to send pkt
  //
  IP_IO_IP_INFO     *IpInfo;
};

extern NET_LIST_ENTRY mTcpRunQue;
extern NET_LIST_ENTRY mTcpListenQue;
extern TCP_SEQNO      mTcpGlobalIss;
extern UINT32         mTcpTick;

//
// TCP_CONNECTED: both ends have synchronized their ISN.
//
#define TCP_CONNECTED(state)  ((state) > TCP_SYN_RCVD)

#define TCP_FIN_RCVD(State) \
    (((State) == TCP_CLOSE_WAIT) || \
    ((State) == TCP_LAST_ACK) || \
    ((State) == TCP_CLOSING) || \
    ((State) == TCP_TIME_WAIT))

#define TCP_LOCAL_CLOSED(State) \
      (((State) == TCP_FIN_WAIT_1) || \
      ((State) == TCP_FIN_WAIT_2) || \
      ((State) == TCP_CLOSING) || \
      ((State) == TCP_TIME_WAIT) || \
      ((State) == TCP_LAST_ACK))

//
// Get the TCP_SEG point from a net buffer's ProtoData
//
#define TCPSEG_NETBUF(NBuf) ((TCP_SEG *) ((NBuf)->ProtoData))

//
// macros to compare sequence no
//
#define TCP_SEQ_LT(SeqA, SeqB)  ((INT32) ((SeqA) - (SeqB)) < 0)
#define TCP_SEQ_LEQ(SeqA, SeqB) ((INT32) ((SeqA) - (SeqB)) <= 0)
#define TCP_SEQ_GT(SeqA, SeqB)  ((INT32) ((SeqB) - (SeqA)) < 0)
#define TCP_SEQ_GEQ(SeqA, SeqB) ((INT32) ((SeqB) - (SeqA)) <= 0)

//
// TCP_SEQ_BETWEEN return whether b <= m <= e
//
#define TCP_SEQ_BETWEEN(b, m, e)  ((e) - (b) >= (m) - (b))

//
// TCP_SUB_SEQ returns Seq1 - Seq2. Make sure Seq1 >= Seq2
//
#define TCP_SUB_SEQ(Seq1, Seq2)     ((UINT32) ((Seq1) - (Seq2)))

#define TCP_FLG_ON(Value, Flag)     ((BOOLEAN) (((Value) & (Flag)) != 0))
#define TCP_SET_FLG(Value, Flag)    ((Value) |= (Flag))
#define TCP_CLEAR_FLG(Value, Flag)  ((Value) &= ~(Flag))

//
// test whether two peers are equal
//
#define TCP_PEER_EQUAL(Pa, Pb) \
  (((Pa)->Ip == (Pb)->Ip) && ((Pa)->Port == (Pb)->Port))

//
// test whether Pa matches Pb, or Pa is more specific
// than pb. Zero means wildcard.
//
#define TCP_PEER_MATCH(Pa, Pb) \
    ((((Pb)->Ip == 0) || ((Pb)->Ip == (Pa)->Ip)) && \
    (((Pb)->Port == 0) || ((Pb)->Port == (Pa)->Port)))

#define TCP_TIMER_ON(Flag, Timer)     ((Flag) & (1 << (Timer)))
#define TCP_SET_TIMER(Flag, Timer)    ((Flag) = (UINT16) ((Flag) | (1 << (Timer))))
#define TCP_CLEAR_TIMER(Flag, Timer)  ((Flag) = (UINT16) ((Flag) & (~(1 << (Timer)))))

#define TCP_TIME_LT(Ta, Tb)           ((INT32) ((Ta) - (Tb)) < 0)
#define TCP_TIME_LEQ(Ta, Tb)          ((INT32) ((Ta) - (Tb)) <= 0)
#define TCP_SUB_TIME(Ta, Tb)          ((UINT32) ((Ta) - (Tb)))

#define TCP_MAX_WIN                   0xFFFFU

typedef
VOID
(*TCP_TIMER_HANDLER) (
  IN TCP_CB * Tcb
  );

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