|
|
/*++
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_
//
// 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 MAX_REFERENCE 64
typedef union _AFD_REFERENCE_DEBUG { struct { ULONGLONG NewCount:4; ULONGLONG LocationId:12; ULONGLONG TickCount:16; 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;
LONGAfdFindReferenceLocation ( 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) { \
PAFD_REFERENCE_DEBUG _s; \ LONG _n; \ LARGE_INTEGER _t; \ _n = InterlockedIncrement( &(_rd)->CurrentReferenceSlot ); \ _s = &(_rd)->ReferenceDebug[_n % MAX_REFERENCE]; \ _s->NewCount = _r; \ _s->LocationId = _l; \ _s->Param = _p; \ KeQueryTickCount (&_t); \ _s->TickCount = _t.QuadPart; \ }
#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.
//
struct _AFD_ENDPOINT;struct _AFD_CONNECTION;
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 { SINGLE_LIST_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
#define AfdBlockTypeDatagram 0xAFD1
#define AfdBlockTypeVcConnecting 0xAFD2
#define AfdBlockTypeVcListening 0xAFD4
#define AfdBlockTypeVcBoth 0xAFD6
#define AfdBlockTypeConnection 0xAFD8
#define AfdBlockTypeHelper 0xAAFD
#define AfdBlockTypeInvalidConnection 0xEAFD
#define AfdBlockTypeInvalidEndpoint 0xCAFD
#define AfdBlockTypeSanHelper 0x0AFD
#define AfdBlockTypeSanEndpoint 0x1AFD
#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
#define AfdConnectionStateFree 0
#define AfdConnectionStateUnaccepted 1
#define AfdConnectionStateReturned 2
#define AfdConnectionStateConnected 3
#define AfdConnectionStateClosing 4
//
// 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)
AbortIndicated:1, :3, DisconnectIndicated:1, :3, ConnectedReferenceAdded:1, :3, SpecialCondition:1, :3, CleanupBegun:1, :3, ClosePendedTransmit:1, :3, OnLRList:1, SanConnection:1, :2; }; LOGICAL ConnectionStateFlags; };} AFD_CONNECTION_STATE_FLAGS;C_ASSERT (sizeof (AFD_CONNECTION_STATE_FLAGS)==sizeof (LOGICAL));
typedef struct _AFD_CONNECTION { // *** Frequently used, mostly read-only fields (state/type/flag changes are rare).
USHORT Type; USHORT State; AFD_CONNECTION_STATE_FLAGS ;
struct _AFD_ENDPOINT *Endpoint; PFILE_OBJECT FileObject; PDEVICE_OBJECT DeviceObject; PEPROCESS OwningProcess;
union { LONGLONG ConnectTime; PIRP AcceptIrp; PIRP ListenIrp; 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;
CLONG BufferredReceiveBytes; CLONG BufferredExpeditedBytes;
USHORT BufferredReceiveCount; USHORT BufferredExpeditedCount; CLONG ReceiveBytesInTransport;
LIST_ENTRY SendIrpListHead; CLONG BufferredSendBytes; CLONG BufferredSendCount;
PIRP DisconnectIrp;
LONG ReceiveIrpsInTransport; // debug only.
} NonBufferring;
} Common;
CLONG MaxBufferredReceiveBytes; CLONG MaxBufferredSendBytes;
PTRANSPORT_ADDRESS RemoteAddress; ULONG RemoteAddressLength; LONG Sequence;
HANDLE Handle;
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
SINGLE_LIST_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 CurrentReferenceSlot; AFD_REFERENCE_DEBUG ReferenceDebug[MAX_REFERENCE];#endif
#ifdef _AFD_VERIFY_DATA_
ULONGLONG VerifySequenceNumber;#endif // _AFD_VERIFY_DATA_
} AFD_CONNECTION, *PAFD_CONNECTION;
#ifdef _AFD_VERIFY_DATA_
VOIDAfdVerifyBuffer ( PAFD_CONNECTION Connection, PVOID Buffer, ULONG Length );VOIDAfdVerifyMdl ( PAFD_CONNECTION Connection, PMDL Mdl, ULONG Offset, ULONG Length );VOIDAfdVerifyAddress ( 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 struct _AFD_TRANSPORT_INFO { LIST_ENTRY TransportInfoListEntry; volatile LONG ReferenceCount; BOOLEAN InfoValid; UNICODE_STRING TransportDeviceName; TDI_PROVIDER_INFO ProviderInfo; //WCHAR TransportDeviceNameStructure;
} AFD_TRANSPORT_INFO, *PAFD_TRANSPORT_INFO;
//
// Endpoint state definitions (can't be zero or state change
// macros won't work correctly).
//
#define AfdEndpointStateOpen 1
#define AfdEndpointStateBound 2
#define AfdEndpointStateConnected 3
#define AfdEndpointStateCleanup 4
#define AfdEndpointStateClosing 5
#define AfdEndpointStateTransmitClosing 6
#define AfdEndpointStateInvalid 7
//
// 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));
typedef 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 ;
PFILE_OBJECT AddressFileObject; PDEVICE_OBJECT AddressDeviceObject; 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;
CLONG BufferredReceiveBytes; CLONG BufferredReceiveCount;
CLONG MaxBufferredReceiveBytes; CLONG BufferredSendBytes; CLONG 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
} 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; CLONG ContextLength;
ULONG LocalAddressLength; PTRANSPORT_ADDRESS LocalAddress;
CLONG DisconnectMode; CLONG 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 CurrentReferenceSlot; AFD_REFERENCE_DEBUG ReferenceDebug[MAX_REFERENCE];#endif
#if DBG
LIST_ENTRY OutstandingIrpListHead; LONG ObReferenceBias;#endif
} AFD_ENDPOINT, *PAFD_ENDPOINT;
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 \ : 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 { \ CLONG DataOffset; /* offset in buffer to start of unread data*/\ union { \ ULONG DatagramFlags; /* flags for datagrams with control info */\ CLONG 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*/ \ CLONG DataLength; /* actual data in the buffer */ \ CLONG 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;
typedef DECLSPEC_ALIGN(MEMORY_ALLOCATION_ALIGNMENT) 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
} AFD_BUFFER, *PAFD_BUFFER;
//
// 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.
//
#define AFD_PLACEMENT_HDR 0
#define AFD_PLACEMENT_IRP 1
#define AFD_PLACEMENT_MDL 2
#define AFD_PLACEMENT_BUFFER 3
#define AFD_PLACEMENT_HDR_IRP (AFD_PLACEMENT_HDR|(AFD_PLACEMENT_IRP<<2))
#define AFD_PLACEMENT_HDR_MDL (AFD_PLACEMENT_HDR|(AFD_PLACEMENT_MDL<<2))
#define AFD_PLACEMENT_IRP_MDL (AFD_PLACEMENT_IRP|(AFD_PLACEMENT_MDL<<2))
#define 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().
//
typedefBOOLEAN(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.
//
typedef 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 PUINT_PTR Information );
typedefNTSTATUS(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
//
typedef struct _AFD_TPACKETS_INFO_INTERNAL AFD_TPACKETS_INFO_INTERNAL, *PAFD_TPACKETS_INFO_INTERNAL;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 CurrentReferenceSlot; AFD_REFERENCE_DEBUG ReferenceDebug[MAX_REFERENCE];#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 { LIST_ENTRY EndpQueueEntry; volatile LONG ReferenceCount; volatile LONG StateFlags;} AFD_TPACKETS_IRP_CTX, *PAFD_TPACKETS_IRP_CTX;
#define AFD_TP_ABORT_PENDING 0x00000001 // Request is being aborted
#define AFD_TP_WORKER_SCHEDULED 0x00000010 // Worker is scheduled or active
#ifdef TDI_SERVICE_SEND_AND_DISCONNECT
#define AFD_TP_SEND_AND_DISCONNECT 0x00000100 // 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)
#define AFD_GET_TPIC(_i) ((PAFD_TPACKETS_IRP_CTX)&(_i)->Tail.Overlay.DriverContext)
//
// 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; CHAR * 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; VOID * POINTER_32 Head; ULONG HeadLength; VOID * 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 { WSABUF32 * 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
VOID * POINTER_32 UserData; // pointer to user data buffer
LONG OptionsLength; // length of follwoing buffer
VOID * POINTER_32 Options; // pointer to buffer containing options
LONG RemoteAddressLength; // length of following buffer
VOID * 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; TDI_CONNECTION_INFORMATION32 * 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 { WSABUF32 * 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 { WSABUF32 * 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 { WSABUF32 * POINTER_32 BufferArray; ULONG BufferCount; ULONG AfdFlags; ULONG TdiFlags; VOID * POINTER_32 Address; ULONG * 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; VOID * 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; }; VOID * 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 { TRANSMIT_PACKETS_ELEMENT * 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; VOID * POINTER_32 ControlBuffer; ULONG * POINTER_32 ControlLength; ULONG * 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_SWITCH_CONTEXT * 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_SWITCH_CONTEXT * 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_SWITCH_CONTEXT * 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_SWITCH_CONTEXT * POINTER_32 SwitchContext; VOID * 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_SWITCH_CONTEXT * POINTER_32 SwitchContext; VOID * 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_SWITCH_CONTEXT * POINTER_32 SwitchContext; VOID * POINTER_32 RequestContext; VOID * POINTER_32 SocketCtxBuf; ULONG SocketCtxBufSize; WSABUF * 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_
|
