diff options
Diffstat (limited to '')
| -rw-r--r-- | private/ntos/tdi/tcpip/tcp/tcp.h | 426 |
1 files changed, 426 insertions, 0 deletions
diff --git a/private/ntos/tdi/tcpip/tcp/tcp.h b/private/ntos/tdi/tcpip/tcp/tcp.h new file mode 100644 index 000000000..d88d3443e --- /dev/null +++ b/private/ntos/tdi/tcpip/tcp/tcp.h @@ -0,0 +1,426 @@ +/********************************************************************/ +/** Microsoft LAN Manager **/ +/** Copyright(c) Microsoft Corp., 1990-1993 **/ +/********************************************************************/ +/* :ts=4 */ + +#ifndef _TCP_INCLUDED_ +#define _TCP_INCLUDED_ + +//** TCP.H - TCP definitions. +// +// This file contains the definitions of TCP protocol specific options, such +// as the sequence numbers and TCB. +// + +#define PROTOCOL_TCP 6 +#define MAX_REMOTE_MSS 536 + +//* Timer stuff. We keep timers as ticks. +#define MS_PER_TICK 100 +#define MS_TO_TICKS(m) ((m) / MS_PER_TICK) +#define MIN_RETRAN_TICKS 3 + +#define DEL_ACK_TICKS 2 +// Define MAX_REXMIT_TO to be number of ticks in 2MSL (=240 seconds) + +#define MAX_REXMIT_TO ((ushort)FinWait2TO) + +#define SWS_TO MS_TO_TICKS(5000) + +#define FIN_WAIT2_TO 240 +#define PUSH_TO MS_TO_TICKS(500) + +typedef ulong TCP_TIME; +#define MAX_CONN_TO_TICKS 0xffff +#define INFINITE_CONN_TO(t) ((t) == 0) +#define TCP_TIME_TO_TICKS(t) (((t)/MS_PER_TICK)+1) + + +// Sequence numbers are kept as signed 32 bit quantities, with macros +// defined to do wraparound comparisons on them. + +typedef int SeqNum; // A sequence number. + +//* Macros for comparions on sequence numbers. + +#define SEQ_GT(a, b) (((a) - (b)) > 0) +#define SEQ_GTE(a, b) (((a) - (b)) >= 0) +#define SEQ_LT(a, b) (((a) - (b)) < 0) +#define SEQ_LTE(a, b) (((a) - (b)) <= 0) +#define SEQ_EQ(a, b) ((a) == (b)) + +//* The TCB - transport control block structure. This is the +// structure that contains all of the state for the transport +// connection, including sequence numbers, flow control information, +// pending sends and receives, etc. + +#define tcb_signature 0x20424354 // 'TCB ' + +struct TCB { + +#ifdef DEBUG + ulong tcb_sig; // Debug signature. +#endif + struct TCB *tcb_next; // Next pointer in TCB table. + DEFINE_LOCK_STRUCTURE(tcb_lock) + // Send sequence variables. + SeqNum tcb_senduna; // Sequence number of first unack'd + // data. + SeqNum tcb_sendnext; // Sequence number of next byte to + // send. + SeqNum tcb_sendmax; // Max value of sendnext this + // epoch. + uint tcb_sendwin; // Send window. + uint tcb_unacked; // Total number of bytes of unacked + // data. + uint tcb_maxwin; // Max send window seen. + uint tcb_cwin; // Congestion window. + uint tcb_ssthresh; // Slow start threshold. + uint tcb_phxsum; // Precomputed pseudo-header xsum. + struct TCPSendReq *tcb_cursend; // Current send in use. + PNDIS_BUFFER tcb_sendbuf; // Current buffer chain being sent. + uint tcb_sendofs; // Offset into start of chain. + uint tcb_sendsize; // Number of bytes unsent in current + // send. + Queue tcb_sendq; // Queue of send requests. + + // Receive sequence variables. + SeqNum tcb_rcvnext; // Next byte we expect to receive. + int tcb_rcvwin; // Receive window we're offering. + SeqNum tcb_sendwl1; // Window update sequence number. + SeqNum tcb_sendwl2; // Window update ack number. + struct TCPRcvReq *tcb_currcv; // Current receive buffer. + uint tcb_indicated; // Bytes of data indicated. + uint tcb_flags; // Flags for this TCB. + uint tcb_fastchk; // Fast receive path check field. + uint (*tcb_rcvhndlr)(struct TCB *, uint, + struct IPRcvBuf *, uint Size); + // Addressing info. + IPAddr tcb_daddr; // Destination IP address. + IPAddr tcb_saddr; // Source IP address. + ushort tcb_dport; // Destination port. + ushort tcb_sport; // Source port. + + ushort tcb_mss; // MSS for this connection. + ushort tcb_rexmit; // Rexmit value. + uint tcb_refcnt; // Reference count for TCB. + SeqNum tcb_rttseq; // Sequence number being measured + // for RTT. + + // Retransmit timer information. These are stored as ticks, where by + // default each tick is 100ms. + ushort tcb_smrtt; // Smoothed rtt value. + ushort tcb_delta; // Delta value. + + ushort tcb_remmss; // MSS advertised by peer. + uchar tcb_slowcount; // Count of reasons why we're on + // the slow path. + uchar tcb_pushtimer; // The 'push' timer. + + // State information. + uchar tcb_state; // State of this TCB. + uchar tcb_rexmitcnt; // Count of rexmits on this TCB. + uchar tcb_pending; // Pending actions on this TCB. + uchar tcb_kacount; // Count of keep alive probes sent. + IP_STATUS tcb_error; // Last error we heard about from + // IP. + + uint tcb_rtt; // Current round trip time TS. + + ushort tcb_rexmittimer; // Timer for rexmit. + ushort tcb_delacktimer; // Timer for delayed ack. + + + uint tcb_defaultwin; // Default rcv. window. + uint tcb_alive; // Keep alive time value. + + struct TCPRAHdr *tcb_raq; // Reassembly queue. + struct TCPRcvReq *tcb_rcvhead; // Head of recv. buffer queue. + struct TCPRcvReq *tcb_rcvtail; // Tail of recv. buffer queue. + uint tcb_pendingcnt; // Bytes waiting to be received. + struct IPRcvBuf *tcb_pendhead; // Head of pending recv. queue. + struct IPRcvBuf *tcb_pendtail; // Tail of pending recv. queue. + + struct TCPConnReq *tcb_connreq; // Connection-type request for + // this connection. + void *tcb_conncontext; // Connection context for this + // connection. + + uint tcb_bcountlow; // Low part of byte count. + uint tcb_bcounthi; // High part of bytecount. + uint tcb_totaltime; // Total number of ticks spent + // sending. + struct TCB *tcb_aonext; // Next pointer on AddrObj. + struct TCPConn *tcb_conn; // Back pointer to conn for TCB. + Queue tcb_delayq; // Queue linkage for delay queue. + uchar tcb_closereason; // Reason we're closing. + uchar tcb_bhprobecnt; // BH probe count. + ushort tcb_swstimer; // Timer for SWS override. + void *tcb_rcvind; // Receive indication handler. + void *tcb_ricontext; // Receive indication context. + // Miscellaneous info, for IP. + IPOptInfo tcb_opt; // Option information. + RouteCacheEntry *tcb_rce; // RCE for this connection. + struct TCPConnReq *tcb_discwait; // Disc-Wait req., if there is one. + struct TCPRcvReq *tcb_exprcv; // Head of expedited recv. buffer + // queue. + struct IPRcvBuf *tcb_urgpending; // Urgent data queue. + uint tcb_urgcnt; // Byte count of data on urgent q. + uint tcb_urgind; // Urgent bytes indicated. + SeqNum tcb_urgstart; // Start of urgent data. + SeqNum tcb_urgend; // End of urgent data. + uint tcb_walkcount; // Count of number of people + // 'walking' this TCB. +#if FAST_RETRANSMIT + ushort tcb_dup; // For Fast recovery algorithm + ushort tcb_force; // Force next send after fast send +#endif + +}; + +//* Definitions for TCP states. +#define TCB_CLOSED 0 // Closed. +#define TCB_LISTEN 1 // Listening. +#define TCB_SYN_SENT 2 // SYN Sent. +#define TCB_SYN_RCVD 3 // SYN received. +#define TCB_ESTAB 4 // Established. +#define TCB_FIN_WAIT1 5 // FIN-WAIT-1 +#define TCB_FIN_WAIT2 6 // FIN-WAIT-2 +#define TCB_CLOSE_WAIT 7 // Close waiting. +#define TCB_CLOSING 8 // Closing state. +#define TCB_LAST_ACK 9 // Last ack state. +#define TCB_TIME_WAIT 10 // Time wait state. + +typedef struct TCB TCB; + +#define SYNC_STATE(s) ((s) > TCB_SYN_RCVD) +#define GRACEFUL_CLOSED_STATE(s) ((s) >= TCB_LAST_ACK) +#define DATA_RCV_STATE(s) ((s) >= TCB_ESTAB && (s) <= TCB_FIN_WAIT2) +#define DATA_SEND_STATE(s) ((s) == TCB_ESTAB || (s) == TCB_CLOSE_WAIT) + +//* Definitions for flags. +#define WINDOW_SET 0x00000001 // Window explictly set. +#define CLIENT_OPTIONS 0x00000002 // Have client IP options on conn. +#define CONN_ACCEPTED 0x00000004 // Connection was accepted. +#define ACTIVE_OPEN 0x00000008 // Connection came from an active + // open. +#define DISC_NOTIFIED 0x00000010 // Client has been notified of a + // disconnect. +#define IN_DELAY_Q 0x00000020 // We're in the delayed action Q. +#define RCV_CMPLTING 0x00000040 // We're completeing rcvs. +#define IN_RCV_IND 0x00000080 // We're calling a rcv. indicate + // handler. +#define NEED_RCV_CMPLT 0x00000100 // We need to have recvs. completed. +#define NEED_ACK 0x00000200 // We need to send an ACK. +#define NEED_OUTPUT 0x00000400 // We need to output. + +#define DELAYED_FLAGS (NEED_RCV_CMPLT | NEED_ACK | NEED_OUTPUT) + + +#define ACK_DELAYED 0x00000800 // We've delayed sending an ACK. + +#define PMTU_BH_PROBE 0x00001000 // We're probing for a PMTU BH. +#define BSD_URGENT 0x00002000 // We're using BSD urgent semantics. +#define IN_DELIV_URG 0x00004000 // We're in the DeliverUrgent routine. +#define URG_VALID 0x00008000 // We've seen urgent data, and + // the urgent data fields are valid. + +#define FIN_NEEDED 0x00010000 // We need to send a FIN. +#define NAGLING 0x00020000 // We are using Nagle's algorithm. +#define IN_TCP_SEND 0x00040000 // We're in TCPSend. +#define FLOW_CNTLD 0x00080000 // We've received a zero window + // from our peer. +#define DISC_PENDING 0x00100000 // A disconnect notification is + // pending. +#define TW_PENDING 0x00200000 // We're waiting to finish going + // to TIME-WAIT. +#define FORCE_OUTPUT 0x00400000 // Output is being forced. +#define FORCE_OUT_SHIFT 22 // Shift to get FORCE_OUTPUT into + // low bit. +#define SEND_AFTER_RCV 0x00800000 // We need to send after we get out + // of recv. +#define GC_PENDING 0x01000000 // A graceful close is pending. +#define KEEPALIVE 0x02000000 // Doing keepalives on this TCB. +#define URG_INLINE 0x04000000 // Urgent data to be processed + // inline. + +#ifdef RASAUTODIAL +#define ACD_CONN_NOTIF 0x08000000 // inform automatic connection + // driver about this connection +#endif // RASAUTODIAL + +#define FIN_OUTSTANDING 0x10000000 // We've sent a FIN 'recently', i.e. + // since the last retransmit. When + // this flag is set sendnext == + // sendmax. + +#define FIN_OUTS_SHIFT 28 // Shift to FIN_OUTSTANDING bit into + // low bit. +#define FIN_SENT 0x20000000 // We've sent a FIN that hasn't + // been acknowledged. Once this + // bit has been turned on in + // FIN-WAIT-1 the sequence number + // of the FIN will be sendmax-1. +#define NEED_RST 0x40000000 // We need to send a RST when + // closing. +#define IN_TCB_TABLE 0x80000000 // TCB is in the TCB table. + +//* The defintion of the 'slow flags'. If any of these flags are set we'll +// be forced off of the fast path. + +#define TCP_SLOW_FLAGS (URG_VALID | FLOW_CNTLD | GC_PENDING | \ + TW_PENDING | DISC_NOTIFIED | IN_DELIV_URG | \ + FIN_NEEDED | FIN_SENT | FIN_OUTSTANDING | \ + DISC_PENDING | PMTU_BH_PROBE) + +//* Close reasons. +#define TCB_CLOSE_RST 0x80 // Received a RST segment. +#define TCB_CLOSE_ABORTED 0x40 // Had a local abort. +#define TCB_CLOSE_TIMEOUT 0x20 // Connection timed out. +#define TCB_CLOSE_REFUSED 0x10 // Connect attempt was refused. +#define TCB_CLOSE_UNREACH 0x08 // Remote destination unreachable. +#define TCB_CLOSE_SUCCESS 0x01 // Successfull close. + +//* TCB Timer macros. +#define START_TCB_TIMER(t, v) (t) = (v) +#define STOP_TCB_TIMER(t) (t) = 0 +#define TCB_TIMER_RUNNING(t) ((t) != 0) + +// Macro to compute retransmit timeout. +#define REXMIT_TO(t) ((((t)->tcb_smrtt >> 2) + (t)->tcb_delta) >> 1) + +//* Definitons for pending actions. We define a PENDING_ACTION macro +// that can be used to decide whether or not we can proceed with an +// activity. The only pending action we really care about is DELETE - others +// are low priority and can be put off. +#define PENDING_ACTION(t) ((t)->tcb_pending & DEL_PENDING) +#define DEL_PENDING 0x01 // Delete is pending. +#define OPT_PENDING 0x02 // Option set is pending. + +//* Macro to see if a TCB is closing. +#define CLOSING(t) ((t)->tcb_pending & DEL_PENDING) + +//* Structure of a TCP packet header. + +struct TCPHeader { + ushort tcp_src; // Source port. + ushort tcp_dest; // Destination port. + SeqNum tcp_seq; // Sequence number. + SeqNum tcp_ack; // Ack number. + ushort tcp_flags; // Flags and data offset. + ushort tcp_window; // Window offered. + ushort tcp_xsum; // Checksum. + ushort tcp_urgent; // Urgent pointer. +}; + +typedef struct TCPHeader TCPHeader; + +//* Definitions for header flags. +#define TCP_FLAG_FIN 0x00000100 +#define TCP_FLAG_SYN 0x00000200 +#define TCP_FLAG_RST 0x00000400 +#define TCP_FLAG_PUSH 0x00000800 +#define TCP_FLAG_ACK 0x00001000 +#define TCP_FLAG_URG 0x00002000 + +#define TCP_FLAGS_ALL (TCP_FLAG_FIN | TCP_FLAG_SYN | TCP_FLAG_RST | \ + TCP_FLAG_ACK | TCP_FLAG_URG) + +//* Flags in the tcb_fastchk field that are not in the TCP header proper. +// Setting these flags forces us off the fast path. +#define TCP_FLAG_SLOW 0x00000001 // Need to be on slow path. +#define TCP_FLAG_IN_RCV 0x00000002 // In recv. path already. + +#if FAST_RETRANSMIT +#define TCP_FLAG_FASTREC 0x00000004 // This is used to mark tcb +#endif // when Fast retransmit is in progress + // Debugging purpose only + +#define TCP_OFFSET_MASK 0xf0 +#define TCP_HDR_SIZE(t) (uint)(((*(uchar *)&(t)->tcp_flags) & TCP_OFFSET_MASK) >> 2) + +#define MAKE_TCP_FLAGS(o, f) ((f) | ((o) << 4)) + +#define TCP_OPT_EOL 0 +#define TCP_OPT_NOP 1 +#define TCP_OPT_MSS 2 +#define MSS_OPT_SIZE 4 + +//* Convenient byte swapped structure for receives. +struct TCPRcvInfo { + SeqNum tri_seq; // Sequence number. + SeqNum tri_ack; // Ack number. + uint tri_window; // Window. + uint tri_urgent; // Urgent pointer. + uint tri_flags; // Flags. +}; + +typedef struct TCPRcvInfo TCPRcvInfo; + + + +//* General structure, at the start of all command specific request structures. + +#define tr_signature 0x20205254 // 'TR ' + +struct TCPReq { +#ifdef DEBUG + ulong tr_sig; +#endif + struct Queue tr_q; // Q linkage. + CTEReqCmpltRtn tr_rtn; // Completion routine. + PVOID tr_context; // User context. + int tr_status; // Final complete status. +}; + +typedef struct TCPReq TCPReq; + + +#ifdef NT + +#ifdef POOL_TAGGING + +#ifdef ExAllocatePool +#undef ExAllocatePool +#endif + +#define ExAllocatePool(type, size) ExAllocatePoolWithTag(type, size, 'tPCT') + +#ifndef CTEAllocMem +#error "CTEAllocMem is not already defined - will override tagging" +#else +#undef CTEAllocMem +#endif + +#define CTEAllocMem(size) ExAllocatePoolWithTag(NonPagedPool, size, 'tPCT') + +#endif // POOL_TAGGING + +// +// TCP endpoint context structure allocated for each open of TCP/UDP. +// A pointer to this structure is stored in FileObject->FsContext. +// +typedef struct _TCP_CONTEXT { + union { + HANDLE AddressHandle; + CONNECTION_CONTEXT ConnectionContext; + HANDLE ControlChannel; + } Handle; + ULONG ReferenceCount; + BOOLEAN CancelIrps; +#if DBG + LIST_ENTRY PendingIrpList; + LIST_ENTRY CancelledIrpList; +#endif + KEVENT CleanupEvent; +} TCP_CONTEXT, *PTCP_CONTEXT; + +#endif // NT + + +#include "tcpdeb.h" + +#endif // _TCP_INCLUDED_ + + |