windows-server-2003/net/sockets/winsock2/wsp/afdsys/afdstr.h

/*++

Copyright (c) 1989  Microsoft Corporation

Module Name:

    afdstr.h

Abstract:

    This module contains typedefs for structures used by AFD.

Author:

    David Treadwell (davidtr)    21-Feb-1992

Revision History:

--*/

#ifndef _AFDSTR_
#define _AFDSTR_

//
// This field defines the layout of a 32-bit pointer.
// This must be ULONG as wow64 support 4gb address on win64.
// You shouldn't POINTER_32 as this will sign-extend addresses when converting
// it to a 64-bit pointer and will end up having the wrong address.
//
typedef ULONG AFD_POINTER_32;

//
// Make sure that queued spinlocks are not used with
// regular spinlock functions by wrapping them into
// a different structure.
//
typedef struct _AFD_QSPIN_LOCK {
    KSPIN_LOCK  ActualSpinLock;
} AFD_QSPIN_LOCK, *PAFD_QSPIN_LOCK;

#if DBG

#ifndef REFERENCE_DEBUG
#define REFERENCE_DEBUG 1
#endif

#ifndef GLOBAL_REFERENCE_DEBUG
#define GLOBAL_REFERENCE_DEBUG 0
#endif

//
// Debug aid for queued spinlocks
// Allows us to verify that spinlock is released using
// the same handle as it was taken with.
//
typedef struct _AFD_LOCK_QUEUE_HANDLE {
    KLOCK_QUEUE_HANDLE  LockHandle;
    PAFD_QSPIN_LOCK     SpinLock;
} AFD_LOCK_QUEUE_HANDLE, *PAFD_LOCK_QUEUE_HANDLE;

#else

#ifndef REFERENCE_DEBUG
#define REFERENCE_DEBUG 0
#endif

#ifndef GLOBAL_REFERENCE_DEBUG
#define GLOBAL_REFERENCE_DEBUG 0
#endif

#define AFD_LOCK_QUEUE_HANDLE KLOCK_QUEUE_HANDLE
#define PAFD_LOCK_QUEUE_HANDLE PKLOCK_QUEUE_HANDLE

#endif // DBG

#if REFERENCE_DEBUG

#define AFD_REF_SHIFT       6
#define AFD_REF_MASK        ((1<<AFD_REF_SHIFT)-1)
#define AFD_MAX_REF         (1<<AFD_REF_SHIFT)
#define AFD_REF_TIME_BITS   16
#define AFD_MAX_REF_TIME    ((1<<AFD_REF_TIME_BITS)-1)
#define AFD_TIME_EXP_SHIFT  4
#define AFD_TIME_EXP_BITS   2
#define AFD_REF_CNT_BITS    4
#define AFD_REF_LOC_BITS    (32-AFD_REF_CNT_BITS-AFD_REF_TIME_BITS-AFD_TIME_EXP_BITS)

C_ASSERT (32-AFD_REF_SHIFT-AFD_REF_TIME_BITS <=
          AFD_TIME_EXP_SHIFT*((1<<AFD_TIME_EXP_BITS)-1));

typedef union _AFD_REFERENCE_DEBUG {
    struct {
        ULONGLONG   NewCount:AFD_REF_CNT_BITS;
        ULONGLONG   LocationId:AFD_REF_LOC_BITS;
        ULONGLONG   TimeExp:AFD_TIME_EXP_BITS;
        ULONGLONG   TimeDif:AFD_REF_TIME_BITS;
        ULONGLONG   Param:32;
    };
    ULONGLONG       QuadPart;
} AFD_REFERENCE_DEBUG, *PAFD_REFERENCE_DEBUG;
C_ASSERT (sizeof (AFD_REFERENCE_DEBUG)==sizeof (ULONGLONG));

typedef struct _AFD_REFERENCE_LOCATION {
    PCHAR       Format;
    PVOID       Address;
} AFD_REFERENCE_LOCATION, *PAFD_REFERENCE_LOCATION;

LONG
AfdFindReferenceLocation (
    IN  PCHAR   Format,
    OUT PLONG   LocationId
    );

#define AFD_GET_ARL(_s) (_arl ? _arl : AfdFindReferenceLocation((_s),&_arl))

#define AFD_UPDATE_REFERENCE_DEBUG(_rd,_r,_l,_p)                            \
        do {                                                                \
            LONG _n, _n1;                                                   \
            ULONGLONG _t = KeQueryInterruptTime ();                         \
            _n = (_rd)->CurrentReferenceSlot;                               \
            _n1 = (((LONG)(_t>>13))<<AFD_REF_SHIFT) + ((_n+1)&AFD_REF_MASK);\
            if (InterlockedCompareExchange (&(_rd)->CurrentReferenceSlot,   \
                                            _n1,_n)==_n) {                  \
                PAFD_REFERENCE_DEBUG _s;                                    \
                LONG    _d,_e=0;                                            \
                (_rd)->CurrentTimeHigh = (LONG)(_t>>(13+32-AFD_REF_SHIFT)); \
                _s = &(_rd)->ReferenceDebug[_n & AFD_REF_MASK];             \
                _s->NewCount = _r;                                          \
                _s->LocationId = _l;                                        \
                _s->Param = _p;                                             \
                _d = (_n1-1-_n) >> AFD_REF_SHIFT;                           \
                while (_d>=AFD_MAX_REF_TIME) {                              \
                    _e += 1;                                                \
                    _d >>= _e*AFD_TIME_EXP_SHIFT;                           \
                }                                                           \
                _s->TimeDif = _d;                                           \
                _s->TimeExp = _e;                                           \
                break;                                                      \
            }                                                               \
        } while (1)


#if GLOBAL_REFERENCE_DEBUG
#define MAX_GLOBAL_REFERENCE 4096

typedef struct _AFD_GLOBAL_REFERENCE_DEBUG {
    PVOID Info1;
    PVOID Info2;
    PVOID Connection;
    ULONG_PTR Action;
    LARGE_INTEGER TickCounter;
    ULONG NewCount;
    ULONG Dummy;
} AFD_GLOBAL_REFERENCE_DEBUG, *PAFD_GLOBAL_REFERENCE_DEBUG;
#endif

#endif

//
// A structure for maintaining work queue information in AFD.
//

typedef struct _AFD_WORK_ITEM {
    LIST_ENTRY WorkItemListEntry;
    PWORKER_THREAD_ROUTINE AfdWorkerRoutine;
    PVOID Context;
} AFD_WORK_ITEM, *PAFD_WORK_ITEM;

//
// Structures for holding connect data pointers and lengths.  This is
// kept separate from the normal structures to save space in those
// structures for transports that do not support and applications
// which do not use connect data.
//

typedef struct _AFD_CONNECT_DATA_INFO {
    PVOID Buffer;
    ULONG BufferLength;
} AFD_CONNECT_DATA_INFO, *PAFD_CONNECT_DATA_INFO;

typedef struct _AFD_CONNECT_DATA_BUFFERS {
    AFD_CONNECT_DATA_INFO SendConnectData;
    AFD_CONNECT_DATA_INFO SendConnectOptions;
    AFD_CONNECT_DATA_INFO ReceiveConnectData;
    AFD_CONNECT_DATA_INFO ReceiveConnectOptions;
    AFD_CONNECT_DATA_INFO SendDisconnectData;
    AFD_CONNECT_DATA_INFO SendDisconnectOptions;
    AFD_CONNECT_DATA_INFO ReceiveDisconnectData;
    AFD_CONNECT_DATA_INFO ReceiveDisconnectOptions;
    TDI_CONNECTION_INFORMATION RequestConnectionInfo;
    TDI_CONNECTION_INFORMATION ReturnConnectionInfo;
    ULONG Flags;
} AFD_CONNECT_DATA_BUFFERS, *PAFD_CONNECT_DATA_BUFFERS;

//
// Structure used for holding disconnect context information.
//

typedef struct _AFD_ENDPOINT AFD_ENDPOINT, *PAFD_ENDPOINT;
typedef struct _AFD_CONNECTION AFD_CONNECTION, *PAFD_CONNECTION;

typedef struct _AFD_TPACKETS_INFO_INTERNAL 
                AFD_TPACKETS_INFO_INTERNAL,
                *PAFD_TPACKETS_INFO_INTERNAL;

typedef DECLSPEC_ALIGN(MEMORY_ALLOCATION_ALIGNMENT)
             struct _AFD_BUFFER 
                    AFD_BUFFER, 
                    *PAFD_BUFFER;

typedef struct _AFD_DISCONNECT_CONTEXT {
    LARGE_INTEGER Timeout;
    PIRP          Irp;
} AFD_DISCONNECT_CONTEXT, *PAFD_DISCONNECT_CONTEXT;


typedef struct _AFD_LR_LIST_ITEM AFD_LR_LIST_ITEM, *PAFD_LR_LIST_ITEM;
typedef BOOLEAN (* PAFD_LR_LIST_ROUTINE) (PAFD_LR_LIST_ITEM Item);

struct _AFD_LR_LIST_ITEM {
    SLIST_ENTRY             SListLink;    // Link in the list
    PAFD_LR_LIST_ROUTINE    Routine;      // Processing routine;
};


//
// Endpoint and connection structures and related informaion.
//
//
// Block types that identify which fields are
// available in the strucutures.
//

#define AfdBlockTypeEndpoint            0xAFD0  // VC endpoint before connect/accept/listen
#define AfdBlockTypeDatagram            0xAFD1  // Datagram endpoint in any state
#define AfdBlockTypeVcConnecting        0xAFD2  // VC endpoint after connect/accept
#define AfdBlockTypeVcListening         0xAFD4  // VC endpoint after listen
#define AfdBlockTypeVcBoth              0xAFD6  // VC endpoint after connect+listen
                                                // (used in multipoint root cases)


#define AfdBlockTypeHelper              0xAAFD  // Regular helper endpoint
#define AfdBlockTypeSanHelper           0x0AFD  // SAN helper endpoint
#define AfdBlockTypeSanEndpoint         0x1AFD  // SAN endpoint

