windows-server-2003/multimedia/directx/dplay/dplay8/protocol/dnprot.h

/*==========================================================================
 *
 *  Copyright (C) 1998-2002 Microsoft Corporation.  All Rights Reserved.
 *
 *  File:		DnProt.h
 *  Content:	This file contains structure definitions for the Direct Net protocol
 *
 *  History:
 *   Date		By		Reason
 *   ====		==		======
 *  11/06/98	ejs		Created
 *  07/01/2000  masonb  Assumed Ownership
 *
 ****************************************************************************/

#ifndef	_DNPROT_INCLUDED_
#define	_DNPROT_INCLUDED_


#define	VOL		volatile
/*
**		Internal Constants
*/

//frames come in 1 of 2 forms, either data frames or cframes. 

//cframes
//cframes come in 3 different sizes.
//connect, connected and hard disconnect are all just a single CFRAME header. If the link is signed then hard disconnect frames
//will also be followed by a signature value. On the wire these therefore look like:
//<CFRAME header><optional signature (8 bytes)>
//connected_signed frames extend the standard CFRAME with a fixed number of additional members. On the wire these frames look like:
//<CFRAME_CONNECTEDSIGNED header>
//sackframes have a fixed initial header and then between 0 and 4 ULONG values giving sack/send masks. If they're sent over
//a signed link they also have a signature value appended. On the wire these frames look like:
//<SACKFRAME header><optional sack/send masks (0 to 16 bytes)><optional signature (8 bytes)>

//These define the largest possible size of header for each cframe type
#define 		MAX_SEND_CFRAME_STANDARD_HEADER_SIZE					(sizeof(CFRAME)+sizeof(ULONGLONG))
#define		MAX_SEND_CFRAME_CONNECTEDSIGNED_HEADER_SIZE			(sizeof(CFRAME_CONNECTEDSIGNED))
#define		MAX_SEND_CFRAME_SACKFRAME_HEADER_SIZE				(sizeof(SACKFRAME8)+sizeof(ULONG)*4+sizeof(ULONGLONG))

//These respectively define the size of the smallest and largest possible cframe header
#define		MIN_SEND_CFRAME_HEADER_SIZE					(_MIN(sizeof(SACKFRAME8), _MIN(sizeof(CFRAME), sizeof(CFRAME_CONNECTEDSIGNED))))
#define		MAX_SEND_CFRAME_HEADER_SIZE					(_MAX(MAX_SEND_CFRAME_CONNECTEDSIGNED_HEADER_SIZE, _MAX(MAX_SEND_CFRAME_STANDARD_HEADER_SIZE, MAX_SEND_CFRAME_SACKFRAME_HEADER_SIZE)))

//dframes
//All dframes have a single fixed initial header (DFRAME). Depending on the data encapsulated there may be a number of additional
//variable length data blocks following this.
//Firstly, there may be 0 to 4 ULONG values giving sack/send masks. The presence or absence of these is determined by
//the PACKET_CONTROL_SACK_MASK1/2 and PACKET_CONTROL_SEND_MASK1/2 bit flags within the bControl member of the DFRAME header
//For a non-coalesced data message, there may then follow a signature (for signed links), followed by all the use data.
//Hence, the packet on the wire looks like:
//<DFRAME header><optional sack/send masks (0 to 16 bytes)><optional signature (8 bytes)><user data>
//A coalesced data message is identified by the PACKET_CONTROL_COALESCE bit flag being set in the bControl member of the DFRAME header
//For a coalesced data message, following the optional masks is an optional signature field (for a signed link). After this 
//is a set of coalesce headers. There are between 2 and MAX_USER_BUFFERS_IN_FRAME of these. Finally, at the end of the frame
//is the coalesced user data. If necessary padding is inserted before and between the user data to ensure each block of user data 
//is DWORD aligned. 
//Hence, on the wire a coalesced data packet looks like:
//<DFRAME header><optional sack/send masks (0 to 16 bytes)><optional signature (8 bytes)><coalesce header (2 bytes)>
//				<coalesce header (2 bytes)>.......<padding (0 or 2 bytes)><user data><padding (0 to 3 bytes)><user data>........
//Finally, a dframe may be a keep alive, and not contain any user data at all. These frames are identified by the PACKET_CONTROL_KEEPALIVE
//flag being flipped on in the frames bControl field. A keep alive contains the optional sack/send masks, a signature if the link is signed
//and the session identity.
//On the wire a keep alive packet looks like:
//<DFRAME header><optional sack/send masks (0 to 16 bytes)><optional signature (8 bytes)><session identity (4 bytes)>

//This defines the maximum number of user buffers we can send in a coalesced dframe
#define		MAX_USER_BUFFERS_IN_FRAME						32			// this number * sizeof(COALESCEHEADER) should stay DWORD aligned 
//This defines the maximum size of a user buffer than can be placed in a coalesced message
//Anything larger than this can't be coalesced. For most SPs (i.e. IP) since we use an MTU smaller than this, we never
//get close to reaching this value anyway
#define		MAX_COALESCE_SIZE								2047		// 1 byte + 3 bits = 11 bits worth of data

//These define the largest possible size of header for each dframe  type
#define		MAX_SEND_DFRAME_NOCOALESCE_HEADER_SIZE		(sizeof(DFRAME)+sizeof(ULONG)*4+sizeof(ULONGLONG))
#define		MAX_SEND_DFRAME_COALESCE_HEADER_SIZE			(sizeof(DFRAME)+sizeof(ULONG)*4+(MAX_USER_BUFFERS_IN_FRAME * sizeof(COALESCEHEADER))+(MAX_USER_BUFFERS_IN_FRAME * 3)+sizeof(ULONGLONG))
#define		MAX_SEND_DFRAME_KEEPALIVE_HEADER_SIZE			(sizeof(DFRAME)+sizeof(ULONG)*4+sizeof(ULONG)+sizeof(ULONGLONG))

