// debug.c
//
// 
// Requires DDK Only
// File created on 2/2/2005
//
#include "pch.h"
#ifdef CPR_WMI_TRACE
#include "debug.tmh"
#else

#ifndef Do_Debug_Print

ULONG   g_DebugLevel = DBG_NONE;
ULONG   g_DebugArea = DBG_NONE;

#else

#define NUMBER_DEBUG_BUFFERS    (sizeof(g_DebugBufferBusy)/sizeof(g_DebugBufferBusy[0]))

// debug level and debug area mask
//ULONG   g_DebugLevel = DBG_ALL;
//ULONG   g_DebugLevel = DBG_INFO;
//ULONG   g_DebugLevel = DBG_TRACE;
ULONG   g_DebugLevel = DBG_NONE;

//ULONG   g_DebugArea = DBG_ALL;
//ULONG	g_DebugArea = DBG_WRITE;
//ULONG   g_DebugArea = DBG_IO;
//ULONG   g_DebugArea = DBG_CREATECLOSE;
//ULONG   g_DebugArea = DBG_IO | DBG_CREATECLOSE;
//ULONG   g_DebugArea = DBG_INIT;
ULONG   g_DebugArea = DBG_NONE;

// Buffers for debug messages are allocated globally instead of 
// on a stack, therefore we need g_DebugBufferBusy flags to 
// protect access to them.
LONG    g_DebugBufferBusy[] = {0, 0, 0, 0, 0, 0, 0, 0}; 
CHAR    g_DebugBuffer[NUMBER_DEBUG_BUFFERS][1024];

///////////////////////////////////////////////////////////////////////////////////////////////////
//  CprDebugPrint
//      Debug messages output routine.
//
//  Arguments:
//      IN  Area
//              Debug area (DBG_PNP, DBG_POWER, etc..)
//
//      IN  Level
//              Debug Level (DBG_ERR, DBG_INFO, etc..)
//
//      IN  Format
//              Debug Message Format
//
//  Return Value:
//      None.
//
VOID CprDebugPrint(
	IN PCPR_DEVICE_EXTENSION pDevExt,
    IN ULONG    Area,
    IN ULONG    Level,
    IN PCCHAR   Format,
    IN          ...
    )
{
    ULONG i;
	char *levelStr;
    va_list vaList;
	int portNumber = 0;

    va_start(vaList, Format);

    // check mask for debug area and debug level
    if ((g_DebugArea & Area) && (Level <= g_DebugLevel))
    {
        // find a free buffer
        for (i = 0; i < NUMBER_DEBUG_BUFFERS; ++i)
        {
            if (InterlockedCompareExchange(&g_DebugBufferBusy[i], 1, 0) == 0)
            {
                NTSTATUS status;

                status = RtlStringCbVPrintfA(
                            g_DebugBuffer[i], 
                            sizeof(g_DebugBuffer[i]),
                            Format,
                            vaList
                            );

                if (Level == DBG_ERR)
					levelStr = "ERR_ ";
                else if (Level == DBG_WARN)
					levelStr = "WARN ";
                else if (Level == DBG_INFO)
					levelStr = "INFO ";
                else
					levelStr = "TRAC ";

				if (pDevExt != NULL)
				{
					portNumber = pDevExt->portNumber;
					if ((portNumber < 0) || (portNumber > MAX_PORTS))
					{
						portNumber = 0;
					}
				}

                DbgPrint("CPR(%2.2d,%3.3d): %s%s\n", KeGetCurrentIrql(), portNumber, levelStr, g_DebugBuffer[i]);

                InterlockedExchange(&g_DebugBufferBusy[i], 0);
                break;
            }
        }
    }

    va_end(vaList);
    return;
}

///////////////////////////////////////////////////////////////////////////////////////////////////
//  CprProcess
//      Dump Irp fields to the debugger.
//
//  Arguments:
//      IN  Irp
//              Irp to display
//
//  Return Value:
//      None.
//