#define AfdBlockTypeInvalidEndpoint     0xCAFD  // Right before we call ExFreePool

#define AfdBlockTypeConnection          0xAFD8  // Connection object
#define AfdBlockTypeInvalidConnection   0xEAFD  // Right before we call ExFreePool


#if DBG
#define IS_AFD_ENDPOINT_TYPE( endpoint )                         \
            ( (endpoint)->Type == AfdBlockTypeEndpoint ||        \
              (endpoint)->Type == AfdBlockTypeDatagram ||        \
              (endpoint)->Type == AfdBlockTypeVcConnecting ||    \
              (endpoint)->Type == AfdBlockTypeVcListening ||     \
              (endpoint)->Type == AfdBlockTypeVcBoth ||          \
              (endpoint)->Type == AfdBlockTypeHelper ||          \
              (endpoint)->Type == AfdBlockTypeSanHelper ||       \
              (endpoint)->Type == AfdBlockTypeSanEndpoint )
#endif

enum {
    AfdConnectionStateFree          = 0,    // On free/AcceptEx/DelayedAccept list
    AfdConnectionStateUnaccepted    = 1,    // On unaccepted list
    AfdConnectionStateReturned      = 2,    // On returned list
    AfdConnectionStateConnected     = 3,    // Accepted or connected
    AfdConnectionStateClosing       = 4     // Not  used anymore
};

//
// Flags that further qualify the state of the connection
//
typedef struct AFD_CONNECTION_STATE_FLAGS {
    union {
        struct {
            LOGICAL TdiBufferring:1,    // (Does not really belon here)
                    :3,                 // This spacing makes strcutures
                                        // much more readable (hex) in the 
                                        // debugger and has no effect
                                        // on the generated code as long
                                        // as number of flags is less than
                                        // 8 (we still take up full 32 bits
                                        // because of aligment requiremens
                                        // of most other fields)
                    Aborted:1,
                    AbortIndicated:1,
                    AbortFailed:1,
                    :1,
                    DisconnectIndicated:1,
                    :3,
                    ConnectedReferenceAdded:1,
                    :3,
                    SpecialCondition:1,
                    :3,
                    CleanupBegun:1,
                    :3,
                    ClosePendedTransmit:1,
                    :3,
                    OnLRList:1,         // Low-resource list
                    SanConnection:1,
                    RcvInitiated:1,     // AFD initiated receive to transport.
                    :1;
        };
        LOGICAL     ConnectionStateFlags;
    };
} AFD_CONNECTION_STATE_FLAGS;
C_ASSERT (sizeof (AFD_CONNECTION_STATE_FLAGS)==sizeof (LOGICAL));

struct _AFD_CONNECTION {
    // *** Frequently used, mostly read-only fields (state/type/flag changes are rare).
    USHORT Type;
    USHORT State;
    AFD_CONNECTION_STATE_FLAGS
#ifdef __cplusplus
        StateFlags
#endif
        ;

    PAFD_ENDPOINT Endpoint;
    PFILE_OBJECT FileObject;
    PDEVICE_OBJECT DeviceObject;
    PEPROCESS   OwningProcess;


    union {
        LONGLONG ConnectTime;   // After connection is accepted.
        PIRP     AcceptIrp;     // For AcceptEx
        PIRP     ListenIrp;     // For delayed accept
        PIRP     ConnectIrp;    // for SAN
    };

    // *** Frequently used volatile fields.
    volatile LONG ReferenceCount;

    union {

        struct {
            LARGE_INTEGER ReceiveBytesIndicated;
            LARGE_INTEGER ReceiveBytesTaken;
            LARGE_INTEGER ReceiveBytesOutstanding;

            LARGE_INTEGER ReceiveExpeditedBytesIndicated;
            LARGE_INTEGER ReceiveExpeditedBytesTaken;
            LARGE_INTEGER ReceiveExpeditedBytesOutstanding;
            BOOLEAN NonBlockingSendPossible;
            BOOLEAN ZeroByteReceiveIndicated;
        } Bufferring;

        struct {
            LIST_ENTRY ReceiveIrpListHead;
            LIST_ENTRY ReceiveBufferListHead;

            ULONG BufferredReceiveBytes;
            ULONG BufferredExpeditedBytes;

            USHORT BufferredReceiveCount;
            USHORT BufferredExpeditedCount;
            ULONG ReceiveBytesInTransport;

            LIST_ENTRY SendIrpListHead;
            
            ULONG BufferredSendBytes;
            ULONG BufferredSendCount;

            PIRP DisconnectIrp;

            LONG  ReceiveIrpsInTransport;   // debug only.
        } NonBufferring;

    } Common;


    ULONG MaxBufferredReceiveBytes;
    ULONG MaxBufferredSendBytes;

    PTRANSPORT_ADDRESS RemoteAddress;
    ULONG RemoteAddressLength;
    LONG    Sequence;

    HANDLE Handle;                          // Ref count protection



    union {
        AFD_WORK_ITEM           WorkItem;   // Work item to free the connection
                                            // Connection has to be at ref 0 to be
                                            // on the work queue, so it cannot be
                                            // on the lists below or being disconnected
                                            // because when on any of these lists the
                                            // ref count is above 0.
        struct {
            union {
                AFD_DISCONNECT_CONTEXT  DisconnectContext;
                                            // Disconnect operation context, we cannot be
                                            // on the listening endpoint list
                SLIST_ENTRY             SListEntry;
                                            // Links for listening endpoint lists
                LIST_ENTRY              ListEntry;
            };
            AFD_LR_LIST_ITEM    LRListItem; // Link for low resource list. When on this
                                            // list connection is referenced, but it can
                                            // also be on the listening endpoint list or
                                            // in the process of disconnecting.
        };
    };

    PAFD_CONNECT_DATA_BUFFERS ConnectDataBuffers;

#if REFERENCE_DEBUG
    LONG CurrentTimeHigh;
    volatile LONG CurrentReferenceSlot;
    AFD_REFERENCE_DEBUG ReferenceDebug[AFD_MAX_REF];
#endif

#ifdef _AFD_VERIFY_DATA_
    ULONGLONG VerifySequenceNumber;
#endif // _AFD_VERIFY_DATA_
};
// Fields of the AFD_CONNECTION are protected by the endpoint
// spinlock, except:
//  Type, FileObject, DeviceObject, OwningProcess, Handle which are
//      only set once and cleared when reference count goes to 0
// Endpoint field itself (and thus the spinlock) can change though.
//  - it is NULL when connection is on listening endpoint backlog
//      and connection cannot be referenced outside of listening endpoint.
//  - when it is assigned to listening endpoint it cannot change outside 
//      of listening endpoint spinlock
//  - when it is assigned to connecting/accepting endpoint, it cannot
//      change at all until reference count drops to 0 and
//      connection is again placed on listening endpoint backlog or
//      destroyed.
//  ReferenceCount only updated via interlocked operations.
//

#ifdef _AFD_VERIFY_DATA_
VOID
AfdVerifyBuffer (
    PAFD_CONNECTION Connection,
    PVOID           Buffer,
    ULONG           Length
    );
VOID
AfdVerifyMdl (
    PAFD_CONNECTION Connection,
    PMDL            Mdl,
    ULONG           Offset,
    ULONG           Length
    );
VOID
AfdVerifyAddress (
    PAFD_CONNECTION Connection,
    PTRANSPORT_ADDRESS Address
    );

#define AFD_VERIFY_BUFFER(_connection,_buffer,_length) \
            AfdVerifyBuffer(_connection,_buffer,_length)
#define AFD_VERIFY_MDL(_connection,_mdl,_offset,_length) \
            AfdVerifyMdl(_connection,_mdl,_offset,_length)
#define AFD_VERIFY_ADDRESS(_connection,_address) \
            AfdVerifyAddress(_connection,_address)
#else
#define AFD_VERIFY_BUFFER(_connection,_buffer,_length)
#define AFD_VERIFY_MDL(_connection,_mdl,_offset,_length)
#define AFD_VERIFY_ADDRESS(_connection,_address)
#endif // _AFD_VERIFY_DATA_

//
// Some macros that make code more readable.
//

#define VcNonBlockingSendPossible Common.Bufferring.NonBlockingSendPossible
#define VcZeroByteReceiveIndicated Common.Bufferring.ZeroByteReceiveIndicated

#define VcReceiveIrpListHead Common.NonBufferring.ReceiveIrpListHead
#define VcReceiveBufferListHead Common.NonBufferring.ReceiveBufferListHead
#define VcSendIrpListHead Common.NonBufferring.SendIrpListHead

#define VcBufferredReceiveBytes Common.NonBufferring.BufferredReceiveBytes
#define VcBufferredExpeditedBytes Common.NonBufferring.BufferredExpeditedBytes
#define VcBufferredReceiveCount Common.NonBufferring.BufferredReceiveCount
#define VcBufferredExpeditedCount Common.NonBufferring.BufferredExpeditedCount

#define VcReceiveBytesInTransport Common.NonBufferring.ReceiveBytesInTransport
#if DBG
#define VcReceiveIrpsInTransport Common.NonBufferring.ReceiveIrpsInTransport
#endif

#define VcBufferredSendBytes Common.NonBufferring.BufferredSendBytes
#define VcBufferredSendCount Common.NonBufferring.BufferredSendCount

#define VcDisconnectIrp Common.NonBufferring.DisconnectIrp

//
// Information stored about each transport device name for which there
// is an open endpoint.
//
typedef
NTSTATUS
(FASTCALL *PIO_CALL_DRIVER) (
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    );

typedef
PAFD_BUFFER
(FASTCALL *PAFD_GET_BUFFER) (
    IN ULONG    BufferDataSize,
    IN ULONG  AddressSize,
    IN PEPROCESS Process
);