//These respectively define the size of the smallest and the largest possible dframe header.
#define 		MIN_SEND_DFRAME_HEADER_SIZE					(sizeof(DFRAME))
#define		MAX_SEND_DFRAME_HEADER_SIZE					(_MAX(MAX_SEND_DFRAME_NOCOALESCE_HEADER_SIZE, _MAX(MAX_SEND_DFRAME_COALESCE_HEADER_SIZE, MAX_SEND_DFRAME_KEEPALIVE_HEADER_SIZE)))



//This defines the largest protocol header we can create.
//Its the largest value out of the biggest possible cframe header and the biggest possible dframe header
#define		MAX_SEND_HEADER_SIZE							(_MAX(MAX_SEND_DFRAME_HEADER_SIZE, MAX_SEND_CFRAME_HEADER_SIZE))

//We must be able to send our largest cframe as a single packet and a keep alive as a single packet
//N.B. since a keep alive is a standard DFRAME with a 4 byte payload this also guarantees we can send a none coalesced dframe
#define		MIN_SEND_MTU									(_MAX(MAX_SEND_CFRAME_HEADER_SIZE, MAX_SEND_DFRAME_KEEPALIVE_HEADER_SIZE))

#define		SMALL_BUFFER_SIZE								(1024 * 2)
#define		MEDIUM_BUFFER_SIZE								(1024 * 4)
#define		LARGE_BUFFER_SIZE								(1024 * 16)


/*
**		Signatures for data structures
*/

#define		PPD_SIGN		' DPP'					// Protocol Data
#define		SPD_SIGN		' DPS'					// Service Provider Descriptor
#define		EPD_SIGN		' DPE'					// End Point Descriptor
#define		MSD_SIGN		' DSM'					// Message Descriptor
#define		FMD_SIGN		' DMF'					// Frame Descriptor
#define		RCD_SIGN		' DCR'					// Receive Descriptor

/*
**		Internal Data Structures
**
*/

typedef	struct	protocoldata	ProtocolData, *PProtocolData;
typedef struct	spdesc			SPD, *PSPD;
typedef	struct	endpointdesc 	EPD, *PEPD;
typedef struct	checkptdata		CHKPT, *PCHKPT;
typedef struct	messagedesc 	MSD, *PMSD;
typedef struct	framedesc		FMD, *PFMD;
typedef struct	recvdesc		RCD, *PRCD;

typedef struct _DN_PROTOCOL_INTERFACE_VTBL DN_PROTOCOL_INTERFACE_VTBL, *PDN_PROTOCOL_INTERFACE_VTBL;

/*	
**	Protocol Data
**
**		This structure contains all of the global state information for the
**	operating protocol.  It is grouped into a structure for (in)convenience
**	against the unlikely possibility that we ever need to run multiple instances
**	out of the same code.
*/


#define		PFLAGS_PROTOCOL_INITIALIZED			0x00000001
#define		PFLAGS_FAIL_SCHEDULE_TIMER			0x00000002	//DEBUG flag. Allows scheduling of timers to be failed

struct protocoldata 
{
	ULONG							ulProtocolFlags;	// State info about DN protocol
	PVOID							Parent;				// Direct Play Object
	UINT							Sign;
	LONG							lSPActiveCount;		// Number of SPs currently bound to protocol

	DWORD							tIdleThreshhold;	// How long will we allow a link to be idle before Checkpointing
	
	DWORD							dwConnectTimeout;	// These two parameter control new connection commands
	DWORD							dwConnectRetries;

	DWORD							dwMaxRecvMsgSize;			//largest message we accept on a receive
	DWORD							dwSendRetriesToDropLink;		//number of send retry attempts before
																//we decide link has died
	DWORD							dwSendRetryIntervalLimit;		//limit for the period between send retries
	
	DWORD							dwDropThresholdRate;			// Percentage of frames allowed to drop before throttling
	DWORD							dwDropThreshold;				// Actual number of frames allowed to drop before throttling
	DWORD							dwThrottleRate;				// Percentage backoff when throttling
	FLOAT							fThrottleRate;					// Actual backoff when throttling (0.0 - 1.0)
	DWORD							dwNumHardDisconnectSends;	// Number of hard disconnect frames sent when hard closing
	DWORD							dwMaxHardDisconnectPeriod;	// Maximum period between hard disconnect sends
	DWORD							dwInitialFrameWindowSize;		// Size of the initial frame window for a connection

	PDN_PROTOCOL_INTERFACE_VTBL		pfVtbl;				// Table of indication entry points in CORE

	IDirectPlay8ThreadPoolWork		*pDPThreadPoolWork;	// Pointer to thread pool interface

#ifdef DBG
	// For Debugging we will track the total number of receives outstanding in the higher layers
	// at all times.
	long ThreadsInReceive;
	long BuffersInReceive;
#endif // DBG
};

/*
**	Service Provider Descriptor
**
**		This structure describes a Service Provider that we are bound to.  It
**	contains at a minimum the vector table to call the SP,  and the SPID that
**	is combined with player IDs to make external DPIDs.  The SPID should also
**	be the index in the SPTable where this descriptor lives.
**
**		We will have one send thread per service provider,  so the thread handle
**	and its wait-event will live in this structure too.
**
**		Lower Edge Protocol Object
**
**		We will also use the SPD as the COM Object given to SP for our lower edge
**	interface.  This means that our Lower Vector Table must be the first field in
**	this structure,  and ref count must be second.
*/