///////////////////////////////////////////////////////////////////////////////////////////////////
//  CprDumpIrp
//      Dump Irp fields to the debugger.
//
//  Arguments:
//      IN  Irp
//              Irp to display
//
//  Return Value:
//      None.
//
VOID CprDumpIrp(
    IN PIRP Irp,
    PCPR_DEVICE_EXTENSION    deviceExtension
	)
{
    ULONG               debugArea;
    PIO_STACK_LOCATION  irpStack;

    // Get our current IRP stack location
    irpStack = IoGetCurrentIrpStackLocation(Irp);

    // determine debug area
    switch (irpStack->MajorFunction)
    {
    case IRP_MJ_PNP:
        debugArea = DBG_PNP;
        break;
    case IRP_MJ_POWER:
        debugArea = DBG_POWER;
        break;
    case IRP_MJ_CREATE:
    case IRP_MJ_CLOSE:
    case IRP_MJ_CLEANUP:
        debugArea = DBG_CREATECLOSE;
        break;
    case IRP_MJ_SYSTEM_CONTROL:
        debugArea = DBG_WMI;
        break;
    case IRP_MJ_READ:
    case IRP_MJ_WRITE:
    case IRP_MJ_DEVICE_CONTROL:
    case IRP_MJ_INTERNAL_DEVICE_CONTROL:
        debugArea = DBG_IO;
        break;
    default:
        debugArea = DBG_GENERAL;
        break;
    }

    CprDebugPrint3(deviceExtension, debugArea, DBG_INFO, "IRP %p %s Port %d",
		Irp, IrpMajorFunctionString(irpStack->MajorFunction),
		deviceExtension->portNumber);

    if (irpStack->MajorFunction == IRP_MJ_PNP)
    {
        CprDebugPrint(deviceExtension, debugArea, DBG_INFO, "%s", PnPMinorFunctionString(irpStack->MinorFunction));
    }
    else if (irpStack->MajorFunction == IRP_MJ_POWER)
    {
        CprDebugPrint(deviceExtension, debugArea, DBG_INFO, "%s", PowerMinorFunctionString(irpStack->MinorFunction));

        if (irpStack->Parameters.Power.Type == SystemPowerState)
        {
            CprDebugPrint(deviceExtension, debugArea, DBG_INFO, "%s", SystemPowerStateString(irpStack->Parameters.Power.State.SystemState));
        }
        else
        {
            CprDebugPrint(deviceExtension, debugArea, DBG_INFO, "%s", DevicePowerStateString(irpStack->Parameters.Power.State.DeviceState));
        }
    }
    else if (irpStack->MajorFunction == IRP_MJ_SYSTEM_CONTROL)
    {
        CprDebugPrint(deviceExtension, debugArea, DBG_INFO, "%s", WMIMinorFunctionString(irpStack->MinorFunction));
    }

    return;
}