typedef
PAFD_TPACKETS_INFO_INTERNAL
(FASTCALL *PAFD_GET_TPINFO) (
    IN ULONG    ElementCount
);

typedef struct _AFD_TRANSPORT_INFO {
    LIST_ENTRY TransportInfoListEntry;
    volatile LONG ReferenceCount;
    BOOLEAN InfoValid;
#ifdef _AFD_VARIABLE_STACK_
    CCHAR   StackSize;
    PAFD_GET_BUFFER GetBuffer;
    PAFD_GET_TPINFO GetTpInfo;
    PIO_CALL_DRIVER CallDriver;
#endif // _AFD_VARIABLE_STACK_
    UNICODE_STRING TransportDeviceName;
    TDI_PROVIDER_INFO ProviderInfo;
    //WCHAR TransportDeviceNameStructure;
} AFD_TRANSPORT_INFO, *PAFD_TRANSPORT_INFO;

//
// Endpoint state definitions (can't be <=0 or state change
// macros won't work correctly).
//
enum {
    AfdEndpointStateOpen             =1,    // Socket created but no yet bound
    AfdEndpointStateBound            =2,
    AfdEndpointStateConnected        =3,
    AfdEndpointStateCleanup          =4,    // Not used anymore
    AfdEndpointStateClosing          =5,
    AfdEndpointStateTransmitClosing  =6,    // TransmitFile with reuse
    AfdEndpointStateInvalid          =7     // Helper endpoints
};

//
// Flags that further qualify the state of the endpoint
//
typedef struct AFD_ENDPOINT_STATE_FLAGS {
    union {
        struct {
            LOGICAL Listening:1,
                    DelayedAcceptance:1,
                    :2,                 // This spacing makes strcutures
                                        // much more readable (hex) in the 
                                        // debugger and has no effect
                                        // on the generated code as long
                                        // as number of flags is less than
                                        // 8 (we still take up full 32 bits
                                        // because of aligment requiremens
                                        // of most other fields)
                    NonBlocking:1,
                    :3,
                    InLine:1,
                    :3,
                    EndpointCleanedUp:1,
                    :3,
                    PollCalled:1,
                    :3,
                    RoutingQueryReferenced:1,
                    RoutingQueryIPv6:1,
                    :2,
                    DisableFastIoSend:1,
                    EnableSendEvent:1,
                    :2,
                    DisableFastIoRecv:1,
                    :3;
        };
        LOGICAL     EndpointStateFlags;
    };
} AFD_ENDPOINT_STATE_FLAGS;
C_ASSERT (sizeof (AFD_ENDPOINT_STATE_FLAGS)==sizeof (LOGICAL));

struct _AFD_ENDPOINT {
    // *** Frequently used, mostly read-only fields (state/type/flag changes are rare).
    USHORT  Type;
    UCHAR   State;
    BOOLEAN AdminAccessGranted;
    ULONG   TdiServiceFlags;        // Tdi transport flags cached for quick access.

    AFD_ENDPOINT_FLAGS __f;         // As requested by the application through the
                                    // Winsock2 provider flags and/or socket type
    AFD_ENDPOINT_STATE_FLAGS 
#ifdef __cplusplus
        StateFlags
#endif
        ;
    PFILE_OBJECT    AddressFileObject;
    union {
        PDEVICE_OBJECT  AddressDeviceObject;
        PSECURITY_DESCRIPTOR SecurityDescriptor; // Only
    };
    PEPROCESS       OwningProcess;

    // *** Frequently used volatile fields.
    AFD_QSPIN_LOCK  SpinLock;       // Pointer sized.
    volatile LONG ReferenceCount;
    ULONG EventsActive;

    //
    // Use a union to overlap the fields that are exclusive to datagram
    // connecting, or listening endpoints.  Since many fields are
    // relevant to only one type of socket, it makes no sense to
    // maintain the fields for all sockets--instead, save some nonpaged
    // pool by combining them.
    //

    union {
        //
        // Information for circuit-based endpoints
        //
        struct {
            union {
                struct {
                    // These members are valid for listening endpoints
                    // (AfdBlockTypeVcListening).
                    LIST_ENTRY UnacceptedConnectionListHead;
                    LIST_ENTRY ReturnedConnectionListHead;
                    LIST_ENTRY ListeningIrpListHead;

                    // The below lists have their own lock which gets
                    // used on the machines that do not support 64-bit
                    // interlocked compare and exchange.  On these machines
                    // using endpoint spinlock to synchronize causes all kinds
                    // of nasty deadlock conditions.
                    union {
                        LIST_ENTRY  ListenConnectionListHead; // Delayed accept
                        SLIST_HEADER FreeConnectionListHead;
                    };
                    SLIST_HEADER PreacceptedConnectionsListHead;

                    LONG FailedConnectionAdds;
                    LONG TdiAcceptPendingCount;

                    LONG Sequence;
                    BOOLEAN EnableDynamicBacklog;
                    BOOLEAN BacklogReplenishActive; // Worker is scheduled
                    USHORT  MaxExtraConnections;  // Extra connections we keep in the free queue
                                                  // based on maximum number of AcceptEx requests
                } Listening;
                struct {
                    KAPC    Apc;
                    USHORT  RemoteSocketAddressOffset;  // Offset inside of socket context
                                                        // pointing to remote address.
                    USHORT  RemoteSocketAddressLength;  // Length of the address.
#ifndef i386
                    BOOLEAN FixAddressAlignment;        // Fix address alignment in
                                                        // SuperAccept
#endif
                };
            };
            // These members are valid for all vc endpoints (but
            // can be NULL)
            PAFD_CONNECTION Connection;
            struct _AFD_ENDPOINT *ListenEndpoint;
            PAFD_CONNECT_DATA_BUFFERS ConnectDataBuffers;
        } VirtualCircuit;

#define VcConnecting    VirtualCircuit
#define VcListening     VirtualCircuit.Listening
#define VcConnection    VirtualCircuit.Connection
        //
        // Information for datagram endpoints.  Note that different
        // information is kept depending on whether the underlying
        // transport buffers internally.
        //

        struct {
            LIST_ENTRY ReceiveIrpListHead;
            LIST_ENTRY PeekIrpListHead;
            LIST_ENTRY ReceiveBufferListHead;

            ULONG BufferredReceiveBytes;
            ULONG BufferredReceiveCount;

            ULONG MaxBufferredReceiveBytes;
            ULONG BufferredSendBytes;
            ULONG MaxBufferredSendBytes;


            ULONG RemoteAddressLength;
            PTRANSPORT_ADDRESS RemoteAddress;

            union {
                struct {
                    LOGICAL CircularQueueing:1,
                        :3,
                        HalfConnect:1,
                        :3,
                        DisablePUError:1,
                        :3,
                        AddressDrop:1,
                        ResourceDrop:1,
                        BufferDrop:1,
                        ErrorDrop:1;
                };
                LOGICAL Flags;
            };
        } Datagram;

        struct {
            LIST_ENTRY SanListLink;
            PVOID   IoCompletionPort;
            PKEVENT IoCompletionEvent;
            LONG    Plsn;   // Provider list sequence number
            LONG    PendingRequests; // Number of pending requests to this process 
        } SanHlpr;

        struct {
            struct _AFD_ENDPOINT *SanHlpr;
            PFILE_OBJECT FileObject;
            union {
                //
                // We can only have either one of two at any given time.
                //
                PAFD_SWITCH_CONTEXT  SwitchContext;
                PVOID       SavedContext;
            };
            PAFD_SWITCH_CONTEXT  LocalContext;
            LIST_ENTRY  IrpList;
            ULONG       SavedContextLength;
            ULONG       RequestId;
            ULONG       SelectEventsActive;
            NTSTATUS    CtxTransferStatus;
            BOOLEAN     ImplicitDup; // Dup-ed into another process without
                                     // explicit request from the applicaiton
                                        
        } SanEndp;

    } Common;


    volatile PVOID Context;
    ULONG ContextLength;

    ULONG LocalAddressLength;
    PTRANSPORT_ADDRESS LocalAddress;

    ULONG DisconnectMode;
    LONG  OutstandingIrpCount;

    HANDLE  AddressHandle;      // TDI transport address object
    PAFD_TRANSPORT_INFO TransportInfo;

    LIST_ENTRY RoutingNotifications;  // For non-blocking sockets
    LIST_ENTRY RequestList;         // For misc requests

    LIST_ENTRY GlobalEndpointListEntry;
    AFD_WORK_ITEM   WorkItem;
    PIRP            Irp;        // AcceptEx or TransmitPackets IRP
    //
    // Non-zero when state change such as binding, accepting,
    // conntecting, and transmit file are in progress.
    LONG  StateChangeInProgress;

    //
    // EventSelect info.
    //

    ULONG EventsEnabled;
    NTSTATUS EventStatus[AFD_NUM_POLL_EVENTS]; // Currently 13 events
    PKEVENT EventObject;

    //
    // Socket grouping.
    //

    LONG GroupID;
    AFD_GROUP_TYPE GroupType;
    LIST_ENTRY ConstrainedEndpointListEntry;

    //
    // Debug stuff.
    //

#if REFERENCE_DEBUG
    LONG CurrentTimeHigh;
    LONG CurrentReferenceSlot;
    AFD_REFERENCE_DEBUG ReferenceDebug[AFD_MAX_REF];
#endif

#if DBG
    LIST_ENTRY OutstandingIrpListHead;
    LONG ObReferenceBias;
#endif
};
// Fields AFD_ENDPOINT structure are protected by the embedded
// spinlock, except:
// AdminAccessGranted, TdiServiceFlags, __f, OwningProcess, TransportInfo,
//  IoCompletionPort, IoCompletionEvent, AddressHandle which are
//  set once and are not touched until reference count goes to 0
// Type, State, LocalAddress, LocalAddressLength, AddressFileObject,
//  AddressDeviceObject, AddressHandle, TdiServiceFlags are protected by the 
//  StateChange interlocked mutex (AddressHandle and TdiServiceFlags can only be set
//  once under the mutex).
// AddressFileObject,AddressDeviceObject,LocalAddress, LocalAddressLength can only be 
//  reset to NULL under the endpoint spinlock in case of TransmitFile (REUSE) on
//  accepting endpoint (StateChange protection still applies).
// Counters: ReferenceCount, FailedConnectionAdds, TdiAcceptPendingCount,
//  Sequence, PendingRequests, SelectEventsActive are accessed with interlocked operations.
// Context, ContextLength, SwitchContext, SavedContext, LocalContext,
//  SavedContextLength, RemoveSocketAddressOffset, RemoteSocketAddressLength
//  are protected by the context lock (AfdLockContext).