// The following are functions that the Service Providers can call in the Protocol
extern HRESULT WINAPI DNSP_IndicateEvent(IDP8SPCallback*, SP_EVENT_TYPE, PVOID);
extern HRESULT WINAPI DNSP_CommandComplete(IDP8SPCallback*, HANDLE, HRESULT, PVOID);


#define	SPFLAGS_SEND_THREAD_SCHEDULED	0x0001	// SP has scheduled a thread to service command frames
#define	SPFLAGS_TERMINATING				0x4000	// SP is being removed

struct spdesc 
{
	IDP8SPCallbackVtbl	*LowerEdgeVtable;	// table used by this SP to call into us, MUST BE FIRST!!!
	UINT				Sign;
	ULONG				ulSPFlags;			// Flags describing this service provider
	IDP8ServiceProvider	*IISPIntf;			// ptr to SP Object
	PProtocolData		pPData;				// Ptr to owning protocol object
	UINT				uiFrameLength;		// Frame size available to us
	UINT				uiUserFrameLength;	// Frame size available to application
	UINT				uiLinkSpeed;		// Local link speed in BPS

	CBilink				blSendQueue;		// List of wire-ready packets to transmit over this SP
	CBilink				blPendingQueue;		// List of packets owned by SP - Shares Lock w/SendQ
	CBilink				blEPDActiveList;	// List of in use End Point Descriptors for this SP

#ifndef DPNBUILD_ONLYONETHREAD
	DNCRITICAL_SECTION	SPLock;			// Guard access to sendQ
#endif // !DPNBUILD_ONLYONETHREAD

#ifdef DBG
	CBilink				blMessageList;		// List of in use Message Descriptors
#endif // DBG
};

/*
**	End Point Descriptor
**
**		An 'EPD' describes a Direct Network instance that we can communicate with.
**	This structure includes all session related information, statistics,  queues,  etc.
**	It will manage any of the three types of service simultaneously.
*/

#define	EPFLAGS_END_POINT_IN_USE		0x0001	// This EndPoint is allocated

// We are always in exactly one of these 4 states
#define	EPFLAGS_STATE_DORMANT			0x0002	// Connection protocol has not yet run
#define	EPFLAGS_STATE_CONNECTING		0x0004	// Attempting to establish reliable link
#define	EPFLAGS_STATE_CONNECTED			0x0008	// Reliable link established
#define	EPFLAGS_STATE_TERMINATING		0x0010	// This end point is being closed down

#define	EPFLAGS_SP_DISCONNECTED			0x0020  // Set when the SP has called ProcessSPDisconnect

#define	EPFLAGS_IN_RECEIVE_COMPLETE		0x0040	// A thread is running in ReceiveComplete routine
#define	EPFLAGS_LINKED_TO_LISTEN		0x0080	// During CONNECT this EPD is linked into the Listen MSD's queue

#define	EPFLAGS_LINK_STABLE				0x0100	// We think we have found the best current transmit parameters
#define	EPFLAGS_STREAM_UNBLOCKED		0x0200	// Reliable traffic is stopped (window or throttle)
#define	EPFLAGS_SDATA_READY				0x0400	// Reliable traffic in the pipe
#define	EPFLAGS_IN_PIPELINE				0x0800	// Indicates that EPD is in the SPD pipeline queue

#define	EPFLAGS_CHECKPOINT_INIT			0x1000	// Need to send a check point packet
#define	EPFLAGS_DELAYED_SENDMASK		0x2000	// unacked check point on wire
#define	EPFLAGS_DELAYED_NACK			0x4000	// Need to send masks for missing receives
#define	EPFLAGS_DELAY_ACKNOWLEDGE		0x8000	// We are waiting for back-traffic before sending ACK frame

#define	EPFLAGS_KEEPALIVE_RUNNING	0x00010000	// Checkpoint is running (borrowed in debug to turn off keepalives)
#define	EPFLAGS_SENT_DISCONNECT		0x00020000	// We have sent a DISCONNECT and are waiting for confirm
#define	EPFLAGS_RECEIVED_DISCONNECT	0x00040000	// We have received a DISCONNECT and will send confirm when done sending
#define	EPFLAGS_DISCONNECT_ACKED	0x00080000	// We sent a DISCONNECT and it has been confirmed

#define	EPFLAGS_COMPLETE_SENDS		0x00100000	// There are Reliable MSDs waiting to be called back
#define	EPFLAGS_FILLED_WINDOW_BYTE	0x00200000	// Filled Byte-Based send window
#define	EPFLAGS_FILLED_WINDOW_FRAME	0x00400000	// We have filled the frame-based SendWindow at least once during last period
#ifndef DPNBUILD_NOPROTOCOLTESTITF
#define EPFLAGS_NO_DELAYED_ACKS		0x00800000	// DEBUG_FLAG -- Turn off DelayedAckTimeout
#endif // !DPNBUILD_NOPROTOCOLTESTITF

#define	EPFLAGS_ACKED_DISCONNECT	0x01000000	// Partner sent a DISCONNECT and we have confirmed it
#define	EPFLAGS_RETRIES_QUEUED		0x02000000	// Frames are waiting for retransmission
#define	EPFLAGS_THROTTLED_BACK		0x04000000	// temporary throttle is engaged to relieve congestion