///////////////////////////////////////////////////////////////////////////////////////////////////
//  IrpMajorFunctionString
//      Function for debug prints to return the text description of the
//      IRP's major function code
//
//  Arguments:
//      IN  MajorFunction
//              Major function of the IRP being processed
//
//  Return Value:
//      returns the major function string
//
PCHAR IrpMajorFunctionString(
    IN  UCHAR MajorFunction
    )
{
    switch (MajorFunction)
    {
    case IRP_MJ_CREATE:
        return "IRP_MJ_CREATE";
    case IRP_MJ_CREATE_NAMED_PIPE:
        return "IRP_MJ_CREATE_NAMED_PIPE";
    case IRP_MJ_CLOSE:
        return "IRP_MJ_CLOSE";
    case IRP_MJ_READ:
        return "IRP_MJ_READ";
    case IRP_MJ_WRITE:
        return "IRP_MJ_WRITE";
    case IRP_MJ_QUERY_INFORMATION:
        return "IRP_MJ_QUERY_INFORMATION";
    case IRP_MJ_SET_INFORMATION:
        return "IRP_MJ_SET_INFORMATION";
    case IRP_MJ_QUERY_EA:
        return "IRP_MJ_QUERY_EA";
    case IRP_MJ_SET_EA:
        return "IRP_MJ_SET_EA";
    case IRP_MJ_FLUSH_BUFFERS:
        return "IRP_MJ_FLUSH_BUFFERS";
    case IRP_MJ_QUERY_VOLUME_INFORMATION:
        return "IRP_MJ_QUERY_VOLUME_INFORMATION";
    case IRP_MJ_SET_VOLUME_INFORMATION:
        return "IRP_MJ_SET_VOLUME_INFORMATION";
    case IRP_MJ_DIRECTORY_CONTROL:
        return "IRP_MJ_DIRECTORY_CONTROL";
    case IRP_MJ_FILE_SYSTEM_CONTROL:
        return "IRP_MJ_FILE_SYSTEM_CONTROL";
    case IRP_MJ_DEVICE_CONTROL:
        return "IRP_MJ_DEVICE_CONTROL";
    case IRP_MJ_INTERNAL_DEVICE_CONTROL:
        return "IRP_MJ_INTERNAL_DEVICE_CONTROL";
    case IRP_MJ_SHUTDOWN:
        return "IRP_MJ_SHUTDOWN";
    case IRP_MJ_LOCK_CONTROL:
        return "IRP_MJ_LOCK_CONTROL";
    case IRP_MJ_CLEANUP:
        return "IRP_MJ_CLEANUP";
    case IRP_MJ_CREATE_MAILSLOT:
        return "IRP_MJ_CREATE_MAILSLOT";
    case IRP_MJ_QUERY_SECURITY:
        return "IRP_MJ_QUERY_SECURITY";
    case IRP_MJ_SET_SECURITY:
        return "IRP_MJ_SET_SECURITY";
    case IRP_MJ_POWER:
        return "IRP_MJ_POWER";
    case IRP_MJ_SYSTEM_CONTROL:
        return "IRP_MJ_SYSTEM_CONTROL";
    case IRP_MJ_DEVICE_CHANGE:
        return "IRP_MJ_DEVICE_CHANGE";
    case IRP_MJ_QUERY_QUOTA:
        return "IRP_MJ_QUERY_QUOTA";
    case IRP_MJ_SET_QUOTA:
        return "IRP_MJ_SET_QUOTA";
    case IRP_MJ_PNP:
        return "IRP_MJ_PNP";
    default:
        return "Unknown IRP Request";
    }
}

///////////////////////////////////////////////////////////////////////////////////////////////////
//  PnPMinorFunctionString
//      Function for debug prints to return the text description of the
//      IRP's minor function code
//
//  Arguments:
//      IN  MinorFunction
//              Minor function of the IRP being processed
//
//  Return Value:
//      returns the minor function string
//
PCHAR PnPMinorFunctionString(
    IN  UCHAR MinorFunction
    )
{
    switch (MinorFunction)
    {
    case IRP_MN_START_DEVICE:
        return "IRP_MN_START_DEVICE";
    case IRP_MN_QUERY_REMOVE_DEVICE:
        return "IRP_MN_QUERY_REMOVE_DEVICE";
    case IRP_MN_REMOVE_DEVICE:
        return "IRP_MN_REMOVE_DEVICE";
    case IRP_MN_CANCEL_REMOVE_DEVICE:
        return "IRP_MN_CANCEL_REMOVE_DEVICE";
    case IRP_MN_STOP_DEVICE:
        return "IRP_MN_STOP_DEVICE";
    case IRP_MN_QUERY_STOP_DEVICE:
        return "IRP_MN_QUERY_STOP_DEVICE";
    case IRP_MN_CANCEL_STOP_DEVICE:
        return "IRP_MN_CANCEL_STOP_DEVICE";
    case IRP_MN_QUERY_DEVICE_RELATIONS:
        return "IRP_MN_QUERY_DEVICE_RELATIONS";
    case IRP_MN_QUERY_INTERFACE:
        return "IRP_MN_QUERY_INTERFACE";
    case IRP_MN_QUERY_CAPABILITIES:
        return "IRP_MN_QUERY_CAPABILITIES";
    case IRP_MN_QUERY_RESOURCES:
        return "IRP_MN_QUERY_RESOURCES";
    case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:
        return "IRP_MN_QUERY_RESOURCE_REQUIREMENTS";
    case IRP_MN_QUERY_DEVICE_TEXT:
        return "IRP_MN_QUERY_DEVICE_TEXT";
    case IRP_MN_FILTER_RESOURCE_REQUIREMENTS:
        return "IRP_MN_FILTER_RESOURCE_REQUIREMENTS";
    case IRP_MN_READ_CONFIG:
        return "IRP_MN_READ_CONFIG";
    case IRP_MN_WRITE_CONFIG:
        return "IRP_MN_WRITE_CONFIG";
    case IRP_MN_EJECT:
        return "IRP_MN_EJECT";
    case IRP_MN_SET_LOCK:
        return "IRP_MN_SET_LOCK";
    case IRP_MN_QUERY_ID:
        return "IRP_MN_QUERY_ID";
    case IRP_MN_QUERY_PNP_DEVICE_STATE:
        return "IRP_MN_QUERY_PNP_DEVICE_STATE";
    case IRP_MN_QUERY_BUS_INFORMATION:
        return "IRP_MN_QUERY_BUS_INFORMATION";
    case IRP_MN_DEVICE_USAGE_NOTIFICATION:
        return "IRP_MN_DEVICE_USAGE_NOTIFICATION";
    case IRP_MN_SURPRISE_REMOVAL:
        return "IRP_MN_SURPRISE_REMOVAL";
    case IRP_MN_QUERY_LEGACY_BUS_INFORMATION:
        return "IRP_MN_QUERY_LEGACY_BUS_INFORMATION";
    default:
        return "Unknown PnP Request";
    }
}

