1454 lines
36 KiB
C
1454 lines
36 KiB
C
/*********************************************************************/
|
|
/** Microsoft Generic Packet Scheduler **/
|
|
/** Copyright(c) Microsoft Corp., 1996-1997 **/
|
|
/********************************************************************/
|
|
|
|
#ifndef __GPCDEF
|
|
#define __GPCDEF
|
|
|
|
//*** gpcdef.h - GPC internal definitions & prototypes
|
|
//
|
|
// This file containes all the GPC data structures & defines
|
|
|
|
|
|
/*
|
|
/////////////////////////////////////////////////////////////////
|
|
//
|
|
// defines
|
|
//
|
|
/////////////////////////////////////////////////////////////////
|
|
*/
|
|
|
|
//
|
|
// Max number of clients per blob (same CF)
|
|
//
|
|
// AbhisheV - This can not be more than sizeof(ULONG)*8.
|
|
//
|
|
|
|
#define MAX_CLIENTS_CTX_PER_BLOB 8
|
|
|
|
|
|
//
|
|
// Max pattern size,
|
|
// GPC_IP_PATTERN = 24 bytes
|
|
// GPC_IPX_PATTERN = 24 bytes
|
|
//
|
|
#define MAX_PATTERN_SIZE sizeof(GPC_IP_PATTERN)
|
|
|
|
extern BOOLEAN IsItChanging;
|
|
|
|
//
|
|
// Pattern flags
|
|
//
|
|
#define PATTERN_SPECIFIC 0x00000001
|
|
#define PATTERN_AUTO 0x00000002
|
|
#define PATTERN_REMOVE_CB_BLOB 0x00000004
|
|
|
|
//
|
|
// Auto Pattern defines
|
|
//
|
|
|
|
// Every PATTERN_TIMEOUT seconds, the PatternTimerExpiry Routine gets called.
|
|
#define PATTERN_TIMEOUT 60000 // 60 seconds
|
|
|
|
// This is the amount of time that a Pattern created for optimization
|
|
// lives on the Pattern List.
|
|
#define AUTO_PATTERN_ENTRY_TIMEOUT 300000 // 5 minutes
|
|
|
|
// This is the number of timer granularity.
|
|
#define NUMBER_OF_WHEELS (AUTO_PATTERN_ENTRY_TIMEOUT/PATTERN_TIMEOUT)
|
|
|
|
// New debug locks [ShreeM]
|
|
// This will enable us to figure out who took the lock last
|
|
// and who released it last. New structure defined below and
|
|
// lock_acquire and lock_release macros are redefined later.
|
|
|
|
typedef struct _GPC_LOCK {
|
|
|
|
NDIS_SPIN_LOCK Lock;
|
|
|
|
#if DBG
|
|
PETHREAD CurrentThread;
|
|
KIRQL CurrentIRQL;
|
|
LONG LockAcquired; // is it current held?
|
|
UCHAR LastAcquireFile[8];
|
|
ULONG LastAcquireLine;
|
|
UCHAR LastReleaseFile[8];
|
|
ULONG LastReleaseLine;
|
|
#endif
|
|
|
|
} GPC_LOCK, PGPC_LOCK;
|
|
|
|
//
|
|
//
|
|
// states for blobs, patterns and more
|
|
//
|
|
typedef enum {
|
|
|
|
GPC_STATE_READY = 0,
|
|
GPC_STATE_INIT,
|
|
GPC_STATE_ADD,
|
|
GPC_STATE_MODIFY,
|
|
GPC_STATE_REMOVE,
|
|
GPC_STATE_FORCE_REMOVE,
|
|
GPC_STATE_DELETE,
|
|
GPC_STATE_INVALID,
|
|
GPC_STATE_NOTREADY,
|
|
GPC_STATE_ERROR,
|
|
GPC_STATE_PENDING
|
|
|
|
} GPC_STATE;
|
|
|
|
|
|
//
|
|
// ObjectVerification macro
|
|
//
|
|
#define VERIFY_OBJECT(_obj, _val) if(_obj) \
|
|
{if(*(GPC_ENUM_OBJECT_TYPE *)_obj!=_val) return STATUS_INVALID_HANDLE;}
|
|
|
|
//
|
|
// define event log error codes
|
|
//
|
|
#define GPC_ERROR_INIT_MAIN 0x00010000
|
|
#define GPC_ERROR_INIT_IOCTL 0x00020000
|
|
|
|
|
|
#define GPC_FLAGS_USERMODE_CLIENT 0x80000000
|
|
|
|
#define IS_USERMODE_CLIENT(_pc) \
|
|
TEST_BIT_ON((_pc)->Flags,GPC_FLAGS_USERMODE_CLIENT)
|
|
|
|
|
|
//
|
|
// for ioctl
|
|
//
|
|
#define SHUTDOWN_DELETE_DEVICE 0x00000100
|
|
#define SHUTDOWN_DELETE_SYMLINK 0x00000200
|
|
|
|
//
|
|
// helper macros
|
|
//
|
|
#define TEST_BIT_ON(_v,_b) (((_v)&(_b))==(_b))
|
|
#define TEST_BIT_OFF(_v,_b) (((_v)&(_b))==0)
|
|
|
|
#if DBG
|
|
|
|
#define NDIS_INIT_LOCK(_sl) {\
|
|
NdisAllocateSpinLock(&(_sl)->Lock); \
|
|
TRACE(LOCKS,(_sl),(_sl)->Lock.OldIrql,"LOCK");\
|
|
(_sl)->LockAcquired = -1; \
|
|
strncpy((_sl)->LastAcquireFile, strrchr(__FILE__,'\\')+1, 7); \
|
|
(_sl)->LastAcquireLine = __LINE__; \
|
|
strncpy((_sl)->LastReleaseFile, strrchr(__FILE__,'\\')+1, 7); \
|
|
(_sl)->LastReleaseLine = __LINE__; \
|
|
(_sl)->CurrentIRQL = KeGetCurrentIrql(); \
|
|
(_sl)->CurrentThread = PsGetCurrentThread(); \
|
|
}
|
|
|
|
#define NDIS_LOCK(_sl) {\
|
|
NdisAcquireSpinLock(&(_sl)->Lock);\
|
|
TRACE(LOCKS,(_sl),(_sl)->Lock.OldIrql,"LOCK");\
|
|
(_sl)->LockAcquired = TRUE; \
|
|
strncpy((_sl)->LastAcquireFile, strrchr(__FILE__,'\\')+1, 7); \
|
|
(_sl)->LastAcquireLine = __LINE__; \
|
|
(_sl)->CurrentIRQL = KeGetCurrentIrql(); \
|
|
(_sl)->CurrentThread = PsGetCurrentThread(); \
|
|
}
|
|
|
|
#define NDIS_UNLOCK(_sl) {\
|
|
(_sl)->LockAcquired = FALSE; \
|
|
strncpy((_sl)->LastReleaseFile, strrchr(__FILE__,'\\')+1, 7); \
|
|
(_sl)->LastReleaseLine = __LINE__; \
|
|
TRACE(LOCKS,(_sl),(_sl)->Lock.OldIrql,"UNLOCK");\
|
|
NdisReleaseSpinLock(&(_sl)->Lock);\
|
|
}
|
|
|
|
#define NDIS_DPR_LOCK(_sl) {\
|
|
NdisDprAcquireSpinLock(&(_sl)->Lock);\
|
|
TRACE(LOCKS,(_sl),(_sl)->Lock.OldIrql,"DPR_LOCK");\
|
|
(_sl)->LockAcquired = TRUE; \
|
|
strncpy((_sl)->LastAcquireFile, strrchr(__FILE__,'\\')+1, 7); \
|
|
(_sl)->LastAcquireLine = __LINE__; \
|
|
(_sl)->CurrentIRQL = KeGetCurrentIrql(); \
|
|
(_sl)->CurrentThread = PsGetCurrentThread(); \
|
|
}
|
|
|
|
#define NDIS_DPR_UNLOCK(_sl) {\
|
|
(_sl)->LockAcquired = FALSE; \
|
|
strncpy((_sl)->LastReleaseFile, strrchr(__FILE__,'\\')+1, 7); \
|
|
(_sl)->LastReleaseLine = __LINE__; \
|
|
TRACE(LOCKS,(_sl),(_sl)->Lock.OldIrql,"DPR_UNLOCK");\
|
|
NdisDprReleaseSpinLock(&(_sl)->Lock);\
|
|
}
|
|
|
|
#else
|
|
|
|
#define NDIS_INIT_LOCK(_sl) NdisAllocateSpinLock(&(_sl)->Lock)
|
|
#define NDIS_LOCK(_sl) NdisAcquireSpinLock(&(_sl)->Lock)
|
|
#define NDIS_UNLOCK(_sl) NdisReleaseSpinLock(&(_sl)->Lock)
|
|
#define NDIS_DPR_LOCK(_sl) NdisDprAcquireSpinLock(&(_sl)->Lock)
|
|
#define NDIS_DPR_UNLOCK(_sl) NdisDprReleaseSpinLock(&(_sl)->Lock)
|
|
|
|
#endif
|
|
|
|
#if DBG && EXTRA_DBG
|
|
#define VERIFY_LIST(_l) DbgVerifyList(_l)
|
|
#else
|
|
#define VERIFY_LIST(_l)
|
|
#endif
|
|
|
|
#define GpcRemoveEntryList(_pl) {PLIST_ENTRY _q = (_pl)->Flink;VERIFY_LIST(_pl);RemoveEntryList(_pl);InitializeListHead(_pl);VERIFY_LIST(_q);}
|
|
#define GpcInsertTailList(_l,_e) VERIFY_LIST(_l);InsertTailList(_l,_e);VERIFY_LIST(_e)
|
|
#define GpcInsertHeadList(_l,_e) VERIFY_LIST(_l);InsertHeadList(_l,_e);VERIFY_LIST(_e)
|
|
|
|
#if 0
|
|
#define GpcInterlockedInsertTailList(_l,_e,_s) \
|
|
NdisInterlockedInsertTailList(_l,_e,_s)
|
|
|
|
#else
|
|
|
|
#define GpcInterlockedInsertTailList(_l,_e,_s) \
|
|
{NDIS_LOCK(_s);VERIFY_LIST(_l);InsertTailList(_l,_e);VERIFY_LIST(_l);NDIS_UNLOCK(_s);}
|
|
#endif
|
|
|
|
|
|
#if NEW_MRSW
|
|
|
|
#define INIT_LOCK InitializeMRSWLock
|
|
#define READ_LOCK EnterReader
|
|
#define READ_UNLOCK ExitReader
|
|
#define WRITE_LOCK EnterWriter
|
|
#define WRITE_UNLOCK ExitWriter
|
|
|
|
#else
|
|
|
|
#define INIT_LOCK InitializeMRSWLock
|
|
#define READ_LOCK AcquireReadLock
|
|
#define READ_UNLOCK ReleaseReadLock
|
|
#define WRITE_LOCK AcquireWriteLock
|
|
#define WRITE_UNLOCK ReleaseWriteLock
|
|
|
|
#endif
|
|
|
|
//
|
|
// Get the CF index from the client block
|
|
//
|
|
#define GetCFIndexFromClient(_cl) (((PCLIENT_BLOCK)(_cl))->pCfBlock->AssignedIndex)
|
|
|
|
//
|
|
// Get the client index from the client block
|
|
//
|
|
#define GetClientIndexFromClient(_cl) (((PCLIENT_BLOCK)(_cl))->AssignedIndex)
|
|
|
|
//
|
|
// return the blob block pointer for the pattern:
|
|
// for specific patterns - its the blob entry in the CB
|
|
// for generic patterns - its the pBlobBlock
|
|
//
|
|
#define GetBlobFromPattern(_p,_i) (_p)->arpBlobBlock[_i]
|
|
|
|
|
|
//
|
|
// return the index bit to the ULONG
|
|
//
|
|
#define ReleaseClientIndex(_v,_i) _v&=~(1<<_i) // clear the bit
|
|
|
|
//
|
|
// statistics macros
|
|
//
|
|
#define StatInc(_m) (glStat._m)++
|
|
#define StatDec(_m) (glStat._m)--
|
|
#define CfStatInc(_cf,_m) (glStat.CfStat[_cf]._m)++
|
|
#define CfStatDec(_cf,_m) (glStat.CfStat[_cf]._m)--
|
|
#define ProtocolStatInc(_p,_m) (glStat.ProtocolStat[_p]._m)++
|
|
#define ProtocolStatDec(_p,_m) (glStat.ProtocolStat[_p]._m)--
|
|
|
|
/*
|
|
/////////////////////////////////////////////////////////////////
|
|
//
|
|
// typedef
|
|
//
|
|
/////////////////////////////////////////////////////////////////
|
|
*/
|
|
|
|
|
|
//
|
|
// completion opcodes
|
|
//
|
|
typedef enum {
|
|
|
|
OP_ANY_CFINFO,
|
|
OP_ADD_CFINFO,
|
|
OP_MODIFY_CFINFO,
|
|
OP_REMOVE_CFINFO
|
|
|
|
} GPC_COMPLETION_OP;
|
|
|
|
|
|
//
|
|
// define object type enum for handle verification
|
|
//
|
|
typedef enum {
|
|
|
|
GPC_ENUM_INVALID,
|
|
GPC_ENUM_CLIENT_TYPE,
|
|
GPC_ENUM_CFINFO_TYPE,
|
|
GPC_ENUM_PATTERN_TYPE
|
|
|
|
} GPC_ENUM_OBJECT_TYPE;
|
|
|
|
|
|
typedef struct _CF_BLOCK CF_BLOCK;
|
|
typedef struct _PATTERN_BLOCK PATTERN_BLOCK;
|
|
|
|
|
|
//
|
|
// A queued notification structure
|
|
//
|
|
typedef struct _QUEUED_NOTIFY {
|
|
|
|
LIST_ENTRY Linkage;
|
|
GPC_NOTIFY_REQUEST_RES NotifyRes;
|
|
PFILE_OBJECT FileObject;
|
|
|
|
} QUEUED_NOTIFY, *PQUEUED_NOTIFY;
|
|
|
|
|
|
//
|
|
// A queued completion structure
|
|
//
|
|
typedef struct _QUEUED_COMPLETION {
|
|
|
|
GPC_COMPLETION_OP OpCode; // what completed
|
|
GPC_HANDLE ClientHandle;
|
|
GPC_HANDLE CfInfoHandle;
|
|
GPC_STATUS Status;
|
|
|
|
} QUEUED_COMPLETION, *PQUEUED_COMPLETION;
|
|
|
|
|
|
//
|
|
// A pending IRP structure
|
|
//
|
|
typedef struct _PENDING_IRP {
|
|
|
|
LIST_ENTRY Linkage;
|
|
|
|
PIRP Irp;
|
|
PFILE_OBJECT FileObject;
|
|
QUEUED_COMPLETION QComp;
|
|
|
|
} PENDING_IRP, *PPENDING_IRP;
|
|
|
|
|
|
#if NEW_MRSW
|
|
|
|
//
|
|
// Multiple Readers Single Write definitions
|
|
// code has been taken from (tdi\tcpipmerge\ip\ipmlock.h)
|
|
//
|
|
|
|
typedef struct _MRSW_LOCK
|
|
{
|
|
KSPIN_LOCK rlReadLock;
|
|
KSPIN_LOCK rlWriteLock;
|
|
LONG lReaderCount;
|
|
} MRSW_LOCK, *PMRSW_LOCK;
|
|
|
|
#else
|
|
|
|
//
|
|
// Multiple Readers Single Write definitions
|
|
// code has been taken from the filter driver project (routing\ip\fltrdrvr)
|
|
//
|
|
|
|
typedef struct _MRSW_LOCK
|
|
{
|
|
KSPIN_LOCK SpinLock;
|
|
LONG ReaderCount;
|
|
} MRSW_LOCK, *PMRSW_LOCK;
|
|
|
|
#endif
|
|
|
|
|
|
//
|
|
// The generic pattern database struct
|
|
//
|
|
typedef struct _GENERIC_PATTERN_DB {
|
|
|
|
MRSW_LOCK Lock;
|
|
Rhizome *pRhizome; // pointer to a Rhizome
|
|
|
|
} GENERIC_PATTERN_DB, *PGENERIC_PATTERN_DB;
|
|
|
|
|
|
|
|
//
|
|
// A client block is used to store specific client context
|
|
//
|
|
typedef struct _CLIENT_BLOCK {
|
|
|
|
//
|
|
// !!! MUST BE FIRST FIELD !!!
|
|
//
|
|
GPC_ENUM_OBJECT_TYPE ObjectType;
|
|
|
|
LIST_ENTRY ClientLinkage; // client blocks list link
|
|
LIST_ENTRY BlobList; // list of blobs of the client
|
|
|
|
CF_BLOCK *pCfBlock;
|
|
GPC_CLIENT_HANDLE ClientCtx;
|
|
ULONG AssignedIndex;
|
|
ULONG Flags;
|
|
ULONG State;
|
|
GPC_LOCK Lock;
|
|
REF_CNT RefCount;
|
|
PFILE_OBJECT pFileObject; // used for async completion
|
|
GPC_HANDLE ClHandle; // handle returned to the client
|
|
GPC_CLIENT_FUNC_LIST FuncList;
|
|
|
|
} CLIENT_BLOCK, *PCLIENT_BLOCK;
|
|
|
|
|
|
//
|
|
// A blob (A.K.A CF_INFO) block holds a GPC header + client specific data
|
|
//
|
|
typedef struct _BLOB_BLOCK {
|
|
|
|
//
|
|
// !!! MUST BE FIRST FIELD !!!
|
|
//
|
|
GPC_ENUM_OBJECT_TYPE ObjectType;
|
|
|
|
LIST_ENTRY ClientLinkage; // linked on the client
|
|
LIST_ENTRY PatternList; // head of pattern linked list
|
|
LIST_ENTRY CfLinkage; // blobs on the CF
|
|
|
|
//PCLIENT_BLOCK pClientBlock; // pointer to installer
|
|
REF_CNT RefCount;
|
|
GPC_STATE State;
|
|
ULONG Flags;
|
|
GPC_CLIENT_HANDLE arClientCtx[MAX_CLIENTS_CTX_PER_BLOB];
|
|
ULONG ClientStatusCountDown;
|
|
GPC_STATUS LastStatus;
|
|
GPC_LOCK Lock;
|
|
CTEBlockStruc WaitBlockAddFailed;
|
|
PCLIENT_BLOCK arpClientStatus[MAX_CLIENTS_CTX_PER_BLOB];
|
|
ULONG ClientDataSize;
|
|
PVOID pClientData;
|
|
ULONG NewClientDataSize;
|
|
PVOID pNewClientData;
|
|
PCLIENT_BLOCK pOwnerClient;
|
|
PCLIENT_BLOCK pCallingClient;
|
|
PCLIENT_BLOCK pCallingClient2;
|
|
HANDLE OwnerClientHandle;
|
|
GPC_CLIENT_HANDLE OwnerClientCtx;
|
|
GPC_HANDLE ClHandle; // handle returned to the client
|
|
|
|
//
|
|
// assume only one client can accept the flow
|
|
//
|
|
PCLIENT_BLOCK pNotifiedClient;
|
|
GPC_CLIENT_HANDLE NotifiedClientCtx;
|
|
|
|
#if NO_USER_PENDING
|
|
CTEBlockStruc WaitBlock;
|
|
#endif
|
|
|
|
} BLOB_BLOCK, *PBLOB_BLOCK;
|
|
|
|
//
|
|
// The classification block is an array of blob pointers
|
|
//
|
|
typedef struct _CLASSIFICATION_BLOCK {
|
|
|
|
REF_CNT RefCount;
|
|
ULONG NumberOfElements;
|
|
HFHandle ClassificationHandle; // how to get back to index tbl
|
|
|
|
// must be last
|
|
PBLOB_BLOCK arpBlobBlock[1];
|
|
|
|
} CLASSIFICATION_BLOCK, *PCLASSIFICATION_BLOCK;
|
|
|
|
//
|
|
// A pattern block holds specific data for the pattern
|
|
//
|
|
typedef struct _PATTERN_BLOCK {
|
|
|
|
//
|
|
// !!! MUST BE FIRST FIELD !!!
|
|
//
|
|
GPC_ENUM_OBJECT_TYPE ObjectType;
|
|
GPC_STATE State;
|
|
|
|
LIST_ENTRY BlobLinkage[GPC_CF_MAX]; // linked on the blob
|
|
LIST_ENTRY TimerLinkage;
|
|
|
|
PBLOB_BLOCK arpBlobBlock[GPC_CF_MAX];
|
|
PCLIENT_BLOCK pClientBlock;
|
|
PCLIENT_BLOCK pAutoClient;
|
|
PCLASSIFICATION_BLOCK pClassificationBlock;
|
|
ULONG WheelIndex;
|
|
REF_CNT RefCount;
|
|
ULONG ClientRefCount;
|
|
ULONG TimeToLive; // for internal patterns
|
|
ULONG Flags;
|
|
ULONG Priority; // for generic pattern
|
|
PVOID DbCtx;
|
|
GPC_LOCK Lock;
|
|
GPC_HANDLE ClHandle; // handle returned to the client
|
|
ULONG ProtocolTemplate;
|
|
|
|
} PATTERN_BLOCK, *PPATTERN_BLOCK;
|
|
|
|
|
|
//
|
|
// A CF block struct. This would construct a linked list of Cf blocks.
|
|
//
|
|
typedef struct _CF_BLOCK {
|
|
|
|
REF_CNT RefCount;
|
|
LIST_ENTRY Linkage; // on the global list
|
|
LIST_ENTRY ClientList; // for the client blocks
|
|
LIST_ENTRY BlobList; // list of blobs
|
|
|
|
ULONG NumberOfClients;
|
|
ULONG AssignedIndex;
|
|
ULONG ClientIndexes;
|
|
GPC_LOCK Lock;
|
|
//MRSW_LOCK ClientSync;
|
|
GPC_LOCK ClientSync;
|
|
ULONG MaxPriorities;
|
|
PGENERIC_PATTERN_DB arpGenericDb[GPC_PROTOCOL_TEMPLATE_MAX];
|
|
|
|
} CF_BLOCK, *PCF_BLOCK;
|
|
|
|
|
|
typedef struct _SPECIFIC_PATTERN_DB {
|
|
|
|
MRSW_LOCK Lock;
|
|
PatHashTable *pDb;
|
|
|
|
} SPECIFIC_PATTERN_DB, *PSPECIFIC_PATTERN_DB;
|
|
|
|
|
|
typedef struct _FRAGMENT_DB {
|
|
|
|
MRSW_LOCK Lock;
|
|
PatHashTable *pDb;
|
|
|
|
} FRAGMENT_DB, *PFRAGMENT_DB;
|
|
|
|
|
|
//
|
|
// A context structure to pass to the pathash scan routine
|
|
//
|
|
typedef struct _SCAN_STRUCT {
|
|
|
|
PCLIENT_BLOCK pClientBlock;
|
|
PPATTERN_BLOCK pPatternBlock;
|
|
PBLOB_BLOCK pBlobBlock;
|
|
ULONG Priority;
|
|
BOOLEAN bRemove;
|
|
|
|
} SCAN_STRUCT, *PSCAN_STRUCT;
|
|
|
|
|
|
//
|
|
// A protocol block holds pointers to databases for a specific
|
|
// protocol template
|
|
//
|
|
typedef struct _PROTOCOL_BLOCK {
|
|
|
|
LIST_ENTRY TimerPatternList[NUMBER_OF_WHEELS];
|
|
ULONG CurrentWheelIndex;
|
|
ULONG SpecificPatternCount;
|
|
ULONG GenericPatternCount;
|
|
ULONG AutoSpecificPatternCount;
|
|
ULONG ProtocolTemplate;
|
|
ULONG PatternSize;
|
|
SPECIFIC_PATTERN_DB SpecificDb;
|
|
PVOID pProtocolDb; // fragments
|
|
GPC_LOCK PatternTimerLock[NUMBER_OF_WHEELS];
|
|
NDIS_TIMER PatternTimer;
|
|
|
|
} PROTOCOL_BLOCK, *PPROTOCOL_BLOCK;
|
|
|
|
|
|
//
|
|
// Global data block
|
|
//
|
|
typedef struct _GLOBAL_BLOCK {
|
|
|
|
LIST_ENTRY CfList; // CF list head
|
|
LIST_ENTRY gRequestList; // Maintain a request list to deal with contention...
|
|
GPC_LOCK Lock;
|
|
GPC_LOCK RequestListLock;
|
|
HandleFactory *pCHTable;
|
|
MRSW_LOCK ChLock; // lock for pCHTable
|
|
PPROTOCOL_BLOCK pProtocols; // pointer to array of supported protocols
|
|
|
|
} GLOBAL_BLOCK, *PGLOBAL_BLOCK;
|
|
|
|
//
|
|
// New request block. This will be used to store the event and linkage.
|
|
// Therefore, when a thread needs to block, allocate a request_block, allocate
|
|
// an event, grab the requestlist lock , put this on the list and wait.
|
|
//
|
|
typedef struct _REQUEST_BLOCK {
|
|
|
|
LIST_ENTRY Linkage;
|
|
NDIS_EVENT RequestEvent;
|
|
|
|
} REQUEST_BLOCK, *PREQUEST_BLOCK;
|
|
|
|
#if NEW_MRSW
|
|
|
|
//
|
|
// VOID
|
|
// InitRwLock(
|
|
// PMRSW_LOCK pLock
|
|
// )
|
|
//
|
|
// Initializes the spin locks and the reader count
|
|
//
|
|
|
|
#define InitializeMRSWLock(l) { \
|
|
KeInitializeSpinLock(&((l)->rlReadLock)); \
|
|
KeInitializeSpinLock(&((l)->rlWriteLock)); \
|
|
(l)->lReaderCount = 0; \
|
|
}
|
|
|
|
|
|
//
|
|
// VOID
|
|
// EnterReader(
|
|
// PMRSW_LOCK pLock,
|
|
// PKIRQL pCurrIrql
|
|
// )
|
|
//
|
|
// Acquires the Reader Spinlock (now thread is at DPC).
|
|
// InterlockedIncrements the reader count (interlocked because the reader
|
|
// lock is not taken when the count is decremented in ExitReader())
|
|
// If the thread is the first reader, also acquires the Writer Spinlock (at
|
|
// DPC to be more efficient) to block writers
|
|
// Releases the Reader Spinlock from DPC, so that it remains at DPC
|
|
// for the duration of the lock being held
|
|
//
|
|
// If a writer is in the code, the first reader will wait on the Writer
|
|
// Spinlock and all subsequent readers will wait on the Reader Spinlock
|
|
// If a reader is in the code and is executing the EnterReader, then a new
|
|
// reader will wait for sometime on the Reader Spinlock, and then proceed
|
|
// on to the code (at DPC)
|
|
//
|
|
#define EnterReader(l, q) {\
|
|
KeAcquireSpinLock(&((l)->rlReadLock), (q)); \
|
|
TRACE(LOCKS,l,*q,"EnterReader"); \
|
|
if(InterlockedIncrement(&((l)->lReaderCount)) == 1) { \
|
|
TRACE(LOCKS,l,(l)->lReaderCount,"EnterReader1"); \
|
|
KeAcquireSpinLockAtDpcLevel(&((l)->rlWriteLock)); \
|
|
TRACE(LOCKS,l,(l)->rlWriteLock,"EnterReader2"); \
|
|
} \
|
|
TRACE(LOCKS,l,(l)->lReaderCount,"EnterReader3"); \
|
|
KeReleaseSpinLockFromDpcLevel(&((l)->rlReadLock)); \
|
|
}
|
|
|
|
#define EnterReaderAtDpcLevel(l) {\
|
|
KeAcquireSpinLockAtDpcLevel(&((l)->rlReadLock)); \
|
|
if(InterlockedIncrement(&((l)->lReaderCount)) == 1) \
|
|
KeAcquireSpinLockAtDpcLevel(&((l)->rlWriteLock)); \
|
|
KeReleaseSpinLockFromDpcLevel(&((l)->rlReadLock)); \
|
|
}
|
|
|
|
//
|
|
// VOID
|
|
// ExitReader(
|
|
// PMRSW_LOCK pLock,
|
|
// KIRQL kiOldIrql
|
|
// )
|
|
//
|
|
// InterlockedDec the reader count.
|
|
// If this is the last reader, then release the Writer Spinlock to let
|
|
// other writers in
|
|
// Otherwise, just lower the irql to what was before the lock was
|
|
// acquired. Either way, the irql is down to original irql
|
|
//
|
|
|
|
#define ExitReader(l, q) {\
|
|
TRACE(LOCKS,l,q,"ExitReader");\
|
|
if(InterlockedDecrement(&((l)->lReaderCount)) == 0) { \
|
|
TRACE(LOCKS,(l)->rlWriteLock,q,"ExitReader1"); \
|
|
KeReleaseSpinLock(&((l)->rlWriteLock), q); \
|
|
} \
|
|
else { \
|
|
TRACE(LOCKS,l,(l)->lReaderCount,"ExitReader2"); \
|
|
KeLowerIrql(q); \
|
|
} \
|
|
}
|
|
|
|
#define ExitReaderFromDpcLevel(l) {\
|
|
if(InterlockedDecrement(&((l)->lReaderCount)) == 0) \
|
|
KeReleaseSpinLockFromDpcLevel(&((l)->rlWriteLock)); \
|
|
}
|
|
|
|
//
|
|
// EnterWriter(
|
|
// PMRSW_LOCK pLock,
|
|
// PKIRQL pCurrIrql
|
|
// )
|
|
//
|
|
// Acquire the reader and then the writer spin lock
|
|
// If there are readers in the code, the first writer will wait
|
|
// on the Writer Spinlock. All other writers will wait (with readers)
|
|
// on the Reader Spinlock
|
|
// If there is a writer in the code then a new writer will wait on
|
|
// the Reader Spinlock
|
|
|
|
#define EnterWriter(l, q) {\
|
|
KeAcquireSpinLock(&((l)->rlReadLock), (q)); \
|
|
TRACE(LOCKS,l,*q,"EnterWriter"); \
|
|
TRACE(LOCKS,l,(l)->rlWriteLock,"EnterWrite1"); \
|
|
KeAcquireSpinLockAtDpcLevel(&((l)->rlWriteLock)); \
|
|
}
|
|
|
|
#define EnterWriterAtDpcLevel(l) { \
|
|
KeAcquireSpinLockAtDpcLevel(&((l)->rlReadLock)); \
|
|
KeAcquireSpinLockAtDpcLevel(&((l)->rlWriteLock)); \
|
|
}
|
|
|
|
|
|
//
|
|
// ExitWriter(
|
|
// PMRSW_LOCK pLock,
|
|
// KIRQL kiOldIrql
|
|
// )
|
|
//
|
|
// Release both the locks
|
|
//
|
|
|
|
#define ExitWriter(l, q) {\
|
|
TRACE(LOCKS,l,(l)->rlWriteLock,"ExitWrite1"); \
|
|
KeReleaseSpinLockFromDpcLevel(&((l)->rlWriteLock)); \
|
|
TRACE(LOCKS,l,q,"ExitWrite1"); \
|
|
KeReleaseSpinLock(&((l)->rlReadLock), q); \
|
|
}
|
|
|
|
|
|
#define ExitWriterFromDpcLevel(l) {\
|
|
KeReleaseSpinLockFromDpcLevel(&((l)->rlWriteLock)); \
|
|
KeReleaseSpinLockFromDpcLevel(&((l)->rlReadLock)); \
|
|
}
|
|
|
|
#else
|
|
|
|
#define InitializeMRSWLock(_pLock) { \
|
|
(_pLock)->ReaderCount = 0; \
|
|
KeInitializeSpinLock(&((_pLock)->SpinLock)); \
|
|
}
|
|
|
|
#define AcquireReadLock(_pLock,_pOldIrql) { \
|
|
TRACE(LOCKS, _pLock, (_pLock)->ReaderCount, "RL.1"); \
|
|
KeAcquireSpinLock(&((_pLock)->SpinLock),_pOldIrql); \
|
|
InterlockedIncrement(&((_pLock)->ReaderCount)); \
|
|
TRACE(LOCKS, _pLock, (_pLock)->ReaderCount, "RL.2"); \
|
|
KeReleaseSpinLockFromDpcLevel(&((_pLock)->SpinLock)); \
|
|
TRACE(LOCKS, _pLock, *(_pOldIrql), "RL.3"); \
|
|
}
|
|
|
|
#define ReleaseReadLock(_pLock,_OldIrql) { \
|
|
TRACE(LOCKS, _pLock, (_pLock)->ReaderCount, "RU.1"); \
|
|
InterlockedDecrement(&((_pLock)->ReaderCount)); \
|
|
TRACE(LOCKS, _pLock, (_pLock)->ReaderCount, "RU.2"); \
|
|
KeLowerIrql(_OldIrql); \
|
|
TRACE(LOCKS, _pLock, _OldIrql, "RU.3"); \
|
|
}
|
|
|
|
#define AcquireWriteLock(_pLock,_pOldIrql) { \
|
|
TRACE(LOCKS, _pLock, _pOldIrql, "WL.1"); \
|
|
KeAcquireSpinLock(&((_pLock)->SpinLock),_pOldIrql); \
|
|
TRACE(LOCKS, _pLock, (_pLock)->ReaderCount, "WL.2"); \
|
|
while(InterlockedDecrement(&((_pLock)->ReaderCount))>=0)\
|
|
{ \
|
|
InterlockedIncrement (&((_pLock)->ReaderCount)); \
|
|
} \
|
|
TRACE(LOCKS, _pLock, (_pLock)->ReaderCount, "WL.3"); \
|
|
}
|
|
|
|
#define ReleaseWriteLock(_pLock,_OldIrql) { \
|
|
TRACE(LOCKS, _pLock, (_pLock)->ReaderCount, "WU.1"); \
|
|
InterlockedExchange(&(_pLock)->ReaderCount,0); \
|
|
TRACE(LOCKS, _pLock, (_pLock)->ReaderCount, "WU.2"); \
|
|
KeReleaseSpinLock(&((_pLock)->SpinLock),_OldIrql); \
|
|
TRACE(LOCKS, _pLock, _OldIrql, "WU.3"); \
|
|
}
|
|
|
|
#endif
|
|
|
|
#if 1
|
|
|
|
#define RSC_READ_LOCK(_l,_i) NDIS_LOCK(_l)
|
|
#define RSC_READ_UNLOCK(_l,_i) NDIS_UNLOCK(_l)
|
|
#define RSC_WRITE_LOCK(_l,_i) NDIS_LOCK(_l)
|
|
#define RSC_WRITE_UNLOCK(_l,_i) NDIS_UNLOCK(_l)
|
|
|
|
#else
|
|
|
|
#define RSC_READ_LOCK WRITE_LOCK
|
|
#define RSC_READ_UNLOCK WRITE_UNLOCK
|
|
#define RSC_WRITE_LOCK WRITE_LOCK
|
|
#define RSC_WRITE_UNLOCK WRITE_UNLOCK
|
|
|
|
#endif
|
|
|
|
/*
|
|
/////////////////////////////////////////////////////////////////
|
|
//
|
|
// IP definitions
|
|
//
|
|
/////////////////////////////////////////////////////////////////
|
|
*/
|
|
|
|
#define DEFAULT_VERLEN 0x45 // Default version and length.
|
|
#define IP_VERSION 0x40
|
|
#define IP_VER_FLAG 0xF0
|
|
#define IP_RSVD_FLAG 0x0080 // Reserved.
|
|
#define IP_DF_FLAG 0x0040 // 'Don't fragment' flag
|
|
#define IP_MF_FLAG 0x0020 // 'More fragments flag'
|
|
#define IP_OFFSET_MASK ~0x00E0 // Mask for extracting offset field.
|
|
|
|
#if (defined(_M_IX86) && (_MSC_FULL_VER > 13009037)) || ((defined(_M_AMD64) || defined(_M_IA64)) && (_MSC_FULL_VER > 13009175))
|
|
#define net_short(_x) _byteswap_ushort((USHORT)(_x))
|
|
#define net_long(_x) _byteswap_ulong(_x)
|
|
#else
|
|
#define net_short(x) ((((x)&0xff) << 8) | (((x)&0xff00) >> 8))
|
|
#define net_long(x) (((((ulong)(x))&0xffL)<<24) | \
|
|
((((ulong)(x))&0xff00L)<<8) | \
|
|
((((ulong)(x))&0xff0000L)>>8) | \
|
|
((((ulong)(x))&0xff000000L)>>24))
|
|
#endif
|
|
/*
|
|
* Protocols (from winsock.h)
|
|
*/
|
|
#define IPPROTO_IP 0 /* dummy for IP */
|
|
#define IPPROTO_ICMP 1 /* control message protocol */
|
|
#define IPPROTO_IGMP 2 /* group management protocol */
|
|
#define IPPROTO_GGP 3 /* gateway^2 (deprecated) */
|
|
#define IPPROTO_TCP 6 /* tcp */
|
|
#define IPPROTO_PUP 12 /* pup */
|
|
#define IPPROTO_UDP 17 /* user datagram protocol */
|
|
#define IPPROTO_IDP 22 /* xns idp */
|
|
#define IPPROTO_ND 77 /* UNOFFICIAL net disk proto */
|
|
#define IPPROTO_IPSEC 51 /* ???????? */
|
|
|
|
#define IPPROTO_RAW 255 /* raw IP packet */
|
|
#define IPPROTO_MAX 256
|
|
|
|
//
|
|
// UDP header definition
|
|
//
|
|
typedef struct _UDP_HEADER {
|
|
ushort uh_src;
|
|
ushort uh_dest;
|
|
ushort uh_length;
|
|
ushort uh_xsum;
|
|
} UDP_HEADER, *PUDP_HEADER;
|
|
|
|
|
|
//
|
|
//* IP Header format.
|
|
//
|
|
typedef struct _IP_HEADER {
|
|
|
|
uchar iph_verlen; // Version and length.
|
|
uchar iph_tos; // Type of service.
|
|
ushort iph_length; // Total length of datagram.
|
|
ushort iph_id; // Identification.
|
|
ushort iph_offset; // Flags and fragment offset.
|
|
uchar iph_ttl; // Time to live.
|
|
uchar iph_protocol; // Protocol.
|
|
ushort iph_xsum; // Header checksum.
|
|
ULONG iph_src; // Source address.
|
|
ULONG iph_dest; // Destination address.
|
|
|
|
} IP_HEADER, *PIP_HEADER;
|
|
|
|
|
|
//
|
|
// Definition of the IPX header.
|
|
//
|
|
typedef struct _IPX_HEADER {
|
|
|
|
USHORT CheckSum;
|
|
UCHAR PacketLength[2];
|
|
UCHAR TransportControl;
|
|
UCHAR PacketType;
|
|
UCHAR DestinationNetwork[4];
|
|
UCHAR DestinationNode[6];
|
|
USHORT DestinationSocket;
|
|
UCHAR SourceNetwork[4];
|
|
UCHAR SourceNode[6];
|
|
USHORT SourceSocket;
|
|
|
|
} IPX_HEADER, *PIPX_HEADER;
|
|
|
|
|
|
/*
|
|
/////////////////////////////////////////////////////////////////
|
|
//
|
|
// extern
|
|
//
|
|
/////////////////////////////////////////////////////////////////
|
|
*/
|
|
|
|
extern GLOBAL_BLOCK glData;
|
|
extern GPC_STAT glStat;
|
|
|
|
#ifdef STANDALONE_DRIVER
|
|
extern GPC_EXPORTED_CALLS glGpcExportedCalls;
|
|
#endif
|
|
|
|
// tags
|
|
|
|
extern ULONG ClassificationFamilyTag;
|
|
extern ULONG ClientTag;
|
|
extern ULONG PatternTag;
|
|
extern ULONG CfInfoTag;
|
|
extern ULONG QueuedNotificationTag;
|
|
extern ULONG PendingIrpTag;
|
|
|
|
extern ULONG HandleFactoryTag;
|
|
extern ULONG PathHashTag;
|
|
extern ULONG RhizomeTag;
|
|
extern ULONG GenPatternDbTag;
|
|
extern ULONG FragmentDbTag;
|
|
extern ULONG CfInfoDataTag;
|
|
extern ULONG ClassificationBlockTag;
|
|
extern ULONG ProtocolTag;
|
|
extern ULONG DebugTag;
|
|
|
|
// Lookaside lists
|
|
|
|
extern NPAGED_LOOKASIDE_LIST ClassificationFamilyLL;
|
|
extern NPAGED_LOOKASIDE_LIST ClientLL;
|
|
extern NPAGED_LOOKASIDE_LIST PatternLL;
|
|
extern NPAGED_LOOKASIDE_LIST CfInfoLL;
|
|
extern NPAGED_LOOKASIDE_LIST QueuedNotificationLL;
|
|
extern NPAGED_LOOKASIDE_LIST PendingIrpLL;
|
|
|
|
/*
|
|
/////////////////////////////////////////////////////////////////
|
|
//
|
|
// prototypes
|
|
//
|
|
/////////////////////////////////////////////////////////////////
|
|
*/
|
|
|
|
|
|
NTSTATUS
|
|
DriverEntry(
|
|
IN PDRIVER_OBJECT DriverObject,
|
|
IN PUNICODE_STRING RegistryPath
|
|
);
|
|
|
|
|
|
GPC_STATUS
|
|
InitSpecificPatternDb(
|
|
IN PSPECIFIC_PATTERN_DB pDb,
|
|
IN ULONG PatternSize
|
|
);
|
|
|
|
GPC_STATUS
|
|
UninitSpecificPatternDb(
|
|
IN PSPECIFIC_PATTERN_DB pDb
|
|
);
|
|
|
|
GPC_STATUS
|
|
InitClassificationHandleTbl(
|
|
IN HandleFactory **ppCHTable
|
|
);
|
|
|
|
VOID
|
|
UninitClassificationHandleTbl(
|
|
IN HandleFactory *pCHTable
|
|
);
|
|
GPC_STATUS
|
|
InitializeGenericDb(
|
|
IN PGENERIC_PATTERN_DB *ppGenericDb,
|
|
IN ULONG NumEntries,
|
|
IN ULONG PatternSize
|
|
);
|
|
|
|
VOID
|
|
UninitializeGenericDb(
|
|
IN PGENERIC_PATTERN_DB *ppGenericDb,
|
|
IN ULONG NumEntries
|
|
);
|
|
|
|
PCLIENT_BLOCK
|
|
CreateNewClientBlock(VOID);
|
|
|
|
VOID
|
|
ReleaseCfBlock(
|
|
IN PCF_BLOCK pCf
|
|
);
|
|
|
|
PCF_BLOCK
|
|
CreateNewCfBlock(
|
|
IN ULONG CfId,
|
|
IN ULONG MaxPriorities
|
|
);
|
|
|
|
VOID
|
|
ReleaseClientBlock(
|
|
IN PCLIENT_BLOCK pClientBlock
|
|
);
|
|
|
|
PPATTERN_BLOCK
|
|
CreateNewPatternBlock(
|
|
IN ULONG Flags
|
|
);
|
|
|
|
VOID
|
|
ReleasePatternBlock(
|
|
IN PPATTERN_BLOCK pPatternBlock
|
|
);
|
|
|
|
PCLASSIFICATION_BLOCK
|
|
CreateNewClassificationBlock(
|
|
IN ULONG NumEntries
|
|
);
|
|
|
|
ULONG
|
|
AssignNewClientIndex(
|
|
IN PCF_BLOCK pCfBlock
|
|
);
|
|
|
|
GPC_STATUS
|
|
AddGenericPattern(
|
|
IN PCLIENT_BLOCK pClient,
|
|
IN PUCHAR pPatternBits,
|
|
IN PUCHAR pMaskBits,
|
|
IN ULONG Priority,
|
|
IN PBLOB_BLOCK pBlob,
|
|
IN PPROTOCOL_BLOCK pProtocol,
|
|
IN OUT PPATTERN_BLOCK *ppPattern
|
|
);
|
|
|
|
|
|
GPC_STATUS
|
|
AddSpecificPattern(
|
|
IN PCLIENT_BLOCK pClient,
|
|
IN PUCHAR pPatternBits,
|
|
IN PUCHAR pMaskBits,
|
|
IN PBLOB_BLOCK pBlob,
|
|
IN PPROTOCOL_BLOCK pProtocol,
|
|
IN OUT PPATTERN_BLOCK *ppPattern,
|
|
OUT PCLASSIFICATION_HANDLE pCH
|
|
);
|
|
|
|
ULONG
|
|
GpcCalcHash(
|
|
IN ULONG ProtocolTempId,
|
|
IN PUCHAR pPattern
|
|
);
|
|
|
|
|
|
VOID
|
|
DereferencePattern(
|
|
IN PPATTERN_BLOCK pPattern
|
|
);
|
|
|
|
VOID
|
|
DereferenceBlob(
|
|
IN PBLOB_BLOCK pBlob
|
|
);
|
|
|
|
PBLOB_BLOCK
|
|
CreateNewBlobBlock(
|
|
IN ULONG ClientDataSize,
|
|
IN PVOID pClientData
|
|
);
|
|
|
|
VOID
|
|
ReleaseBlobBlock(
|
|
IN PBLOB_BLOCK pBlobBlock
|
|
);
|
|
|
|
GPC_STATUS
|
|
HandleFragment(
|
|
IN PCLIENT_BLOCK pClientBlock,
|
|
IN PPROTOCOL_BLOCK pProtocol,
|
|
IN BOOLEAN bFirstFrag,
|
|
IN BOOLEAN bLastFrag,
|
|
IN ULONG PacketId,
|
|
IN OUT PPATTERN_BLOCK *ppPatternBlock,
|
|
OUT PBLOB_BLOCK *ppBlob
|
|
);
|
|
|
|
NTSTATUS
|
|
InternalSearchPattern(
|
|
IN PCLIENT_BLOCK pClientBlock,
|
|
IN PPROTOCOL_BLOCK pProtocol,
|
|
IN PVOID pPatternKey,
|
|
OUT PPATTERN_BLOCK *ppPatternBlock,
|
|
OUT PCLASSIFICATION_HANDLE pClassificationHandle,
|
|
IN BOOLEAN bNoCache
|
|
);
|
|
|
|
GPC_STATUS
|
|
InitFragmentDb(
|
|
IN PFRAGMENT_DB *ppFragDb
|
|
);
|
|
|
|
GPC_STATUS
|
|
UninitFragmentDb(
|
|
IN PFRAGMENT_DB pFragDb
|
|
);
|
|
|
|
VOID
|
|
DereferenceClient(
|
|
IN PCLIENT_BLOCK pClient
|
|
);
|
|
|
|
|
|
GPC_STATUS
|
|
ClientAddCfInfo(
|
|
IN PCLIENT_BLOCK pClient,
|
|
IN PBLOB_BLOCK pBlob,
|
|
OUT PGPC_CLIENT_HANDLE pClientCfInfoContext
|
|
);
|
|
|
|
VOID
|
|
ClientAddCfInfoComplete(
|
|
IN PCLIENT_BLOCK pClient,
|
|
IN PBLOB_BLOCK pBlob,
|
|
IN GPC_STATUS Status
|
|
);
|
|
|
|
GPC_STATUS
|
|
ClientModifyCfInfo(
|
|
IN PCLIENT_BLOCK pClient,
|
|
IN PBLOB_BLOCK pBlob,
|
|
IN ULONG CfInfoSize,
|
|
IN PVOID pClientData
|
|
);
|
|
|
|
VOID
|
|
ClientModifyCfInfoComplete(
|
|
IN PCLIENT_BLOCK pClient,
|
|
IN PBLOB_BLOCK pBlob,
|
|
IN GPC_STATUS Status
|
|
);
|
|
|
|
GPC_STATUS
|
|
ClientRemoveCfInfo(
|
|
IN PCLIENT_BLOCK pClient,
|
|
IN PBLOB_BLOCK pBlob,
|
|
IN GPC_CLIENT_HANDLE ClientCfInfoContext
|
|
);
|
|
|
|
VOID
|
|
ClientRemoveCfInfoComplete(
|
|
IN PCLIENT_BLOCK pClient,
|
|
IN PBLOB_BLOCK pBlob,
|
|
IN GPC_STATUS Status
|
|
);
|
|
|
|
GPC_STATUS
|
|
RemoveSpecificPattern(
|
|
IN PCLIENT_BLOCK pClient,
|
|
IN PPROTOCOL_BLOCK pProtocol,
|
|
IN PPATTERN_BLOCK pPattern,
|
|
IN BOOLEAN ForceRemoval
|
|
);
|
|
|
|
VOID
|
|
ClientRefsExistForSpecificPattern(
|
|
IN PCLIENT_BLOCK pClient,
|
|
IN PPROTOCOL_BLOCK pProtocol,
|
|
IN PPATTERN_BLOCK pPattern
|
|
);
|
|
|
|
VOID
|
|
ReadySpecificPatternForDeletion(
|
|
IN PCLIENT_BLOCK pClient,
|
|
IN PPROTOCOL_BLOCK pProtocol,
|
|
IN PPATTERN_BLOCK pPattern
|
|
);
|
|
|
|
GPC_STATUS
|
|
RemoveGenericPattern(
|
|
IN PCLIENT_BLOCK pClient,
|
|
IN PPROTOCOL_BLOCK pProtocol,
|
|
IN PPATTERN_BLOCK pPattern
|
|
);
|
|
|
|
VOID
|
|
ReleaseClassificationBlock(
|
|
IN PCLASSIFICATION_BLOCK pClassificationBlock
|
|
);
|
|
|
|
VOID
|
|
ClearPatternLinks(
|
|
IN PPATTERN_BLOCK pPattern,
|
|
IN PPROTOCOL_BLOCK pProtocol,
|
|
IN ULONG CfIndex
|
|
);
|
|
|
|
VOID
|
|
ModifyCompleteClients(
|
|
IN PCLIENT_BLOCK pClient,
|
|
IN PBLOB_BLOCK pBlob
|
|
);
|
|
|
|
//CLASSIFICATION_HANDLE
|
|
//GetClassificationHandle(
|
|
// IN PCLIENT_BLOCK pClient,
|
|
// IN PPATTERN_BLOCK pPattern
|
|
// );
|
|
|
|
VOID
|
|
FreeClassificationHandle(
|
|
IN PCLIENT_BLOCK pClient,
|
|
IN CLASSIFICATION_HANDLE CH
|
|
);
|
|
|
|
GPC_STATUS
|
|
CleanupBlobs(
|
|
IN PCLIENT_BLOCK pClient
|
|
);
|
|
|
|
|
|
#ifdef STANDALONE_DRIVER
|
|
/*
|
|
/////////////////////////////////////////////////////////////////
|
|
//
|
|
// GPC inetrface APIs
|
|
//
|
|
/////////////////////////////////////////////////////////////////
|
|
*/
|
|
|
|
|
|
GPC_STATUS
|
|
GpcGetCfInfoClientContext(
|
|
IN GPC_HANDLE ClientHandle,
|
|
IN CLASSIFICATION_HANDLE ClassificationHandle,
|
|
OUT PGPC_CLIENT_HANDLE pClientCfInfoContext
|
|
);
|
|
|
|
GPC_CLIENT_HANDLE
|
|
GpcGetCfInfoClientContextWithRef(
|
|
IN GPC_HANDLE ClientHandle,
|
|
IN CLASSIFICATION_HANDLE ClassificationHandle,
|
|
IN ULONG Offset
|
|
);
|
|
|
|
GPC_STATUS
|
|
GpcGetUlongFromCfInfo(
|
|
IN GPC_HANDLE ClientHandle,
|
|
IN CLASSIFICATION_HANDLE ClassificationHandle,
|
|
IN ULONG Offset,
|
|
IN PULONG pValue
|
|
);
|
|
|
|
GPC_STATUS
|
|
GpcRegisterClient(
|
|
IN ULONG CfId,
|
|
IN ULONG Flags,
|
|
IN ULONG MaxPriorities,
|
|
IN PGPC_CLIENT_FUNC_LIST pClientFuncList,
|
|
IN GPC_CLIENT_HANDLE ClientContext,
|
|
OUT PGPC_HANDLE pClientHandle
|
|
);
|
|
|
|
GPC_STATUS
|
|
GpcDeregisterClient(
|
|
IN GPC_HANDLE ClientHandle
|
|
);
|
|
|
|
GPC_STATUS
|
|
GpcAddCfInfo(
|
|
IN GPC_HANDLE ClientHandle,
|
|
IN ULONG CfInfoSize,
|
|
IN PVOID pClientCfInfo,
|
|
IN GPC_CLIENT_HANDLE ClientCfInfoContext,
|
|
OUT PGPC_HANDLE pGpcCfInfoHandle
|
|
);
|
|
|
|
GPC_STATUS
|
|
GpcAddPattern(
|
|
IN GPC_HANDLE ClientHandle,
|
|
IN ULONG ProtocolTemplate,
|
|
IN PVOID Pattern,
|
|
IN PVOID Mask,
|
|
IN ULONG Priority,
|
|
IN GPC_HANDLE GpcCfInfoHandle,
|
|
OUT PGPC_HANDLE pGpcPatternHandle,
|
|
OUT PCLASSIFICATION_HANDLE pClassificationHandle
|
|
);
|
|
|
|
VOID
|
|
GpcAddCfInfoNotifyComplete(
|
|
IN GPC_HANDLE ClientHandle,
|
|
IN GPC_HANDLE GpcCfInfoHandle,
|
|
IN GPC_STATUS Status,
|
|
IN GPC_CLIENT_HANDLE ClientCfInfoContext
|
|
);
|
|
|
|
GPC_STATUS
|
|
GpcModifyCfInfo (
|
|
IN GPC_HANDLE ClientHandle,
|
|
IN GPC_HANDLE GpcCfInfoHandle,
|
|
IN ULONG CfInfoSize,
|
|
IN PVOID pClientCfInfo
|
|
);
|
|
|
|
VOID
|
|
GpcModifyCfInfoNotifyComplete(
|
|
IN GPC_HANDLE ClientHandle,
|
|
IN GPC_HANDLE GpcCfInfoHandle,
|
|
IN GPC_STATUS Status
|
|
);
|
|
|
|
GPC_STATUS
|
|
GpcRemoveCfInfo (
|
|
IN GPC_HANDLE ClientHandle,
|
|
IN GPC_HANDLE GpcCfInfoHandle
|
|
);
|
|
|
|
VOID
|
|
GpcRemoveCfInfoNotifyComplete(
|
|
IN GPC_HANDLE ClientHandle,
|
|
IN GPC_HANDLE GpcCfInfoHandle,
|
|
IN GPC_STATUS Status
|
|
);
|
|
|
|
GPC_STATUS
|
|
GpcRemovePattern (
|
|
IN GPC_HANDLE ClientHandle,
|
|
IN GPC_HANDLE GpcPatternHandle
|
|
);
|
|
|
|
GPC_STATUS
|
|
GpcClassifyPattern (
|
|
IN GPC_HANDLE ClientHandle,
|
|
IN ULONG ProtocolTemplate,
|
|
IN PVOID pPattern,
|
|
OUT PGPC_CLIENT_HANDLE pClientCfInfoContext,
|
|
IN OUT PCLASSIFICATION_HANDLE pClassificationHandle,
|
|
IN ULONG Offset,
|
|
IN PULONG pValue,
|
|
IN BOOLEAN bNoCache
|
|
);
|
|
|
|
GPC_STATUS
|
|
GpcClassifyPacket (
|
|
IN GPC_HANDLE ClientHandle,
|
|
IN ULONG ProtocolTemplate,
|
|
IN PVOID pNdisPacket,
|
|
IN ULONG TransportHeaderOffset,
|
|
IN PTC_INTERFACE_ID InterfaceId,
|
|
OUT PGPC_CLIENT_HANDLE pClientCfInfoContext,
|
|
OUT PCLASSIFICATION_HANDLE pClassificationHandle
|
|
);
|
|
|
|
GPC_STATUS
|
|
GpcEnumCfInfo (
|
|
IN GPC_HANDLE ClientHandle,
|
|
IN OUT PHANDLE pCfInfoHandle,
|
|
OUT PHANDLE pCfInfoMapHandle,
|
|
IN OUT PULONG pCfInfoCount,
|
|
IN OUT PULONG pBufferSize,
|
|
OUT PGPC_ENUM_CFINFO_BUFFER Buffer
|
|
);
|
|
|
|
#endif // STANDALONE_DRIVER
|
|
|
|
GPC_STATUS
|
|
GetClientCtxAndUlongFromCfInfo(
|
|
IN GPC_HANDLE ClientHandle,
|
|
IN OUT PCLASSIFICATION_HANDLE pClassificationHandle,
|
|
OUT PGPC_CLIENT_HANDLE pClientCfInfoContext,
|
|
IN ULONG Offset,
|
|
IN PULONG pValue
|
|
);
|
|
|
|
GPC_STATUS
|
|
privateGpcRemoveCfInfo(
|
|
IN GPC_HANDLE ClientHandle,
|
|
IN GPC_HANDLE GpcCfInfoHandle,
|
|
IN ULONG Flags
|
|
);
|
|
|
|
GPC_STATUS
|
|
privateGpcRemovePattern(
|
|
IN GPC_HANDLE ClientHandle,
|
|
IN GPC_HANDLE GpcPatternHandle,
|
|
IN BOOLEAN ForceRemoval
|
|
);
|
|
|
|
VOID
|
|
UMClientRemoveCfInfoNotify(
|
|
IN PCLIENT_BLOCK pClient,
|
|
IN PBLOB_BLOCK pBlob
|
|
);
|
|
|
|
|
|
VOID
|
|
UMCfInfoComplete(
|
|
IN GPC_COMPLETION_OP OpCode,
|
|
IN PCLIENT_BLOCK pClient,
|
|
IN PBLOB_BLOCK pBlob,
|
|
IN GPC_STATUS Status
|
|
);
|
|
|
|
VOID
|
|
CloseAllObjects(
|
|
IN PFILE_OBJECT FileObject,
|
|
IN PIRP Irp
|
|
);
|
|
|
|
NTSTATUS
|
|
IoctlInitialize(
|
|
IN PDRIVER_OBJECT DriverObject,
|
|
IN PULONG InitShutdownMask
|
|
);
|
|
|
|
NTSTATUS
|
|
CheckQueuedNotification(
|
|
IN PIRP Irp,
|
|
IN OUT ULONG *outputBufferLength
|
|
);
|
|
|
|
NTSTATUS
|
|
CheckQueuedCompletion(
|
|
IN PQUEUED_COMPLETION pQItem,
|
|
IN PIRP Irp
|
|
);
|
|
|
|
VOID
|
|
PatternTimerExpired(
|
|
IN PVOID SystemSpecific1,
|
|
IN PVOID FunctionContext,
|
|
IN PVOID SystemSpecific2,
|
|
IN PVOID SystemSpecific3
|
|
);
|
|
|
|
GPC_STATUS
|
|
AddSpecificPatternWithTimer(
|
|
IN PCLIENT_BLOCK pClient,
|
|
IN ULONG ProtocolTemplate,
|
|
IN PVOID PatternKey,
|
|
OUT PPATTERN_BLOCK *ppPattern,
|
|
OUT PCLASSIFICATION_HANDLE pClassificationHandle
|
|
);
|
|
|
|
NTSTATUS
|
|
InitPatternTimer(
|
|
IN ULONG ProtocolTemplate
|
|
);
|
|
|
|
|
|
#endif // __GPCDEF
|