#ifndef DPNBUILD_NOPROTOCOLTESTITF
#define	EPFLAGS_LINK_FROZEN				0x08000000	// DEBUG FLAG -- Do not run dynamic algorithm on this link
#endif // !DPNBUILD_NOPROTOCOLTESTITF

#define	EPFLAGS_INDICATED_DISCONNECT		0x10000000	// Ensure that we onlly call CORE once to indicate disconnection
#define	EPFLAGS_TESTING_GROWTH			0x20000000	// We are currently taking a growth sample
#define	EPFLAGS_HARD_DISCONNECT_SOURCE	0x40000000	// We're the source for a hard disconnect sequence
														// i.e. Core has instigated a hard close on this ep
#define	EPFLAGS_HARD_DISCONNECT_TARGET	0x80000000	// We're the target for a hard disconnect sequence
														// i.e. We're received a hard disconnect request from remote ep

#define	MAX_RECEIVE_RANGE			64		// largest # of frames we will retain past a missing frame
#define	MAX_FRAME_OFFSET			(MAX_RECEIVE_RANGE - 1)

	//sequence window as split into 4 quarters
#define	SEQ_WINDOW_1Q				64
#define	SEQ_WINDOW_2Q				128
#define	SEQ_WINDOW_3Q				192
#define	SEQ_WINDOW_4Q				256

#define	INITIAL_STATIC_PERIOD		(10 * 1000)		// How long does link remain static after finding set-point.
													// This value will double every time link finds the same set-point.

#ifndef DPNBUILD_NOMULTICAST
#define	EPFLAGS2_MULTICAST_SEND			0x00000001		// multicast send placeholder endpoint
#define	EPFLAGS2_MULTICAST_RECEIVE			0x00000002		// multicast receive placeholder endpoint
#endif	// DPNBUILD_NOMULTICAST
#ifndef DPNBUILD_NOPROTOCOLTESTITF
#define EPFLAGS2_DEBUG_NO_RETRIES			0x00000004
#endif // !DPNBUILD_NOPROTOCOLTESTITF
#define EPFLAGS2_NOCOALESCENCE				0x00000008    	// We are talking to an older partner and must not use coalescence
#define EPFLAGS2_KILLED						0x00000010		// Someone has removed the 'base' reference to make this go away
															// We dont want to let this happen twice...
#define EPFLAGS2_HARD_DISCONNECT_COMPLETE	0x00000020
#define EPFLAGS2_SUPPORTS_SIGNING			0x00000040		// Remote partner supports signing on packets
															// This doesn't mean packets actually are signed, it just means
															// that their protocol version would support it
#define EPFLAGS2_FAST_SIGNED_LINK			0x00000080		// Packets over link should be fast signed
#define EPFLAGS2_FULL_SIGNED_LINK			0x00000100		// Packets over link should be fully signed
#define EPFLAGS2_SIGNED_LINK					0x00000180		// Combination of both above flags


struct endpointdesc 
{
	HANDLE				hEndPt;				// Together with SP index uniquely defines an End Point we can reach
	LONG 				lRefCnt;			// Reference count
	UINT				Sign;				// Signature to validate data structure
	PSPD				pSPD;				// specifies the SP on which this remote instance lives
	ULONG VOL			ulEPFlags;			// End Point Flags
	ULONG VOL			ulEPFlags2;			// Extra endpoint flags
	PVOID				Context;			// Context value returned with all indications
	PMSD				pCommand;			// Connect or Listen command with which this end point was created or Disconnect cmd
	CBilink				blActiveLinkage;	// linkage for SPD list of active EndPoints
	CBilink				blSPLinkage;		// linkage to listen command during connect
	CBilink				blChkPtQueue;		// linkage for active CheckPoints

	UINT				uiUserFrameLength;	// Largest frame we can transmit

	UINT				uiRTT;				// Current RTT --  Integer portion
	UINT				fpRTT;				// Fixed Point 16.16 RTT
	
	UINT				uiDropCount;		// localized packet drop count (recent drops)
	DWORD				dwDropBitMask;		// bit mask of dropped frames (32 frame max)
	DWORD				tThrottleTime;		// Timestamp when last Checking occured
	UINT				uiThrottleEvents;	// count of temporary backoffs for all reasons
	
	UINT				uiAdaptAlgCount;	// Acknowledge count remaining before running adaptive algorithm
	DWORD				tLastPacket;		// Timestamp when last packet arrived
	
	UINT				uiWindowFilled;		// Count of times we fill the send window
	
	UINT				uiPeriodAcksBytes;	// frames acked since change in tuning
	UINT				uiPeriodXmitTime;	// time link has been transmitting since change in tuning
	UINT				uiPeriodRateB;
	UINT				uiPeakRateB;		// Largest sample we ever measure

	PVOID				pvHardDisconnectContext;	//The context value passed down to us when a hard disconnect has been requested
												//For a normal disconnect this is stored as part of the disconnect MSD, but since
												//we don't have one of those for a hard disconnect it has to be added here

	//Signing. We store 2 secret values for signing, the local one for us to use when signing our packets, and the remote one
	//we use to check incoming packets. The type of signing is controlled by the EPFLAGS2_FAST/FULL_SIGNED_LINK flags
	//For full signing, where we update the secret's each time the sequence space wraps, we also store the values of the old
	//secret. This is needed when we send retries (old local secret) or we received delayed incoming packets (old remote secret)

	//We also track modifier values for the secrets. These are derived from the signatures of reliable messages we've sent (for local
	//modifier) or received (for remote modifier). Each time the sequence space is wrapped we update the secrets using the modifiers
	//to prevent replay attacks