///////////////////////////////////////////////////////////////////////////////////////////////////
//  PowerMinorFunctionString
//      Function for debug prints to return the text description of the
//      IRP's minor function code
//
//  Arguments:
//      IN  MinorFunction
//              Minor function of the IRP being processed
//
//  Return Value:
//      returns the minor function string
//
PCHAR PowerMinorFunctionString(
    IN  UCHAR MinorFunction
    )
{
    switch (MinorFunction)
    {
    case IRP_MN_SET_POWER:
        return "IRP_MN_SET_POWER";
    case IRP_MN_QUERY_POWER:
        return "IRP_MN_QUERY_POWER";
    case IRP_MN_WAIT_WAKE:
        return "IRP_MN_WAIT_WAKE";
    case IRP_MN_POWER_SEQUENCE:
        return "IRP_MN_POWER_SEQUENCE";
    default:
        return "Unknown Power Request";
    }
}

///////////////////////////////////////////////////////////////////////////////////////////////////
//  SystemPowerStateString
//      Returns SYSTEM_POWER_STATE as a string
//
//  Arguments:
//      IN  SystemState
//              SYSTEM_POWER_STATE
//
//  Return Value:
//      returns the SYSTEM_POWER_STATE string
//
PCHAR SystemPowerStateString(
    IN  SYSTEM_POWER_STATE  SystemState
    )
{
    switch (SystemState)
    {
    case PowerSystemUnspecified:
        return "PowerSystemUnspecified";
    case PowerSystemWorking:
        return "PowerSystemWorking";
    case PowerSystemSleeping1:
        return "PowerSystemSleeping1";
    case PowerSystemSleeping2:
        return "PowerSystemSleeping2";
    case PowerSystemSleeping3:
        return "PowerSystemSleeping3";
    case PowerSystemHibernate:
        return "PowerSystemHibernate";
    case PowerSystemShutdown:
        return "PowerSystemShutdown";
    case PowerSystemMaximum:
        return "PowerSystemMaximum";
    default:
        return "PowerSystemUnknown";
    }
}

///////////////////////////////////////////////////////////////////////////////////////////////////
//  DevicePowerStateString
//      Returns DEVICE_POWER_STATE as a string
//
//  Arguments:
//      IN  DeviceState
//              DEVICE_POWER_STATE
//
//  Return Value:
//      returns the DEVICE_POWER_STATE string
//
PCHAR DevicePowerStateString(
    IN  DEVICE_POWER_STATE  DeviceState
    )
{
    switch (DeviceState)
    {
    case PowerDeviceUnspecified:
        return "PowerDeviceUnspecified";
    case PowerDeviceD0:
        return "PowerDeviceD0";
    case PowerDeviceD1:
        return "PowerDeviceD1";
    case PowerDeviceD2:
        return "PowerDeviceD2";
    case PowerDeviceD3:
        return "PowerDeviceD3";
    case PowerDeviceMaximum:
        return "PowerDeviceMaximum";
    default:
        return "PowerDeviceUnknown";
    }
}