typedef struct _AFD_POLL_ENDPOINT_INFO {
    PAFD_ENDPOINT Endpoint;
    PFILE_OBJECT FileObject;
    HANDLE Handle;
    ULONG PollEvents;
} AFD_POLL_ENDPOINT_INFO, *PAFD_POLL_ENDPOINT_INFO;

typedef struct _AFD_POLL_INFO_INTERNAL {
    LIST_ENTRY PollListEntry;
    ULONG NumberOfEndpoints;
    PIRP Irp;
    union {
        struct {
            KDPC Dpc;
            KTIMER Timer;
        };
        KAPC    Apc;            // for SAN
    };
    BOOLEAN Unique;
    BOOLEAN TimerStarted;
    BOOLEAN SanPoll;
    AFD_POLL_ENDPOINT_INFO EndpointInfo[1];
} AFD_POLL_INFO_INTERNAL, *PAFD_POLL_INFO_INTERNAL;

//
// A couple of useful manifests that make code more readable.
//

#define ReceiveDatagramIrpListHead Common.Datagram.ReceiveIrpListHead
#define PeekDatagramIrpListHead Common.Datagram.PeekIrpListHead
#define ReceiveDatagramBufferListHead Common.Datagram.ReceiveBufferListHead
#define DgBufferredReceiveCount Common.Datagram.BufferredReceiveCount
#define DgBufferredReceiveBytes Common.Datagram.BufferredReceiveBytes
#define DgBufferredSendBytes Common.Datagram.BufferredSendBytes

#define AFD_CONNECTION_FROM_ENDPOINT( endpoint ) (  \
        (((endpoint)->Type & AfdBlockTypeVcConnecting)==AfdBlockTypeVcConnecting) \
            ? (endpoint)->Common.VirtualCircuit.Connection                        \
            : (PAFD_CONNECTION)NULL                                               \
     )

//
// A structure which describes buffers used by AFD to perform bufferring
// for TDI providers which do not perform internal bufferring.
// It is also used in other code path as buffer descriptors.
//
typedef struct _AFD_BUFFER_HEADER AFD_BUFFER_HEADER, *PAFD_BUFFER_HEADER;

#define _AFD_BUFFER_HEADER_                                                    \
    union {                                                                    \
      TDI_CONNECTION_INFORMATION TdiInfo; /*holds info for TDI requests */     \
                                          /*with remote address */             \
      struct {                                                                 \
        union {           /* Links */                                          \
          struct {                                                             \
            union {                                                            \
              SINGLE_LIST_ENTRY SList; /* for buffer lookaside lists */        \
              PAFD_BUFFER_HEADER  Next; /* for transmit packet lists */        \
            };                                                                 \
            PFILE_OBJECT FileObject; /* for cached file in transmit file */    \
          };                                                                   \
          LIST_ENTRY BufferListEntry; /* for endpoint/connection lists */      \
        };                                                                     \
        union {                                                                \
          struct {                                                             \
            ULONG   DataOffset;   /* offset in buffer to start of unread data*/\
            union {                                                            \
              ULONG   DatagramFlags;/* flags for datagrams with control info */\
              LONG    RefCount; /* Permit partial copy outside the lock*/      \
            };                                                                 \
          };                                                                   \
          LARGE_INTEGER FileOffset;/* data offset from the start of the file */\
        };                                                                     \
        UCHAR       _Test; /* used to test relative field pos in the union */  \
      };                                                                       \
    };                                                                         \
    union {                                                                    \
      PVOID     Context; /* stores context info (endp/conn/etc)*/              \
      NTSTATUS  Status;/* stores status of completed operation */              \
    };                                                                         \
    PMDL        Mdl;             /* pointer to an MDL describing the buffer*/  \
    ULONG       DataLength;      /* actual data in the buffer */               \
    ULONG       BufferLength;    /* amount of space allocated for the buffer */\
    union {                                                                    \
      struct {                                                                 \
        /* Flags that describe data in the buffer */                           \
        UCHAR   ExpeditedData:1, /* The buffer contains expedited data*/       \
                :3,                                                            \
                PartialMessage:1,/* This is a partial message*/                \
                :3;                                                            \
        /* Flags that keep allocation information */                           \
        UCHAR   NdisPacket:1,    /* Context is a packet to return to NDIS/TDI*/\
                :3,                                                            \
                Placement:2,     /* Relative placement of the pieces */        \
                AlignmentAdjusted:1, /* MM block alignment was adjusted to */  \
                                 /* meet AFD buffer alignment requirement */   \
                Lookaside:1;     /* Poped from Slist (no quota charge)*/       \
      };                                                                       \
      USHORT    Flags;                                                         \
    };                                                                         \
    USHORT      AllocatedAddressLength/* length allocated for address */       \


struct _AFD_BUFFER_HEADER {
    _AFD_BUFFER_HEADER_ ;
};

//
// The buffer management code makes the following assumptions
// about the union at the top the buffer header so that list
// links and DataOffset field are not in conflict with
// RemoteAddress fields of the TDI_CONNECTION_INFORMATION.
//
C_ASSERT (FIELD_OFFSET (AFD_BUFFER_HEADER, TdiInfo.RemoteAddress) >=
                            FIELD_OFFSET (AFD_BUFFER_HEADER, _Test));
C_ASSERT (FIELD_OFFSET (AFD_BUFFER_HEADER, TdiInfo.RemoteAddressLength)>=
                            FIELD_OFFSET (AFD_BUFFER_HEADER, _Test));

C_ASSERT(FIELD_OFFSET (AFD_BUFFER_HEADER, AllocatedAddressLength)==
                FIELD_OFFSET(AFD_BUFFER_HEADER, Flags)+sizeof (USHORT));

typedef struct AFD_BUFFER_TAG {
    union {
        struct {
            _AFD_BUFFER_HEADER_;    // easy access to individual members
        };
        AFD_BUFFER_HEADER Header;   // access to the header as a whole
    };
#if DBG
    PVOID Caller;
    PVOID CallersCaller;
#endif
    // UCHAR Address[];            // address of datagram sender
} AFD_BUFFER_TAG, *PAFD_BUFFER_TAG;

struct _AFD_BUFFER {
    union {
        struct {
            _AFD_BUFFER_HEADER_;    // easy access to individual members
        };
        AFD_BUFFER_HEADER Header;   // access to the header as a whole
    };
    PIRP Irp;                      // pointer to the IRP associated w/the buffer
    PVOID Buffer;                  // a pointer to the actual data buffer

#if DBG
    LIST_ENTRY DebugListEntry;
    PVOID Caller;
    PVOID CallersCaller;
#endif
    // IRP Irp;                    // the IRP follows this structure
    // MDL Mdl;                    // the MDL follows the IRP
    // UCHAR Address[];            // address of datagram sender
    // UCHAR Buffer[BufferLength]; // the actual data buffer is last
} ;

//
// Placement of pieces that comprise the AFD_BUFFER.
// We have four pieces: header, IRP, MDL, data buffer
// and use 2 bits to encode each.
// We need to save the first piece so we know where the memory block
// starts when we need to return it to the memory manager.
//
enum {
    AFD_PLACEMENT_HDR      =0,
    AFD_PLACEMENT_IRP      =1,
    AFD_PLACEMENT_MDL      =2,
    AFD_PLACEMENT_BUFFER   =3,
    AFD_PLACEMENT_HDR_IRP  =(AFD_PLACEMENT_HDR|(AFD_PLACEMENT_IRP<<2)),
    AFD_PLACEMENT_HDR_MDL  =(AFD_PLACEMENT_HDR|(AFD_PLACEMENT_MDL<<2)),
    AFD_PLACEMENT_IRP_MDL  =(AFD_PLACEMENT_IRP|(AFD_PLACEMENT_MDL<<2)),
    AFD_PLACEMENT_HDR_IRP_MDL=(AFD_PLACEMENT_HDR|(AFD_PLACEMENT_IRP<<2)|(AFD_PLACEMENT_MDL<<4))
};


//
// ALIGN_DOWN_A aligns to given alignment requirement
// (as opposed to the type in the original ALIGN_DOWN macro)
//
#define ALIGN_DOWN_A(length,alignment)   \
    (((ULONG)(length)) & ~ ((alignment)-1))

//
// ALIGN_DOWN_A for pointers.
//
#define ALIGN_DOWN_A_POINTER(address,alignment)  \
    ((PVOID)(((ULONG_PTR)(address)) & ~ ((ULONG_PTR)(alignment)-1)))


//
// ALIGN_UP_A aligns to given alignment requirement
// (as opposed to the type in the original ALIGN_UP macro)
//
#define ALIGN_UP_A(length,alignment)   \
    ((((ULONG)(length)) + (alignment)-1) & ~ ((alignment)-1))

//
// ALIGN_UP_A for pointers.
//
#define ALIGN_UP_A_POINTER(address,alignment)  \
    ALIGN_DOWN_A_POINTER(((ULONG_PTR)(address) + alignment-1), alignment)

//
// ALIGN_UP_TO_TYPE aligns size to make sure it meets
// the type alignment requirement
//
#define ALIGN_UP_TO_TYPE(length,type)   \
    ALIGN_UP_A(length,TYPE_ALIGNMENT(type))