	ULONGLONG			ullCurrentLocalSecret;
	ULONGLONG			ullOldLocalSecret;
	ULONGLONG			ullCurrentRemoteSecret;
	ULONGLONG			ullOldRemoteSecret;

	ULONGLONG			ullLocalSecretModifier;
	ULONGLONG			ullRemoteSecretModifier;
	BYTE				byLocalSecretModifierSeqNum;
	BYTE				byRemoteSecretModifierSeqNum;
	
	// While we are in DYNAMIC state we want to remember stats from our previous xmit parameters,  at this
	// point that means RTT and AvgSendRate.  This lets us compare the measurements at our new rate so we can
	// ensure that thruput increases with sendrate,  and that RTT is not growing out of proportion.
	//
	//   If either thru-put stops improving or RTT grows unreasonably then we can plateau our xmit parameters
	// and transition to STABLE state.

	UINT				uiLastRateB;
	UINT				uiLastBytesAcked;
	DWORD				tLastThruPutSample;

	// Connection State		-	 State of reliable connection
	//
	//	Send Queuing is getting somewhat complex.  Let me spell it out in Anglish.
	//
	//	blXPriSendQ		is the list of MSDs awaiting shipment (and being shipped)
	//	CurrentSend		pts to the MSD we are currently pulling frames out of.
	//  CurrentFrame 	pts to the next FMD that we will put on the wire.
	//	blSendWindow	is a bilinked list of transmitted but unacknowledged frames.  This list may span multi MSDs
	//
	//	WindowF			is our current MAX window size expressed in frames
	//	WindowB			is our current MAX window size expressed in bytes
	//
	//	UnAckedFrames	is the count of unacknowledged frames on the wire (actual window size)
	//	UnAckedBytes	is the count of unacknowledged bytes on the wire

	DWORD				uiQueuedMessageCount;	// How many MSDs are waiting on all three send queues

	CBilink				blHighPriSendQ;		// These are now mixed Reliable and Datagram traffic
	CBilink				blNormPriSendQ;
	CBilink				blLowPriSendQ;
	CBilink				blCompleteSendList;	// Reliable messages completed and awaiting indication to user

	DWORD				dwSessID;			// Session ID so we can detect re-started links
	PMSD				pCurrentSend;		// Head of queue is lead edge of window.  window can span multiple frames.
	PFMD				pCurrentFrame;		// frame currently transmitting. this will be trailing edge of window
	CBilink				blSendWindow;
	CBilink				blRetryQueue;		// Packets waiting for re-transmission

	//		Lost Packet Lists
	//
	//		When we need to retry a packet and we discover that it is not reliable,  then we need to inform partner
	//	that he can stop waiting for the data.  We will piggyback this info on another frame if possible

	//		Current Transmit Parameters:
	
	UINT				uiWindowF;			// window size (frames)
	UINT				uiWindowB;			// window size (bytes)
	UINT				uiWindowBIndex;		// index (scaler) for byte-based window
	UINT				uiUnackedFrames;	// outstanding frame count
	UINT				uiUnackedBytes;		// outstanding byte count

	UINT				uiBurstGap;			// number of ms to wait between bursts
	INT					iBurstCredit;		// Either credit or deficit from previous Transmit Burst

	// 		Last Known Good Transmit Parameters --  Values which we believe are safe...

	UINT				uiGoodWindowF;
	UINT				uiGoodWindowBI;
	UINT				uiGoodBurstGap;
	UINT				uiGoodRTT;
	
	UINT				uiRestoreWindowF;
	UINT				uiRestoreWindowBI;
	UINT				uiRestoreBurstGap;
	DWORD				tLastDelta;			// Timestamp when we last modified xmit parms

	// 		Reliable Link State

	BYTE VOL			bNextSend;			// Next serial number to assign
	BYTE VOL			bNextReceive;		// Next frame serial we expect to receive

	// Group BYTE members for good packing
	BYTE VOL			bNextMsgID;			// Next ID for datagram frames ! NOW USED FOR CFRAMES ONLY
	BYTE				bLastDataRetry;		// Retry count on frame N(R) - 1

	BYTE				bHighestAck;		// The highest sequence number that has been ACK'd.  This may not be the first frame in the SendWindow due to masks.

	//	The following fields are all for tracking reliable receives

	//  The next two fields allow us to return more state with every ACK packet.  Since each ack explicitly
	// names one frame,  the highest in-sequenced packet received so far,  we want to remember the arrival time
	// and the Retry count of this packet so we can report it in each ACK.  It will be the transmitter's
	// responsibility to ensure that a single data-point never gets processed more then once,  skewing our calcs.
	
	DWORD				tLastDataFrame;		// Timestamp from the arrival of N(R) - 1

	ULONG				ulReceiveMask;		// mask representing first 32 frames in our rcv window
	ULONG				ulReceiveMask2;		// second 32 frames in our window
	DWORD				tReceiveMaskDelta;	// timestamp when a new bit was last set in ReceiveMask (full 64-bit mask)

	ULONG				ulSendMask;			// mask representing unreliable send frames that have timed out and need
	ULONG				ulSendMask2;		// to be reported to receiver as missing.

	PRCD				pNewMessage;		// singly linked list of message elements
	PRCD				pNewTail;			// tail pointer for singly linked list of msg elements
	CBilink				blOddFrameList;		// Out Of Order frames
	CBilink				blCompleteList;		// List of MESSAGES ready to be indicated
	UINT				uiCompleteMsgCount;	// Count of messages on the CompleteList