///////////////////////////////////////////////////////////////////////////////////////////////////
//  WMIMinorFunctionString
//      Function for debug prints to return the text description of the
//      IRP's minor function code
//
//  Arguments:
//      IN  MinorFunction
//              Minor function of the IRP being processed
//
//  Return Value:
//      returns the minor function string
//
PCHAR WMIMinorFunctionString (
    IN  UCHAR MinorFunction
    )
{
    switch (MinorFunction)
    {
    case IRP_MN_CHANGE_SINGLE_INSTANCE:
        return "IRP_MN_CHANGE_SINGLE_INSTANCE";
    case IRP_MN_CHANGE_SINGLE_ITEM:
        return "IRP_MN_CHANGE_SINGLE_ITEM";
    case IRP_MN_DISABLE_COLLECTION:
        return "IRP_MN_DISABLE_COLLECTION";
    case IRP_MN_DISABLE_EVENTS:
        return "IRP_MN_DISABLE_EVENTS";
    case IRP_MN_ENABLE_COLLECTION:
        return "IRP_MN_ENABLE_COLLECTION";
    case IRP_MN_ENABLE_EVENTS:
        return "IRP_MN_ENABLE_EVENTS";
    case IRP_MN_EXECUTE_METHOD:
        return "IRP_MN_EXECUTE_METHOD";
    case IRP_MN_QUERY_ALL_DATA:
        return "IRP_MN_QUERY_ALL_DATA";
    case IRP_MN_QUERY_SINGLE_INSTANCE:
        return "IRP_MN_QUERY_SINGLE_INSTANCE";
    case IRP_MN_REGINFO:
        return "IRP_MN_REGINFO";
    default:
        return "Unknown System Control Request";
    }
}

