able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/tdi/sample/sys/utils.cpp

1105 lines
32 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
////////////////////////////////////////////////////////////////////
//
// 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
//////////////////////////////////////////////////////////////////////
Reference in a new issue Copy permalink