//
// ALIGN_UP_TO_TYPE for pointers.
//
#define ALIGN_UP_TO_TYPE_POINTER(address,type)   \
    ALIGN_UP_A_POINTER(address,TYPE_ALIGNMENT(type))

#if DBG

#define IS_VALID_AFD_BUFFER(b) (                                                                                                    \
    ((b)->Placement==AFD_PLACEMENT_HDR)                                                                                             \
        ? ((PUCHAR)b<(PUCHAR)(b)->Buffer && (PUCHAR)b<(PUCHAR)(b)->Mdl && (PUCHAR)b<(PUCHAR)(b)->Irp)                               \
        : (((b)->Placement==AFD_PLACEMENT_MDL)                                                                                      \
            ? ((PUCHAR)(b)->Mdl<(PUCHAR)(b)->Buffer && (PUCHAR)(b)->Mdl<(PUCHAR)b && (PUCHAR)(b)->Mdl<(PUCHAR)(b)->Irp)             \
            : ((b->Placement==AFD_PLACEMENT_IRP)                                                                                    \
                ? ((PUCHAR)(b)->Irp<(PUCHAR)(b)->Buffer && (PUCHAR)(b)->Irp<(PUCHAR)b && (PUCHAR)(b)->Irp<(PUCHAR)(b)->Mdl)         \
                : ((PUCHAR)(b)->Buffer<(PUCHAR)(b)->Irp && (PUCHAR)(b)->Buffer<(PUCHAR)b && (PUCHAR)(b)->Buffer<(PUCHAR)(b)->Mdl))  \
            )                                                                                                                       \
        )                                                                                                                           \

#endif


//
// Pointer to an IRP cleanup routine. This is used as a parameter to
// AfdCompleteIrpList().
//

typedef
BOOLEAN
(NTAPI * PAFD_IRP_CLEANUP_ROUTINE)(
    IN PIRP Irp
    );

//
// Debug statistics.
//

typedef struct _AFD_QUOTA_STATS {
    LARGE_INTEGER Charged;
    LARGE_INTEGER Returned;
} AFD_QUOTA_STATS;

typedef struct _AFD_HANDLE_STATS {
    LONG AddrOpened;
    LONG AddrClosed;
    LONG AddrRef;
    LONG AddrDeref;
    LONG ConnOpened;
    LONG ConnClosed;
    LONG ConnRef;
    LONG ConnDeref;
    LONG FileRef;
    LONG FileDeref;
} AFD_HANDLE_STATS;

typedef struct _AFD_QUEUE_STATS {
    LONG AfdWorkItemsQueued;
    LONG ExWorkItemsQueued;
    LONG WorkerEnter;
    LONG WorkerLeave;
    LONG AfdWorkItemsProcessed;
    PETHREAD AfdWorkerThread;
} AFD_QUEUE_STATS;

typedef struct _AFD_CONNECTION_STATS {
    LONG ConnectedReferencesAdded;
    LONG ConnectedReferencesDeleted;
    LONG GracefulDisconnectsInitiated;
    LONG GracefulDisconnectsCompleted;
    LONG GracefulDisconnectIndications;
    LONG AbortiveDisconnectsInitiated;
    LONG AbortiveDisconnectsCompleted;
    LONG AbortiveDisconnectIndications;
    LONG ConnectionIndications;
    LONG ConnectionsDropped;
    LONG ConnectionsAccepted;
    LONG ConnectionsPreaccepted;
    LONG ConnectionsReused;
    LONG EndpointsReused;
} AFD_CONNECTION_STATS;

//
// Global data. Resouces and lookaside list descriptors
// cannot be statically allocated, as they need to ALWAYS be nonpageable,
// even when the entire driver is paged out.
// Alignment table is variable-size and also cannot be statically allocated.
//

enum {
    AFD_LARGE_BUFFER_LIST=0,
    AFD_MEDIUM_BUFFER_LIST,
    AFD_SMALL_BUFFER_LIST,
    AFD_BUFFER_TAG_LIST,
    AFD_TP_INFO_LIST,
    AFD_REMOTE_ADDR_LIST,
    AFD_NUM_LOOKASIDE_LISTS
} AFD_LOOKASIDE_LISTS_INDEX;

typedef struct _AFD_GLOBAL_DATA {
    ERESOURCE               Resource;
    NPAGED_LOOKASIDE_LIST   List[AFD_NUM_LOOKASIDE_LISTS];
#define LargeBufferList     List[AFD_LARGE_BUFFER_LIST]
#define MediumBufferList    List[AFD_MEDIUM_BUFFER_LIST]
#define SmallBufferList     List[AFD_SMALL_BUFFER_LIST]
#define BufferTagList       List[AFD_BUFFER_TAG_LIST]
#define TpInfoList          List[AFD_TP_INFO_LIST]
#define RemoteAddrList      List[AFD_REMOTE_ADDR_LIST]
    LONG                    TrimFlags;
    KTIMER                  Timer;
    KDPC                    Dpc;
    UCHAR                   BufferAlignmentTable[ANYSIZE_ARRAY];
} AFD_GLOBAL_DATA, *PAFD_GLOBAL_DATA;

//
// Context structure for misc requests pended in AFD.
//
typedef struct _AFD_REQUEST_CONTEXT AFD_REQUEST_CONTEXT, *PAFD_REQUEST_CONTEXT;

//
// The routine is called after request is removed from endpoint list
// for cleanup purposes
//
typedef BOOLEAN (* PAFD_REQUEST_CLEANUP) (
                    PAFD_ENDPOINT           Endpoint,
                    PAFD_REQUEST_CONTEXT     NotifyCtx
                    );

//
// This structure has to no more 16 bytes long so we can
// reuse IrpSp->Parameters for it.
//
struct _AFD_REQUEST_CONTEXT {
    LIST_ENTRY              EndpointListLink;   // Link in endpoint list
    PAFD_REQUEST_CLEANUP    CleanupRoutine;     // Routine to call to cancel
    PVOID                   Context;            // Request dependent context
                                                // (PIRP)
};

//
// We use list entry fields to synchronize completion with cleanup/cancel
// routine assuming that as long as the entry is in the list
// both Flink and Blink fields cannot be NULL. (using these
// fields for synchronization allows us to cut down on
// cancel spinlock usage)
//

#define AfdEnqueueRequest(Endpoint,Request)                     \
    ExInterlockedInsertTailList(&(Endpoint)->RequestList,       \
                                &(Request)->EndpointListLink,   \
                                &(Endpoint)->SpinLock)


#define AfdIsRequestInQueue(Request)                           \
            ((Request)->EndpointListLink.Flink!=NULL)

#define AfdMarkRequestCompleted(Request)                       \
            (Request)->EndpointListLink.Blink = NULL

#define AfdIsRequestCompleted(Request)                         \
            ((Request)->EndpointListLink.Blink==NULL)


typedef struct _ROUTING_NOTIFY {
    LIST_ENTRY      NotifyListLink;
    PIRP            NotifyIrp;
    PVOID           NotifyContext;
} ROUTING_NOTIFY, *PROUTING_NOTIFY;

typedef struct _AFD_ADDRESS_ENTRY {
    LIST_ENTRY      AddressListLink;
    UNICODE_STRING  DeviceName;
    TA_ADDRESS      Address;
} AFD_ADDRESS_ENTRY, *PAFD_ADDRESS_ENTRY;

typedef struct _AFD_ADDRESS_CHANGE {
    LIST_ENTRY      ChangeListLink;
    union {
        PAFD_ENDPOINT   Endpoint;
        PIRP            Irp;
    };
    USHORT          AddressType;
    BOOLEAN         NonBlocking;
} AFD_ADDRESS_CHANGE, *PAFD_ADDRESS_CHANGE;


typedef 
NTSTATUS
(* PAFD_IMMEDIATE_CALL) (
    IN  PFILE_OBJECT        FileObject,
    IN  ULONG               IoctlCode,
    IN  KPROCESSOR_MODE     RequestorMode,
    IN  PVOID               InputBuffer,
    IN  ULONG               InputBufferLength,
    IN  PVOID               OutputBuffer,
    IN  ULONG               OutputBufferLength,
    OUT PULONG_PTR          Information
    );

typedef
NTSTATUS
(FASTCALL * PAFD_IRP_CALL) (
    IN  PIRP                Irp,
    IN  PIO_STACK_LOCATION  IrpSp
    );
    
typedef struct _AFD_TRANSMIT_PACKETS_ELEMENT {
#define TP_MDL      0x80000000
#define TP_COMBINE  0x40000000
    ULONG Flags;
    ULONG Length;
    union {
        struct {
            LARGE_INTEGER FileOffset;
            PFILE_OBJECT  FileObject;
        };
        struct {
            PVOID         Buffer;
            PMDL          Mdl;
        };
    };
} AFD_TRANSMIT_PACKETS_ELEMENT, *PAFD_TRANSMIT_PACKETS_ELEMENT;

//
// Structure to keep track of transmit packets request
//
struct _AFD_TPACKETS_INFO_INTERNAL {
    union {
        SINGLE_LIST_ENTRY   SListEntry;     // Link on S-List
        PFILE_OBJECT    TdiFileObject;      // Tdi objects (sending to)
    };

    PDEVICE_OBJECT  TdiDeviceObject;

    PMDL            HeadMdl;        // Ready to send chain
    PMDL            *TailMdl;
    
    PAFD_BUFFER_HEADER  HeadPd;     // Corresponding packet chain
    PAFD_BUFFER_HEADER  *TailPd;

    PIRP            ReadIrp;        // Irp used for file reads.
    PAFD_TRANSMIT_PACKETS_ELEMENT
                    ElementArray;   // Packet array
    
    ULONG           NextElement;    // Next element to send.
    ULONG           ElementCount;   // Total number of elements in the array
    