	PVOID				SendTimer;			// Timer for next send-burst opportunity
	UINT				SendTimerUnique;

	UINT				uiNumRetriesRemaining;	// This  is used during CONNECT and HARD_DISCONNECT processing
												//to track how many more times we should retry either the connect or 
												//hard disconnect
	UINT				uiRetryTimeout;		// Current T1 timer value
	
	PVOID				LinkTimer;		// Used to generate timer events when link is connecting and hard disconnecting
	UINT				LinkTimerUnique;
	
	PVOID				RetryTimer;			// window to receive Ack
	UINT				RetryTimerUnique;	
	
	PVOID				DelayedAckTimer;	// wait for piggyback opportunity before sending Ack
	UINT				DelayedAckTimerUnique;

	PVOID				DelayedMaskTimer;	// wait for piggyback opportunity before sending
	UINT				DelayedMaskTimerUnique;
	
	PVOID				BGTimer;			// Periodic background timer
	UINT				BGTimerUnique;		// serial for background timer

	UINT				uiBytesAcked;
	
	//	Link statistics
	//
	//	All of the following stuff is calculated and stored here for the purpose of reporting in the ConnectionInfo structure
	
	UINT 				uiMsgSentHigh;
	UINT 				uiMsgSentNorm;
	UINT 				uiMsgSentLow;
	UINT 				uiMsgTOHigh;
	UINT 				uiMsgTONorm;
	UINT 				uiMsgTOLow;
	
	UINT 				uiMessagesReceived;

	UINT				uiGuaranteedFramesSent;
	UINT				uiGuaranteedBytesSent;
	UINT				uiDatagramFramesSent;
	UINT				uiDatagramBytesSent;

	UINT				uiGuaranteedFramesReceived;
	UINT				uiGuaranteedBytesReceived;
	UINT				uiDatagramFramesReceived;
	UINT				uiDatagramBytesReceived;

	UINT				uiDatagramFramesDropped;	// datagram frame we failed to  deliver
	UINT				uiDatagramBytesDropped;		// datagram bytes we didnt deliver
	UINT				uiGuaranteedFramesDropped;
	UINT				uiGuaranteedBytesDropped;

#ifndef DPNBUILD_ONLYONETHREAD
	DNCRITICAL_SECTION	EPLock;				// Serialize all access to Endpoint
#endif // !DPNBUILD_ONLYONETHREAD

#ifdef DBG
	UINT				uiTotalThrottleEvents;
	BYTE				bLastDataSeq;		// for DEBUG porpoises
	CHAR				LastPacket[MAX_SEND_HEADER_SIZE + 4]; 	// record first portion of last packet received on EPD
#endif // DBG
};

/*
**		Check Point Data
**
**		Keeps track of local-end info about a checkpoint in-progress.
*/

struct checkptdata 
{
	CBilink			blLinkage;				// Linkage for list of CPs on an EndPoint
	DWORD			tTimestamp;				// Local time at start of checkpoint
	UCHAR			bMsgID;					// Msg ID expected in CP response
};

/*
**	Descriptor IDs
**
**		Any Descriptor that may be submitted to an SP as a context must have
**	a field which allows us to determine which structure is returned in a
**	completion call.  This field must obviously be in a uniform place in all
**	structures,  and could be expanded to be a command specifier as well.
**	Done!  Lets call it a command ID.
*/

typedef enum CommandID 
{
	COMMAND_ID_NONE,
	COMMAND_ID_SEND_RELIABLE,
	COMMAND_ID_SEND_DATAGRAM,
	COMMAND_ID_SEND_COALESCE,
	COMMAND_ID_CONNECT,
	COMMAND_ID_LISTEN,
	COMMAND_ID_ENUM,
	COMMAND_ID_ENUMRESP,
	COMMAND_ID_DISCONNECT,
	COMMAND_ID_DISC_RESPONSE,
	COMMAND_ID_CFRAME,
	COMMAND_ID_KEEPALIVE,
	COMMAND_ID_COPIED_RETRY,
	COMMAND_ID_COPIED_RETRY_COALESCE,
#ifndef DPNBUILD_NOMULTICAST
	COMMAND_ID_LISTEN_MULTICAST,
	COMMAND_ID_CONNECT_MULTICAST_SEND,
	COMMAND_ID_CONNECT_MULTICAST_RECEIVE,
#endif	// DPNBUILD_NOMULTICAST
} COMMANDID;


/*	Message Descriptor
**
**		An 'MSD' describes a message being sent or received by the protocol.  It keeps track
**	of the message elements, tracking which have been sent/received/acknowledged.
*/

//	Flags ONE field is protected by the MSD->CommandLock

#define		MFLAGS_ONE_IN_USE					0x0001
#define		MFLAGS_ONE_IN_SERVICE_PROVIDER	0x0002	// This MSD is inside an SP call
#define		MFLAGS_ONE_CANCELLED				0x0004	// command was cancelled while owned by SP
#define		MFLAGS_ONE_TIMEDOUT				0x0008	// sends only: timed out while event was scheduled
#define		MFLAGS_ONE_COMPLETE				0x0010	// connect only: operation is complete and indicated to Core
#define		MFLAGS_ONE_FAST_SIGNED				0x0020	// listen only. Links should be established with fast signing
#define		MFLAGS_ONE_FULL_SIGNED				0x0040	// listen only. Links should be established with full signing													
#define		MFLAGS_ONE_SIGNED					(MFLAGS_ONE_FULL_SIGNED |MFLAGS_ONE_FAST_SIGNED) 	
														// combination of above two flags. Allows to check for signing easily
