1105 lines
32 KiB
C++
1105 lines
32 KiB
C++
////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright (c) 2001 Microsoft Corporation
|
|
//
|
|
// Module Name:
|
|
// utils.cpp
|
|
//
|
|
// Abstract:
|
|
// This module contains some utility functions for the tdi sample driver
|
|
//
|
|
/////////////////////////////////////////////////////////////////////
|
|
|
|
#include "sysvars.h"
|
|
|
|
|
|
/////////////////////////////////////////////////////
|
|
// private constants
|
|
/////////////////////////////////////////////////////
|
|
|
|
|
|
//const PCHAR strFunc1 = "TSAllocateMemory";
|
|
const PCHAR strFunc2 = "TSFreeMemory";
|
|
const PCHAR strFunc3 = "TSScanMemoryPool";
|
|
//const PCHAR strFunc4 = "TSInsertNode";
|
|
const PCHAR strFunc5 = "TSRemoveNode";
|
|
const PCHAR strFunc6 = "TSGetObjectFromHandle";
|
|
//const PCHAR strFunc6 = "TSAllocateIrp";
|
|
//const PCHAR strFunc7 = "TSFreeIrp";
|
|
//const PCHAR strFunc8 = "TSPrintTaAddress";
|
|
const PCHAR strFunc9 = "TSllocateIrpPool";
|
|
const PCHAR strFuncA = "TSFreeIrpPool";
|
|
|
|
////////////////////////////////////////////////////
|
|
// public functions
|
|
////////////////////////////////////////////////////
|
|
|
|
|
|
// --------------------------------------------------------------------
|
|
//
|
|
// Function: TSAllocateMemory
|
|
//
|
|
// Arguments: ppvVirtualAddress -- addr of pointer to set to allocated block
|
|
// ulLength -- length of memory to allocate
|
|
// strFunction -- ptr to function name string
|
|
// strTitle -- ptr to title of this allocation
|
|
//
|
|
// Returns: lStatus
|
|
//
|
|
// Descript: This function acts as a wrapper for the ExAllocatePoolWithTag
|
|
// function. It also stores info for each memory block that can
|
|
// identify them in case of "memory leaks"
|
|
//
|
|
// ---------------------------------------------------------------------
|
|
|
|
//
|
|
// this structure store information about this memory block to allow
|
|
// us to track memory blocks, and verify that they are freed properly, that
|
|
// we don't write beyond the end of them, etc
|
|
//
|
|
struct PRIVATE_MEMORY
|
|
{
|
|
ULONG ulSignature; // ulMEMORY_BLOCK
|
|
PCHAR strFunction; // name of function doing allocate
|
|
PCHAR strTitle; // Title for specific allocate
|
|
ULONG ulLength; // ulong index of trailer (=(length/4)-1
|
|
PRIVATE_MEMORY *pLastMemPtr; // ptr to last allocated block
|
|
PRIVATE_MEMORY *pNextMemPtr; // ptr to next allocated block
|
|
};
|
|
|
|
const ULONG ulTRAIL_PATTERN = 0x0f1e2d3c;
|
|
const ULONG ulMEMORY_BLOCK = 0x4b5a6978;
|
|
#define TDISAMPLE_TAG 'aSDT'
|
|
|
|
|
|
NTSTATUS
|
|
TSAllocateMemory(PVOID *ppvVirtualAddress,
|
|
ULONG ulLength,
|
|
CONST PCHAR strFunction,
|
|
CONST PCHAR strTitle)
|
|
{
|
|
PVOID pvBaseMemory; // base -- where actual memory allocated
|
|
|
|
//
|
|
// allocate for length plus header plus trailer, rounded up to next dword
|
|
//
|
|
ulLength += (sizeof(PRIVATE_MEMORY) + sizeof(ULONG) + 3);
|
|
ulLength &= 0xfffffffc;
|
|
|
|
//
|
|
// allocate it
|
|
//
|
|
pvBaseMemory = ExAllocatePoolWithTag(NonPagedPool,
|
|
ulLength,
|
|
TDISAMPLE_TAG);
|
|
|
|
//
|
|
// things to do if allocation was successful
|
|
//
|
|
if (pvBaseMemory)
|
|
{
|
|
//
|
|
// zero the memory
|
|
//
|
|
RtlZeroMemory(pvBaseMemory, ulLength);
|
|
|
|
//
|
|
// set up our header and trailer info
|
|
//
|
|
PRIVATE_MEMORY *pPrivateMemory // our header information
|
|
= (PRIVATE_MEMORY *)pvBaseMemory;
|
|
PULONG pulBase
|
|
= (PULONG)pvBaseMemory;
|
|
//
|
|
// adjust the ptr we return to allocated memory
|
|
//
|
|
*ppvVirtualAddress = (PUCHAR)pvBaseMemory + sizeof(PRIVATE_MEMORY);
|
|
|
|
//
|
|
// set up our header information
|
|
//
|
|
ulLength /= sizeof(ULONG); // set ulLength to ulong index of trailer
|
|
--ulLength;
|
|
|
|
pPrivateMemory->ulSignature = ulMEMORY_BLOCK;
|
|
pPrivateMemory->strFunction = strFunction;
|
|
pPrivateMemory->strTitle = strTitle;
|
|
pPrivateMemory->ulLength = ulLength;
|
|
|
|
//
|
|
// set up the trailer information
|
|
//
|
|
pulBase[ulLength] = ulTRAIL_PATTERN;
|
|
|
|
//
|
|
// insert at head of linked list..
|
|
// (note that memory is already initialized to null)
|
|
//
|
|
TSAcquireSpinLock(&MemTdiSpinLock);
|
|
if (pvMemoryList)
|
|
{
|
|
((PRIVATE_MEMORY *)pvMemoryList)->pLastMemPtr = pPrivateMemory;
|
|
pPrivateMemory->pNextMemPtr = (PRIVATE_MEMORY *)pvMemoryList;
|
|
}
|
|
pvMemoryList = pPrivateMemory;
|
|
TSReleaseSpinLock(&MemTdiSpinLock);
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
DebugPrint3("%s: unable to allocate %u bytes for %s\n",
|
|
strFunction, ulLength, strTitle);
|
|
*ppvVirtualAddress = NULL;
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
//
|
|
// Function: TSFreeMemory
|
|
//
|
|
// Arguments: pvVirtualAddress -- address of memory block to free
|
|
//
|
|
// Returns: None
|
|
//
|
|
// Descript: This function is a wrapper around the ExFreePool
|
|
// function. it helps track memory
|
|
// to make sure that we cleanup up everything...
|
|
//
|
|
// --------------------------------------------------------------------
|
|
|
|
VOID
|
|
TSFreeMemory(PVOID pvVirtualAddress)
|
|
{
|
|
if (pvVirtualAddress == NULL)
|
|
{
|
|
DebugPrint1("%s: memory block already freed!\n", strFunc2);
|
|
DbgBreakPoint();
|
|
return;
|
|
}
|
|
|
|
//
|
|
// back up to start of header information
|
|
//
|
|
pvVirtualAddress = (PVOID)((PUCHAR)pvVirtualAddress - sizeof(PRIVATE_MEMORY));
|
|
|
|
|
|
PRIVATE_MEMORY *pPrivateMemory // ptr to our header block
|
|
= (PRIVATE_MEMORY *)pvVirtualAddress;
|
|
PULONG pulTemp // temp ptr into allocated block
|
|
= (PULONG)pvVirtualAddress;
|
|
ULONG ulLength
|
|
= pPrivateMemory->ulLength;
|
|
//
|
|
// is this a valid memory block?
|
|
//
|
|
if (pPrivateMemory->ulSignature != ulMEMORY_BLOCK)
|
|
{
|
|
DebugPrint2("%s: invalid memory block at %p!\n",
|
|
strFunc2,
|
|
pPrivateMemory);
|
|
DbgBreakPoint();
|
|
return;
|
|
}
|
|
|
|
//
|
|
// check that the trailer is still ok
|
|
//
|
|
if (pulTemp[ulLength] != ulTRAIL_PATTERN)
|
|
{
|
|
DebugPrint2("%s: trailer overwritten for block staring at %p\n",
|
|
strFunc2,
|
|
pPrivateMemory);
|
|
DbgBreakPoint();
|
|
return;
|
|
}
|
|
|
|
//
|
|
// remove it from the linked list..
|
|
//
|
|
TSAcquireSpinLock(&MemTdiSpinLock);
|
|
|
|
//
|
|
// is it first block in list?
|
|
//
|
|
if (pPrivateMemory->pLastMemPtr == (PRIVATE_MEMORY *)NULL)
|
|
{
|
|
pvMemoryList = pPrivateMemory->pNextMemPtr;
|
|
}
|
|
else
|
|
{
|
|
PRIVATE_MEMORY *pLastPrivateMemory
|
|
= pPrivateMemory->pLastMemPtr;
|
|
pLastPrivateMemory->pNextMemPtr = pPrivateMemory->pNextMemPtr;
|
|
}
|
|
|
|
//
|
|
// fix ptr of next memory block if necessary
|
|
//
|
|
if (pPrivateMemory->pNextMemPtr != (PVOID)NULL)
|
|
{
|
|
PRIVATE_MEMORY *pNextPrivateMemory
|
|
= pPrivateMemory->pNextMemPtr;
|
|
pNextPrivateMemory->pLastMemPtr = pPrivateMemory->pLastMemPtr;
|
|
}
|
|
TSReleaseSpinLock(&MemTdiSpinLock);
|
|
|
|
//
|
|
// zero memory and free--make sure we adjust ulLength to be the true length
|
|
//
|
|
RtlZeroMemory(pvVirtualAddress, sizeof(ULONG) * (ulLength + 1));
|
|
ExFreePool(pvVirtualAddress);
|
|
|
|
}
|
|
|
|
// -------------------------------------------------------------------
|
|
//
|
|
// Function: TSScanMemoryPool
|
|
//
|
|
// Arguments: none
|
|
//
|
|
// Returns: none
|
|
//
|
|
// Descript: Scans to see if any tdi sample owned memory blocks have
|
|
// not been freed
|
|
//
|
|
// -------------------------------------------------------------------
|
|
|
|
VOID
|
|
TSScanMemoryPool(VOID)
|
|
{
|
|
TSAcquireSpinLock(&MemTdiSpinLock);
|
|
if (pvMemoryList)
|
|
{
|
|
PRIVATE_MEMORY *pPrivateMemory // our header information
|
|
= (PRIVATE_MEMORY *)pvMemoryList;
|
|
PULONG pulTemp;
|
|
|
|
DebugPrint0("The following memory blocks have not been freed!\n");
|
|
while (pPrivateMemory)
|
|
{
|
|
//
|
|
// is this a valid memory block?
|
|
//
|
|
if (pPrivateMemory->ulSignature != ulMEMORY_BLOCK)
|
|
{
|
|
DebugPrint1("Memory block at %p has an invalid signature!\n",
|
|
pPrivateMemory);
|
|
DbgBreakPoint();
|
|
}
|
|
DebugPrint2("Memory block at %p: total length = %d bytes\n",
|
|
pPrivateMemory,
|
|
sizeof(ULONG) * (pPrivateMemory->ulLength + 1));
|
|
DebugPrint2("Block '%s' was allocated by function %s\n",
|
|
pPrivateMemory->strTitle,
|
|
pPrivateMemory->strFunction);
|
|
|
|
pulTemp = (PULONG)pPrivateMemory;
|
|
|
|
//
|
|
// check that the trailer is still ok
|
|
//
|
|
if (pulTemp[pPrivateMemory->ulLength] != ulTRAIL_PATTERN)
|
|
{
|
|
DebugPrint0("The trailer for this memory block has been overwritten\n");
|
|
DbgBreakPoint();
|
|
}
|
|
DebugPrint0("\n");
|
|
|
|
pPrivateMemory = pPrivateMemory->pNextMemPtr;
|
|
}
|
|
DebugPrint0("\n\n\n");
|
|
}
|
|
else
|
|
{
|
|
DebugPrint0("All Tdi Sample memory blocks freed properly!\n");
|
|
}
|
|
TSReleaseSpinLock(&MemTdiSpinLock);
|
|
}
|
|
|
|
|
|
// --------------------------------------------
|
|
//
|
|
// Function: TSInsertNode
|
|
//
|
|
// Arguments: pNewNode -- node to insert into list
|
|
//
|
|
// Returns: Handle where we put things
|
|
//
|
|
// Descript: insert the object at the first empty slot in the
|
|
// table. Return Handle for it (NULL if error)
|
|
//
|
|
// --------------------------------------------
|
|
|
|
ULONG
|
|
TSInsertNode(PGENERIC_HEADER pNewNode)
|
|
{
|
|
ULONG ulTdiHandle = 0;
|
|
|
|
for (ULONG ulCount = 0; ulCount < ulMAX_OBJ_HANDLES; ulCount++)
|
|
{
|
|
if (pObjectList->GenHead[ulCount] == NULL)
|
|
{
|
|
pObjectList->GenHead[ulCount] = pNewNode;
|
|
ulTdiHandle = (ulCount + pNewNode->ulSignature);
|
|
break;
|
|
}
|
|
}
|
|
return ulTdiHandle;
|
|
}
|
|
|
|
// ---------------------------------------------
|
|
//
|
|
// Function: TSRemoveNode
|
|
//
|
|
// Arguments: pOldNode -- node to remove from it's linked list..
|
|
//
|
|
// Returns: none
|
|
//
|
|
// Descript: remove from appropriate linked list
|
|
//
|
|
// ---------------------------------------------
|
|
|
|
VOID
|
|
TSRemoveNode(ULONG ulTdiHandle)
|
|
{
|
|
ULONG ulType;
|
|
ULONG ulSlot;
|
|
PGENERIC_HEADER pGenericHeader;
|
|
|
|
ulType = ulTdiHandle & usOBJ_TYPE_MASK;
|
|
|
|
if ((ulType == ulControlChannelObject) ||
|
|
(ulType == ulAddressObject) ||
|
|
(ulType == ulEndpointObject))
|
|
{
|
|
ulSlot = ulTdiHandle & usOBJ_HANDLE_MASK;
|
|
|
|
pGenericHeader = pObjectList->GenHead[ulSlot];
|
|
if (pGenericHeader)
|
|
{
|
|
if (pGenericHeader->ulSignature == ulType)
|
|
{
|
|
pObjectList->GenHead[ulSlot] = NULL;
|
|
return;
|
|
}
|
|
|
|
//
|
|
// from here down, error cases
|
|
//
|
|
else
|
|
{
|
|
DebugPrint1("%s: wrong type for node!\n", strFunc5);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DebugPrint1("%s: node is null!\n", strFunc5);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DebugPrint1("%s: Bad handle type value\n", strFunc5);
|
|
}
|
|
}
|
|
|
|
|
|
// ---------------------------------------------
|
|
//
|
|
// Function: TSGetObjectFromHandle
|
|
//
|
|
// Arguments: TdiHandle -- the handle passed in to us
|
|
// ulType -- the type the handle needs to have
|
|
//
|
|
// Returns: pGenericHeader of object (NULL if error)
|
|
//
|
|
// Descript: fetch object from list via handle
|
|
//
|
|
// ---------------------------------------------
|
|
|
|
PGENERIC_HEADER
|
|
TSGetObjectFromHandle(ULONG ulTdiHandle,
|
|
ULONG ulType)
|
|
{
|
|
ULONG ulHandleType = ulTdiHandle & usOBJ_TYPE_MASK;
|
|
|
|
if ((ulHandleType & ulType) == ulHandleType)
|
|
{
|
|
ULONG ulHandleSlot = ulTdiHandle & usOBJ_HANDLE_MASK;
|
|
PGENERIC_HEADER pGenericHeader = pObjectList->GenHead[ulHandleSlot];
|
|
|
|
if (pGenericHeader)
|
|
{
|
|
if (pGenericHeader->ulSignature == ulHandleType)
|
|
{
|
|
return pGenericHeader;
|
|
}
|
|
|
|
//
|
|
// from here down, error conditions
|
|
//
|
|
else
|
|
{
|
|
DebugPrint1("%s: wrong type for node!\n", strFunc6);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DebugPrint1("%s: node is null!\n", strFunc6);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DebugPrint1("%s: Bad handle type value\n", strFunc6);
|
|
}
|
|
// DbgBreakPoint();
|
|
return NULL;
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------
|
|
//
|
|
// Function: TSAllocateIrp
|
|
//
|
|
// Arguments: pDeviceObject -- device object to call with this irp
|
|
// pIrpPool -- irp pool to allocate from (may be NULL)
|
|
//
|
|
// Returns: IRP that was allocated (NULL if error)
|
|
//
|
|
// Descript: allocates a single IRP for use in calling the
|
|
// lower level driver (TdiProvider)
|
|
//
|
|
// NOTE: much of this code taken from ntos\io\iosubs.c\IoBuildDeviceIoRequest
|
|
// see TSAllocateIrpPool for how we cheat
|
|
//
|
|
// ----------------------------------------------------
|
|
|
|
PIRP
|
|
TSAllocateIrp(PDEVICE_OBJECT pDeviceObject,
|
|
PIRP_POOL pIrpPool)
|
|
{
|
|
PIRP pNewIrp = NULL;
|
|
|
|
if (pIrpPool)
|
|
{
|
|
pNewIrp = pIrpPool->pAvailIrpList;
|
|
if (!pNewIrp)
|
|
{
|
|
TSAcquireSpinLock(&pIrpPool->TdiSpinLock);
|
|
pIrpPool->pAvailIrpList = pIrpPool->pUsedIrpList;
|
|
pIrpPool->pUsedIrpList = NULL;
|
|
TSReleaseSpinLock(&pIrpPool->TdiSpinLock);
|
|
pNewIrp = pIrpPool->pAvailIrpList;
|
|
}
|
|
if (pNewIrp)
|
|
{
|
|
pIrpPool->pAvailIrpList = pNewIrp->AssociatedIrp.MasterIrp;
|
|
pNewIrp->AssociatedIrp.MasterIrp = NULL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pNewIrp = IoAllocateIrp(pDeviceObject->StackSize, FALSE);
|
|
pNewIrp->Tail.Overlay.Thread = PsGetCurrentThread();;
|
|
}
|
|
|
|
if (pNewIrp)
|
|
{
|
|
PIO_STACK_LOCATION pIrpSp = IoGetNextIrpStackLocation(pNewIrp);
|
|
|
|
pIrpSp->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
|
|
pIrpSp->Parameters.DeviceIoControl.OutputBufferLength = 0;
|
|
pIrpSp->Parameters.DeviceIoControl.InputBufferLength = 0;
|
|
pIrpSp->Parameters.DeviceIoControl.IoControlCode = 0x00000003;
|
|
pIrpSp->Parameters.DeviceIoControl.Type3InputBuffer = NULL;
|
|
pNewIrp->UserBuffer = NULL;
|
|
pNewIrp->UserIosb = NULL;
|
|
pNewIrp->UserEvent = NULL;
|
|
pNewIrp->RequestorMode = KernelMode;
|
|
}
|
|
|
|
return pNewIrp;
|
|
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------
|
|
//
|
|
// Function: TSFreeIrp
|
|
//
|
|
// Arguments: IRP to free
|
|
// pIrpPool -- pool to free to (may be NULL)
|
|
//
|
|
// Returns: none
|
|
//
|
|
// Descript: Frees the IRP passed in
|
|
// See TSAllocateIrpPool for how we cheat..
|
|
//
|
|
// ----------------------------------------------------
|
|
|
|
VOID
|
|
TSFreeIrp(PIRP pIrp,
|
|
PIRP_POOL pIrpPool)
|
|
{
|
|
if (pIrpPool)
|
|
{
|
|
TSAcquireSpinLock(&pIrpPool->TdiSpinLock);
|
|
pIrp->AssociatedIrp.MasterIrp = pIrpPool->pUsedIrpList;
|
|
pIrpPool->pUsedIrpList = pIrp;
|
|
TSReleaseSpinLock(&pIrpPool->TdiSpinLock);
|
|
if (pIrpPool->fMustFree)
|
|
{
|
|
TSFreeIrpPool(pIrpPool);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
IoFreeIrp(pIrp);
|
|
}
|
|
}
|
|
|
|
|
|
// ---------------------------------
|
|
//
|
|
// Function: TSPrintTaAddress
|
|
//
|
|
// Arguments: pTaAddress -- address to print out info for
|
|
//
|
|
// Returns: none
|
|
//
|
|
// Descript: prints out information in pTaAddress structure
|
|
//
|
|
// ---------------------------------
|
|
|
|
|
|
VOID
|
|
TSPrintTaAddress(PTA_ADDRESS pTaAddress)
|
|
{
|
|
BOOLEAN fShowAddress = TRUE;
|
|
|
|
DebugPrint0("AddressType = TDI_ADDRESS_TYPE_");
|
|
switch (pTaAddress->AddressType)
|
|
{
|
|
case TDI_ADDRESS_TYPE_UNSPEC:
|
|
DebugPrint0("UNSPEC\n");
|
|
break;
|
|
case TDI_ADDRESS_TYPE_UNIX:
|
|
DebugPrint0("UNIX\n");
|
|
break;
|
|
|
|
case TDI_ADDRESS_TYPE_IP:
|
|
DebugPrint0("IP\n");
|
|
fShowAddress = FALSE;
|
|
{
|
|
PTDI_ADDRESS_IP pTdiAddressIp = (PTDI_ADDRESS_IP)pTaAddress->Address;
|
|
PUCHAR pucTemp = (PUCHAR)&pTdiAddressIp->in_addr;
|
|
DebugPrint5("sin_port = 0x%04x\n"
|
|
"in_addr = %u.%u.%u.%u\n",
|
|
pTdiAddressIp->sin_port,
|
|
pucTemp[0], pucTemp[1],
|
|
pucTemp[2], pucTemp[3]);
|
|
}
|
|
break;
|
|
|
|
case TDI_ADDRESS_TYPE_IMPLINK:
|
|
DebugPrint0("IMPLINK\n");
|
|
break;
|
|
case TDI_ADDRESS_TYPE_PUP:
|
|
DebugPrint0("PUP\n");
|
|
break;
|
|
case TDI_ADDRESS_TYPE_CHAOS:
|
|
DebugPrint0("CHAOS\n");
|
|
break;
|
|
|
|
case TDI_ADDRESS_TYPE_IPX:
|
|
DebugPrint0("IPX\n");
|
|
fShowAddress = FALSE;
|
|
{
|
|
PTDI_ADDRESS_IPX pTdiAddressIpx = (PTDI_ADDRESS_IPX)pTaAddress->Address;
|
|
DebugPrint8("NetworkAddress = 0x%08x\n"
|
|
"NodeAddress = %u.%u.%u.%u.%u.%u\n"
|
|
"Socket = 0x%04x\n",
|
|
pTdiAddressIpx->NetworkAddress,
|
|
pTdiAddressIpx->NodeAddress[0],
|
|
pTdiAddressIpx->NodeAddress[1],
|
|
pTdiAddressIpx->NodeAddress[2],
|
|
pTdiAddressIpx->NodeAddress[3],
|
|
pTdiAddressIpx->NodeAddress[4],
|
|
pTdiAddressIpx->NodeAddress[5],
|
|
pTdiAddressIpx->Socket);
|
|
|
|
}
|
|
break;
|
|
|
|
case TDI_ADDRESS_TYPE_NBS:
|
|
DebugPrint0("NBS\n");
|
|
break;
|
|
case TDI_ADDRESS_TYPE_ECMA:
|
|
DebugPrint0("ECMA\n");
|
|
break;
|
|
case TDI_ADDRESS_TYPE_DATAKIT:
|
|
DebugPrint0("DATAKIT\n");
|
|
break;
|
|
case TDI_ADDRESS_TYPE_CCITT:
|
|
DebugPrint0("CCITT\n");
|
|
break;
|
|
case TDI_ADDRESS_TYPE_SNA:
|
|
DebugPrint0("SNA\n");
|
|
break;
|
|
case TDI_ADDRESS_TYPE_DECnet:
|
|
DebugPrint0("DECnet\n");
|
|
break;
|
|
case TDI_ADDRESS_TYPE_DLI:
|
|
DebugPrint0("DLI\n");
|
|
break;
|
|
case TDI_ADDRESS_TYPE_LAT:
|
|
DebugPrint0("LAT\n");
|
|
break;
|
|
case TDI_ADDRESS_TYPE_HYLINK:
|
|
DebugPrint0("HYLINK\n");
|
|
break;
|
|
|
|
case TDI_ADDRESS_TYPE_APPLETALK:
|
|
DebugPrint0("APPLETALK\n");
|
|
fShowAddress = FALSE;
|
|
{
|
|
PTDI_ADDRESS_APPLETALK pTdiAddressAppleTalk = (PTDI_ADDRESS_APPLETALK)pTaAddress->Address;
|
|
|
|
DebugPrint3("Network = 0x%04x\n"
|
|
"Node = 0x%02x\n"
|
|
"Socket = 0x%02x\n",
|
|
pTdiAddressAppleTalk->Network,
|
|
pTdiAddressAppleTalk->Node,
|
|
pTdiAddressAppleTalk->Socket);
|
|
}
|
|
break;
|
|
|
|
case TDI_ADDRESS_TYPE_NETBIOS:
|
|
DebugPrint0("NETBIOS\n");
|
|
fShowAddress = FALSE;
|
|
{
|
|
PTDI_ADDRESS_NETBIOS pTdiAddressNetbios = (PTDI_ADDRESS_NETBIOS)pTaAddress->Address;
|
|
UCHAR pucName[17];
|
|
|
|
//
|
|
// make sure we have a zero-terminated name to print...
|
|
//
|
|
RtlCopyMemory(pucName, pTdiAddressNetbios->NetbiosName, 16);
|
|
pucName[16] = 0;
|
|
DebugPrint0("NetbiosNameType = TDI_ADDRESS_NETBIOS_TYPE_");
|
|
switch (pTdiAddressNetbios->NetbiosNameType)
|
|
{
|
|
case TDI_ADDRESS_NETBIOS_TYPE_UNIQUE:
|
|
DebugPrint0("UNIQUE\n");
|
|
break;
|
|
case TDI_ADDRESS_NETBIOS_TYPE_GROUP:
|
|
DebugPrint0("GROUP\n");
|
|
break;
|
|
case TDI_ADDRESS_NETBIOS_TYPE_QUICK_UNIQUE:
|
|
DebugPrint0("QUICK_UNIQUE\n");
|
|
break;
|
|
case TDI_ADDRESS_NETBIOS_TYPE_QUICK_GROUP:
|
|
DebugPrint0("QUICK_GROUP\n");
|
|
break;
|
|
default:
|
|
DebugPrint1("INVALID [0x%04x]\n",
|
|
pTdiAddressNetbios->NetbiosNameType);
|
|
break;
|
|
}
|
|
DebugPrint1("NetbiosName = %s\n", pucName);
|
|
}
|
|
break;
|
|
|
|
case TDI_ADDRESS_TYPE_8022:
|
|
DebugPrint0("8022\n");
|
|
fShowAddress = FALSE;
|
|
{
|
|
PTDI_ADDRESS_8022 pTdiAddress8022 = (PTDI_ADDRESS_8022)pTaAddress->Address;
|
|
|
|
DebugPrint6("Address = %02x-%02x-%02x-%02x-%02x-%02x\n",
|
|
pTdiAddress8022->MACAddress[0],
|
|
pTdiAddress8022->MACAddress[1],
|
|
pTdiAddress8022->MACAddress[2],
|
|
pTdiAddress8022->MACAddress[3],
|
|
pTdiAddress8022->MACAddress[4],
|
|
pTdiAddress8022->MACAddress[5]);
|
|
|
|
}
|
|
break;
|
|
|
|
case TDI_ADDRESS_TYPE_OSI_TSAP:
|
|
DebugPrint0("OSI_TSAP\n");
|
|
fShowAddress = FALSE;
|
|
{
|
|
PTDI_ADDRESS_OSI_TSAP pTdiAddressOsiTsap = (PTDI_ADDRESS_OSI_TSAP)pTaAddress->Address;
|
|
ULONG ulSelectorLength;
|
|
ULONG ulAddressLength;
|
|
PUCHAR pucTemp = pTdiAddressOsiTsap->tp_addr;
|
|
|
|
DebugPrint0("TpAddrType = ISO_");
|
|
switch (pTdiAddressOsiTsap->tp_addr_type)
|
|
{
|
|
case ISO_HIERARCHICAL:
|
|
DebugPrint0("HIERARCHICAL\n");
|
|
ulSelectorLength = pTdiAddressOsiTsap->tp_tsel_len;
|
|
ulAddressLength = pTdiAddressOsiTsap->tp_taddr_len;
|
|
break;
|
|
case ISO_NON_HIERARCHICAL:
|
|
DebugPrint0("NON_HIERARCHICAL\n");
|
|
ulSelectorLength = 0;
|
|
ulAddressLength = pTdiAddressOsiTsap->tp_taddr_len;
|
|
break;
|
|
default:
|
|
DebugPrint1("INVALID [0x%04x]\n",
|
|
pTdiAddressOsiTsap->tp_addr_type);
|
|
ulSelectorLength = 0;
|
|
ulAddressLength = 0;
|
|
break;
|
|
}
|
|
if (ulSelectorLength)
|
|
{
|
|
ULONG ulCount;
|
|
|
|
DebugPrint0("TransportSelector: ");
|
|
for (ulCount = 0; ulCount < ulSelectorLength; ulCount++)
|
|
{
|
|
DebugPrint1("%02x ", *pucTemp);
|
|
++pucTemp;
|
|
}
|
|
DebugPrint0("\n");
|
|
}
|
|
if (ulAddressLength)
|
|
{
|
|
ULONG ulCount;
|
|
|
|
DebugPrint0("TransportAddress: ");
|
|
for (ulCount = 0; ulCount < ulAddressLength; ulCount++)
|
|
{
|
|
DebugPrint1("%02x ", *pucTemp);
|
|
++pucTemp;
|
|
}
|
|
DebugPrint0("\n");
|
|
}
|
|
}
|
|
break;
|
|
|
|
case TDI_ADDRESS_TYPE_NETONE:
|
|
DebugPrint0("NETONE\n");
|
|
fShowAddress = FALSE;
|
|
{
|
|
PTDI_ADDRESS_NETONE pTdiAddressNetone = (PTDI_ADDRESS_NETONE)pTaAddress->Address;
|
|
UCHAR pucName[21];
|
|
|
|
//
|
|
// make sure have 0-terminated name
|
|
//
|
|
RtlCopyMemory(pucName,
|
|
pTdiAddressNetone->NetoneName,
|
|
20);
|
|
pucName[20] = 0;
|
|
DebugPrint0("NetoneNameType = TDI_ADDRESS_NETONE_TYPE_");
|
|
switch (pTdiAddressNetone->NetoneNameType)
|
|
{
|
|
case TDI_ADDRESS_NETONE_TYPE_UNIQUE:
|
|
DebugPrint0("UNIQUE\n");
|
|
break;
|
|
case TDI_ADDRESS_NETONE_TYPE_ROTORED:
|
|
DebugPrint0("ROTORED\n");
|
|
break;
|
|
default:
|
|
DebugPrint1("INVALID [0x%04x]\n",
|
|
pTdiAddressNetone->NetoneNameType);
|
|
break;
|
|
}
|
|
DebugPrint1("NetoneName = %s\n",
|
|
pucName);
|
|
}
|
|
break;
|
|
|
|
case TDI_ADDRESS_TYPE_VNS:
|
|
DebugPrint0("VNS\n");
|
|
fShowAddress = FALSE;
|
|
{
|
|
PTDI_ADDRESS_VNS pTdiAddressVns = (PTDI_ADDRESS_VNS)pTaAddress->Address;
|
|
|
|
DebugPrint4("NetAddress: %02x-%02x-%02x-%02x\n",
|
|
pTdiAddressVns->net_address[0],
|
|
pTdiAddressVns->net_address[1],
|
|
pTdiAddressVns->net_address[2],
|
|
pTdiAddressVns->net_address[3]);
|
|
DebugPrint5("SubnetAddr: %02x-%02x\n"
|
|
"Port: %02x-%02x\n"
|
|
"Hops: %u\n",
|
|
pTdiAddressVns->subnet_addr[0],
|
|
pTdiAddressVns->subnet_addr[1],
|
|
pTdiAddressVns->port[0],
|
|
pTdiAddressVns->port[1],
|
|
pTdiAddressVns->hops);
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
case TDI_ADDRESS_TYPE_NETBIOS_EX:
|
|
DebugPrint0("NETBIOS_EX\n");
|
|
fShowAddress = FALSE;
|
|
{
|
|
PTDI_ADDRESS_NETBIOS_EX pTdiAddressNetbiosEx = (PTDI_ADDRESS_NETBIOS_EX)pTaAddress->Address;
|
|
UCHAR pucEndpointName[17];
|
|
UCHAR pucNetbiosName[17];
|
|
|
|
//
|
|
// make sure we have zero-terminated names to print...
|
|
//
|
|
RtlCopyMemory(pucEndpointName,
|
|
pTdiAddressNetbiosEx->EndpointName,
|
|
16);
|
|
pucEndpointName[16] = 0;
|
|
RtlCopyMemory(pucNetbiosName,
|
|
pTdiAddressNetbiosEx->NetbiosAddress.NetbiosName,
|
|
16);
|
|
pucNetbiosName[16] = 0;
|
|
|
|
DebugPrint1("EndpointName = %s\n"
|
|
"NetbiosNameType = TDI_ADDRESS_NETBIOS_TYPE_",
|
|
pucEndpointName);
|
|
|
|
switch (pTdiAddressNetbiosEx->NetbiosAddress.NetbiosNameType)
|
|
{
|
|
case TDI_ADDRESS_NETBIOS_TYPE_UNIQUE:
|
|
DebugPrint0("UNIQUE\n");
|
|
break;
|
|
case TDI_ADDRESS_NETBIOS_TYPE_GROUP:
|
|
DebugPrint0("GROUP\n");
|
|
break;
|
|
case TDI_ADDRESS_NETBIOS_TYPE_QUICK_UNIQUE:
|
|
DebugPrint0("QUICK_UNIQUE\n");
|
|
break;
|
|
case TDI_ADDRESS_NETBIOS_TYPE_QUICK_GROUP:
|
|
DebugPrint0("QUICK_GROUP\n");
|
|
break;
|
|
default:
|
|
DebugPrint1("INVALID [0x%04x]\n",
|
|
pTdiAddressNetbiosEx->NetbiosAddress.NetbiosNameType);
|
|
break;
|
|
}
|
|
DebugPrint1("NetbiosName = %s\n", pucNetbiosName);
|
|
}
|
|
break;
|
|
|
|
case TDI_ADDRESS_TYPE_IP6:
|
|
DebugPrint0("IPv6\n");
|
|
fShowAddress = FALSE;
|
|
{
|
|
PTDI_ADDRESS_IP6 pTdiAddressIp6 = (PTDI_ADDRESS_IP6)pTaAddress->Address;
|
|
PUCHAR pucTemp = (PUCHAR)&pTdiAddressIp6->sin6_addr;
|
|
|
|
DebugPrint3("SinPort6 = 0x%04x\n"
|
|
"FlowInfo = 0x%08x\n"
|
|
"ScopeId = 0x%08x\n",
|
|
pTdiAddressIp6->sin6_port,
|
|
pTdiAddressIp6->sin6_flowinfo,
|
|
pTdiAddressIp6->sin6_scope_id);
|
|
|
|
DebugPrint8("In6_addr = %x%02x:%x%02x:%x%02x:%x%02x:",
|
|
pucTemp[0], pucTemp[1],
|
|
pucTemp[2], pucTemp[3],
|
|
pucTemp[4], pucTemp[5],
|
|
pucTemp[6], pucTemp[7]);
|
|
DebugPrint8("%x%02x:%x%02x:%x%02x:%x%02x\n",
|
|
pucTemp[8], pucTemp[9],
|
|
pucTemp[10], pucTemp[11],
|
|
pucTemp[12], pucTemp[13],
|
|
pucTemp[14], pucTemp[15]);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
DebugPrint1("UNKNOWN [0x%08x]\n", pTaAddress->AddressType);
|
|
break;
|
|
}
|
|
|
|
if (fShowAddress)
|
|
{
|
|
PUCHAR pucTemp = pTaAddress->Address;
|
|
|
|
DebugPrint1("AddressLength = %d\n"
|
|
"Address = ",
|
|
pTaAddress->AddressLength);
|
|
|
|
for (ULONG ulCount = 0; ulCount < pTaAddress->AddressLength; ulCount++)
|
|
{
|
|
DebugPrint1("%02x ", *pucTemp);
|
|
pucTemp++;
|
|
}
|
|
|
|
DebugPrint0("\n");
|
|
}
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------
|
|
//
|
|
// Function: TSAllocateIrpPool
|
|
//
|
|
// Arguments: device object
|
|
//
|
|
// Returns: ptr to irp pool
|
|
//
|
|
// Descript: allocates an IRP pool when the driver starts, so
|
|
// we don't have to worry about being in an inappropriate
|
|
// IRQL when we need one...
|
|
//
|
|
// NOTE: we cheat a little in maintaining our list of available Irps
|
|
// We use the AssociatedIrp.MasterIrp field to point to the
|
|
// next IRP in our list. Because of this, we need to explicitly
|
|
// set this field to NULL whenever we remove one of the IRPs from our
|
|
// list..
|
|
//
|
|
// ----------------------------------------------------
|
|
|
|
PIRP_POOL
|
|
TSAllocateIrpPool(PDEVICE_OBJECT pDeviceObject,
|
|
ULONG ulPoolSize)
|
|
{
|
|
PIRP_POOL pIrpPool = NULL;
|
|
|
|
if ((TSAllocateMemory((PVOID *)&pIrpPool,
|
|
sizeof(IRP_POOL) + (ulPoolSize * sizeof(PVOID)),
|
|
strFunc9,
|
|
"IrpPool")) == STATUS_SUCCESS)
|
|
{
|
|
PIRP pNewIrp;
|
|
|
|
TSAllocateSpinLock(&pIrpPool->TdiSpinLock);
|
|
pIrpPool->ulPoolSize = ulPoolSize;
|
|
pIrpPool->fMustFree = FALSE;
|
|
|
|
for (ULONG ulCount = 0; ulCount < ulPoolSize; ulCount++)
|
|
{
|
|
pNewIrp = IoAllocateIrp(pDeviceObject->StackSize, FALSE);
|
|
if (pNewIrp)
|
|
{
|
|
pNewIrp->Tail.Overlay.Thread = PsGetCurrentThread();
|
|
//
|
|
// store this irp in the list of allocated irps
|
|
//
|
|
pIrpPool->pAllocatedIrp[ulCount] = pNewIrp;
|
|
//
|
|
// and add it to the beginning of the list of available irps
|
|
//
|
|
pNewIrp->AssociatedIrp.MasterIrp = pIrpPool->pAvailIrpList;
|
|
pIrpPool->pAvailIrpList = pNewIrp;
|
|
}
|
|
}
|
|
}
|
|
|
|
return pIrpPool;
|
|
}
|
|
|
|
|
|
// ----------------------------------------------------
|
|
//
|
|
// Function: TSFreeIrpPool
|
|
//
|
|
// Arguments: ptr to irp pool to free
|
|
//
|
|
// Returns: none
|
|
//
|
|
// Descript: Frees the IRP pool allocated above
|
|
//
|
|
// ----------------------------------------------------
|
|
|
|
VOID
|
|
TSFreeIrpPool(PIRP_POOL pIrpPool)
|
|
{
|
|
if (pIrpPool)
|
|
{
|
|
//
|
|
// free each irp in the Avail list
|
|
// clearing it from the allocated list
|
|
//
|
|
PIRP pThisIrp;
|
|
PIRP pIrpList;
|
|
|
|
for(;;)
|
|
{
|
|
//
|
|
// protect irppool structure while get AvailList or UsedList
|
|
//
|
|
TSAcquireSpinLock(&pIrpPool->TdiSpinLock);
|
|
pIrpList = pIrpPool->pAvailIrpList;
|
|
if (pIrpList)
|
|
{
|
|
pIrpPool->pAvailIrpList = NULL;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// nothing on avail list, try used list
|
|
//
|
|
pIrpList = pIrpPool->pUsedIrpList;
|
|
if (pIrpList)
|
|
{
|
|
pIrpPool->pUsedIrpList = NULL;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// nothing on either list
|
|
// go thru the pAllocatedIrp list just to be sure all are freed
|
|
//
|
|
for (ULONG ulCount = 0; ulCount < pIrpPool->ulPoolSize; ulCount++)
|
|
{
|
|
if (pIrpPool->pAllocatedIrp[ulCount])
|
|
{
|
|
pIrpPool->fMustFree = TRUE;
|
|
TSReleaseSpinLock(&pIrpPool->TdiSpinLock);
|
|
DebugPrint1("Irp at %p not freed!\n",
|
|
pIrpPool->pAllocatedIrp[ulCount]);
|
|
//
|
|
// return here if a late irp needs to finish up cleanup
|
|
//
|
|
return;
|
|
}
|
|
}
|
|
TSReleaseSpinLock(&pIrpPool->TdiSpinLock);
|
|
//
|
|
// finished cleanup here -- all irps accounted for
|
|
//
|
|
TSFreeSpinLock(&pIrpPool->TdiSpinLock);
|
|
TSFreeMemory(pIrpPool);
|
|
return;
|
|
}
|
|
}
|
|
|
|
TSReleaseSpinLock(&pIrpPool->TdiSpinLock);
|
|
|
|
while (pIrpList)
|
|
{
|
|
pThisIrp = pIrpList;
|
|
pIrpList = pIrpList->AssociatedIrp.MasterIrp;
|
|
pThisIrp->AssociatedIrp.MasterIrp = NULL;
|
|
|
|
for (ULONG ulCount = 0; ulCount < pIrpPool->ulPoolSize; ulCount++)
|
|
{
|
|
if (pIrpPool->pAllocatedIrp[ulCount] == pThisIrp)
|
|
{
|
|
pIrpPool->pAllocatedIrp[ulCount] = NULL;
|
|
break;
|
|
}
|
|
}
|
|
IoFreeIrp(pThisIrp);
|
|
} // end of while(pIrpList)
|
|
} // end of for(;;)
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// end of file utils.cpp
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
|