    ULONG           RemainingPkts;  // Number of packets remaining to be sent.
    USHORT          NumSendIrps;    // Actual number of send IRPs
    BOOLEAN         ArrayAllocated; // Element array is allocated (not built-in).
    BOOLEAN         PdNeedsPps;     // Packet descriptor being built needs post-
                                    // processing after completion.
    ULONG           PdLength;       // Currently accumulated send length
    ULONG           SendPacketLength; // Maximum length of the packet
                                    // APC/Work item for worker scheduling
    union {
        KAPC                Apc;
        WORK_QUEUE_ITEM     WorkItem;
    };

#if REFERENCE_DEBUG
    LONG CurrentTimeHigh;
    LONG CurrentReferenceSlot;
    AFD_REFERENCE_DEBUG ReferenceDebug[AFD_MAX_REF];
#endif
#if AFD_PERF_DBG
    LONG            WorkersExecuted;
#endif
#define AFD_TP_MIN_SEND_IRPS    2   // Need at least two to keep transport busy
#define AFD_TP_MAX_SEND_IRPS    8   // Max is based on current flags layout below
    PIRP            SendIrp[AFD_TP_MAX_SEND_IRPS];
    // ElementArray
    // SendIrp1
    // SendIrp2
};

//
// Structure maintained in driver context of the TPackets IRP
//
typedef struct _AFD_TPACKETS_IRP_CTX AFD_TPACKETS_IRP_CTX, *PAFD_TPACKETS_IRP_CTX;
#define AFD_GET_TPIC(_i) ((PAFD_TPACKETS_IRP_CTX)&(_i)->Tail.Overlay.DriverContext)
struct _AFD_TPACKETS_IRP_CTX {
    PAFD_TPACKETS_IRP_CTX       Next;           // Next TPackets IRP in the list
    LONG                        Flags;          // Application flags.
    volatile LONG               ReferenceCount; // IRP reference count
    volatile LONG               StateFlags;     // TPackets state flags
};

#define AFD_GET_TPIRP(_i) CONTAINING_RECORD(_i,IRP,Tail.Overlay.DriverContext)

#define AFD_TP_ABORT_PENDING         0x00000001  // Request is being aborted
#define AFD_TP_WORKER_SCHEDULED      0x00000002  // Worker is scheduled or active
#define AFD_TP_SENDS_POSTED          0x00000010  // All sends have been posted.
#define AFD_TP_QUEUED                0x00000020  // Irp is in the queue.
#define AFD_TP_SEND                  0x00000100  // This is a plain send in TP queue.
#define AFD_TP_AFD_SEND              0x00000200  // This is AFD send IRP.
#ifdef TDI_SERVICE_SEND_AND_DISCONNECT
#define AFD_TP_SEND_AND_DISCONNECT   0x00000400  // S&D is enabled
#endif // TDI_SERVICE_SEND_AND_DISCONNECT

#define AFD_TP_READ_CALL_PENDING     0x00001000  // MDL_READ call is imminent or in progress on ReadIrp
#define AFD_TP_READ_COMP_PENDING     0x00002000  // Read completion is expected on ReadIrp
#define AFD_TP_READ_BUSY (AFD_TP_READ_CALL_PENDING|AFD_TP_READ_COMP_PENDING)

    // TDI_SEND call is imminent or in progress on send Irp i
#define AFD_TP_SEND_CALL_PENDING(i) (0x00010000<<((i)*2))
    // Send completion is expected on send Irp i
#define AFD_TP_SEND_COMP_PENDING(i) (0x00020000<<((i)*2))
#define AFD_TP_SEND_BUSY(i)         (0x00030000<<((i)*2))
#define AFD_TP_SEND_MASK            (0x55550000)


#if DBG
//
// N.B. This structure MUST be alligned on memory allocation boundary
//

typedef struct DECLSPEC_ALIGN(MEMORY_ALLOCATION_ALIGNMENT) _AFD_POOL_HEADER {
    SIZE_T Size;
    PCHAR FileName;
    ULONG LineNumber;
    LONG  InUse;
} AFD_POOL_HEADER, *PAFD_POOL_HEADER;
#define AFD_POOL_OVERHEAD  (sizeof(AFD_POOL_HEADER))
#else
#define AFD_POOL_OVERHEAD   0
#endif

//
// This macro verifies that the 32-bit mapping of the structures in 64-bit
// compiler match original 32-bit structures.  Note, that the verification is
// performed when this file is compiled by 32 bit compiler, but
// the actual structures are used by 64 bit code.
//