#ifdef DBG
#define		MFLAGS_ONE_COMPLETED_TO_CORE	0x4000
#define		MFLAGS_ONE_ON_GLOBAL_LIST		0x8000
#endif // DBG

// Flags TWO field is protected by the EPD->EPLock

#define		MFLAGS_TWO_TRANSMITTING			0x0001
#define		MFLAGS_TWO_SEND_COMPLETE		0x0002	// send command completed
#define		MFLAGS_TWO_ABORT				0x0004	// Send/Disconnect has been aborted. Do no further processing
#define		MFLAGS_TWO_END_OF_STREAM		0x0008	// This MSD is an EOS frame. Could be a user cmd or a response
#define		MFLAGS_TWO_KEEPALIVE			0x0010	// This MSD is an empty frame to exercise the reliable engine
#define		MFLAGS_TWO_ABORT_WILL_COMPLETE	0x0020	// AbortSendsOnConnection intends to complete this to the core, other functions can clear it

#ifdef DBG
#define		MFLAGS_TWO_ENQUEUED				0x1000	// This MSD is on one of the EPD SendQs
#endif // DBG

#pragma TODO(simonpow, "Should union some members of the structure below to share memory between those used in sends, connects and listen")

struct messagedesc 
{
	COMMANDID			CommandID;				// THIS MUST BE FIRST FIELD
	LONG				lRefCnt;				// Reference count
	UINT				Sign;					// Signature
	ULONG VOL			ulMsgFlags1;			// State info serialized by MSD->CommandLock
	ULONG VOL			ulMsgFlags2;			// State info serialized by EPD->EPLock
	PEPD				pEPD;					// Destination End Point
	PSPD				pSPD;					// SP fielding this command
	PVOID				Context;				// User provided context value
	ULONG VOL			ulSendFlags;			// Flags submitted by User in send call
	INT					iMsgLength;				// Total length of user data
	UINT VOL			uiFrameCount;			// Number of frames needed to xmit data, protected by EPLock for reliables
	CBilink				blFrameList;			// List of frames to transport this message, or for a Listen, endpoints that are connecting
	CBilink				blQLinkage;				// linkage for various sendQs
	CBilink				blSPLinkage;			// linkage for SP command list, protected by SP->SPLock

	HANDLE				hCommand;				// handle when submitted to SP (used for connect & listen)
	DWORD				dwCommandDesc;			// Descriptor associated with hCommand
	HANDLE				hListenEndpoint;
	
	PVOID				TimeoutTimer;
	UINT				TimeoutTimerUnique;

		//used for listen commands when signing is enabled
		//we periodically change the connect secret and hence have to keep the last one in case
		//an incoming connection straddles this change
	ULONGLONG			ullCurrentConnectSecret;
	ULONGLONG			ullLastConnectSecret;
	DWORD				dwTimeConnectSecretChanged;

#ifndef DPNBUILD_ONLYONETHREAD
	DNCRITICAL_SECTION		CommandLock;
#endif // !DPNBUILD_ONLYONETHREAD

#ifdef DBG
	CCallStack			CallStackCoreCompletion;
#endif // DBG
};

/*
**		Frame Descriptor
**
**		There are two non-obvious things about the FMD structure.  First is that the built-in Buffer Descriptor array
**	has two elements defined in front of it.  The first element,  Reserved1 and Reserved2 are present to allow the Service
**	Provider to pre-pend a header buffer,  and the second element,  ImmediateLength and ImmediatePointer are for this
**	protocol to prepend its header.  The ImmediatePointer is initialized to point to the ImmediateData field.
**
**		The second thing is that the ulFFlags field is serialized with the ENDPOINTLOCK of the EPD which this frame is linked to.
**	This is good because every time the FFlags fields is modified we have already taken the EPLock already.  The exception to this
**	rule is when we are initializing the FMD.  In this case the FMD has not been loosed on the world yet so there cannot be any
**	contention for it.  We have seperated out the one flag,  FRAME_SUBMITTED, into its own BOOL variable because this one is
**	protected by the SP's SPLock,  and like the EPLock above,  it is already claimed when this flag gets modified.
*/

//#define		FFLAGS_IN_USE				0x0001
#define		FFLAGS_TRANSMITTED			0x0002
#define		FFLAGS_END_OF_MESSAGE		0x0004
#define		FFLAGS_END_OF_STREAM		0x0008

//#define		FFLAGS_FRAME_SUBMITTED		0x0010	// SP Currently owns this frame
#define		FFLAGS_RETRY_TIMER_SET		0x0020	// Just what it sounds like
//#define		FFLAGS_NACK_RETRANSMIT_SENT	0x0040	// We sent a NACK initiated retry.
#define		FFLAGS_IN_SEND_WINDOW		0x0080	// This reliable frame has been transmitted and is waiting for Ack

#define		FFLAGS_CHECKPOINT			0x0100	// We are asking for a response
//#define		FFLAGS_KEEPALIVE			0x0200
//#define		FFLAGS_ACKED_BY_MASK		0x0400	// This has been acked out-of-order so its still in the SendWindow
#define		FFLAGS_RETRY_QUEUED			0x0800	// Frame currently sitting on the retry queue


//#define		FFLAGS_NEW_MESSAGE			0x00010000
#define		FFLAGS_RELIABLE					0x00020000
//#define		FFLAGS_SEQUENTIAL			0x00040000
#define		FFLAGS_FINAL_ACK				0x00080000
#define		FFLAGS_DONT_COALESCE			0x00100000
#define 		FFLAGS_FINAL_HARD_DISCONNECT	0x00200000