/////////////////////////////////////////////////////////////////////////////////////////////////// 
//  CprTdiDumpAddress
//      Dumps TA_ADDRESS to debugger
//
//  Arguments:
//      IN  Address
//              pointer to TA_ADDRESS structure
//
//  Return Value:
//      None
//
VOID CprTdiDumpAddress(
    IN  PTA_ADDRESS         Address
    )
{
    if (Address == NULL)
    {
        return;
    }

    switch (Address->AddressType)
    {
    case TDI_ADDRESS_TYPE_UNSPEC:
        CprDebugPrint(NULL, DBG_IO, DBG_INFO, "TDI_ADDRESS_TYPE_UNSPEC");
        break;
    case TDI_ADDRESS_TYPE_UNIX:
        CprDebugPrint(NULL, DBG_IO, DBG_INFO, "TDI_ADDRESS_TYPE_UNIX");
        break;
    case TDI_ADDRESS_TYPE_IP:
        {
            PTDI_ADDRESS_IP pTdiAddress = (PTDI_ADDRESS_IP)Address->Address;

            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "TDI_ADDRESS_TYPE_IP");
            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "sin_port %x", pTdiAddress->sin_port);
            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "in_addr %x", pTdiAddress->in_addr);
        }
        break;
    case TDI_ADDRESS_TYPE_IMPLINK:
        CprDebugPrint(NULL, DBG_IO, DBG_INFO, "TDI_ADDRESS_TYPE_IMPLINK");
        break;
    case TDI_ADDRESS_TYPE_PUP:
        CprDebugPrint(NULL, DBG_IO, DBG_INFO, "TDI_ADDRESS_TYPE_PUP");
        break;
    case TDI_ADDRESS_TYPE_CHAOS:
        CprDebugPrint(NULL, DBG_IO, DBG_INFO, "TDI_ADDRESS_TYPE_CHAOS");
        break;
    case TDI_ADDRESS_TYPE_IPX:
        {
            PTDI_ADDRESS_IPX pTdiAddress = (PTDI_ADDRESS_IPX)Address->Address;

            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "TDI_ADDRESS_TYPE_IPX");

            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "NetworkAddress %x", pTdiAddress->NetworkAddress);
            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "NodeAddress[0] %x", pTdiAddress->NodeAddress[0]);
            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "NodeAddress[1] %x", pTdiAddress->NodeAddress[1]);
            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "NodeAddress[2] %x", pTdiAddress->NodeAddress[2]);
            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "NodeAddress[3] %x", pTdiAddress->NodeAddress[3]);
            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "NodeAddress[4] %x", pTdiAddress->NodeAddress[4]);
            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "NodeAddress[5] %x", pTdiAddress->NodeAddress[5]);
            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "Socket %x", pTdiAddress->Socket);
        }
        break;
    case TDI_ADDRESS_TYPE_NBS:
        CprDebugPrint(NULL, DBG_IO, DBG_INFO, "TDI_ADDRESS_TYPE_NBS");
        break;
    case TDI_ADDRESS_TYPE_ECMA:
        CprDebugPrint(NULL, DBG_IO, DBG_INFO, "TDI_ADDRESS_TYPE_ECMA");
        break;
    case TDI_ADDRESS_TYPE_DATAKIT:
        CprDebugPrint(NULL, DBG_IO, DBG_INFO, "TDI_ADDRESS_TYPE_DATAKIT");
        break;
    case TDI_ADDRESS_TYPE_CCITT:
        CprDebugPrint(NULL, DBG_IO, DBG_INFO, "TDI_ADDRESS_TYPE_CCITT");
        break;
    case TDI_ADDRESS_TYPE_SNA:
        CprDebugPrint(NULL, DBG_IO, DBG_INFO, "TDI_ADDRESS_TYPE_SNA");
        break;
    case TDI_ADDRESS_TYPE_DECnet:
        CprDebugPrint(NULL, DBG_IO, DBG_INFO, "TDI_ADDRESS_TYPE_DECnet");
        break;
    case TDI_ADDRESS_TYPE_DLI:
        CprDebugPrint(NULL, DBG_IO, DBG_INFO, "TDI_ADDRESS_TYPE_DLI");
        break;
    case TDI_ADDRESS_TYPE_LAT:
        CprDebugPrint(NULL, DBG_IO, DBG_INFO, "TDI_ADDRESS_TYPE_LAT");
        break;
    case TDI_ADDRESS_TYPE_HYLINK:
        CprDebugPrint(NULL, DBG_IO, DBG_INFO, "TDI_ADDRESS_TYPE_HYLINK");
        break;
    case TDI_ADDRESS_TYPE_APPLETALK:
        {
            PTDI_ADDRESS_APPLETALK pTdiAddress = (PTDI_ADDRESS_APPLETALK)Address->Address;

            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "TDI_ADDRESS_TYPE_APPLETALK");
            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "Network %x", pTdiAddress->Network);
            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "Node %x", pTdiAddress->Node);
            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "Socket %x", pTdiAddress->Socket);
        }
        break;
    case TDI_ADDRESS_TYPE_NETBIOS:
        {
            PTDI_ADDRESS_NETBIOS pTdiAddress = (PTDI_ADDRESS_NETBIOS)Address->Address;

            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "TDI_ADDRESS_TYPE_NETBIOS");
            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "NetbiosNameType %x", pTdiAddress->NetbiosNameType);
            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "NetbiosName %s", pTdiAddress->NetbiosName);
        }
        break;
    case TDI_ADDRESS_TYPE_8022:
        {
            PTDI_ADDRESS_8022 pTdiAddress = (PTDI_ADDRESS_8022)Address->Address;

            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "TDI_ADDRESS_TYPE_8022");
            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "MACAddress[0] %x", pTdiAddress->MACAddress[0]);
            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "MACAddress[1] %x", pTdiAddress->MACAddress[1]);
            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "MACAddress[2] %x", pTdiAddress->MACAddress[2]);
            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "MACAddress[3] %x", pTdiAddress->MACAddress[3]);
            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "MACAddress[4] %x", pTdiAddress->MACAddress[4]);
            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "MACAddress[5] %x", pTdiAddress->MACAddress[5]);
        }
        break;
    case TDI_ADDRESS_TYPE_OSI_TSAP:
        CprDebugPrint(NULL, DBG_IO, DBG_INFO, "TDI_ADDRESS_TYPE_OSI_TSAP");
        break;
    case TDI_ADDRESS_TYPE_NETONE:
        CprDebugPrint(NULL, DBG_IO, DBG_INFO, "TDI_ADDRESS_TYPE_NETONE");
        break;
    case TDI_ADDRESS_TYPE_VNS:
        CprDebugPrint(NULL, DBG_IO, DBG_INFO, "TDI_ADDRESS_TYPE_VNS");
        break;
    case TDI_ADDRESS_TYPE_NETBIOS_EX:
        {
            PTDI_ADDRESS_NETBIOS_EX pTdiAddress = (PTDI_ADDRESS_NETBIOS_EX)Address->Address;

            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "TDI_ADDRESS_TYPE_NETBIOS_EX");

            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "EndpointName %s", pTdiAddress->EndpointName);
            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "NetbiosAddress.NetbiosNameType %x", pTdiAddress->NetbiosAddress.NetbiosNameType);
            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "NetbiosAddress.NetbiosName %s", pTdiAddress->NetbiosAddress.NetbiosName);
        }
        break;
