/*========================================================================== * * 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: // //connected_signed frames extend the standard CFRAME with a fixed number of additional members. On the wire these frames look like: // //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: // //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: // //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: // // ............... //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: // //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_