#ifdef _WIN64
#define AFD_CHECK32on64(_str,_fld)
#define AFD_MAX_NATURAL_ALIGNMENT32  sizeof(ULONG)
#else
#define AFD_CHECK32on64(_str,_fld)    \
    C_ASSERT (FIELD_OFFSET (_str,_fld)==FIELD_OFFSET(_str##32,_fld))
#endif

//
// Structures for mapping IOCTL parameters for 32-bit clients on 64-bit
// platform.
//
typedef UNALIGNED struct _WSABUF32 {
    ULONG            len;
    AFD_POINTER_32   buf;
} WSABUF32, *LPWSABUF32;
AFD_CHECK32on64(WSABUF,len);
AFD_CHECK32on64(WSABUF,buf);

typedef UNALIGNED struct _QualityOfService32 {
    FLOWSPEC      SendingFlowspec;       /* the flow spec for data sending */
    FLOWSPEC      ReceivingFlowspec;     /* the flow spec for data receiving */
    WSABUF32      ProviderSpecific;      /* additional provider specific stuff */
} QOS32, * LPQOS32;
AFD_CHECK32on64(QOS,SendingFlowspec);
AFD_CHECK32on64(QOS,ReceivingFlowspec);
AFD_CHECK32on64(QOS,ProviderSpecific);

typedef UNALIGNED struct _AFD_ACCEPT_INFO32 {
    BOOLEAN     SanActive;
    LONG        Sequence;
    VOID * POINTER_32 AcceptHandle;
} AFD_ACCEPT_INFO32, *PAFD_ACCEPT_INFO32;
AFD_CHECK32on64(AFD_ACCEPT_INFO,SanActive);
AFD_CHECK32on64(AFD_ACCEPT_INFO,Sequence);
AFD_CHECK32on64(AFD_ACCEPT_INFO,AcceptHandle);

typedef UNALIGNED struct _AFD_SUPER_ACCEPT_INFO32 {
    BOOLEAN     SanActive;
    BOOLEAN     FixAddressAlignment;
    VOID * POINTER_32 AcceptHandle;
    ULONG ReceiveDataLength;
    ULONG LocalAddressLength;
    ULONG RemoteAddressLength;
} AFD_SUPER_ACCEPT_INFO32, *PAFD_SUPER_ACCEPT_INFO32;
AFD_CHECK32on64(AFD_SUPER_ACCEPT_INFO,SanActive);
AFD_CHECK32on64(AFD_SUPER_ACCEPT_INFO,FixAddressAlignment);
AFD_CHECK32on64(AFD_SUPER_ACCEPT_INFO,AcceptHandle);
AFD_CHECK32on64(AFD_SUPER_ACCEPT_INFO,ReceiveDataLength);
AFD_CHECK32on64(AFD_SUPER_ACCEPT_INFO,LocalAddressLength);
AFD_CHECK32on64(AFD_SUPER_ACCEPT_INFO,RemoteAddressLength);

typedef UNALIGNED struct _AFD_POLL_HANDLE_INFO32 {
    VOID * POINTER_32 Handle;
    ULONG             PollEvents;
    NTSTATUS          Status;
} AFD_POLL_HANDLE_INFO32, *PAFD_POLL_HANDLE_INFO32;
AFD_CHECK32on64(AFD_POLL_HANDLE_INFO,Handle);
AFD_CHECK32on64(AFD_POLL_HANDLE_INFO,PollEvents);
AFD_CHECK32on64(AFD_POLL_HANDLE_INFO,Status);

typedef UNALIGNED struct _AFD_POLL_INFO32 {
    LARGE_INTEGER Timeout;
    ULONG NumberOfHandles;
    BOOLEAN Unique;
    AFD_POLL_HANDLE_INFO32 Handles[1];
} AFD_POLL_INFO32, *PAFD_POLL_INFO32;
AFD_CHECK32on64(AFD_POLL_INFO,Timeout);
AFD_CHECK32on64(AFD_POLL_INFO,NumberOfHandles);
AFD_CHECK32on64(AFD_POLL_INFO,Unique);
AFD_CHECK32on64(AFD_POLL_INFO,Handles);

typedef UNALIGNED struct _AFD_HANDLE_INFO632 {
    VOID * POINTER_32 TdiAddressHandle;
    VOID * POINTER_32 TdiConnectionHandle;
} AFD_HANDLE_INFO32, *PAFD_HANDLE_INFO32;
AFD_CHECK32on64(AFD_HANDLE_INFO,TdiAddressHandle);
AFD_CHECK32on64(AFD_HANDLE_INFO,TdiConnectionHandle);

typedef UNALIGNED struct _AFD_TRANSMIT_FILE_INFO32 {
    LARGE_INTEGER Offset;
    LARGE_INTEGER WriteLength;
    ULONG SendPacketLength;
    VOID * POINTER_32 FileHandle;
    AFD_POINTER_32 Head;
    ULONG HeadLength;
    AFD_POINTER_32 Tail;
    ULONG TailLength;
    ULONG Flags;
} AFD_TRANSMIT_FILE_INFO32, *PAFD_TRANSMIT_FILE_INFO32;
AFD_CHECK32on64(AFD_TRANSMIT_FILE_INFO,Offset);
AFD_CHECK32on64(AFD_TRANSMIT_FILE_INFO,WriteLength);
AFD_CHECK32on64(AFD_TRANSMIT_FILE_INFO,SendPacketLength);
AFD_CHECK32on64(AFD_TRANSMIT_FILE_INFO,FileHandle);
AFD_CHECK32on64(AFD_TRANSMIT_FILE_INFO,Head);
AFD_CHECK32on64(AFD_TRANSMIT_FILE_INFO,HeadLength);
AFD_CHECK32on64(AFD_TRANSMIT_FILE_INFO,Tail);
AFD_CHECK32on64(AFD_TRANSMIT_FILE_INFO,TailLength);
AFD_CHECK32on64(AFD_TRANSMIT_FILE_INFO,Flags);

typedef UNALIGNED struct _AFD_SEND_INFO32 {
    AFD_POINTER_32 BufferArray;
    ULONG BufferCount;
    ULONG AfdFlags;
    ULONG TdiFlags;
} AFD_SEND_INFO32, *PAFD_SEND_INFO32;
AFD_CHECK32on64(AFD_SEND_INFO,BufferArray);
AFD_CHECK32on64(AFD_SEND_INFO,BufferCount);
AFD_CHECK32on64(AFD_SEND_INFO,AfdFlags);
AFD_CHECK32on64(AFD_SEND_INFO,TdiFlags);

typedef UNALIGNED struct _TDI_REQUEST32 {
    union {
        VOID * POINTER_32 AddressHandle;
        VOID * POINTER_32 ConnectionContext;
        VOID * POINTER_32 ControlChannel;
    } Handle;

    VOID * POINTER_32 RequestNotifyObject;
    VOID * POINTER_32 RequestContext;
    TDI_STATUS TdiStatus;
} TDI_REQUEST32, *PTDI_REQUEST32;
AFD_CHECK32on64(TDI_REQUEST,Handle);
AFD_CHECK32on64(TDI_REQUEST,RequestNotifyObject);
AFD_CHECK32on64(TDI_REQUEST,RequestContext);
AFD_CHECK32on64(TDI_REQUEST,TdiStatus);

typedef UNALIGNED struct _TDI_CONNECTION_INFORMATION32 {
    LONG UserDataLength;            // length of user data buffer
    AFD_POINTER_32 UserData;        // pointer to user data buffer
    LONG OptionsLength;             // length of follwoing buffer
    AFD_POINTER_32 Options;         // pointer to buffer containing options
    LONG RemoteAddressLength;       // length of following buffer
    AFD_POINTER_32 RemoteAddress;   // buffer containing the remote address
} TDI_CONNECTION_INFORMATION32, *PTDI_CONNECTION_INFORMATION32;
AFD_CHECK32on64(TDI_CONNECTION_INFORMATION,UserDataLength);
AFD_CHECK32on64(TDI_CONNECTION_INFORMATION,UserData);
AFD_CHECK32on64(TDI_CONNECTION_INFORMATION,OptionsLength);
AFD_CHECK32on64(TDI_CONNECTION_INFORMATION,Options);
AFD_CHECK32on64(TDI_CONNECTION_INFORMATION,RemoteAddressLength);
AFD_CHECK32on64(TDI_CONNECTION_INFORMATION,RemoteAddress);

typedef UNALIGNED struct _TDI_REQUEST_SEND_DATAGRAM32 {
    TDI_REQUEST32 Request;
    AFD_POINTER_32 SendDatagramInformation;
} TDI_REQUEST_SEND_DATAGRAM32, *PTDI_REQUEST_SEND_DATAGRAM32;
AFD_CHECK32on64(TDI_REQUEST_SEND_DATAGRAM,Request);
AFD_CHECK32on64(TDI_REQUEST_SEND_DATAGRAM,SendDatagramInformation);


typedef UNALIGNED struct _AFD_SEND_DATAGRAM_INFO32 {
    AFD_POINTER_32 BufferArray;
    ULONG BufferCount;
    ULONG AfdFlags;
    TDI_REQUEST_SEND_DATAGRAM32 TdiRequest;
    TDI_CONNECTION_INFORMATION32 TdiConnInfo;
} AFD_SEND_DATAGRAM_INFO32, *PAFD_SEND_DATAGRAM_INFO32;
AFD_CHECK32on64(AFD_SEND_DATAGRAM_INFO,BufferArray);
AFD_CHECK32on64(AFD_SEND_DATAGRAM_INFO,BufferCount);
AFD_CHECK32on64(AFD_SEND_DATAGRAM_INFO,AfdFlags);
AFD_CHECK32on64(AFD_SEND_DATAGRAM_INFO,TdiRequest);
AFD_CHECK32on64(AFD_SEND_DATAGRAM_INFO,TdiConnInfo);

typedef UNALIGNED struct _AFD_RECV_INFO32 {
    AFD_POINTER_32 BufferArray;
    ULONG BufferCount;
    ULONG AfdFlags;
    ULONG TdiFlags;
} AFD_RECV_INFO32, *PAFD_RECV_INFO32;
AFD_CHECK32on64(AFD_RECV_INFO,BufferArray);
AFD_CHECK32on64(AFD_RECV_INFO,BufferCount);
AFD_CHECK32on64(AFD_RECV_INFO,AfdFlags);
AFD_CHECK32on64(AFD_RECV_INFO,TdiFlags);

typedef UNALIGNED struct _AFD_RECV_DATAGRAM_INFO32 {
    AFD_POINTER_32 BufferArray;
    ULONG BufferCount;
    ULONG AfdFlags;
    ULONG TdiFlags;
    AFD_POINTER_32 Address;
    AFD_POINTER_32 AddressLength;
} AFD_RECV_DATAGRAM_INFO32, *PAFD_RECV_DATAGRAM_INFO32;
AFD_CHECK32on64(AFD_RECV_DATAGRAM_INFO,BufferArray);
AFD_CHECK32on64(AFD_RECV_DATAGRAM_INFO,BufferCount);
AFD_CHECK32on64(AFD_RECV_DATAGRAM_INFO,AfdFlags);
AFD_CHECK32on64(AFD_RECV_DATAGRAM_INFO,TdiFlags);
AFD_CHECK32on64(AFD_RECV_DATAGRAM_INFO,Address);
AFD_CHECK32on64(AFD_RECV_DATAGRAM_INFO,AddressLength);

typedef UNALIGNED struct _AFD_CONNECT_JOIN_INFO32 {
    BOOLEAN     SanActive;
    VOID * POINTER_32   RootEndpoint;   // Root endpoint for joins
    VOID * POINTER_32   ConnectEndpoint;// Connect/leaf endpoint for async connects
    TRANSPORT_ADDRESS   RemoteAddress;  // Remote address
} AFD_CONNECT_JOIN_INFO32, *PAFD_CONNECT_JOIN_INFO32;
AFD_CHECK32on64(AFD_CONNECT_JOIN_INFO,SanActive);
AFD_CHECK32on64(AFD_CONNECT_JOIN_INFO,RootEndpoint);
AFD_CHECK32on64(AFD_CONNECT_JOIN_INFO,ConnectEndpoint);
AFD_CHECK32on64(AFD_CONNECT_JOIN_INFO,RemoteAddress);

typedef UNALIGNED struct _AFD_EVENT_SELECT_INFO32 {
    VOID * POINTER_32 Event;
    ULONG PollEvents;
} AFD_EVENT_SELECT_INFO32, *PAFD_EVENT_SELECT_INFO32;
AFD_CHECK32on64(AFD_EVENT_SELECT_INFO,Event);
AFD_CHECK32on64(AFD_EVENT_SELECT_INFO,PollEvents);

typedef UNALIGNED struct _AFD_QOS_INFO32 {
    QOS32 Qos;
    BOOLEAN GroupQos;
} AFD_QOS_INFO32, *PAFD_QOS_INFO32;
AFD_CHECK32on64(AFD_QOS_INFO,Qos);
AFD_CHECK32on64(AFD_QOS_INFO,GroupQos);

typedef UNALIGNED struct _AFD_TRANSPORT_IOCTL_INFO32 {
    VOID *  POINTER_32 Handle;
    AFD_POINTER_32 InputBuffer;
    ULONG   InputBufferLength;
    ULONG   IoControlCode;
    ULONG   AfdFlags;
    ULONG   PollEvent;
} AFD_TRANSPORT_IOCTL_INFO32, *PAFD_TRANSPORT_IOCTL_INFO32;
AFD_CHECK32on64(AFD_TRANSPORT_IOCTL_INFO,Handle);
AFD_CHECK32on64(AFD_TRANSPORT_IOCTL_INFO,InputBuffer);
AFD_CHECK32on64(AFD_TRANSPORT_IOCTL_INFO,InputBufferLength);
AFD_CHECK32on64(AFD_TRANSPORT_IOCTL_INFO,IoControlCode);
AFD_CHECK32on64(AFD_TRANSPORT_IOCTL_INFO,AfdFlags);
AFD_CHECK32on64(AFD_TRANSPORT_IOCTL_INFO,PollEvent);

typedef UNALIGNED struct _TRANSMIT_PACKETS_ELEMENT32 {
    ULONG dwElFlags;
#define TP_MEMORY   1
#define TP_FILE     2
#define TP_EOP      4
    ULONG cLength;
    union {
        struct {
            LARGE_INTEGER       nFileOffset;
            VOID *  POINTER_32  hFile;
        };
        AFD_POINTER_32          pBuffer;
    };
} TRANSMIT_PACKETS_ELEMENT32, *LPTRANSMIT_PACKETS_ELEMENT32;
AFD_CHECK32on64(TRANSMIT_PACKETS_ELEMENT,dwElFlags);
AFD_CHECK32on64(TRANSMIT_PACKETS_ELEMENT,nFileOffset);
AFD_CHECK32on64(TRANSMIT_PACKETS_ELEMENT,hFile);
AFD_CHECK32on64(TRANSMIT_PACKETS_ELEMENT,pBuffer);

typedef UNALIGNED struct _AFD_TPACKETS_INFO32 {
    AFD_POINTER_32              ElementArray;
    ULONG                       ElementCount;
    ULONG                       SendSize;
    ULONG                       Flags;
} AFD_TPACKETS_INFO32, *PAFD_TPACKETS_INFO32;
AFD_CHECK32on64(AFD_TPACKETS_INFO,ElementArray);
AFD_CHECK32on64(AFD_TPACKETS_INFO,ElementCount);
AFD_CHECK32on64(AFD_TPACKETS_INFO,SendSize);
AFD_CHECK32on64(AFD_TPACKETS_INFO,Flags);

typedef UNALIGNED struct _AFD_RECV_MESSAGE_INFO32 {
    AFD_RECV_DATAGRAM_INFO32    dgi;
    AFD_POINTER_32              ControlBuffer;
    AFD_POINTER_32              ControlLength;
    AFD_POINTER_32              MsgFlags;
} AFD_RECV_MESSAGE_INFO32, *PAFD_RECV_MESSAGE_INFO32;
AFD_CHECK32on64(AFD_RECV_MESSAGE_INFO,dgi);
AFD_CHECK32on64(AFD_RECV_MESSAGE_INFO,MsgFlags);
AFD_CHECK32on64(AFD_RECV_MESSAGE_INFO,ControlBuffer);
AFD_CHECK32on64(AFD_RECV_MESSAGE_INFO,ControlLength);


typedef UNALIGNED struct _AFD_SWITCH_OPEN_PACKET32 {
    VOID * POINTER_32   CompletionPort; 
    VOID * POINTER_32   CompletionEvent;
} AFD_SWITCH_OPEN_PACKET32, *PAFD_SWITCH_OPEN_PACKET32;
AFD_CHECK32on64(AFD_SWITCH_OPEN_PACKET,CompletionPort);
AFD_CHECK32on64(AFD_SWITCH_OPEN_PACKET,CompletionEvent);

typedef UNALIGNED struct _AFD_SWITCH_CONTEXT_INFO32 {
    VOID * POINTER_32               SocketHandle;
    AFD_POINTER_32                  SwitchContext;
} AFD_SWITCH_CONTEXT_INFO32, *PAFD_SWITCH_CONTEXT_INFO32;
AFD_CHECK32on64(AFD_SWITCH_CONTEXT_INFO,SocketHandle);
AFD_CHECK32on64(AFD_SWITCH_CONTEXT_INFO,SwitchContext);

typedef UNALIGNED struct _AFD_SWITCH_CONNECT_INFO32 {
    VOID * POINTER_32               ListenHandle;
    AFD_POINTER_32                  SwitchContext;
    TRANSPORT_ADDRESS               RemoteAddress;
} AFD_SWITCH_CONNECT_INFO32, *PAFD_SWITCH_CONNECT_INFO32;
AFD_CHECK32on64(AFD_SWITCH_CONNECT_INFO,ListenHandle);
AFD_CHECK32on64(AFD_SWITCH_CONNECT_INFO,SwitchContext);
AFD_CHECK32on64(AFD_SWITCH_CONNECT_INFO,RemoteAddress);

typedef UNALIGNED struct _AFD_SWITCH_ACCEPT_INFO32 {
    VOID * POINTER_32   AcceptHandle;
    ULONG               ReceiveLength;
} AFD_SWITCH_ACCEPT_INFO32, *PAFD_SWITCH_ACCEPT_INFO32;
AFD_CHECK32on64(AFD_SWITCH_ACCEPT_INFO,AcceptHandle);
AFD_CHECK32on64(AFD_SWITCH_ACCEPT_INFO,ReceiveLength);

typedef UNALIGNED struct _AFD_SWITCH_EVENT_INFO32 {
    VOID * POINTER_32   SocketHandle;
    AFD_POINTER_32      SwitchContext;
    ULONG               EventBit;
    NTSTATUS            Status;
} AFD_SWITCH_EVENT_INFO32, *PAFD_SWITCH_EVENT_INFO32;
AFD_CHECK32on64(AFD_SWITCH_EVENT_INFO,SocketHandle);
AFD_CHECK32on64(AFD_SWITCH_EVENT_INFO,SwitchContext);
AFD_CHECK32on64(AFD_SWITCH_EVENT_INFO,EventBit);
AFD_CHECK32on64(AFD_SWITCH_EVENT_INFO,Status);

typedef UNALIGNED struct _AFD_SWITCH_REQUEST_INFO32 {
    VOID * POINTER_32   SocketHandle;
    AFD_POINTER_32      SwitchContext;
    AFD_POINTER_32      RequestContext;
    NTSTATUS            RequestStatus;
    ULONG               DataOffset;
} AFD_SWITCH_REQUEST_INFO32, *PAFD_SWITCH_REQUEST_INFO32;
AFD_CHECK32on64(AFD_SWITCH_REQUEST_INFO,SocketHandle);
AFD_CHECK32on64(AFD_SWITCH_REQUEST_INFO,SwitchContext);
AFD_CHECK32on64(AFD_SWITCH_REQUEST_INFO,RequestContext);
AFD_CHECK32on64(AFD_SWITCH_REQUEST_INFO,RequestStatus);
AFD_CHECK32on64(AFD_SWITCH_REQUEST_INFO,DataOffset);

typedef UNALIGNED struct _AFD_SWITCH_ACQUIRE_CTX_INFO32 {
    VOID * POINTER_32   SocketHandle;
    AFD_POINTER_32      SwitchContext;
    AFD_POINTER_32      SocketCtxBuf;
    ULONG               SocketCtxBufSize;
} AFD_SWITCH_ACQUIRE_CTX_INFO32, *PAFD_SWITCH_ACQUIRE_CTX_INFO32;
AFD_CHECK32on64(AFD_SWITCH_ACQUIRE_CTX_INFO,SocketHandle);
AFD_CHECK32on64(AFD_SWITCH_ACQUIRE_CTX_INFO,SwitchContext);
AFD_CHECK32on64(AFD_SWITCH_ACQUIRE_CTX_INFO,SocketCtxBuf);
AFD_CHECK32on64(AFD_SWITCH_ACQUIRE_CTX_INFO,SocketCtxBufSize);

typedef UNALIGNED struct _AFD_SWITCH_TRANSFER_CTX_INFO32 {
    VOID * POINTER_32   SocketHandle;
    AFD_POINTER_32      SwitchContext;
    AFD_POINTER_32      RequestContext;
    AFD_POINTER_32      SocketCtxBuf;
    ULONG               SocketCtxBufSize;
    AFD_POINTER_32      RcvBufferArray;
    ULONG               RcvBufferCount;
    NTSTATUS            Status;
} AFD_SWITCH_TRANSFER_CTX_INFO32, *PAFD_SWITCH_TRANSFER_CTX_INFO32;
AFD_CHECK32on64(AFD_SWITCH_TRANSFER_CTX_INFO,SocketHandle);
AFD_CHECK32on64(AFD_SWITCH_TRANSFER_CTX_INFO,SwitchContext);
AFD_CHECK32on64(AFD_SWITCH_TRANSFER_CTX_INFO,RequestContext);
AFD_CHECK32on64(AFD_SWITCH_TRANSFER_CTX_INFO,SocketCtxBuf);
AFD_CHECK32on64(AFD_SWITCH_TRANSFER_CTX_INFO,SocketCtxBufSize);
AFD_CHECK32on64(AFD_SWITCH_TRANSFER_CTX_INFO,RcvBufferArray);
AFD_CHECK32on64(AFD_SWITCH_TRANSFER_CTX_INFO,RcvBufferCount);
AFD_CHECK32on64(AFD_SWITCH_TRANSFER_CTX_INFO,Status);

typedef UNALIGNED struct _AFD_PARTIAL_DISCONNECT_INFO32 {
    ULONG DisconnectMode;
    LARGE_INTEGER Timeout;
} AFD_PARTIAL_DISCONNECT_INFO32, *PAFD_PARTIAL_DISCONNECT_INFO32;
AFD_CHECK32on64(AFD_PARTIAL_DISCONNECT_INFO,DisconnectMode);
AFD_CHECK32on64(AFD_PARTIAL_DISCONNECT_INFO,Timeout);

typedef UNALIGNED struct _AFD_SUPER_DISCONNECT_INFO32 {
    ULONG  Flags;
} AFD_SUPER_DISCONNECT_INFO32, *PAFD_SUPER_DISCONNECT_INFO32;
AFD_CHECK32on64(AFD_SUPER_DISCONNECT_INFO,Flags);

typedef UNALIGNED struct _AFD_INFORMATION32 {
    ULONG InformationType;
    union {
        BOOLEAN Boolean;
        ULONG Ulong;
        LARGE_INTEGER LargeInteger;
    } Information;
} AFD_INFORMATION32, *PAFD_INFORMATION32;
AFD_CHECK32on64(AFD_INFORMATION,InformationType);
AFD_CHECK32on64(AFD_INFORMATION,Information);
AFD_CHECK32on64(AFD_INFORMATION,Information.Boolean);
AFD_CHECK32on64(AFD_INFORMATION,Information.Ulong);
AFD_CHECK32on64(AFD_INFORMATION,Information.LargeInteger);


typedef UNALIGNED struct _TDI_CMSGHDR32 {
    ULONG       cmsg_len;
    LONG        cmsg_level;
    LONG        cmsg_type;
    /* followed by UCHAR cmsg_data[] */
} TDI_CMSGHDR32, *PTDI_CMSGHDR32;
AFD_CHECK32on64(TDI_CMSGHDR,cmsg_len);
AFD_CHECK32on64(TDI_CMSGHDR,cmsg_level);
AFD_CHECK32on64(TDI_CMSGHDR,cmsg_type);

#ifdef _WIN64
#define TDI_CMSGHDR_ALIGN32(length)                         \
            ( ((length) + TYPE_ALIGNMENT(TDI_CMSGHDR32)-1) &\
                (~(TYPE_ALIGNMENT(TDI_CMSGHDR32)-1)) )      \

#define TDI_CMSGDATA_ALIGN32(length)                        \
            ( ((length) + AFD_MAX_NATURAL_ALIGNMENT32-1) &  \
                (~(AFD_MAX_NATURAL_ALIGNMENT32-1)) )
#endif //_WIN64

#endif // ndef _AFDSTR_