#ifndef WIN2K
    case TDI_ADDRESS_TYPE_IP6:
        {
            PTDI_ADDRESS_IP6 pTdiAddress = (PTDI_ADDRESS_IP6)Address->Address;

            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "TDI_ADDRESS_TYPE_IP6");
            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "sin6_port %x", pTdiAddress->sin6_port);
            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "sin6_flowinfo %x", pTdiAddress->sin6_flowinfo);
            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "sin6_addr[0] %x", pTdiAddress->sin6_addr[0]);
            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "sin6_addr[1] %x", pTdiAddress->sin6_addr[1]);
            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "sin6_addr[2] %x", pTdiAddress->sin6_addr[2]);
            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "sin6_addr[3] %x", pTdiAddress->sin6_addr[3]);
            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "sin6_addr[4] %x", pTdiAddress->sin6_addr[4]);
            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "sin6_addr[5] %x", pTdiAddress->sin6_addr[5]);
            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "sin6_addr[6] %x", pTdiAddress->sin6_addr[6]);
            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "sin6_addr[7] %x", pTdiAddress->sin6_addr[7]);
            CprDebugPrint(NULL, DBG_IO, DBG_INFO, "sin6_scope_id %x", pTdiAddress->sin6_scope_id);

        }
        break;
#endif
    default:
        CprDebugPrint(NULL, DBG_IO, DBG_INFO, "Unknown Address->AddressType %x", Address->AddressType);
        break;
    }

    return;
}

///////////////////////////////////////////////////////////////////////////////////////////////////
//  CprDumpBuffer
//      Dump Buffer
//
//  Arguments:
//		IN PUCHAR buf,
//		ULONG     bufSize
//
//  Return Value:
//      None.
//
VOID CprDumpBuffer(
	IN char	  *str,
	IN PUCHAR buf,
	ULONG     bufSize
	)
{
	ULONG i, j, k;
	ULONG r = 0;	// Current Row Offset

	DbgPrint("   ------------------------------------------------------------------------\n");
	DbgPrint("   Dump Buffer (%s): buf %p bufSize %d (0x%X)\n", str, buf, bufSize, bufSize);

	// if bufSize is negative, return
	if (bufSize & 0x800000000)
		return;

	for (i = 0; i < bufSize; i += 16, r += 16)
	{
		// print relative address
		DbgPrint("   %04X ", r);

		// print data as hexidecimal
		//
		for (j = 0; (j < 16) && ( (r+j) < bufSize); j++)
		{
			if (j == 8)
				DbgPrint(" ");

			DbgPrint(" %02X", buf[r+j]);
		}

		// Pad output if not a complete line
		//
		if (j <= 8)
			DbgPrint(" ");

		for ( ; j < 16; j++)
		{
			DbgPrint("   ");
		}

		DbgPrint("  ");

		// print data as ASCII
		//
		for (k = 0; (k < 16) && ( (r+k) < bufSize); k++)
		{
			if ((buf[r+k] < 0x20) || (buf[r+k] > 0x7E))
			{
				DbgPrint(".");
			}
			else
			{
				DbgPrint("%c", buf[r+k]);
			}
		}

		DbgPrint("\n");
	}

	DbgPrint("\n");
}

#endif

#endif