You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3696 lines
95 KiB
3696 lines
95 KiB
/*++
|
|
|
|
Copyright (c) 1996 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
api.c
|
|
|
|
Abstract:
|
|
|
|
This module contains the traffic control apis.
|
|
|
|
Author:
|
|
|
|
Jim Stewart ( jstew ) July 28, 1996
|
|
|
|
Revision History:
|
|
|
|
Ofer Bar ( oferbar ) Oct 1, 1997 - Rev 2
|
|
Shreedhar Madhavapeddi (ShreeM) March 10, 1999 Rev 3
|
|
|
|
--*/
|
|
|
|
/*
|
|
*********************************************************************
|
|
Revision 3 => Changes [ShreeM]
|
|
|
|
1. Build concrete state machines for Interface, Flow and Filter structures.
|
|
2. Define Locks for each of these structures.
|
|
3. Use above Locks for recording every state transistion.
|
|
4. Use debug logs to record transitions.
|
|
5. The Global lock is always taken before any of the Flow, Filter or Interface locks.
|
|
*/
|
|
|
|
#include "precomp.h"
|
|
//#pragma hdrstop
|
|
//#include "oscode.h"
|
|
|
|
/*
|
|
************************************************************************
|
|
|
|
Description:
|
|
|
|
This will create a new client handle and will also associate
|
|
it with a client's handler list. It also checks for the version number.
|
|
|
|
Arguments:
|
|
|
|
TciVersion - The client expected version
|
|
ClientHandlerList - The client's handler list
|
|
pClientHandle - output client handle
|
|
|
|
Return Value:
|
|
|
|
NO_ERROR
|
|
ERROR_NOT_ENOUGH_MEMORY out of memory
|
|
ERROR_INVALID_PARAMETER one of the parameters is NULL
|
|
ERROR_INCOMPATIBLE_TC_VERSION wrong version
|
|
ERROR_NO_SYSTEM_RESOURCES not enough resources (handles)
|
|
|
|
|
|
************************************************************************
|
|
*/
|
|
DWORD
|
|
APIENTRY
|
|
TcRegisterClient(
|
|
IN ULONG TciVersion,
|
|
IN HANDLE ClRegCtx,
|
|
IN PTCI_CLIENT_FUNC_LIST ClientHandlerList,
|
|
OUT PHANDLE pClientHandle
|
|
)
|
|
{
|
|
DWORD Status;
|
|
PCLIENT_STRUC pClient;
|
|
BOOL RegisterWithGpc = FALSE;
|
|
|
|
|
|
VERIFY_INITIALIZATION_STATUS;
|
|
|
|
IF_DEBUG(CALLS) {
|
|
WSPRINT(("==>TcRegisterClient: Called: Ver= %d, Ctx=%x\n",
|
|
TciVersion, ClRegCtx));
|
|
}
|
|
|
|
if (IsBadWritePtr(pClientHandle,sizeof(HANDLE))) {
|
|
Status = ERROR_INVALID_PARAMETER;
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcRegisterClient: Error = 0x%X\n", Status ));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// Set a default pClientHandle as early as possible
|
|
//
|
|
__try {
|
|
|
|
*pClientHandle = TC_INVALID_HANDLE;
|
|
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
Status = GetExceptionCode();
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcRegisterClient: Exception Error: = 0x%X\n", Status ));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
if (TciVersion != CURRENT_TCI_VERSION) {
|
|
|
|
Status = ERROR_INCOMPATIBLE_TCI_VERSION;
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcRegisterClient: Error = 0x%X\n", Status ));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
if (IsBadReadPtr(ClientHandlerList,sizeof(TCI_CLIENT_FUNC_LIST))) {
|
|
|
|
Status = ERROR_INVALID_PARAMETER;
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcRegisterClient: Error = 0x%X\n", Status ));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
if (IsBadCodePtr((FARPROC) ClientHandlerList->ClNotifyHandler)) {
|
|
|
|
//
|
|
// a client must support a notification handler
|
|
//
|
|
|
|
Status = ERROR_INVALID_PARAMETER;
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcRegisterClient: Error = 0x%X\n", Status ));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
// Prevent another thread from doing TcRegisterClient and TcDeregisterClient
|
|
GetLock( ClientRegDeregLock );
|
|
|
|
//
|
|
// finish initialization (if needed)
|
|
//
|
|
|
|
InitializeWmi();
|
|
|
|
Status = EnumAllInterfaces();
|
|
|
|
if (ERROR_FAILED(Status)) {
|
|
|
|
FreeLock( ClientRegDeregLock );
|
|
return Status;
|
|
}
|
|
|
|
Status = OpenGpcClients(GPC_CF_QOS);
|
|
if (ERROR_FAILED(Status)) {
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcRegisterClient: Error = 0x%X\n", Status ));
|
|
}
|
|
|
|
FreeLock( ClientRegDeregLock );
|
|
return Status;
|
|
}
|
|
|
|
|
|
//
|
|
// allocate a new client structure and link it on the global list
|
|
//
|
|
|
|
Status = CreateClientStruc(0, // This will be the client reg ctx
|
|
&pClient
|
|
);
|
|
|
|
if (ERROR_FAILED(Status)) {
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcRegisterClient: Error = 0x%X\n", Status ));
|
|
}
|
|
|
|
FreeLock( ClientRegDeregLock );
|
|
return Status;
|
|
|
|
}
|
|
|
|
//
|
|
// copy the handler list privately
|
|
//
|
|
|
|
__try {
|
|
|
|
RtlCopyMemory(&pClient->ClHandlers,
|
|
ClientHandlerList,
|
|
sizeof(TCI_CLIENT_FUNC_LIST));
|
|
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
Status = GetExceptionCode();
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcRegisterClient: Exception Error: = 0x%X\n", Status ));
|
|
}
|
|
|
|
FreeLock( ClientRegDeregLock );
|
|
return Status;
|
|
}
|
|
|
|
pClient->ClRegCtx = ClRegCtx;
|
|
|
|
//
|
|
// Update linked lists, add the client to the global linked list of
|
|
// clients.
|
|
//
|
|
// NOTE! NOTE! NOTE! NOTE! NOTE! NOTE! NOTE! NOTE! NOTE! NOTE!
|
|
//
|
|
// Once we add the client to the list, it can get notified by an
|
|
// incoming event, for example: TC_NOTIFY_IFC_CHANGE,
|
|
// so everything should be in place by the time we release the lock!
|
|
//
|
|
|
|
GetLock(pClient->Lock);
|
|
SET_STATE(pClient->State, OPEN);
|
|
FreeLock(pClient->Lock);
|
|
|
|
GetLock( pGlobals->Lock );
|
|
|
|
// If this is the first client then register for GPC notifications
|
|
if ( IsListEmpty( &pGlobals->ClientList ) )
|
|
RegisterWithGpc = TRUE;
|
|
|
|
InsertTailList( &pGlobals->ClientList, &pClient->Linkage );
|
|
FreeLock( pGlobals->Lock );
|
|
|
|
//
|
|
// so far so good, set the returned handle
|
|
//
|
|
|
|
__try {
|
|
|
|
*pClientHandle = (HANDLE)pClient->ClHandle;
|
|
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
Status = GetExceptionCode();
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcRegisterClient: Exception Error: = 0x%X\n", Status ));
|
|
}
|
|
|
|
// We couldn't return the handle so we do our best effort to undo
|
|
// the client registration
|
|
TcDeregisterClient((HANDLE)pClient->ClHandle);
|
|
|
|
FreeLock( ClientRegDeregLock );
|
|
return Status;
|
|
}
|
|
|
|
if ( RegisterWithGpc )
|
|
{
|
|
Status = StartGpcNotifyThread();
|
|
|
|
if ( Status )
|
|
{
|
|
// We couldn't return the handle so we do our best effort to undo
|
|
// the client registration
|
|
TcDeregisterClient((HANDLE)pClient->ClHandle);
|
|
|
|
FreeLock( ClientRegDeregLock );
|
|
return Status;
|
|
}
|
|
}
|
|
|
|
|
|
// Finally allow other TcRegisterClient and TcDeregisterClient to go through
|
|
FreeLock( ClientRegDeregLock );
|
|
|
|
IF_DEBUG(CALLS) {
|
|
WSPRINT(("<==TcRegisterClient: ClHandle=%d Status=%X\n",
|
|
pClient->ClHandle, Status));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
************************************************************************
|
|
|
|
Description:
|
|
|
|
The will call the system to enumerate all the TC aware interfaces.
|
|
For each interface, it will return the interface instance name and
|
|
a list of supported network addresses. This list can also be empty
|
|
if the interface currently does not have an address associated with.
|
|
On return, *pBufferSize is set to the actual number of bytes filled
|
|
in Buffer. If the buffer is too small to hold all the interfaces
|
|
data, it will return ERROR_INSUFFICIENT_BUFFER.
|
|
|
|
Arguments:
|
|
|
|
ClientHandle - the client handle from TcRegisterClient
|
|
pBufferSize - in: allocate buffer size, out: returned byte count
|
|
InterfaceBuffer - the buffer
|
|
|
|
Return Value:
|
|
|
|
NO_ERROR
|
|
ERROR_INVALID_HANDLE invalid client handle
|
|
ERROR_INVALID_PARAMETER one of the parameters is NULL
|
|
ERROR_INSUFFICIENT_BUFFER buffer too small to enumerate all interfaces
|
|
ERROR_NOT_ENOUGH_MEMORY system out of memory
|
|
|
|
************************************************************************
|
|
*/
|
|
DWORD
|
|
APIENTRY
|
|
TcEnumerateInterfaces(
|
|
IN HANDLE ClientHandle,
|
|
IN OUT PULONG pBufferSize,
|
|
OUT PTC_IFC_DESCRIPTOR InterfaceBuffer
|
|
)
|
|
{
|
|
PCLIENT_STRUC pClient;
|
|
DWORD Status = NO_ERROR;
|
|
ULONG MyBufferSize = 2 KiloBytes; // is this enough?!?
|
|
ULONG Offset2IfcName;
|
|
ULONG Offset2IfcID;
|
|
INT t, InputBufSize, CurrentLength = 0;
|
|
PLIST_ENTRY pHead, pEntry;
|
|
PTC_IFC pTcIfc;
|
|
|
|
IF_DEBUG(CALLS) {
|
|
WSPRINT(("==>TcEnumerateInterfaces: Called: ClientHandle= %d",
|
|
ClientHandle ));
|
|
}
|
|
|
|
VERIFY_INITIALIZATION_STATUS;
|
|
|
|
|
|
if ( IsBadWritePtr(pBufferSize, sizeof(ULONG))
|
|
|| IsBadWritePtr(InterfaceBuffer, *pBufferSize) ) {
|
|
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
__try {
|
|
|
|
InputBufSize = *pBufferSize;
|
|
*pBufferSize = 0; // reset it in case of an error
|
|
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
Status = GetExceptionCode();
|
|
|
|
return Status;
|
|
}
|
|
|
|
pClient = (PCLIENT_STRUC)GetHandleObjectWithRef(ClientHandle, ENUM_CLIENT_TYPE, 'TCEI');
|
|
|
|
if (pClient == NULL) {
|
|
|
|
return ERROR_INVALID_HANDLE;
|
|
}
|
|
|
|
ASSERT((HANDLE)pClient->ClHandle == ClientHandle);
|
|
|
|
GetLock(pGlobals->Lock);
|
|
|
|
//
|
|
// walk the list of TC interfaces
|
|
//
|
|
|
|
pHead = &pGlobals->TcIfcList;
|
|
pEntry = pHead->Flink;
|
|
|
|
while (pEntry != pHead) {
|
|
|
|
|
|
pTcIfc = (PTC_IFC)CONTAINING_RECORD(pEntry,
|
|
TC_IFC,
|
|
Linkage
|
|
);
|
|
|
|
//
|
|
// 273978 - if the interface is down - dont show it.
|
|
//
|
|
GetLock(pTcIfc->Lock);
|
|
|
|
if (QUERY_STATE(pTcIfc->State) != OPEN) {
|
|
|
|
FreeLock(pTcIfc->Lock);
|
|
pEntry = pEntry->Flink;
|
|
continue;
|
|
}
|
|
|
|
FreeLock(pTcIfc->Lock);
|
|
|
|
//
|
|
// calculate the offset to the interface name buffer data
|
|
//
|
|
|
|
Offset2IfcName = FIELD_OFFSET(TC_IFC_DESCRIPTOR, AddressListDesc) +
|
|
pTcIfc->AddrListBytesCount;
|
|
|
|
//
|
|
// calculate the offset to the interface ID buffer data
|
|
//
|
|
|
|
Offset2IfcID = Offset2IfcName +
|
|
pTcIfc->InstanceNameLength + sizeof(WCHAR);
|
|
|
|
//
|
|
// total descriptor length
|
|
//
|
|
|
|
t = Offset2IfcID
|
|
+ pTcIfc->InstanceIDLength + sizeof(WCHAR); // ID
|
|
|
|
t = MULTIPLE_OF_EIGHT(t);
|
|
|
|
if (t <= InputBufSize - CurrentLength) {
|
|
|
|
__try {
|
|
//
|
|
// enough space in the buffer
|
|
//
|
|
|
|
InterfaceBuffer->Length = t;
|
|
|
|
//
|
|
// update the interface name pointer, place it right after
|
|
// the address desc. buffer
|
|
//
|
|
|
|
InterfaceBuffer->pInterfaceName =
|
|
(LPWSTR)((PUCHAR)InterfaceBuffer + Offset2IfcName);
|
|
|
|
//
|
|
// update the interface ID ID pointer, place it right after
|
|
// the Interface Name string
|
|
//
|
|
|
|
InterfaceBuffer->pInterfaceID =
|
|
(LPWSTR)((PUCHAR)InterfaceBuffer + Offset2IfcID);
|
|
|
|
//
|
|
// copy the address list
|
|
//
|
|
|
|
RtlCopyMemory(&InterfaceBuffer->AddressListDesc,
|
|
pTcIfc->pAddressListDesc,
|
|
pTcIfc->AddrListBytesCount
|
|
);
|
|
|
|
//
|
|
// copy the interface name
|
|
//
|
|
|
|
RtlCopyMemory(InterfaceBuffer->pInterfaceName,
|
|
&pTcIfc->InstanceName[0],
|
|
pTcIfc->InstanceNameLength + sizeof(WCHAR)
|
|
);
|
|
|
|
//
|
|
// copy the interface ID
|
|
//
|
|
|
|
RtlCopyMemory(InterfaceBuffer->pInterfaceID,
|
|
&pTcIfc->InstanceID[0],
|
|
pTcIfc->InstanceIDLength + sizeof(WCHAR)
|
|
);
|
|
|
|
|
|
//
|
|
// update the output buffer size
|
|
//
|
|
|
|
CurrentLength += t;
|
|
|
|
//
|
|
// advance the interface buffer to the next free space
|
|
//
|
|
|
|
InterfaceBuffer =
|
|
(PTC_IFC_DESCRIPTOR)((PUCHAR)InterfaceBuffer + t);
|
|
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
Status = GetExceptionCode();
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcEnumerateInterfaces: Exception Error: = 0x%X\n",
|
|
Status ));
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
|
|
//
|
|
// get next entry in the linked list
|
|
//
|
|
|
|
pEntry = pEntry->Flink;
|
|
|
|
} else {
|
|
|
|
//
|
|
// buffer too small to contain data
|
|
// so lets just
|
|
//
|
|
CurrentLength += t;
|
|
|
|
//
|
|
// get next entry in the linked list
|
|
//
|
|
|
|
pEntry = pEntry->Flink;
|
|
|
|
Status = ERROR_INSUFFICIENT_BUFFER;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
FreeLock(pGlobals->Lock);
|
|
|
|
REFDEL(&pClient->RefCount, 'TCEI');
|
|
|
|
|
|
__try {
|
|
|
|
*pBufferSize = CurrentLength;
|
|
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
Status = GetExceptionCode();
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcEnumerateInterfaces: Exception Error: = 0x%X\n",
|
|
Status ));
|
|
}
|
|
}
|
|
|
|
IF_DEBUG(CALLS) {
|
|
WSPRINT(("<==TcEnumerateInterfaces: Returned= 0x%X\n", Status ));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
************************************************************************
|
|
|
|
Description:
|
|
|
|
This routine will open an interface for the client.
|
|
It needs to know the interface name, as it was returned from
|
|
TcEnumerateInterfaces. The client is also expected to give a context
|
|
that will be passed to the client upon certains notifications.
|
|
|
|
|
|
Arguments:
|
|
|
|
InterfaceName - the intefrace name
|
|
ClientHandle - as returned from TcRegisterClient
|
|
ClIfcCtx - a client context for this specific interface
|
|
pIfcHandle - returned interface handle
|
|
|
|
Return Value:
|
|
|
|
NO_ERROR
|
|
ERROR_INVALID_PARAMETER one of the parameters is NULL
|
|
ERROR_NOT_ENOUGH_MEMORY system out of memory
|
|
ERROR_NOT_FOUND failed to find an interface with the name provided
|
|
|
|
|
|
************************************************************************
|
|
*/
|
|
DWORD
|
|
APIENTRY
|
|
TcOpenInterfaceW(
|
|
IN LPWSTR pInterfaceName,
|
|
IN HANDLE ClientHandle,
|
|
IN HANDLE ClIfcCtx,
|
|
OUT PHANDLE pIfcHandle
|
|
)
|
|
{
|
|
DWORD Status;
|
|
ULONG Instance;
|
|
PINTERFACE_STRUC pClInterface;
|
|
PCLIENT_STRUC pClient;
|
|
HANDLE Handle;
|
|
PTC_IFC pTcIfc;
|
|
|
|
VERIFY_INITIALIZATION_STATUS;
|
|
|
|
//
|
|
// Validate the pifcHandle
|
|
//
|
|
if (IsBadWritePtr(pIfcHandle, sizeof(HANDLE))) {
|
|
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
// Set a return value early
|
|
__try {
|
|
|
|
*pIfcHandle = TC_INVALID_HANDLE;
|
|
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
Status = GetExceptionCode();
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcOpenInterfaces: Exception Error: = 0x%X\n",
|
|
Status ));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// Validate the pInterfaceName
|
|
//
|
|
|
|
if (IsBadStringPtrW(pInterfaceName,MAX_STRING_LENGTH)) {
|
|
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
IF_DEBUG(CALLS) {
|
|
WSPRINT(("==>TcOpenInterface: Called: ClientHandle= %d, Name=%S\n",
|
|
ClientHandle, pInterfaceName));
|
|
}
|
|
|
|
|
|
pClient = (PCLIENT_STRUC)GetHandleObjectWithRef(ClientHandle, ENUM_CLIENT_TYPE, 'TCOI');
|
|
|
|
if (pClient == NULL) {
|
|
|
|
return ERROR_INVALID_HANDLE;
|
|
}
|
|
|
|
ASSERT((HANDLE)pClient->ClHandle == ClientHandle);
|
|
|
|
//
|
|
// verify that the interface name exist
|
|
//
|
|
|
|
pTcIfc = GetTcIfcWithRef(pInterfaceName, 'TCOI');
|
|
|
|
if (pTcIfc == NULL) {
|
|
|
|
REFDEL(&pClient->RefCount, 'TCOI');
|
|
return ERROR_NOT_FOUND;
|
|
|
|
}
|
|
|
|
//
|
|
// create a client interface structure
|
|
//
|
|
|
|
Status = CreateClInterfaceStruc(ClIfcCtx, &pClInterface);
|
|
|
|
if (ERROR_FAILED(Status)) {
|
|
|
|
REFDEL(&pClient->RefCount, 'TCOI');
|
|
REFDEL(&pTcIfc->RefCount, 'TCOI');
|
|
|
|
return Status;
|
|
|
|
} else {
|
|
|
|
REFADD(&pClInterface->RefCount, 'TCOI');
|
|
|
|
}
|
|
|
|
//
|
|
// set up the client interface structure and link it to the client data
|
|
//
|
|
|
|
pClInterface->pTcIfc = pTcIfc;
|
|
pClInterface->pClient = pClient;
|
|
|
|
GetLock(pClInterface->Lock);
|
|
SET_STATE(pClInterface->State, OPEN);
|
|
FreeLock(pClInterface->Lock);
|
|
|
|
GetLock(pGlobals->Lock);
|
|
//
|
|
// add the interface on the client's list
|
|
//
|
|
GetLock(pClient->Lock);
|
|
GetLock(pTcIfc->Lock);
|
|
|
|
if ( (QUERY_STATE(pClient->State) != OPEN)
|
|
|| (QUERY_STATE(pTcIfc->State) != OPEN) )
|
|
{
|
|
|
|
FreeLock(pTcIfc->Lock);
|
|
FreeLock(pClient->Lock);
|
|
FreeLock(pGlobals->Lock);
|
|
|
|
IF_DEBUG(CALLS) {
|
|
WSPRINT(("<==TcOpenInterface: IfcHandle=%d Status=%X\n",
|
|
pClInterface->ClHandle, Status));
|
|
}
|
|
|
|
//
|
|
// Ideally we need to dereference the Interface, we really
|
|
// need only a subset of the functions.
|
|
//
|
|
FreeHandle(pClInterface->ClHandle);
|
|
CloseHandle(pClInterface->IfcEvent);
|
|
FreeMem(pClInterface);
|
|
|
|
REFDEL(&pClient->RefCount, 'TCOI');
|
|
REFDEL(&pTcIfc->RefCount, 'TCOI');
|
|
|
|
return ERROR_NOT_FOUND;
|
|
|
|
}
|
|
|
|
__try {
|
|
|
|
// the handle is all the client wants.
|
|
*pIfcHandle = (HANDLE)pClInterface->ClHandle;
|
|
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
Status = GetExceptionCode();
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcOpenInterfaceW: Exception Error: = 0x%X\n",
|
|
Status ));
|
|
}
|
|
|
|
FreeLock(pTcIfc->Lock);
|
|
FreeLock(pClient->Lock);
|
|
FreeLock(pGlobals->Lock);
|
|
|
|
REFDEL(&pClient->RefCount, 'TCOI');
|
|
REFDEL(&pTcIfc->RefCount, 'TCOI');
|
|
REFDEL(&pClInterface->RefCount, 'TCOI');
|
|
|
|
return Status;
|
|
}
|
|
|
|
InsertTailList( &pClient->InterfaceList, &pClInterface->Linkage );
|
|
|
|
//
|
|
// for every interface add one ref count
|
|
//
|
|
|
|
REFADD(&pClient->RefCount, 'CIFC');
|
|
REFADD(&pTcIfc->RefCount, 'CIFC');
|
|
|
|
pClient->InterfaceCount++;
|
|
|
|
//
|
|
// add the interface on the TC interface list for back reference
|
|
//
|
|
|
|
InsertTailList( &pTcIfc->ClIfcList, &pClInterface->NextIfc );
|
|
|
|
FreeLock(pTcIfc->Lock);
|
|
FreeLock(pClient->Lock);
|
|
FreeLock(pGlobals->Lock);
|
|
|
|
|
|
REFDEL(&pClient->RefCount, 'TCOI');
|
|
REFDEL(&pTcIfc->RefCount, 'TCOI');
|
|
REFDEL(&pClInterface->RefCount, 'TCOI');
|
|
|
|
IF_DEBUG(CALLS) {
|
|
WSPRINT(("<==TcOpenInterface: IfcHandle=%d Status=%X\n",
|
|
pClInterface->ClHandle, Status));
|
|
}
|
|
|
|
return Status;
|
|
|
|
}
|
|
|
|
|
|
/*
|
|
************************************************************************
|
|
|
|
Description:
|
|
|
|
The ANSI version of TcOpenInterfaceW
|
|
|
|
Arguments:
|
|
|
|
See TcOpenInterfaceW
|
|
|
|
Return Value:
|
|
|
|
See TcOpenInterfaceW
|
|
|
|
************************************************************************
|
|
*/
|
|
DWORD
|
|
APIENTRY
|
|
TcOpenInterfaceA(
|
|
IN LPSTR pInterfaceName,
|
|
IN HANDLE ClientHandle,
|
|
IN HANDLE ClIfcCtx,
|
|
OUT PHANDLE pIfcHandle
|
|
)
|
|
{
|
|
LPWSTR pWstr;
|
|
int l;
|
|
DWORD Status;
|
|
|
|
|
|
if (IsBadWritePtr(pIfcHandle,sizeof(HANDLE))) {
|
|
|
|
return ERROR_INVALID_PARAMETER;
|
|
|
|
}
|
|
|
|
__try {
|
|
|
|
*pIfcHandle = TC_INVALID_HANDLE;
|
|
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
Status = GetExceptionCode();
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcOpenInterfaceA: Exception Error: = 0x%X\n",
|
|
Status ));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
if (IsBadStringPtrA(pInterfaceName,MAX_STRING_LENGTH)) {
|
|
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
|
|
__try {
|
|
|
|
l = strlen(pInterfaceName) + 1;
|
|
|
|
AllocMem(&pWstr, l*sizeof(WCHAR));
|
|
|
|
if (pWstr == NULL) {
|
|
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
|
|
if ( -1 == mbstowcs(pWstr, pInterfaceName, l)) {
|
|
|
|
FreeMem(pWstr);
|
|
return ERROR_NO_UNICODE_TRANSLATION;
|
|
|
|
}
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
Status = GetExceptionCode();
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcOpenInterfaceA: Exception Error: = 0x%X\n",
|
|
Status ));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
Status = TcOpenInterfaceW(pWstr,
|
|
ClientHandle,
|
|
ClIfcCtx,
|
|
pIfcHandle
|
|
);
|
|
FreeMem(pWstr);
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
************************************************************************
|
|
|
|
Description:
|
|
|
|
This will close the interface previously open witt TcOpenInterface.
|
|
All flows should be deleted before calling it, o/w an error will be
|
|
returned. All notificaitons will stop being reported on this interface.
|
|
|
|
Arguments:
|
|
|
|
InterfaceHandle - the interface handle
|
|
|
|
Return Value:
|
|
|
|
NO_ERROR
|
|
ERROR_INVALID_HANDLE bad interface handle
|
|
ERROR_TC_SUPPORTED_OBJECTS_EXIST not all flows have been deleted for
|
|
this interface
|
|
|
|
************************************************************************
|
|
*/
|
|
DWORD
|
|
APIENTRY
|
|
TcCloseInterface(
|
|
IN HANDLE InterfaceHandle
|
|
)
|
|
{
|
|
|
|
DWORD Status = NO_ERROR;
|
|
PINTERFACE_STRUC pInterface;
|
|
HANDLE hWaitEvent;
|
|
PFLOW_STRUC pFlow;
|
|
PLIST_ENTRY pEntry;
|
|
|
|
VERIFY_INITIALIZATION_STATUS;
|
|
|
|
IF_DEBUG(CALLS) {
|
|
WSPRINT(("==>TcCloseInterface: Called: IfcHandle= %d\n",
|
|
InterfaceHandle));
|
|
}
|
|
|
|
pInterface = (PINTERFACE_STRUC)GetHandleObjectWithRef(InterfaceHandle,
|
|
ENUM_INTERFACE_TYPE, 'TCCI');
|
|
|
|
if (pInterface == NULL) {
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("==>TcCloseInterface: ERROR_INVALID_HANDLE\n"));
|
|
}
|
|
|
|
//
|
|
// If the Interface State is FORCED_KERNELCLOSE, it means we need
|
|
// to hang out here until the callback (in cbinterfacenotifyclient is done).
|
|
//
|
|
GetLock( pGlobals->Lock );
|
|
|
|
pInterface = (PINTERFACE_STRUC)GetHandleObject(InterfaceHandle,
|
|
ENUM_INTERFACE_TYPE);
|
|
|
|
if (pInterface) {
|
|
|
|
if (pInterface->CallbackThreadId == GetCurrentThreadId()) {
|
|
// same thread - bail!
|
|
FreeLock(pGlobals->Lock);
|
|
|
|
} else {
|
|
|
|
GetLock(pInterface->Lock);
|
|
|
|
// This is the state before the callback, so we shall wait here.
|
|
if (QUERY_STATE(pInterface->State) == FORCED_KERNELCLOSE) {
|
|
|
|
REFADD(&pInterface->RefCount, 'TCCW');
|
|
|
|
pInterface->Flags |= TC_FLAGS_WAITING;
|
|
FreeLock(pInterface->Lock);
|
|
hWaitEvent = pInterface->IfcEvent;
|
|
|
|
IF_DEBUG(INTERFACES) {
|
|
WSPRINT(("<==TcCloseInterface: Premature Forced Kernel Close, waiting for the callbacks to complete\n"));
|
|
}
|
|
|
|
FreeLock(pGlobals->Lock);
|
|
REFDEL(&pInterface->RefCount, 'TCCW');
|
|
WaitForSingleObject(hWaitEvent, INFINITE);
|
|
CloseHandle(hWaitEvent);
|
|
|
|
} else {
|
|
|
|
FreeLock(pInterface->Lock);
|
|
FreeLock(pGlobals->Lock);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
FreeLock(pGlobals->Lock);
|
|
|
|
}
|
|
|
|
return ERROR_INVALID_HANDLE;
|
|
}
|
|
|
|
ASSERT((HANDLE)pInterface->ClHandle == InterfaceHandle);
|
|
|
|
//
|
|
// release the ref count we added when we opened the interface
|
|
//
|
|
|
|
GetLock( pGlobals->Lock );
|
|
|
|
if (pInterface->FlowCount > 0) {
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("<==TcCloseInterface: ERROR: there are still open flows on this interface!\n"));
|
|
}
|
|
#if DBG
|
|
pEntry = pInterface->FlowList.Flink;
|
|
while (pEntry != &pInterface->FlowList) {
|
|
|
|
pFlow = CONTAINING_RECORD(pEntry, FLOW_STRUC, Linkage);
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("<==TcCloseInterface: Flow %x (handle %x) is open with RefCount:%d\n", pFlow, pFlow->ClHandle, pFlow->RefCount));
|
|
}
|
|
|
|
pEntry = pEntry->Flink;
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
FreeLock(pGlobals->Lock);
|
|
REFDEL(&pInterface->RefCount, 'TCCI');
|
|
Status = ERROR_TC_SUPPORTED_OBJECTS_EXIST;
|
|
return Status;
|
|
|
|
}
|
|
|
|
//
|
|
// OK, so we are taking it out for sure now.
|
|
//
|
|
GetLock(pInterface->Lock);
|
|
|
|
if (QUERY_STATE(pInterface->State) == OPEN) {
|
|
|
|
SET_STATE(pInterface->State, USERCLOSED_KERNELCLOSEPENDING);
|
|
FreeLock(pInterface->Lock);
|
|
|
|
} else if (QUERY_STATE(pInterface->State) == FORCED_KERNELCLOSE) {
|
|
|
|
//
|
|
// if the interface is going down, we are going to notify the
|
|
// client, make sure we wait here till the callbacks are done.
|
|
//
|
|
FreeLock(pInterface->Lock);
|
|
|
|
pInterface->Flags |= TC_FLAGS_WAITING;
|
|
hWaitEvent = pInterface->IfcEvent;
|
|
|
|
IF_DEBUG(INTERFACES) {
|
|
WSPRINT(("<==TcCloseInterface: Forced Kernel Close, waiting for the callbacks to complete\n"));
|
|
}
|
|
|
|
FreeLock(pGlobals->Lock);
|
|
|
|
REFDEL(&pInterface->RefCount, 'TCCI');
|
|
WaitForSingleObject(hWaitEvent, INFINITE);
|
|
|
|
CloseHandle(hWaitEvent);
|
|
return ERROR_INVALID_HANDLE;
|
|
|
|
} else {
|
|
|
|
//
|
|
// Is someone else (wmi) already taking it out.
|
|
//
|
|
FreeLock(pInterface->Lock);
|
|
FreeLock( pGlobals->Lock );
|
|
REFDEL(&pInterface->RefCount, 'TCCI');
|
|
|
|
return ERROR_INVALID_HANDLE;
|
|
|
|
}
|
|
|
|
|
|
FreeLock(pGlobals->Lock);
|
|
|
|
Status = CloseInterface(pInterface, FALSE);
|
|
|
|
IF_DEBUG(CALLS) {
|
|
WSPRINT(("<==TcCloseInterface: Status=%X\n",
|
|
Status));
|
|
}
|
|
|
|
//
|
|
// Shall we wait until the last interface goes away? (292120 D)
|
|
//
|
|
GetLock( pGlobals->Lock );
|
|
|
|
if (pInterface->CallbackThreadId != 0 ) {
|
|
//
|
|
// We are doing a notification, don't block (343058)
|
|
//
|
|
|
|
FreeLock(pGlobals->Lock);
|
|
REFDEL(&pInterface->RefCount, 'TCCI');
|
|
|
|
} else {
|
|
pInterface->Flags |= TC_FLAGS_WAITING;
|
|
hWaitEvent = pInterface->IfcEvent;
|
|
|
|
IF_DEBUG(INTERFACES) {
|
|
|
|
WSPRINT(("<==TcCloseInterface: Waiting for event to get set when we are ready to delete!!\n"));
|
|
|
|
}
|
|
|
|
FreeLock(pGlobals->Lock);
|
|
REFDEL(&pInterface->RefCount, 'TCCI');
|
|
WaitForSingleObject(hWaitEvent, INFINITE);
|
|
CloseHandle(hWaitEvent);
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
************************************************************************
|
|
|
|
Description:
|
|
|
|
This call will add a new flow on the interface.
|
|
|
|
Arguments:
|
|
|
|
IfcHandle - the interface handle to add the flow on
|
|
ClFlowCtx - a client given flow context
|
|
AddressType - determines what protocol template to use with the GPC
|
|
Flags - reserved, will be used to indicate a persistent flow
|
|
pGenericFlow - flow parameters
|
|
pFlowHandle - returned flow handle in case of success
|
|
|
|
Return Value:
|
|
|
|
NO_ERROR
|
|
ERROR_SIGNAL_PENDING
|
|
|
|
General error codes:
|
|
|
|
ERROR_INVALID_HANDLE bad handle.
|
|
ERROR_NOT_ENOUGH_MEMORY system out of memory
|
|
ERROR_INVALID_PARAMETER a general parameter is invalid
|
|
|
|
TC specific error codes:
|
|
|
|
ERROR_INVALID_SERVICE_TYPE unspecified or bad intserv service type
|
|
ERROR_INVALID_TOKEN_RATE unspecified or bad TokenRate
|
|
ERROR_INVALID_PEAK_RATE bad PeakBandwidth
|
|
ERROR_INVALID_SD_MODE invalid ShapeDiscardMode
|
|
ERROR_INVALID_PRIORITY invalid priority value
|
|
ERROR_INVALID_TRAFFIC_CLASS invalid traffic class value
|
|
ERROR_ADDRESS_TYPE_NOT_SUPPORTED the address type is not supported for
|
|
this interface
|
|
ERROR_NO_SYSTEM_RESOURCES not enough resources to accommodate flows
|
|
|
|
************************************************************************
|
|
*/
|
|
DWORD
|
|
APIENTRY
|
|
TcAddFlow(
|
|
IN HANDLE IfcHandle,
|
|
IN HANDLE ClFlowCtx,
|
|
IN ULONG Flags,
|
|
IN PTC_GEN_FLOW pGenericFlow,
|
|
OUT PHANDLE pFlowHandle
|
|
)
|
|
{
|
|
DWORD Status, Status2 = NO_ERROR;
|
|
PFLOW_STRUC pFlow;
|
|
PINTERFACE_STRUC pInterface;
|
|
PCLIENT_STRUC pClient;
|
|
PGPC_CLIENT pGpcClient;
|
|
ULONG l;
|
|
HANDLE hFlowTemp;
|
|
|
|
IF_DEBUG(CALLS) {
|
|
WSPRINT(("==>TcAddFlow: Called: IfcHandle= %d, ClFlowCtx=%d\n",
|
|
IfcHandle, ClFlowCtx ));
|
|
}
|
|
|
|
VERIFY_INITIALIZATION_STATUS;
|
|
|
|
if (IsBadWritePtr(pFlowHandle,sizeof(HANDLE))) {
|
|
|
|
Status = ERROR_INVALID_PARAMETER;
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcAddFlow: Error = 0x%X\n", Status ));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
__try {
|
|
|
|
*pFlowHandle = TC_INVALID_HANDLE;
|
|
|
|
if (IsBadReadPtr(pGenericFlow, sizeof(TC_GEN_FLOW))) {
|
|
|
|
Status = ERROR_INVALID_PARAMETER;
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcAddFlow: Error = 0x%X\n", Status ));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
l = FIELD_OFFSET(TC_GEN_FLOW, TcObjects) + pGenericFlow->TcObjectsLength;
|
|
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
Status = GetExceptionCode();
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcAddFlow: Exception Error: = 0x%X\n", Status ));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
if (IsBadReadPtr(pGenericFlow, l)) {
|
|
|
|
Status = ERROR_INVALID_PARAMETER;
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcAddFlow: Error = 0x%X\n", Status ));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
pInterface = (PINTERFACE_STRUC)GetHandleObjectWithRef(IfcHandle,
|
|
ENUM_INTERFACE_TYPE, 'TCAF');
|
|
|
|
if (pInterface == NULL) {
|
|
|
|
Status = ERROR_INVALID_HANDLE;
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcAddFlow: Error = 0x%X\n", Status ));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
ASSERT((HANDLE)pInterface->ClHandle == IfcHandle);
|
|
|
|
//
|
|
// search for an open GPC client that supports this address type
|
|
//
|
|
|
|
pGpcClient = FindGpcClient(GPC_CF_QOS);
|
|
|
|
if (pGpcClient == NULL) {
|
|
|
|
//
|
|
// not found!
|
|
//
|
|
|
|
Status = ERROR_ADDRESS_TYPE_NOT_SUPPORTED;
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcAddFlow: Error = 0x%X\n", Status ));
|
|
}
|
|
|
|
REFDEL(&pInterface->RefCount, 'TCAF');
|
|
return Status;
|
|
}
|
|
|
|
|
|
//
|
|
// create a new flow structure
|
|
//
|
|
Status = CreateFlowStruc(ClFlowCtx, pGenericFlow, &pFlow);
|
|
|
|
if (ERROR_FAILED(Status)) {
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcAddFlow: Error = 0x%X\n", Status ));
|
|
}
|
|
|
|
REFDEL(&pInterface->RefCount, 'TCAF');
|
|
return Status;
|
|
}
|
|
|
|
pClient = pInterface->pClient;
|
|
|
|
//
|
|
// initialize the flow structure and add it on the intefrace list
|
|
//
|
|
|
|
pFlow->pInterface = pInterface;
|
|
pFlow->UserFlags = Flags;
|
|
|
|
pFlow->pGpcClient = pGpcClient;
|
|
|
|
//
|
|
// call to actually add the flow
|
|
//
|
|
|
|
Status = IoAddFlow( pFlow, TRUE );
|
|
|
|
if (!ERROR_FAILED(Status)) {
|
|
|
|
__try {
|
|
|
|
*pFlowHandle = (HANDLE)pFlow->ClHandle;
|
|
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
Status2 = GetExceptionCode();
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcAddFlow: Exception Error: = 0x%X\n", Status2 ));
|
|
}
|
|
|
|
hFlowTemp = (HANDLE)pFlow->ClHandle;
|
|
}
|
|
}
|
|
|
|
if (!ERROR_PENDING(Status)) {
|
|
|
|
//
|
|
// call completed, either success or failure...
|
|
//
|
|
CompleteAddFlow(pFlow, Status);
|
|
}
|
|
|
|
//
|
|
// !!! don't reference pFlow after this since it may be gone!!!
|
|
//
|
|
|
|
if (Status2 != NO_ERROR) {
|
|
|
|
// We won't be able to return the flow, so we need to try to delete it
|
|
// and return the error
|
|
|
|
TcDeleteFlow(hFlowTemp);
|
|
return (Status2);
|
|
|
|
}
|
|
|
|
IF_DEBUG(CALLS) {
|
|
WSPRINT(("<==TcAddFlow: Returned= 0x%X\n", Status ));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
************************************************************************
|
|
|
|
Description:
|
|
|
|
This call will modify the flow.
|
|
|
|
Arguments:
|
|
|
|
FlowHandle - flow handle to modify
|
|
pGenericFlow - new flow parameters
|
|
|
|
Return Value:
|
|
|
|
See TcAddFlow
|
|
|
|
************************************************************************
|
|
*/
|
|
DWORD
|
|
APIENTRY
|
|
TcModifyFlow(
|
|
IN HANDLE FlowHandle,
|
|
IN PTC_GEN_FLOW pGenericFlow
|
|
)
|
|
{
|
|
DWORD Status;
|
|
PFLOW_STRUC pFlow;
|
|
ULONG l;
|
|
|
|
IF_DEBUG(CALLS) {
|
|
WSPRINT(("==>TcModifyFlow: Called: FlowHandle= %d\n",
|
|
FlowHandle ));
|
|
}
|
|
|
|
VERIFY_INITIALIZATION_STATUS;
|
|
|
|
if (IsBadReadPtr(pGenericFlow,sizeof(TC_GEN_FLOW))) {
|
|
|
|
Status = ERROR_INVALID_PARAMETER;
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcModifyFlow: Error = 0x%X\n", Status ));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// Figure out the full length for immediate verification and also for later usage
|
|
//
|
|
|
|
__try {
|
|
|
|
l = FIELD_OFFSET(TC_GEN_FLOW, TcObjects) + pGenericFlow->TcObjectsLength;
|
|
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
Status = GetExceptionCode();
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcModifyFlow: Exception Error: = 0x%X\n",
|
|
Status ));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
if (IsBadReadPtr(pGenericFlow,l)) {
|
|
|
|
Status = ERROR_INVALID_PARAMETER;
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcModifyFlow: Error = 0x%X\n", Status ));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
pFlow = (PFLOW_STRUC)GetHandleObjectWithRef(FlowHandle, ENUM_GEN_FLOW_TYPE, 'TCMF');
|
|
|
|
if (pFlow == NULL) {
|
|
|
|
Status = ERROR_INVALID_HANDLE;
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcModifyFlow: Error = 0x%X\n", Status ));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
else if (pFlow == INVALID_HANDLE_VALUE )
|
|
{
|
|
|
|
Status = ERROR_NOT_READY;
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcModifyFlow: Error = 0x%X\n", Status ));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
ASSERT((HANDLE)pFlow->ClHandle == FlowHandle);
|
|
|
|
GetLock(pFlow->Lock);
|
|
|
|
if (IS_MODIFYING(pFlow->Flags)) {
|
|
|
|
FreeLock(pFlow->Lock);
|
|
|
|
IF_DEBUG(REFCOUNTS) {
|
|
WSPRINT(("0 DEREF FLOW %X (%X) - ref (%d)\n", pFlow->ClHandle, pFlow, pFlow->RefCount));
|
|
}
|
|
|
|
REFDEL(&pFlow->RefCount, 'TCMF');
|
|
|
|
return ERROR_NOT_READY;
|
|
|
|
}
|
|
|
|
AllocMem(&pFlow->pGenFlow1, l);
|
|
|
|
if (pFlow->pGenFlow1 == NULL) {
|
|
|
|
Status = ERROR_NOT_ENOUGH_MEMORY;
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcModifyFlow: Error = 0x%X\n", Status ));
|
|
}
|
|
|
|
FreeLock(pFlow->Lock);
|
|
|
|
IF_DEBUG(REFCOUNTS) {
|
|
WSPRINT(("1 DEREF FLOW %X (%X) - ref (%d)\n", pFlow->ClHandle, pFlow, pFlow->RefCount));
|
|
}
|
|
|
|
REFDEL(&pFlow->RefCount, 'TCMF');
|
|
|
|
return Status;
|
|
}
|
|
|
|
__try {
|
|
|
|
RtlCopyMemory(pFlow->pGenFlow1, pGenericFlow, l);
|
|
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
Status = GetExceptionCode();
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcModifyFlow: Exception Error: = 0x%X\n",
|
|
Status ));
|
|
}
|
|
|
|
FreeLock(pFlow->Lock);
|
|
//IF_DEBUG(REFCOUNTS) { WSPRINT(("2\n"));
|
|
IF_DEBUG(REFCOUNTS) {
|
|
WSPRINT(("2 DEREF FLOW %X (%X) ref (%d)\n", pFlow->ClHandle, pFlow, pFlow->RefCount));
|
|
}
|
|
|
|
REFDEL(&pFlow->RefCount, 'TCMF');
|
|
|
|
return Status;
|
|
}
|
|
|
|
pFlow->Flags |= TC_FLAGS_MODIFYING;
|
|
pFlow->GenFlowLen1 = l;
|
|
|
|
FreeLock(pFlow->Lock);
|
|
|
|
//
|
|
// call to actually modify the flow
|
|
//
|
|
|
|
Status = IoModifyFlow( pFlow, TRUE );
|
|
|
|
if (!ERROR_PENDING(Status)) {
|
|
|
|
//
|
|
// call completed, either success or failure...
|
|
//
|
|
|
|
CompleteModifyFlow(pFlow, Status);
|
|
}
|
|
|
|
//
|
|
// !!! don't reference pFlow after this since it may be gone!!!
|
|
//
|
|
//IF_DEBUG(REFCOUNTS) { WSPRINT(("3\n"));
|
|
IF_DEBUG(REFCOUNTS) {
|
|
WSPRINT(("3 DEREF FLOW %X (%X), ref(%d)\n", pFlow->ClHandle, pFlow, pFlow->RefCount));
|
|
}
|
|
|
|
IF_DEBUG(CALLS) {
|
|
WSPRINT(("<==TcModifyFlow: Returned= 0x%X\n", Status ));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
************************************************************************
|
|
|
|
Description:
|
|
|
|
This will delete the flow. All the filters must have been deleted
|
|
by now, o/w an error code will be returned. Also the handle is
|
|
invalidated. No TC_NOTIFY_FLOW_CLOSE will be reported for this flow.
|
|
|
|
Arguments:
|
|
|
|
FlowHandle - handle of the flow to delete
|
|
|
|
Return Value:
|
|
|
|
NO_ERROR
|
|
ERROR_SIGNAL_PENDING
|
|
ERROR_INVALID_HANDLE invalid or NULL handle
|
|
ERROR_TC_SUPPORTED_OBJECTS_EXIST not all the filters have been deleted
|
|
|
|
|
|
************************************************************************
|
|
*/
|
|
DWORD
|
|
APIENTRY
|
|
TcDeleteFlow(
|
|
IN HANDLE FlowHandle
|
|
)
|
|
{
|
|
DWORD Status;
|
|
PFLOW_STRUC pFlow;
|
|
|
|
IF_DEBUG(CALLS) {
|
|
WSPRINT(("==>TcDeleteFlow: Called: FlowHandle= %d\n",
|
|
FlowHandle ));
|
|
}
|
|
|
|
VERIFY_INITIALIZATION_STATUS;
|
|
|
|
pFlow = (PFLOW_STRUC)GetHandleObjectWithRef(FlowHandle, ENUM_GEN_FLOW_TYPE, 'TCDF');
|
|
|
|
if (pFlow == NULL) {
|
|
|
|
Status = ERROR_INVALID_HANDLE;
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcDeleteFlow: Error = 0x%X\n", Status ));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
else if (pFlow == INVALID_HANDLE_VALUE )
|
|
{
|
|
|
|
Status = ERROR_NOT_READY;
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcDeleteFlow: Error = 0x%X\n", Status ));
|
|
}
|
|
|
|
return ERROR_NOT_READY;
|
|
}
|
|
|
|
ASSERT((HANDLE)pFlow->ClHandle == FlowHandle);
|
|
|
|
//
|
|
// Set the state and call to actually delete the flow
|
|
//
|
|
GetLock(pFlow->Lock);
|
|
|
|
if (QUERY_STATE(pFlow->State) == OPEN) {
|
|
|
|
if (IS_MODIFYING(pFlow->Flags))
|
|
{
|
|
//
|
|
// Someone else is taking this out.
|
|
//
|
|
FreeLock(pFlow->Lock);
|
|
REFDEL(&pFlow->RefCount, 'TCDF');
|
|
|
|
return ERROR_NOT_READY;
|
|
}
|
|
|
|
SET_STATE(pFlow->State, USERCLOSED_KERNELCLOSEPENDING);
|
|
FreeLock(pFlow->Lock);
|
|
|
|
} else {
|
|
|
|
//
|
|
// Someone else is taking this out.
|
|
//
|
|
FreeLock(pFlow->Lock);
|
|
REFDEL(&pFlow->RefCount, 'TCDF');
|
|
|
|
return ERROR_INVALID_HANDLE;
|
|
|
|
}
|
|
|
|
Status = DeleteFlow(pFlow, FALSE);
|
|
|
|
if (ERROR_FAILED(Status)) {
|
|
|
|
GetLock(pFlow->Lock);
|
|
SET_STATE(pFlow->State, OPEN);
|
|
FreeLock(pFlow->Lock);
|
|
|
|
}
|
|
|
|
//
|
|
// !!! don't reference pFlow after this since it may be gone!!!
|
|
//
|
|
//IF_DEBUG(REFCOUNTS) { WSPRINT(("4\n"));
|
|
IF_DEBUG(REFCOUNTS) {
|
|
WSPRINT(("4 DEREF FLOW %X (%X) ref(%d)\n", pFlow->ClHandle, pFlow, pFlow->RefCount));
|
|
}
|
|
|
|
REFDEL(&pFlow->RefCount, 'TCDF');
|
|
|
|
IF_DEBUG(CALLS) {
|
|
WSPRINT(("<==TcDeleteFlow: Returned= 0x%X\n", Status ));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
************************************************************************
|
|
|
|
Description:
|
|
|
|
Will add a filter and attach it to the flow.
|
|
|
|
Arguments:
|
|
|
|
FlowHandle - handle of the flow to add the filter on
|
|
pGenericFilter - the filter characteristics
|
|
pFilterHandle - the returned filter handle after success
|
|
|
|
Return Value:
|
|
|
|
NO_ERROR
|
|
|
|
General error codes:
|
|
|
|
ERROR_INVALID_HANDLE bad handle.
|
|
ERROR_NOT_ENOUGH_MEMORY system out of memory
|
|
ERROR_INVALID_PARAMETER a general parameter is invalid
|
|
|
|
TC specific error codes:
|
|
|
|
ERROR_INVALID_ADDRESS_TYPE invalid address type
|
|
ERROR_DUPLICATE_FILTER attempt to install identical filters on
|
|
different flows
|
|
ERROR_FILTER_CONFLICT attempt to install conflicting filter
|
|
|
|
************************************************************************
|
|
*/
|
|
DWORD
|
|
APIENTRY
|
|
TcAddFilter(
|
|
IN HANDLE FlowHandle,
|
|
IN PTC_GEN_FILTER pGenericFilter,
|
|
OUT PHANDLE pFilterHandle
|
|
)
|
|
{
|
|
DWORD Status;
|
|
PFLOW_STRUC pFlow;
|
|
PFILTER_STRUC pFilter;
|
|
ULONG PatternSize;
|
|
|
|
IF_DEBUG(CALLS) {
|
|
WSPRINT(("==>TcAddFilter: Called: FlowHandle=%d\n", FlowHandle ));
|
|
}
|
|
|
|
VERIFY_INITIALIZATION_STATUS;
|
|
|
|
if (IsBadWritePtr(pFilterHandle,sizeof(HANDLE))) {
|
|
|
|
Status = ERROR_INVALID_PARAMETER;
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcAddFilter: Error = 0x%X\n", Status ));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
__try {
|
|
|
|
*pFilterHandle = TC_INVALID_HANDLE;
|
|
|
|
if ( IsBadReadPtr(pGenericFilter,sizeof(TC_GEN_FILTER))
|
|
|| IsBadReadPtr(pGenericFilter->Pattern,pGenericFilter->PatternSize)
|
|
|| IsBadReadPtr(pGenericFilter->Mask,pGenericFilter->PatternSize)) {
|
|
|
|
Status = ERROR_INVALID_PARAMETER;
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcAddFilter: Error = 0x%X\n", Status ));
|
|
}
|
|
|
|
return Status;
|
|
|
|
}
|
|
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
Status = GetExceptionCode();
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcAddFilter: Exception Error: = 0x%X\n", Status ));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
pFlow = (PFLOW_STRUC)GetHandleObjectWithRef(FlowHandle,
|
|
ENUM_GEN_FLOW_TYPE, 'TAFL');
|
|
|
|
if (pFlow == NULL) {
|
|
|
|
Status = ERROR_INVALID_HANDLE;
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcAddFilter: Error = 0x%X\n", Status ));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
else if (pFlow == INVALID_HANDLE_VALUE )
|
|
{
|
|
|
|
Status = ERROR_NOT_READY;
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcAddFilter: Error = 0x%X\n", Status ));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
ASSERT((HANDLE)pFlow->ClHandle == FlowHandle);
|
|
|
|
//
|
|
// create a new filter structure
|
|
//
|
|
|
|
Status = CreateFilterStruc(pGenericFilter, pFlow, &pFilter);
|
|
|
|
if ( Status != NO_ERROR ) {
|
|
|
|
if ( ERROR_PENDING(Status) )
|
|
Status = ERROR_NOT_READY;
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcAddFilter: Error = 0x%X\n", Status ));
|
|
}
|
|
//IF_DEBUG(REFCOUNTS) { WSPRINT(("5\n"));
|
|
IF_DEBUG(REFCOUNTS) {
|
|
WSPRINT(("5 DEREF FLOW %X (%X) ref(%d)\n", pFlow->ClHandle, pFlow, pFlow->RefCount));
|
|
}
|
|
|
|
REFDEL(&pFlow->RefCount, 'TAFL');
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// initialize the filter structure and add it on the flow list
|
|
//
|
|
|
|
pFilter->pFlow = pFlow;
|
|
//
|
|
// call to actually add the filter
|
|
//
|
|
|
|
Status = IoAddFilter( pFilter );
|
|
|
|
if (!ERROR_FAILED(Status)) {
|
|
|
|
__try {
|
|
|
|
*pFilterHandle = (HANDLE)pFilter->ClHandle;
|
|
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
Status = GetExceptionCode();
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcAddFilter: Exception Error: = 0x%X\n", Status ));
|
|
}
|
|
|
|
}
|
|
|
|
GetLock(pGlobals->Lock);
|
|
GetLock(pFlow->Lock);
|
|
|
|
if (QUERY_STATE(pFlow->State) == OPEN) {
|
|
|
|
SET_STATE(pFilter->State, OPEN);
|
|
InsertTailList(&pFlow->FilterList, &pFilter->Linkage);
|
|
REFADD(&pFlow->RefCount, 'FILT');
|
|
|
|
FreeLock(pFlow->Lock);
|
|
|
|
}
|
|
else {
|
|
|
|
IF_DEBUG(WARNINGS) {
|
|
WSPRINT(("Flow %X (handle %X) is not OPEN! \n", pFlow, pFlow->ClHandle));
|
|
}
|
|
|
|
FreeLock(pFlow->Lock);
|
|
DeleteFilter(pFilter);
|
|
Status = ERROR_INVALID_HANDLE;
|
|
}
|
|
|
|
FreeLock(pGlobals->Lock);
|
|
|
|
} else {
|
|
|
|
//
|
|
// failed, release the filter resources
|
|
//
|
|
REFDEL(&pFilter->RefCount, 'FILT');
|
|
|
|
}
|
|
//IF_DEBUG(REFCOUNTS) { WSPRINT(("6\n"));
|
|
IF_DEBUG(REFCOUNTS) {
|
|
WSPRINT(("6 DEREF FLOW %X (%X) (%d)\n", pFlow->ClHandle, pFlow, pFlow->RefCount));
|
|
}
|
|
|
|
REFDEL(&pFlow->RefCount, 'TAFL');
|
|
|
|
IF_DEBUG(CALLS) {
|
|
WSPRINT(("<==TcAddFilter: Returned= 0x%X\n", Status ));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
/*
|
|
************************************************************************
|
|
|
|
Description:
|
|
|
|
Deletes the filter and invalidates the handle.
|
|
|
|
Arguments:
|
|
|
|
FilterHandle - handle of the filter to be deleted
|
|
|
|
Return Value:
|
|
|
|
NO_ERROR
|
|
ERROR_INVALID_HANDLE invalid or NULL handle
|
|
|
|
************************************************************************
|
|
*/
|
|
DWORD
|
|
APIENTRY
|
|
TcDeleteFilter(
|
|
IN HANDLE FilterHandle
|
|
)
|
|
{
|
|
DWORD Status;
|
|
PFILTER_STRUC pFilter;
|
|
|
|
IF_DEBUG(CALLS) {
|
|
WSPRINT(("==>TcDeleteFilter: Called: FilterHandle=%d\n",
|
|
FilterHandle ));
|
|
}
|
|
|
|
VERIFY_INITIALIZATION_STATUS;
|
|
|
|
pFilter = (PFILTER_STRUC)GetHandleObjectWithRef(FilterHandle,
|
|
ENUM_FILTER_TYPE, 'TDFL');
|
|
|
|
if (pFilter == NULL) {
|
|
|
|
Status = ERROR_INVALID_HANDLE;
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcDeleteFilter: Error = 0x%X\n", Status ));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
ASSERT((HANDLE)pFilter->ClHandle == FilterHandle);
|
|
|
|
GetLock(pFilter->Lock);
|
|
|
|
if (QUERY_STATE(pFilter->State) == OPEN) {
|
|
|
|
SET_STATE(pFilter->State, USERCLOSED_KERNELCLOSEPENDING);
|
|
FreeLock(pFilter->Lock);
|
|
|
|
} else {
|
|
|
|
//
|
|
// Someone else is taking this out.
|
|
//
|
|
FreeLock(pFilter->Lock);
|
|
REFDEL(&pFilter->RefCount, 'TDFL');
|
|
|
|
return ERROR_INVALID_HANDLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
Status = DeleteFilter(pFilter);
|
|
|
|
IF_DEBUG(CALLS) {
|
|
WSPRINT(("<==TcDeleteFilter: Returned= 0x%X\n", Status ));
|
|
}
|
|
|
|
REFDEL(&pFilter->RefCount, 'TDFL');
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
************************************************************************
|
|
|
|
Description:
|
|
|
|
This will deregister the client and release all associated resources.
|
|
TC_NOTIFY_IFC_CHANGE notifications will no longer be reported to
|
|
this client. All interface must have being close prior to calling
|
|
this API, o/w an error will be returned.
|
|
|
|
Arguments:
|
|
|
|
ClientHandle - handle of the client to be deregistered
|
|
|
|
Return Value:
|
|
|
|
NO_ERROR
|
|
ERROR_INVALID_HANDLE invalid or NULL handle
|
|
ERROR_TC_SUPPORTED_OBJECTS_EXIST not all the interfaces have been
|
|
closed for this client
|
|
|
|
************************************************************************
|
|
*/
|
|
DWORD
|
|
TcDeregisterClient(
|
|
IN HANDLE ClientHandle
|
|
)
|
|
{
|
|
DWORD Status;
|
|
ULONG Instance;
|
|
PINTERFACE_STRUC pClInterface;
|
|
PCLIENT_STRUC pClient;
|
|
PLIST_ENTRY pEntry;
|
|
BOOLEAN fOpenInterfacesFound;
|
|
BOOLEAN fDeRegisterWithGpc = FALSE;
|
|
|
|
VERIFY_INITIALIZATION_STATUS;
|
|
Status = NO_ERROR;
|
|
fOpenInterfacesFound = FALSE;
|
|
|
|
IF_DEBUG(CALLS) {
|
|
WSPRINT(("==>TcDeregisterClient: ClientHandle=%d\n",
|
|
ClientHandle));
|
|
}
|
|
|
|
pClient = (PCLIENT_STRUC)GetHandleObject(ClientHandle, ENUM_CLIENT_TYPE);
|
|
|
|
if (pClient == NULL) {
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("<==TcDeregisterClient: ERROR_INVALID_HANDLE\n"));
|
|
}
|
|
|
|
return ERROR_INVALID_HANDLE;
|
|
}
|
|
|
|
ASSERT((HANDLE)pClient->ClHandle == ClientHandle);
|
|
|
|
// Prevent another thread from doing TcRegisterClient and TcDeregisterClient
|
|
GetLock( ClientRegDeregLock );
|
|
|
|
GetLock( pGlobals->Lock );
|
|
|
|
// Go through the interface list and check if any interfaces are open.
|
|
// for a checked build, lets dump out the interfaces and the refcounts on these
|
|
// interfaces too. [ShreeM]
|
|
|
|
pEntry = pClient->InterfaceList.Flink;
|
|
while (pEntry != &pClient->InterfaceList) {
|
|
|
|
pClInterface = CONTAINING_RECORD(pEntry, INTERFACE_STRUC, Linkage);
|
|
|
|
GetLock(pClInterface->Lock);
|
|
|
|
if ((QUERY_STATE(pClInterface->State) == FORCED_KERNELCLOSE) ||
|
|
(QUERY_STATE(pClInterface->State) == KERNELCLOSED_USERCLEANUP)) {
|
|
|
|
#if DBG
|
|
IF_DEBUG(WARNINGS) {
|
|
WSPRINT(("<==TcDeregisterClient: Interface %x (H%x) is FORCED_KERNELCLOSE with RefCount:%d\n",
|
|
pClInterface, pClInterface->ClHandle, pClInterface->RefCount));
|
|
}
|
|
#endif
|
|
|
|
} else {
|
|
|
|
fOpenInterfacesFound = TRUE;
|
|
|
|
#if DBG
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("<==TcDeregisterClient: Interface %x (H%x) is open with RefCount:%d\n", pClInterface, pClInterface->ClHandle, pClInterface->RefCount));
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
pEntry = pEntry->Flink;
|
|
FreeLock(pClInterface->Lock);
|
|
|
|
|
|
|
|
if (fOpenInterfacesFound) {
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("<==TcDeregisterClient: ERROR_TC_SUPPORTED_OBJECTS_EXIST (%d Interfaces)\n", pClient->InterfaceCount));
|
|
}
|
|
|
|
FreeLock( ClientRegDeregLock );
|
|
FreeLock( pGlobals->Lock );
|
|
return ERROR_TC_SUPPORTED_OBJECTS_EXIST;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// Lets mark it as deleting.
|
|
//
|
|
GetLock(pClient->Lock);
|
|
SET_STATE(pClient->State, USERCLOSED_KERNELCLOSEPENDING);
|
|
FreeLock(pClient->Lock);
|
|
|
|
IF_DEBUG(HANDLES) {
|
|
WSPRINT(("<==TcDeregisterClient: client (%x), RefCount:%d\n", pClient->ClHandle, pClient->RefCount));
|
|
}
|
|
|
|
REFDEL(&pClient->RefCount, 'CLNT');
|
|
|
|
if ( IsListEmpty( &pGlobals->ClientList ) )
|
|
fDeRegisterWithGpc = TRUE;
|
|
|
|
FreeLock( pGlobals->Lock );
|
|
|
|
if ( fDeRegisterWithGpc )
|
|
{
|
|
// When there are no clients left stop listening to
|
|
// GPC notifications.
|
|
Status = StopGpcNotifyThread();
|
|
}
|
|
|
|
FreeLock( ClientRegDeregLock );
|
|
|
|
IF_DEBUG(CALLS) {
|
|
WSPRINT(("<==TcDeregisterClient: NO_ERROR\n" ));
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
************************************************************************
|
|
|
|
Description:
|
|
|
|
Sends a WMI query on the guid with the instance name.
|
|
Also sets the notification state to TRUE (=notify) or FALSE (dont notify).
|
|
|
|
Arguments:
|
|
|
|
IfcHandle - interface to send the query to
|
|
pGuidParam - GUID of the queried property
|
|
NotifyChange - set the notification state for this property
|
|
BufferSize - size of allocated buffer
|
|
Buffer - the buffer for returned result
|
|
|
|
Return Value:
|
|
|
|
NO_ERROR
|
|
ERROR_INVALID_HANDLE bad interface handle
|
|
ERROR_INVALID_PARAMETER bad parameter
|
|
ERROR_INSUFFICIENT_BUFFER buffer too small for result
|
|
ERROR_NOT_SUPPORTED unsupported GUID
|
|
|
|
************************************************************************
|
|
*/
|
|
DWORD
|
|
APIENTRY
|
|
TcQueryInterface(
|
|
IN HANDLE IfcHandle,
|
|
IN LPGUID pGuidParam,
|
|
IN BOOLEAN NotifyChange,
|
|
IN OUT PULONG pBufferSize,
|
|
OUT PVOID Buffer
|
|
)
|
|
{
|
|
DWORD Status;
|
|
PINTERFACE_STRUC pInterface;
|
|
WMIHANDLE hWmiHandle;
|
|
TCHAR cstr[MAX_STRING_LENGTH];
|
|
PWNODE_SINGLE_INSTANCE pWnode;
|
|
ULONG cBufSize;
|
|
ULONG InputBufferSize;
|
|
|
|
|
|
IF_DEBUG(CALLS) {
|
|
WSPRINT(("==>TcQueryInterface: Called: Name=%d\n",
|
|
IfcHandle));
|
|
}
|
|
|
|
VERIFY_INITIALIZATION_STATUS;
|
|
|
|
if (IsBadWritePtr(pBufferSize, sizeof(ULONG))) {
|
|
|
|
return ERROR_INVALID_PARAMETER;
|
|
|
|
}
|
|
|
|
__try {
|
|
|
|
InputBufferSize = *pBufferSize;
|
|
*pBufferSize = 0;
|
|
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
Status = GetExceptionCode();
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcModifyFlow: Exception Error: = 0x%X\n",
|
|
Status ));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
if (IsBadReadPtr(pGuidParam,sizeof(GUID))) {
|
|
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
if ( (InputBufferSize != 0)
|
|
&& (IsBadWritePtr(Buffer,InputBufferSize)) )
|
|
{
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
pInterface = (PINTERFACE_STRUC)GetHandleObjectWithRef(IfcHandle,
|
|
ENUM_INTERFACE_TYPE, 'TCQI');
|
|
|
|
if (pInterface == NULL) {
|
|
|
|
return ERROR_INVALID_HANDLE;
|
|
}
|
|
|
|
|
|
Status = WmiOpenBlock( pGuidParam, // object
|
|
0, // access
|
|
&hWmiHandle
|
|
);
|
|
|
|
if (ERROR_FAILED(Status)) {
|
|
|
|
TC_TRACE(ERRORS, ("[TcQueryInterface]: WmiOpenBlock failed with %x \n", Status));
|
|
REFDEL(&pInterface->RefCount, 'TCQI');
|
|
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// allocate memory for the output wnode
|
|
//
|
|
|
|
cBufSize = sizeof(WNODE_SINGLE_INSTANCE)
|
|
+ InputBufferSize
|
|
+ MAX_STRING_LENGTH * sizeof(TCHAR);
|
|
|
|
AllocMem(&pWnode, cBufSize);
|
|
|
|
if (pWnode == NULL) {
|
|
|
|
Status = ERROR_NOT_ENOUGH_MEMORY;
|
|
|
|
} else {
|
|
|
|
//
|
|
// query for the single instance
|
|
//
|
|
|
|
#ifndef UNICODE
|
|
|
|
if (-1 == wcstombs(cstr,
|
|
pInterface->pTcIfc->InstanceName,
|
|
pInterface->pTcIfc->InstanceNameLength
|
|
))
|
|
{
|
|
Status = ERROR_NO_UNICODE_TRANSLATION;
|
|
}
|
|
else
|
|
{
|
|
|
|
Status = WmiQuerySingleInstance( hWmiHandle,
|
|
cstr,
|
|
&cBufSize,
|
|
pWnode
|
|
);
|
|
}
|
|
#else
|
|
|
|
Status = WmiQuerySingleInstance( hWmiHandle,
|
|
pInterface->pTcIfc->InstanceName,
|
|
&cBufSize,
|
|
pWnode
|
|
);
|
|
#endif
|
|
|
|
|
|
if (!ERROR_FAILED(Status))
|
|
{
|
|
Status = WmiNotificationRegistration(pGuidParam,
|
|
NotifyChange,
|
|
CbWmiParamNotification,
|
|
PtrToUlong(IfcHandle),
|
|
NOTIFICATION_CALLBACK_DIRECT
|
|
);
|
|
|
|
if (Status == ERROR_WMI_ALREADY_DISABLED ||
|
|
Status == ERROR_WMI_ALREADY_ENABLED) {
|
|
|
|
//
|
|
// ignore these errors, we assumed it's okay
|
|
//
|
|
|
|
Status = NO_ERROR;
|
|
}
|
|
|
|
//
|
|
// Now that we are registered with WMI - add it OR delete it from our list. (258218)
|
|
//
|
|
|
|
if (NotifyChange) {
|
|
|
|
if (!TcipAddToNotificationList(
|
|
pGuidParam,
|
|
pInterface,
|
|
0
|
|
)) {
|
|
//
|
|
// Failed to put it on the list for some reason..
|
|
//
|
|
TC_TRACE(ERRORS, ("[TcQueryInterface]: Could not add the GUID/IFC to private list \n"));
|
|
|
|
}
|
|
} else {
|
|
|
|
if (!TcipDeleteFromNotificationList(
|
|
pGuidParam,
|
|
pInterface,
|
|
0
|
|
)) {
|
|
//
|
|
// Failed to remove it from the list for some reason..
|
|
//
|
|
TC_TRACE(ERRORS, ("[TcQueryInterface]: Could not remove the GUID/IFC from private list \n"));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!ERROR_FAILED(Status)) {
|
|
|
|
//
|
|
// parse the wnode
|
|
//
|
|
|
|
//
|
|
// check to see if the user allocated enough space for the
|
|
// returned buffer
|
|
//
|
|
|
|
if (pWnode->SizeDataBlock <= InputBufferSize) {
|
|
|
|
__try {
|
|
|
|
RtlCopyMemory(Buffer,
|
|
(PBYTE)OffsetToPtr(pWnode, pWnode->DataBlockOffset),
|
|
pWnode->SizeDataBlock
|
|
);
|
|
|
|
*pBufferSize = pWnode->SizeDataBlock;
|
|
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
Status = GetExceptionCode();
|
|
|
|
TC_TRACE(ERRORS, ("[TcQueryInterface]: Exception 0x%x while copying data \n", Status));
|
|
}
|
|
|
|
} else {
|
|
|
|
//
|
|
// output buffer too small
|
|
//
|
|
|
|
Status = ERROR_INSUFFICIENT_BUFFER;
|
|
|
|
__try {
|
|
|
|
*pBufferSize = pWnode->SizeDataBlock;
|
|
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
Status = GetExceptionCode();
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
WmiCloseBlock(hWmiHandle);
|
|
|
|
if (pWnode)
|
|
FreeMem(pWnode);
|
|
|
|
REFDEL(&pInterface->RefCount, 'TCQI');
|
|
|
|
IF_DEBUG(CALLS) {
|
|
WSPRINT(("<==TcQueryInterface: Returned= 0x%X\n", Status ));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
/*
|
|
************************************************************************
|
|
|
|
Description:
|
|
|
|
Sends a WMI set on the GUID with the instance name.
|
|
Not all propertied are writeable.
|
|
|
|
Arguments:
|
|
IfcHandle - interface handle to set the property on
|
|
pGuidParam - GUID of the property
|
|
BufferSize - allocate buffer size
|
|
Buffer - buffer that contains the data to be set
|
|
|
|
Return Value:
|
|
|
|
NO_ERROR
|
|
ERROR_INVALID_HANDLE bad interface handle
|
|
ERROR_INVALID_PARAMETER bad parameter
|
|
ERROR_NOT_SUPPORTED unsupported GUID
|
|
ERROR_WRITE_PROTECT GUID is read-only
|
|
|
|
************************************************************************
|
|
*/
|
|
DWORD
|
|
APIENTRY
|
|
TcSetInterface(
|
|
IN HANDLE IfcHandle,
|
|
IN LPGUID pGuidParam,
|
|
IN ULONG BufferSize,
|
|
IN PVOID Buffer
|
|
)
|
|
{
|
|
DWORD Status;
|
|
PINTERFACE_STRUC pInterface;
|
|
WMIHANDLE hWmiHandle;
|
|
TCHAR cstr[MAX_STRING_LENGTH];
|
|
PWNODE_SINGLE_INSTANCE pWnode;
|
|
ULONG cBufSize;
|
|
|
|
VERIFY_INITIALIZATION_STATUS;
|
|
|
|
|
|
if ( IsBadReadPtr(pGuidParam,sizeof(GUID))
|
|
|| (BufferSize == 0)
|
|
|| IsBadReadPtr(Buffer,BufferSize)) {
|
|
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
pInterface = (PINTERFACE_STRUC)GetHandleObjectWithRef(IfcHandle,
|
|
ENUM_INTERFACE_TYPE, 'TCSI');
|
|
|
|
if (pInterface == NULL) {
|
|
|
|
return ERROR_INVALID_HANDLE;
|
|
}
|
|
|
|
__try {
|
|
|
|
Status = WmiOpenBlock( pGuidParam, // object
|
|
0, // access
|
|
&hWmiHandle
|
|
);
|
|
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
Status = GetExceptionCode();
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcSetInterface: Exception Error: = 0x%X\n",
|
|
Status ));
|
|
}
|
|
|
|
REFDEL(&pInterface->RefCount, 'TCSI');
|
|
return Status;
|
|
}
|
|
|
|
|
|
if (ERROR_FAILED(Status)) {
|
|
|
|
TC_TRACE(ERRORS, ("[TcSetInterface]: WmiOpenBlock failed with error 0x%x \n", Status));
|
|
REFDEL(&pInterface->RefCount, 'TCSI');
|
|
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// allocate memory for the output wnode
|
|
//
|
|
|
|
cBufSize = sizeof(WNODE_SINGLE_INSTANCE)
|
|
+ BufferSize
|
|
+ MAX_STRING_LENGTH * sizeof(TCHAR);
|
|
|
|
AllocMem(&pWnode, cBufSize);
|
|
|
|
if (pWnode == NULL) {
|
|
|
|
Status = ERROR_NOT_ENOUGH_MEMORY;
|
|
|
|
} else {
|
|
|
|
//
|
|
// set the single instance
|
|
//
|
|
|
|
__try {
|
|
|
|
#ifndef UNICODE
|
|
|
|
if (-1 == wcstombs(cstr,
|
|
pInterface->pTcIfc->InstanceName,
|
|
pInterface->pTcIfc->InstanceNameLength
|
|
)) {
|
|
|
|
Status = ERROR_NO_UNICODE_TRANSLATION;
|
|
|
|
}
|
|
else {
|
|
|
|
|
|
Status = WmiSetSingleInstance( hWmiHandle,
|
|
cstr,
|
|
1,
|
|
BufferSize,
|
|
Buffer
|
|
);
|
|
}
|
|
#else
|
|
Status = WmiSetSingleInstance( hWmiHandle,
|
|
pInterface->pTcIfc->InstanceName,
|
|
1,
|
|
BufferSize,
|
|
Buffer
|
|
);
|
|
|
|
#endif
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
Status = GetExceptionCode();
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcSetInterface: Exception Error: = 0x%X\n",
|
|
Status ));
|
|
}
|
|
}
|
|
}
|
|
|
|
WmiCloseBlock(hWmiHandle);
|
|
|
|
if (pWnode)
|
|
FreeMem(pWnode);
|
|
|
|
REFDEL(&pInterface->RefCount, 'TCSI');
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
************************************************************************
|
|
|
|
Description:
|
|
|
|
Will issue a WMI query on the specific flow instance name.
|
|
|
|
Arguments:
|
|
|
|
pFlowName - flow instance name
|
|
pGuidParam - GUID of the queried property
|
|
BufferSize - size of allocated buffer
|
|
Buffer - the buffer for returned result
|
|
|
|
Return Value:
|
|
|
|
NO_ERROR
|
|
ERROR_INVALID_PARAMETER bad parameter
|
|
ERROR_INSUFFICIENT_BUFFER buffer too small for result
|
|
ERROR_NOT_SUPPORTED unsupported GUID
|
|
ERROR_WMI_GUID_NOT_FOUND
|
|
ERROR_WMI_INSTANCE_NOT_FOUND
|
|
|
|
************************************************************************
|
|
*/
|
|
DWORD
|
|
APIENTRY
|
|
TcQueryFlowW(
|
|
IN LPWSTR pFlowName,
|
|
IN LPGUID pGuidParam,
|
|
IN OUT PULONG pBufferSize,
|
|
OUT PVOID Buffer
|
|
)
|
|
{
|
|
DWORD Status;
|
|
HANDLE hWmiHandle;
|
|
TCHAR cstr[MAX_STRING_LENGTH];
|
|
PWNODE_SINGLE_INSTANCE pWnode;
|
|
ULONG cBufSize;
|
|
ULONG InputBufferSize;
|
|
|
|
|
|
if (IsBadWritePtr(pBufferSize, sizeof(ULONG)))
|
|
{
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
__try {
|
|
|
|
InputBufferSize = *pBufferSize;
|
|
*pBufferSize = 0;
|
|
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
Status = GetExceptionCode();
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcSetFlowW: Exception Error: = 0x%X\n",
|
|
Status ));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
if ( IsBadReadPtr(pGuidParam, sizeof(GUID))
|
|
|| IsBadStringPtr(pFlowName, MAX_STRING_LENGTH)
|
|
|| IsBadWritePtr(Buffer,InputBufferSize) )
|
|
{
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
Status = WmiOpenBlock(pGuidParam, // object
|
|
0, // access
|
|
&hWmiHandle);
|
|
|
|
if (ERROR_FAILED(Status)) {
|
|
|
|
TC_TRACE(ERRORS, ("[TcQueryInterface]: WmiOpenBlock Error: = 0x%X\n", Status ));
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// allocate memory for the output wnode
|
|
//
|
|
|
|
cBufSize = sizeof(WNODE_SINGLE_INSTANCE)
|
|
+ InputBufferSize
|
|
+ MAX_STRING_LENGTH * sizeof(TCHAR);
|
|
|
|
AllocMem(&pWnode, cBufSize);
|
|
|
|
if (pWnode == NULL) {
|
|
|
|
Status = ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
else
|
|
{
|
|
|
|
//
|
|
// query for the single instance
|
|
//
|
|
|
|
|
|
#ifndef UNICODE
|
|
|
|
if (-1 == wcstombs(cstr,
|
|
pFlowName,
|
|
wcslen(pFlowName)
|
|
))
|
|
{
|
|
Status = ERROR_NO_UNICODE_TRANSLATION;
|
|
}
|
|
else
|
|
{
|
|
|
|
Status = WmiQuerySingleInstance( hWmiHandle,
|
|
cstr,
|
|
&cBufSize,
|
|
pWnode
|
|
);
|
|
}
|
|
#else
|
|
|
|
Status = WmiQuerySingleInstance( hWmiHandle,
|
|
pFlowName,
|
|
&cBufSize,
|
|
pWnode
|
|
);
|
|
#endif
|
|
|
|
if (!ERROR_FAILED(Status)) {
|
|
|
|
//
|
|
// parse the wnode
|
|
//
|
|
|
|
|
|
//
|
|
// check to see if the user allocated enough space for the
|
|
// returned buffer
|
|
//
|
|
|
|
if (pWnode->SizeDataBlock <= InputBufferSize) {
|
|
|
|
__try {
|
|
|
|
RtlCopyMemory(Buffer,
|
|
(PBYTE)OffsetToPtr(pWnode, pWnode->DataBlockOffset),
|
|
pWnode->SizeDataBlock
|
|
);
|
|
|
|
*pBufferSize = pWnode->SizeDataBlock;
|
|
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
Status = GetExceptionCode();
|
|
|
|
TC_TRACE(ERRORS, ("[TcQueryInterface]: RtlCopyMemory Exception Error: = 0x%X\n", Status ));
|
|
}
|
|
|
|
} else {
|
|
|
|
//
|
|
// output buffer too small
|
|
//
|
|
__try {
|
|
*pBufferSize = pWnode->SizeDataBlock;
|
|
|
|
Status = ERROR_INSUFFICIENT_BUFFER;
|
|
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
Status = GetExceptionCode();
|
|
|
|
TC_TRACE(ERRORS, ("[TcQueryInterface]: RtlCopyMemory Exception Error: = 0x%X\n", Status ));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
WmiCloseBlock(hWmiHandle);
|
|
|
|
if(pWnode)
|
|
FreeMem(pWnode);
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
/*
|
|
************************************************************************
|
|
|
|
Description:
|
|
|
|
The ANSI version of TcQueryFlowW
|
|
|
|
Arguments:
|
|
|
|
See TcQueryFlowW
|
|
|
|
Return Value:
|
|
|
|
See TcQueryFlowW
|
|
|
|
************************************************************************
|
|
*/
|
|
DWORD
|
|
APIENTRY
|
|
TcQueryFlowA(
|
|
IN LPSTR pFlowName,
|
|
IN LPGUID pGuidParam,
|
|
IN OUT PULONG pBufferSize,
|
|
OUT PVOID Buffer
|
|
)
|
|
{
|
|
LPWSTR pWstr = NULL;
|
|
int l;
|
|
DWORD Status;
|
|
|
|
if (IsBadStringPtrA(pFlowName,MAX_STRING_LENGTH)) {
|
|
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
|
|
l = strlen(pFlowName) + 1;
|
|
|
|
AllocMem(&pWstr, l*sizeof(WCHAR));
|
|
|
|
if (pWstr == NULL) {
|
|
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
|
|
if (-1 == mbstowcs(pWstr, pFlowName, l)) {
|
|
|
|
FreeMem(pWstr);
|
|
return ERROR_NO_UNICODE_TRANSLATION;
|
|
|
|
}
|
|
|
|
|
|
Status = TcQueryFlowW(pWstr,
|
|
pGuidParam,
|
|
pBufferSize,
|
|
Buffer
|
|
);
|
|
|
|
FreeMem(pWstr);
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
************************************************************************
|
|
|
|
Description:
|
|
|
|
Will issue a WMI set on the specific flow instance name.
|
|
|
|
Arguments:
|
|
|
|
pFlowName - flow instance name
|
|
pGuidParam - GUID of the queried property
|
|
BufferSize - size of allocated buffer
|
|
Buffer - the buffer to set
|
|
|
|
Return Value:
|
|
|
|
NO_ERROR
|
|
ERROR_INVALID_PARAMETER bad parameter
|
|
ERROR_INSUFFICIENT_BUFFER buffer too small for result
|
|
ERROR_NOT_SUPPORTED unsupported GUID
|
|
ERROR_WMI_GUID_NOT_FOUND
|
|
ERROR_WMI_INSTANCE_NOT_FOUND
|
|
|
|
************************************************************************
|
|
*/
|
|
DWORD
|
|
APIENTRY
|
|
TcSetFlowW(
|
|
IN LPWSTR pFlowName,
|
|
IN LPGUID pGuidParam,
|
|
IN ULONG BufferSize,
|
|
IN PVOID Buffer
|
|
)
|
|
{
|
|
DWORD Status;
|
|
HANDLE hWmiHandle;
|
|
TCHAR cstr[MAX_STRING_LENGTH];
|
|
PWNODE_SINGLE_INSTANCE pWnode;
|
|
ULONG cBufSize;
|
|
|
|
if ( IsBadStringPtr(pFlowName,MAX_STRING_LENGTH)
|
|
|| IsBadReadPtr(pGuidParam,sizeof(GUID))
|
|
|| (BufferSize == 0)
|
|
|| IsBadReadPtr(Buffer,BufferSize)) {
|
|
|
|
return ERROR_INVALID_PARAMETER;
|
|
|
|
}
|
|
|
|
Status = WmiOpenBlock( pGuidParam, // object
|
|
0, // access
|
|
&hWmiHandle
|
|
);
|
|
|
|
if (ERROR_FAILED(Status)) {
|
|
|
|
TC_TRACE(ERRORS, ("[TcSetFlow]: WmiOpenBlock failed with 0x%x \n", Status));
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// allocate memory for the output wnode
|
|
//
|
|
|
|
cBufSize = sizeof(WNODE_SINGLE_INSTANCE)
|
|
+ BufferSize
|
|
+ MAX_STRING_LENGTH * sizeof(TCHAR);
|
|
|
|
|
|
AllocMem(&pWnode, cBufSize);
|
|
|
|
if (pWnode == NULL) {
|
|
|
|
Status = ERROR_NOT_ENOUGH_MEMORY;
|
|
|
|
} else {
|
|
|
|
//
|
|
// set the single instance
|
|
//
|
|
|
|
__try {
|
|
#ifndef UNICODE
|
|
|
|
if (-1 == wcstombs(cstr,
|
|
pFlowName,
|
|
wcslen(pFlowName)
|
|
)) {
|
|
|
|
Status = ERROR_NO_UNICODE_TRANSLATION;
|
|
|
|
} else {
|
|
|
|
Status = WmiQuerySingleInstance( hWmiHandle,
|
|
cstr,
|
|
&cBufSize,
|
|
pWnode
|
|
);
|
|
}
|
|
#else
|
|
Status = WmiSetSingleInstance( hWmiHandle,
|
|
pFlowName,
|
|
1,
|
|
BufferSize,
|
|
Buffer
|
|
);
|
|
#endif
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
Status = GetExceptionCode();
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcSetFlowW: Exception Error: = 0x%X\n",
|
|
Status ));
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
WmiCloseBlock(hWmiHandle);
|
|
|
|
if (pWnode)
|
|
FreeMem(pWnode);
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
************************************************************************
|
|
|
|
Description:
|
|
|
|
The ANSI version of TcSetFlowW
|
|
|
|
Arguments:
|
|
|
|
See TcSetFlowW
|
|
|
|
Return Value:
|
|
|
|
See TcSetFlowW
|
|
|
|
************************************************************************
|
|
*/
|
|
DWORD
|
|
APIENTRY
|
|
TcSetFlowA(
|
|
IN LPSTR pFlowName,
|
|
IN LPGUID pGuidParam,
|
|
IN ULONG BufferSize,
|
|
IN PVOID Buffer
|
|
)
|
|
{
|
|
LPWSTR pWstr;
|
|
int l;
|
|
DWORD Status;
|
|
|
|
if (IsBadStringPtrA(pFlowName,MAX_STRING_LENGTH)) {
|
|
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
l = strlen(pFlowName) + 1;
|
|
|
|
AllocMem(&pWstr, l*sizeof(WCHAR));
|
|
|
|
if (pWstr == NULL) {
|
|
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
|
|
if(-1 == mbstowcs(pWstr, pFlowName, l)) {
|
|
// couldn't convert some multibyte characters - bail with error.
|
|
|
|
FreeMem(pWstr);
|
|
return ERROR_NO_UNICODE_TRANSLATION;
|
|
}
|
|
|
|
|
|
Status = TcSetFlowW(pWstr,
|
|
pGuidParam,
|
|
BufferSize,
|
|
Buffer
|
|
);
|
|
|
|
FreeMem(pWstr);
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
************************************************************************
|
|
|
|
Description:
|
|
|
|
Will return the flow inatsnace name associated with the flow handle.
|
|
|
|
Arguments:
|
|
|
|
FlowHandle - the flow handle
|
|
StrSize - how many TCHAR can fit in the string buffer
|
|
pFlowName - a pointer to a string buffer
|
|
|
|
Return Value:
|
|
|
|
See TcGetFlowNameW
|
|
|
|
************************************************************************
|
|
*/
|
|
DWORD
|
|
APIENTRY
|
|
TcGetFlowNameW(
|
|
IN HANDLE FlowHandle,
|
|
IN ULONG StrSize,
|
|
OUT LPWSTR pFlowName
|
|
)
|
|
{
|
|
PFLOW_STRUC pFlow;
|
|
DWORD Status;
|
|
|
|
VERIFY_INITIALIZATION_STATUS;
|
|
|
|
if (IsBadWritePtr(pFlowName,StrSize*sizeof(WCHAR))) {
|
|
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
pFlow = (PFLOW_STRUC)GetHandleObjectWithRef(FlowHandle, ENUM_GEN_FLOW_TYPE, 'TGFW');
|
|
|
|
if (pFlow == NULL) {
|
|
|
|
return ERROR_INVALID_HANDLE;
|
|
}
|
|
else if (pFlow == INVALID_HANDLE_VALUE )
|
|
{
|
|
|
|
Status = ERROR_NOT_READY;
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcGetFlowNameW: Error = 0x%X\n", Status ));
|
|
}
|
|
|
|
return ERROR_NOT_READY;
|
|
}
|
|
|
|
ASSERT((HANDLE)pFlow->ClHandle == FlowHandle);
|
|
|
|
if (pFlow->InstanceNameLength+sizeof(WCHAR) > (USHORT)StrSize) {
|
|
|
|
//IF_DEBUG(REFCOUNTS) { WSPRINT(("8\n"));
|
|
IF_DEBUG(REFCOUNTS) {
|
|
WSPRINT(("8 DEREF FLOW %X (%X) ref(%d)\n", pFlow->ClHandle, pFlow, pFlow->RefCount));
|
|
}
|
|
REFDEL(&pFlow->RefCount, 'TGFW');
|
|
|
|
return ERROR_INSUFFICIENT_BUFFER;
|
|
}
|
|
|
|
__try {
|
|
|
|
wcscpy(pFlowName, pFlow->InstanceName);
|
|
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
Status = GetExceptionCode();
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcGetFlowName: Exception Error: = 0x%X\n", Status ));
|
|
}
|
|
|
|
REFDEL(&pFlow->RefCount, 'TGFW');
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
IF_DEBUG(REFCOUNTS) {
|
|
WSPRINT(("9 DEREF FLOW %X (%X) ref(%d)\n", pFlow->ClHandle, pFlow, pFlow->RefCount));
|
|
}
|
|
|
|
REFDEL(&pFlow->RefCount, 'TGFW');
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
************************************************************************
|
|
|
|
Description:
|
|
|
|
The ANSI version of TcGetFlowNameW
|
|
|
|
Arguments:
|
|
|
|
See TcGetFlowNameW
|
|
|
|
Return Value:
|
|
|
|
See TcGetFlowNameW
|
|
|
|
************************************************************************
|
|
*/
|
|
DWORD
|
|
APIENTRY
|
|
TcGetFlowNameA(
|
|
IN HANDLE FlowHandle,
|
|
IN ULONG StrSize,
|
|
OUT LPSTR pFlowName
|
|
)
|
|
{
|
|
PFLOW_STRUC pFlow;
|
|
DWORD Status = NO_ERROR;
|
|
|
|
VERIFY_INITIALIZATION_STATUS;
|
|
|
|
if (IsBadWritePtr(pFlowName,StrSize * sizeof(CHAR))) {
|
|
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
pFlow = (PFLOW_STRUC)GetHandleObjectWithRef(FlowHandle, ENUM_GEN_FLOW_TYPE, 'TGFA');
|
|
|
|
if (pFlow == NULL) {
|
|
|
|
return ERROR_INVALID_HANDLE;
|
|
}
|
|
else if (pFlow == INVALID_HANDLE_VALUE )
|
|
{
|
|
|
|
Status = ERROR_NOT_READY;
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcGetFlowNameA: Error = 0x%X\n", Status ));
|
|
}
|
|
|
|
return ERROR_NOT_READY;
|
|
}
|
|
|
|
ASSERT((HANDLE)pFlow->ClHandle == FlowHandle);
|
|
|
|
if (pFlow->InstanceNameLength+sizeof(CHAR) > (USHORT)StrSize) {
|
|
|
|
IF_DEBUG(REFCOUNTS) {
|
|
WSPRINT(("11 DEREF FLOW %X (%X) ref(%d)\n", pFlow->ClHandle, pFlow, pFlow->RefCount));
|
|
}
|
|
REFDEL(&pFlow->RefCount, 'TGFA');
|
|
|
|
return ERROR_INSUFFICIENT_BUFFER;
|
|
}
|
|
|
|
__try {
|
|
|
|
if (-1 == wcstombs(
|
|
pFlowName,
|
|
pFlow->InstanceName,
|
|
pFlow->InstanceNameLength)) {
|
|
|
|
Status = ERROR_NO_UNICODE_TRANSLATION;
|
|
|
|
}
|
|
|
|
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
Status = GetExceptionCode();
|
|
|
|
IF_DEBUG(ERRORS) {
|
|
WSPRINT(("TcGetFlowName: Exception Error: = 0x%X\n", Status ));
|
|
}
|
|
|
|
REFDEL(&pFlow->RefCount, 'TGFA');
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
|
|
IF_DEBUG(REFCOUNTS) {
|
|
WSPRINT(("12 DEREF FLOW %X (%X) ref(%d)\n", pFlow->ClHandle, pFlow, pFlow->RefCount));
|
|
}
|
|
|
|
REFDEL(&pFlow->RefCount, 'TGFA');
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
************************************************************************
|
|
|
|
Description:
|
|
|
|
This will return a specified number of flows with their respective
|
|
filter, given the buffer is big enough. The user allocates the buffer,
|
|
and passes a pointer to an enumeration token. This will be used
|
|
by the GPC to keep track what was the last enumerated flow and will
|
|
initially be point to a NULL value (reset by TC_RESET_ENUM_TOKEN).
|
|
The user will also pass the number of requested flow and will get back
|
|
the actual number of flows that have been placed in the buffer.
|
|
If the buffer is too small, an error code will be returned. If there are
|
|
no more flows to enumerate, NO_ERROR will be returned and pFlowCount
|
|
will be set to zero. It is invalid to request zero flows
|
|
|
|
Arguments:
|
|
|
|
IfcHandle - the interface to enumerate flows on
|
|
pEnumToken - enumeration handles pointer,
|
|
user must not change after the first call
|
|
pFlowCount - in: # of requested flows; out: actual # of flows returned
|
|
pBufSize - in: allocated bytes; out: filled bytes
|
|
Buffer - formatted data
|
|
|
|
Return Value:
|
|
|
|
NO_ERROR
|
|
ERROR_INVALID_HANDLE bad interface handle
|
|
ERROR_INVALID_PARAMETER one of the pointers is null or either
|
|
pFlowCount or pBufSize are set to zero
|
|
ERROR_INSUFFICIENT_BUFFER indicates that the provided buffer is too
|
|
small to return even the information for a
|
|
single flow and the attached filters.
|
|
ERROR_NOT_ENOUGH_MEMORY out of memory
|
|
ERROR_INVALID_DATA enumeration handle no longer valid
|
|
|
|
************************************************************************
|
|
*/
|
|
DWORD
|
|
APIENTRY
|
|
TcEnumerateFlows(
|
|
IN HANDLE IfcHandle,
|
|
IN OUT PHANDLE pEnumHandle,
|
|
IN OUT PULONG pFlowCount,
|
|
IN OUT PULONG pBufSize,
|
|
OUT PENUMERATION_BUFFER Buffer
|
|
)
|
|
{
|
|
DWORD Status;
|
|
PINTERFACE_STRUC pInterface;
|
|
PGPC_ENUM_CFINFO_RES OutBuffer;
|
|
ULONG cFlows;
|
|
ULONG BufSize;
|
|
ULONG TotalFlows;
|
|
ULONG TotalBytes;
|
|
PFLOW_STRUC pFlow;
|
|
PGPC_CLIENT pGpcClient;
|
|
PLIST_ENTRY pHead, pEntry;
|
|
GPC_HANDLE GpcFlowHandle;
|
|
PGPC_ENUM_CFINFO_BUFFER pGpcEnumBuf;
|
|
PCF_INFO_QOS pCfInfo;
|
|
ULONG Len, i, j;
|
|
ULONG GenFlowSize;
|
|
PCHAR p;
|
|
BOOLEAN bMore;
|
|
PTC_GEN_FILTER pFilter;
|
|
PGPC_GEN_PATTERN pPattern;
|
|
|
|
ULONG InputBufSize;
|
|
ULONG InputFlowCount;
|
|
|
|
VERIFY_INITIALIZATION_STATUS;
|
|
|
|
IF_DEBUG(CALLS) {
|
|
WSPRINT(("==>TcEnumerateFlows: Called: IfcHandle= %d",
|
|
IfcHandle ));
|
|
}
|
|
|
|
|
|
if ( IsBadWritePtr(pBufSize, sizeof(ULONG))
|
|
|| IsBadWritePtr(pFlowCount, sizeof(ULONG))
|
|
|| IsBadWritePtr(pEnumHandle,sizeof(HANDLE)) ) {
|
|
|
|
return ERROR_INVALID_PARAMETER;
|
|
|
|
}
|
|
|
|
__try {
|
|
|
|
InputBufSize = *pBufSize;
|
|
// *pBufSize = 0; // reset it in case of an error
|
|
InputFlowCount = *pFlowCount;
|
|
GpcFlowHandle = *pEnumHandle;
|
|
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
Status = GetExceptionCode();
|
|
|
|
return Status;
|
|
}
|
|
|
|
if ( IsBadWritePtr(Buffer, InputBufSize)
|
|
|| (InputFlowCount == 0) ) {
|
|
|
|
return ERROR_INVALID_PARAMETER;
|
|
|
|
}
|
|
|
|
if (InputBufSize == 0) {
|
|
|
|
return ERROR_INSUFFICIENT_BUFFER;
|
|
|
|
}
|
|
|
|
pInterface = (PINTERFACE_STRUC)GetHandleObjectWithRef(IfcHandle,
|
|
ENUM_INTERFACE_TYPE, 'TCEF');
|
|
|
|
if (pInterface == NULL) {
|
|
|
|
return ERROR_INVALID_HANDLE;
|
|
}
|
|
|
|
|
|
pGpcClient = FindGpcClient(GPC_CF_QOS);
|
|
|
|
if (pGpcClient == NULL) {
|
|
|
|
REFDEL(&pInterface->RefCount, 'TCEF');
|
|
|
|
return ERROR_DEV_NOT_EXIST;
|
|
}
|
|
|
|
//
|
|
// We are enumerating flows on the interface. we cant afford to have the
|
|
// flows deleted from teh list, therefore we shall take the global lock here.
|
|
//
|
|
GetLock(pGlobals->Lock);
|
|
|
|
// back to regularly scheduled programming
|
|
|
|
TotalFlows = 0;
|
|
TotalBytes = 0;
|
|
|
|
bMore = TRUE;
|
|
|
|
while (bMore) {
|
|
|
|
BufSize = InputBufSize - TotalBytes;
|
|
cFlows = InputFlowCount - TotalFlows;
|
|
|
|
Status = IoEnumerateFlows(pGpcClient,
|
|
&GpcFlowHandle,
|
|
&cFlows,
|
|
&BufSize,
|
|
&OutBuffer
|
|
);
|
|
|
|
if (!ERROR_FAILED(Status)) {
|
|
|
|
//
|
|
// parse the output buffer and return only the flows that have the
|
|
// interface name in them
|
|
//
|
|
|
|
pGpcEnumBuf = &OutBuffer->EnumBuffer[0];
|
|
|
|
for (i = 0; i < cFlows; i++) {
|
|
|
|
//
|
|
// get the CfInfo
|
|
//
|
|
|
|
pCfInfo = (PCF_INFO_QOS)((PCHAR)pGpcEnumBuf +
|
|
pGpcEnumBuf->CfInfoOffset);
|
|
|
|
//
|
|
// check if this flow belongs to this interface
|
|
//
|
|
|
|
if (wcscmp(pCfInfo->InstanceName,
|
|
pInterface->pTcIfc->InstanceName) == 0) {
|
|
|
|
//
|
|
// the flow is installed on this instance
|
|
//
|
|
|
|
GenFlowSize = FIELD_OFFSET(TC_GEN_FLOW, TcObjects)
|
|
+ pCfInfo->GenFlow.TcObjectsLength;
|
|
|
|
//
|
|
// The GPC used GPC_GEN_PATTERN when it computed
|
|
// PatternMaskLen. But, we are using TC_GEN_FILTER
|
|
// to display the patterns. So, we need to account
|
|
// for the difference in GPC_GEN_PATTERN and
|
|
// TC_GEN_FILTER.
|
|
//
|
|
// No, this cannot be made cleaner by getting the GPC
|
|
// to use TC_GEN_FILTER. The GPC is a generic packet
|
|
// classifier and hence shouldn't know about TC_GEN_FILTER.
|
|
//
|
|
|
|
Len = FIELD_OFFSET(ENUMERATION_BUFFER, GenericFilter)
|
|
+ GenFlowSize
|
|
+ pGpcEnumBuf->PatternMaskLen
|
|
- pGpcEnumBuf->PatternCount * sizeof(GPC_GEN_PATTERN)
|
|
+ pGpcEnumBuf->PatternCount * sizeof(TC_GEN_FILTER);
|
|
|
|
Len = ((Len + (sizeof(PVOID)-1)) & ~(sizeof(PVOID)-1));
|
|
|
|
if (TotalBytes + Len > InputBufSize) {
|
|
|
|
//
|
|
// not enough buffer output space
|
|
//
|
|
|
|
if (TotalFlows == 0)
|
|
Status = ERROR_INSUFFICIENT_BUFFER;
|
|
|
|
bMore = FALSE;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// fill the output buffer
|
|
//
|
|
|
|
__try {
|
|
|
|
Buffer->Length = Len;
|
|
Buffer->OwnerProcessId = PtrToUlong(pGpcEnumBuf->OwnerClientCtx);
|
|
Buffer->FlowNameLength = pGpcEnumBuf->InstanceNameLength;
|
|
wcscpy(Buffer->FlowName, pGpcEnumBuf->InstanceName);
|
|
Buffer->NumberOfFilters = pGpcEnumBuf->PatternCount;
|
|
pFilter = (PTC_GEN_FILTER)
|
|
((PCHAR)Buffer
|
|
+ FIELD_OFFSET(ENUMERATION_BUFFER, GenericFilter));
|
|
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
Status = GetExceptionCode();
|
|
|
|
break;
|
|
}
|
|
|
|
pPattern = &pGpcEnumBuf->GenericPattern[0];
|
|
|
|
//
|
|
// fill the filters
|
|
//
|
|
|
|
for (j = 0; j < pGpcEnumBuf->PatternCount; j++) {
|
|
|
|
switch(pPattern->ProtocolId) {
|
|
|
|
case GPC_PROTOCOL_TEMPLATE_IP:
|
|
|
|
pFilter->AddressType = NDIS_PROTOCOL_ID_TCP_IP;
|
|
ASSERT(pPattern->PatternSize
|
|
== sizeof(IP_PATTERN));
|
|
break;
|
|
|
|
case GPC_PROTOCOL_TEMPLATE_IPX:
|
|
|
|
pFilter->AddressType = NDIS_PROTOCOL_ID_IPX;
|
|
ASSERT(pPattern->PatternSize
|
|
== sizeof(IPX_PATTERN));
|
|
break;
|
|
|
|
default:
|
|
ASSERT(0);
|
|
}
|
|
|
|
pFilter->PatternSize = pPattern->PatternSize ;
|
|
pFilter->Pattern = (PVOID)((PCHAR)pFilter
|
|
+ sizeof(TC_GEN_FILTER));
|
|
pFilter->Mask = (PVOID)((PCHAR)pFilter->Pattern
|
|
+ pPattern->PatternSize);
|
|
|
|
//
|
|
// copy the pattern
|
|
//
|
|
|
|
p = ((PUCHAR)pPattern) + pPattern->PatternOffset;
|
|
|
|
RtlCopyMemory(pFilter->Pattern,
|
|
p,
|
|
pPattern->PatternSize);
|
|
|
|
//
|
|
// copy the mask
|
|
//
|
|
|
|
p = ((PUCHAR)pPattern) + pPattern->MaskOffset;
|
|
|
|
RtlCopyMemory(pFilter->Mask,
|
|
p,
|
|
pPattern->PatternSize);
|
|
|
|
//
|
|
// advance the filter pointer to the next item
|
|
//
|
|
|
|
pFilter = (PTC_GEN_FILTER)
|
|
((PCHAR)pFilter
|
|
+ sizeof(TC_GEN_FILTER)
|
|
+ pPattern->PatternSize * 2);
|
|
|
|
pPattern = (PGPC_GEN_PATTERN)(p + pPattern->PatternSize);
|
|
|
|
} // for (...)
|
|
|
|
//
|
|
// fill the flow
|
|
//
|
|
|
|
__try {
|
|
|
|
Buffer->pFlow = (PTC_GEN_FLOW)pFilter;
|
|
RtlCopyMemory(pFilter,
|
|
&pCfInfo->GenFlow,
|
|
GenFlowSize
|
|
);
|
|
|
|
//
|
|
// advance to the next available slot in
|
|
// the output buffer
|
|
//
|
|
|
|
Buffer = (PENUMERATION_BUFFER)((PCHAR)Buffer + Len);
|
|
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
Status = GetExceptionCode();
|
|
|
|
break;
|
|
}
|
|
|
|
|
|
//
|
|
// update total counts
|
|
//
|
|
|
|
TotalBytes += Len;
|
|
TotalFlows++;
|
|
}
|
|
|
|
//
|
|
// advance to the next entry in the GPC returned buffer
|
|
//
|
|
|
|
pGpcEnumBuf = (PGPC_ENUM_CFINFO_BUFFER)((PCHAR)pGpcEnumBuf
|
|
+ pGpcEnumBuf->Length);
|
|
}
|
|
|
|
//
|
|
// release the buffer
|
|
//
|
|
|
|
FreeMem(OutBuffer);
|
|
|
|
//
|
|
// check to see if we still have room for more flows
|
|
// and adjust the call parameters
|
|
//
|
|
|
|
if (TotalFlows == InputFlowCount ||
|
|
TotalBytes + sizeof(ENUMERATION_BUFFER) > InputBufSize ) {
|
|
|
|
//
|
|
// that's it, stop enumerating here
|
|
//
|
|
|
|
break;
|
|
}
|
|
|
|
//
|
|
// check the GpcFlowHandle and quit if needed
|
|
//
|
|
|
|
if (GpcFlowHandle == NULL) {
|
|
|
|
break;
|
|
}
|
|
|
|
} else {
|
|
|
|
//
|
|
// there was some error returned,
|
|
// we still have to check if that's the first call
|
|
//
|
|
//
|
|
|
|
if (Status == ERROR_INVALID_DATA) {
|
|
__try {
|
|
|
|
*pEnumHandle = NULL;
|
|
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
Status = GetExceptionCode();
|
|
|
|
}
|
|
|
|
} else if (TotalFlows > 0) {
|
|
|
|
Status = NO_ERROR;
|
|
|
|
}
|
|
|
|
break;
|
|
}
|
|
} // while
|
|
|
|
if (!ERROR_FAILED(Status)) {
|
|
|
|
__try {
|
|
|
|
*pEnumHandle = GpcFlowHandle;
|
|
*pFlowCount = TotalFlows;
|
|
*pBufSize = TotalBytes;
|
|
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
Status = GetExceptionCode();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// Free all the flow refs taken at the start.
|
|
//
|
|
FreeLock(pGlobals->Lock);
|
|
|
|
REFDEL(&pInterface->RefCount, 'TCEF');
|
|
|
|
IF_DEBUG(CALLS) {
|
|
WSPRINT(("<==TcEnumerateFlows: Returned= 0x%X\n", Status ));
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
|
|
|