struct framedesc 
{
	COMMANDID		CommandID;					// THIS MUST BE FIRST FIELD to match MSD
	LONG			lRefCnt;					// Reference count
	UINT			Sign;
	UINT			uiFrameLength;
	ULONG VOL		ulFFlags;					// Protected by EPLock
	BOOL VOL		bSubmitted;					// Pull out this one flag for protection by EPLock (data frames only)
	PMSD			pMSD;						// owning message
	PEPD			pEPD;						// owning link;  ONLY VALID ON COMMAND FRAMES!
	BYTE			bPacketFlags;
	CBilink			blMSDLinkage;
	CBilink			blQLinkage;
	CBilink			blWindowLinkage;	
	CBilink			blCoalesceLinkage;
	PFMD			pCSD;						// pointer to containing coalesce header frame descriptor (non-retry coalesced frames only)
	
	UINT			uiRetry;					// number of times this frame has been transmitted
	DWORD			dwFirstSendTime;			// time when we first send the frame
	DWORD			dwLastSendTime;			// time when we last sent the frame (starts == to dwFirstSendTime and
											// updates on each resend)
	DWORD			tAcked;
	
	SPSENDDATA		SendDataBlock;				// Block to submit frame to SP
	CHAR			ImmediateData[MAX_SEND_HEADER_SIZE];

	// DO NOT MODIFY LAST FIVE FIELDS IN FRAME STRUCTURE

	UINT			uiReserved1;		// two resv fields are buf..
	LPVOID			lpReserved2;		// ..desc for SP to add header
	UINT			uiImmediateLength;			// These two lines constitute buffer descriptor
	LPVOID			lpImmediatePointer;			// for immediate data (our protocol headers)
	BUFFERDESC	 	rgBufferList[MAX_USER_BUFFERS_IN_FRAME];	// KEEP THIS FIELD AT END SO WE CAN ADD BUFFERS DYNAMICALLY
};


/*
**		Receive Descriptor
**
**		This data structure tracks a  single buffer received from the network.
**	It may or may not constitute an entire message.
*/

typedef	enum 
{
	RBT_SERVICE_PROVIDER_BUFFER,
	RBT_SERVICE_PROVIDER_BUFFER_COALESCE,
	RBT_PROTOCOL_NORM_BUFFER,
	RBT_PROTOCOL_MED_BUFFER,
	RBT_PROTOCOL_BIG_BUFFER,
	RBT_DYNAMIC_BUFFER
}	BUFFER_TYPE;

//#define		RFLAGS_FRAME_OUT_OF_ORDER		0x0001	// This buffer was received out-of-order
#define		RFLAGS_FRAME_INDICATED_NONSEQ	0x0002	// This buffer was indicated out of order, but is still in Out of Order list
//#define		RFLAGS_ON_OUT_OF_ORDER_LIST		0x0004	//
//#define		RFLAGS_IN_COMPLETE_PROCESS		0x0008
#define		RFLAGS_FRAME_LOST				0x0010	// This RCD represents and Unreliable frame that has been lost

struct recvdesc 
{
	DWORD				tTimestamp;					// timestamp upon packets arrival
	LONG				lRefCnt;
	UINT				Sign;						// Signature to identify data structure
	UINT				uiDataSize;					// data in this frame
	UINT				uiFrameCount;				// frames in message
	UINT				uiMsgSize;					// total byte count of message
	BYTE				bSeq;						// Sequence number of this frame
	BYTE				bFrameFlags;				// Flag field from actual frame
	BYTE				bFrameControl;
	PBYTE				pbData;						// pointer to actual data
	UINT				ulRFlags;					// Receive flags
	CBilink				blOddFrameLinkage;			// BILINKage for queues
	CBilink				blCompleteLinkage;			// 2nd Bilink so RCD can remain in Out Of Order Queue after indication
	PRCD				pMsgLink;					// Single link for frame in message
	DWORD				dwNumCoalesceHeaders;		// number of coalesce headers in message
	PSPRECEIVEDBUFFER	pRcvBuff;					// ptr to SP's receive data structure
};

typedef	struct buf		BUF, *PBUF;
typedef struct medbuf	MEDBUF, *PMEDBUF;
typedef	struct bigbuf	BIGBUF, *PBIGBUF;
typedef	struct dynbuf	DYNBUF, *PDYNBUF;

// NOTE: These structures Type members must stay lined up with the dwProtocolData member
// of an SPRECEIVEDBUFFER!!!
struct buf 
{
	PVOID			pvReserved;
	BUFFER_TYPE		Type;							// Identifies this as our buffer or SPs buffer
	BYTE			data[SMALL_BUFFER_SIZE];		// 2K small buffer for combining multi-frame sends
};

struct medbuf 
{
	PVOID			pvReserved;
	BUFFER_TYPE		Type;							// Identifies this as our buffer or SPs buffer
	BYTE			data[MEDIUM_BUFFER_SIZE];		// 4K mid size buffer
};

struct bigbuf 
{
	PVOID			pvReserved;
	BUFFER_TYPE		Type;							// Identifies this as our buffer or SPs buffer
	BYTE			data[LARGE_BUFFER_SIZE];		// ARBITRARY SIZE OF MAX SEND (16K)
};

struct dynbuf 
{
	PVOID			pvReserved;
	BUFFER_TYPE		Type;							// Identifies this as our buffer or SPs buffer
};

#endif // _DNPROT_INCLUDED_