windows-xp/Source/XPSP1/NT/net/netbeui/kdext/nbfcom.c

/*++

Copyright (c) 1998  Microsoft Corporation

Module Name:

    nbfcom.c

Abstract:

    This file contains the generic routines
    for the kernel debugger extensions dll.

Author:

    Chaitanya Kodeboyina (Chaitk)

Environment:

    User Mode

--*/

#include "precomp.h"

#pragma hdrstop

//
// Misc Helper Routines
//

ULONG
GetLocation (
    PCHAR String
    )
{
    ULONG Location;
    
    Location = GetExpression( String );
    if (!Location) {
        dprintf("unable to get %s\n",String);
        return 0;
    }

    return Location;
}

ULONG
GetUlongValue (
    PCHAR String
    )
{
    ULONG Location;
    ULONG Value;
    ULONG result;


    Location = GetExpression( String );
    if (!Location) {
        dprintf("unable to get %s\n",String);
        return 0;
    }

    if ((!ReadMemory((DWORD)Location,&Value,sizeof(ULONG),&result)) ||
        (result < sizeof(ULONG))) {
        dprintf("unable to get %s\n",String);
        return 0;
    }

    return Value;
}

VOID
dprintSymbolPtr
(
    PVOID Pointer,
    PCHAR EndOfLine
)
{
    UCHAR SymbolName[ 80 ];
    ULONG Displacement;

    GetSymbol( Pointer, SymbolName, &Displacement );

    if ( Displacement == 0 )
    {
        dprintf( "(%s)%s", SymbolName, EndOfLine );
    }
    else
    {
        dprintf( "(%s + 0x%X)%s", SymbolName, Displacement, EndOfLine );
    }
}

VOID
dprint_nchar
(
    PCHAR pch,
    int cch
)
{
    CHAR ch;
    int index;

    for ( index = 0; index < cch; index ++ )
    {
        ch = pch[ index ];
        dprintf( "%c", ( ch >= 32 ) ? ch : '.' );
    }
}

VOID
dprint_hardware_address
(
    PUCHAR Address
)
{
    dprintf( "%02x-%02x-%02x-%02x-%02x-%02x",
             Address[ 0 ],
             Address[ 1 ],
             Address[ 2 ],
             Address[ 3 ],
             Address[ 4 ],
             Address[ 5 ] );
}

BOOL
dprint_enum_name
(
    ULONG Value,
    PENUM_INFO pEnumInfo
)
{
    while ( pEnumInfo->pszDescription != NULL )
    {
        if ( pEnumInfo->Value == Value )
        {
            dprintf( "%.40s", pEnumInfo->pszDescription );
            return( TRUE );
        }
        pEnumInfo ++;
    }

    dprintf( "Unknown enumeration value." );
    return( FALSE );
}

BOOL
dprint_flag_names
(
    ULONG Value,
    PFLAG_INFO pFlagInfo
)
{
    BOOL bFoundOne = FALSE;

    while ( pFlagInfo->pszDescription != NULL )
    {
        if ( pFlagInfo->Value & Value )
        {
            if ( bFoundOne )
            {
                dprintf( " | " );
            }
            bFoundOne = TRUE;

            dprintf( "%.15s", pFlagInfo->pszDescription );
        }
        pFlagInfo ++;
    }

    return( bFoundOne );
}

BOOL
dprint_masked_value
(
    ULONG Value,
    ULONG Mask
)
{
    CHAR Buf[ 9 ];
    ULONG nibble;
    int index;

    for ( index = 0; index < 8; index ++ )
    {
        nibble = ( Mask & 0xF0000000 );
/*
        dprintf( "#%d: nibble == %08X\n"
                 "      Mask == %08X\n"
                 "     Value == %08X\n", index, nibble, Mask, Value );

*/
        if ( nibble )
        {
            Buf[ index ] = "0123456789abcdef"[ (( nibble & Value ) >> 28) & 0xF ];
        }
        else
        {
            Buf[ index ] = ' ';
        }

        Mask <<= 4;
        Value <<= 4;
    }

    Buf[ 8 ] = '\0';

    dprintf( "%s", Buf );

    return( TRUE );
}

VOID dprint_addr_list
( 
    ULONG FirstAddress, 
    ULONG OffsetToNextPtr 
)
{
    ULONG Address;
    ULONG result;
    int index;

    Address = FirstAddress;

    if ( Address == (ULONG)NULL )
    {
        dprintf( "%08X (Empty)\n", Address );
        return;
    }

    dprintf( "{ " );

    for ( index = 0; Address != (ULONG)NULL; index ++ )
    {
        if ( index != 0 )
        {
            dprintf( ", ");
        }
        dprintf( "%08X", Address );

        if ( !ReadMemory( Address + OffsetToNextPtr,
                          &Address,
                          sizeof( Address ),
                          &result ))
        {
            dprintf( "ReadMemory() failed." );
            Address = (ULONG)NULL;
        }
    }
    dprintf( " }\n" );
}

VOID PrintStringofLenN(PVOID Pointer, ULONG PtrProxy, ULONG printDetail)
{
    dprint_nchar((CHAR *)Pointer, 16);
}

VOID PrintClosestSymbol(PVOID Pointer, ULONG PtrProxy, ULONG printDetail)
{
    dprintSymbolPtr((PVOID)(*(ULONG *)Pointer), "");
}

VOID PrintFields
( 
    PVOID   pStructure, 
    ULONG   structProxy,
    CHAR   *fieldPrefix,
    ULONG   printDetail,
    StructAccessInfo *pStructInfo
)
{
    FieldAccessInfo *pFieldInfo;
    BOOLEAN printAll;
    BOOLEAN printField;
    UINT    i, j, k;
    ULONG  *pUlong;
    ULONG   proxyPtr;
    ULONG   childDetail;

    dprintf("\n@@Struct: %s @ %08x\n", pStructInfo->Name, structProxy);
    
    if (printDetail == NULL_INFO)
    {
        return;
    }
    
    if ((fieldPrefix == NULL) || (fieldPrefix[0] == '\0'))
        printAll = TRUE;
    else
        printAll = FALSE;

    for (i = 0; i < MAX_FIELD; i++)
    {
        pFieldInfo = &pStructInfo->fieldInfo[i];

        if (pFieldInfo->Name[0] == '\0')
            break;

        printField = FALSE;
        if ((printDetail == FULL_SHAL)
                || (printDetail == FULL_DEEP)
                    || (pFieldInfo->Importance == HIG)
                            || ((printDetail != SUMM_INFO) &&
                                    (pFieldInfo->Importance > LOW)))
        {
            printField = TRUE;
        }
        
        if (pFieldInfo->Name[0] == '@')
        {
            if (printField)
            {
                dprintf("\n");
            }
            continue;
        }

        if ((printAll) || strstr(pFieldInfo->Name, fieldPrefix))
        {
            pUlong = (ULONG *)(((CHAR *)pStructure) + pFieldInfo->Offset);
            proxyPtr = (ULONG)(((CHAR *)structProxy) + pFieldInfo->Offset);

            if (pFieldInfo->PrintField)
            {
                switch (printDetail)
                {
                    case FULL_DEEP:
                    case NORM_DEEP:
                        childDetail = printDetail;
                        break;

                    case NORM_SHAL:
                    case FULL_SHAL:
                        childDetail = SUMM_INFO;
                        break;
                        
                    case SUMM_INFO:
                        childDetail = NULL_INFO;
                }

                if (printField)
                {
                    dprintf("@Field: %40s\t", pFieldInfo->Name);
    
                    dprintf("\n%08x  ", proxyPtr);

                    pFieldInfo->PrintField(pUlong, 
                                           proxyPtr, 
                                           childDetail);

                    dprintf("\n");
                }
            }
            else
            {
                if (printField)                
                {
                    dprintf("@Field: %40s\t", pFieldInfo->Name);

                    if (pFieldInfo->Size <= sizeof(ULONG))
                    {
                        dprintf("%08x ", proxyPtr);
                        j = pFieldInfo->Size;
                    }
                    else
                    {                    
                        for (k = 0, j = 4; j <= pFieldInfo->Size; j += 4)
                        {
                            if (j % 16 == 4)
                            {
                                k = (k + 1) % 8;
                                if (k == 0)
                                {
                                    dprintf("\n");
                                }

                                dprintf("\n%08x ", proxyPtr);
                                                            
                                proxyPtr += 0x10;
                            }
                            
                            dprintf(" %08x", *pUlong++);
                        }

                        j = pFieldInfo->Size - j + 4;
                    }

                    switch (j)
                    {
                        case 4:
                            dprintf(" %08x", *pUlong);
                            break;

                        case 3:
                            dprintf(" ....%04x", *(USHORT *)pUlong);
                            pUlong = (ULONG *)(((UCHAR *)pUlong) + 2);
                            dprintf(" ......%02x", *(UCHAR  *)pUlong);
                            break;

                        case 2:
                            dprintf(" ....%04x", *(USHORT *)pUlong);
                            break;

                        case 1:
                            dprintf(" ......%02x", *(UCHAR  *)pUlong);
                            break;
                    }
                    
                    dprintf("\n");
                }
            }
        }
    }
}

//
// Misc NBF Specific Helpers
//

#if PKT_LOG

VOID PrintPktLogQue(PVOID pointer, ULONG proxyPtr, ULONG printDetail)
{
    UINT         i, j;
    PKT_LOG_QUE  PktLog;
    PKT_LOG_QUE *pPktLog;
    ULONG        bytesRead;

    // Get list of logged packets & debug print level
    if (pointer == NULL)
    {
        // Read the packet log queue
        if (!ReadMemory(proxyPtr, &PktLog, sizeof(PKT_LOG_QUE), &bytesRead))
        {
            dprintf("%s @ %08x: Could not read structure\n", 
                            "Packet Log Queue", proxyPtr);
            return;
        }

        pPktLog = &PktLog;
    }
    else
    {
        pPktLog = (PKT_LOG_QUE *) pointer;
    }

    // Print the packet log queue
    dprintf("PktNext = %d, PktQue = %08x\n",
                pPktLog->PktNext,
               &((PKT_LOG_QUE *)proxyPtr)->PktQue);

    for (i = 0; i < PKT_QUE_SIZE; i++)
    {
        j = (pPktLog->PktNext + i) % PKT_QUE_SIZE;
        
        dprintf("P%02d: TS = %05d, BT = %5d, BS = %5d, DH = %08x, PD = %08x\n",  
                    j,
                    pPktLog->PktQue[j].TimeLogged,
                    pPktLog->PktQue[j].BytesTotal,
                    pPktLog->PktQue[j].BytesSaved,
                    *(ULONG *)pPktLog->PktQue[j].PacketData,
                   &((PKT_LOG_QUE *)proxyPtr)->PktQue[j].PacketData);
    }
}

VOID PrintPktIndQue(PVOID pointer, ULONG proxyPtr, ULONG printDetail)
{
    UINT         i, j;
    PKT_IND_QUE  PktLog;
    PKT_IND_QUE *pPktLog;
    ULONG        bytesRead;

    // Get list of logged packets & debug print level
    if (pointer == NULL)
    {
        // Read the packet log queue
        if (!ReadMemory(proxyPtr, &PktLog, sizeof(PKT_IND_QUE), &bytesRead))
        {
            dprintf("%s @ %08x: Could not read structure\n", 
                            "Packet Ind Queue", proxyPtr);
            return;
        }

        pPktLog = &PktLog;
    }
    else
    {
        pPktLog = (PKT_IND_QUE *) pointer;
    }

    // Print the packet log queue
    dprintf("PktNext = %d, PktQue = %08x\n",
                pPktLog->PktNext,
               &((PKT_IND_QUE *)proxyPtr)->PktQue);

    for (i = 0; i < PKT_QUE_SIZE; i++)
    {
        j = (pPktLog->PktNext + i) % PKT_QUE_SIZE;
        
        dprintf("P%02d: TS = %05d, BT = %5d, BI = %5d, BK = %5d, PD = %08x, S = %08x\n",
                    j,
                    pPktLog->PktQue[j].TimeLogged,
                    pPktLog->PktQue[j].BytesTotal,
                    pPktLog->PktQue[j].BytesIndic,
                    pPktLog->PktQue[j].BytesTaken,
                    &((PKT_LOG_QUE *)proxyPtr)->PktQue[j].PacketData,
                    pPktLog->PktQue[j].IndcnStatus);
    }
}

#endif

VOID PrintNbfNetbiosAddressFromPtr(PVOID AddressPtrPointer, ULONG AddressPtrProxy, ULONG printDetail)
{
    ULONG                   pNetbiosAddressProxy;
    ULONG                   bytesRead;

    if (AddressPtrPointer == NULL)
    {
        if (!ReadMemory(AddressPtrProxy, &AddressPtrPointer, sizeof(PVOID), &bytesRead))
        {
            dprintf("%s @ %08x: Could not read structure\n", 
                            "NBF Netbios Address Ptr", AddressPtrProxy);
            return;
        }
    }

    pNetbiosAddressProxy = *(ULONG *)AddressPtrPointer;
    
    dprintf("%08x (Ptr)\n", pNetbiosAddressProxy);

    if (pNetbiosAddressProxy)
    {
        PrintNbfNetbiosAddress(NULL, *(ULONG *)AddressPtrPointer, printDetail);
    }
}

VOID PrintNbfNetbiosAddress(PVOID AddressPointer, ULONG AddressProxy, ULONG printDetail)
{
    PNBF_NETBIOS_ADDRESS    pNetbiosAddress;
    NBF_NETBIOS_ADDRESS     NetbiosAddress;
    ULONG                   bytesRead;
    CHAR                    NetbiosNameTypes[3][10] = { "UNIQUE", "GROUP", "EITHER" };

    if (AddressPointer == NULL)
    {
        if (!ReadMemory(AddressProxy, &NetbiosAddress, sizeof(NBF_NETBIOS_ADDRESS), &bytesRead))
        {
            dprintf("%s @ %08x: Could not read structure\n", 
                            "NBF Netbios Address", AddressProxy);
            return;
        }
        
        pNetbiosAddress = &NetbiosAddress;
    }
    else
    {
        pNetbiosAddress = (PNBF_NETBIOS_ADDRESS) AddressPointer;
    }
    
    dprintf("Name: ");
    dprint_nchar(pNetbiosAddress->NetbiosName, 16);
    dprintf(", ");
    
    if (pNetbiosAddress->NetbiosNameType > 2)
    {
        dprintf("Type: %s\n", "UNKNOWN");
    }
    else
    {
        dprintf("Type: %s\n", 
                        NetbiosNameTypes[pNetbiosAddress->NetbiosNameType]);
    }
}

VOID PrintNbfPacketPoolListFromPtr(PVOID PacketPoolPtrPointer, ULONG PacketPoolPtrProxy, ULONG printDetail)
{
    ULONG                   pPacketPoolProxy;
    ULONG                   bytesRead;

    if (PacketPoolPtrPointer == NULL)
    {
        if (!ReadMemory(PacketPoolPtrProxy, &PacketPoolPtrPointer, sizeof(PVOID), &bytesRead))
        {
            dprintf("%s @ %08x: Could not read structure\n", 
                            "NBF Packet Pool Ptr", PacketPoolPtrProxy);
            return;
        }
    }

    pPacketPoolProxy = *(ULONG *)PacketPoolPtrPointer;
    
    dprintf("%08x (Ptr)\n", pPacketPoolProxy);

    if (pPacketPoolProxy)
    {
        PrintNbfPacketPoolList(NULL, *(ULONG *)PacketPoolPtrPointer, printDetail);
    }
}

VOID PrintNbfPacketPoolList(PVOID PacketPoolPointer, ULONG PacketPoolProxy, ULONG printDetail)
{
    PNBF_POOL_LIST_DESC     pPacketPoolList;
    NBF_POOL_LIST_DESC      PacketPoolList;
    ULONG                   bytesRead;

    if (PacketPoolPointer == NULL)
    {
        if (!ReadMemory(PacketPoolProxy, &PacketPoolList, sizeof(NBF_POOL_LIST_DESC), &bytesRead))
        {
            dprintf("%s @ %08x: Could not read structure\n", 
                                "NBF Packet Pool", PacketPoolProxy);
            return;
        }

        pPacketPoolList = &PacketPoolList;
    }
    else
    {
        pPacketPoolList = (PNBF_POOL_LIST_DESC) PacketPoolPointer;
    }

    while (pPacketPoolList)
    {
        dprintf("PoolHandle: %08x, Num: %08x, Total: %08x\n",
                    pPacketPoolList->PoolHandle,
                    pPacketPoolList->NumElements,
                    pPacketPoolList->TotalElements);

        if ((PacketPoolProxy = (ULONG) pPacketPoolList->Next) == (ULONG) NULL)
            break;
        
        if (!ReadMemory(PacketPoolProxy, &PacketPoolList, sizeof(NBF_POOL_LIST_DESC), &bytesRead))
        {
            dprintf("%s @ %08x: Could not read structure\n", 
                                "NBF Packet Pool", PacketPoolProxy);
            return;
        }
        
        pPacketPoolList = &PacketPoolList;
    }    
}

VOID PrintListFromListEntryAndOffset(PVOID ListEntryPointer, ULONG ListEntryProxy, ULONG ListEntryOffset)
{
    PLIST_ENTRY             pListEntry;
    LIST_ENTRY              ListEntry;
    ULONG                   ListHeadProxy;
    ULONG                   bytesRead;
    ULONG                   numItems;

    if (ListEntryPointer == NULL)
    {
        if (!ReadMemory(ListEntryProxy, &ListEntry, sizeof(LIST_ENTRY), &bytesRead))
        {
            dprintf("%s @ %08x: Could not read structure\n", 
                                    "List Entry", ListEntryProxy);
            return;
        }

        pListEntry = &ListEntry;
    }
    else
    {
        pListEntry = (PLIST_ENTRY) ListEntryPointer;
    }

    dprintf("\n%08x  LE : %08x, %08x\n", ListEntryProxy - ListEntryOffset, 
                                            pListEntry->Flink, 
                                            pListEntry->Blink);

    ListHeadProxy = ListEntryProxy; numItems = 0;
    
    while (((ULONG) pListEntry->Flink != ListHeadProxy) && (numItems < 100))
    {
        ListEntryProxy = (ULONG) pListEntry->Flink;
        
        if (!ReadMemory(ListEntryProxy, &ListEntry, sizeof(LIST_ENTRY), &bytesRead))
        {
            dprintf("%s @ %08x: Could not read structure\n", 
                                    "List Entry", ListEntryProxy);
            return;
        }
    
        pListEntry = &ListEntry;

        dprintf("%08x  %02d : %08x, %08x\n", ListEntryProxy - ListEntryOffset, 
                                                numItems++, 
                                                pListEntry->Flink, 
                                                pListEntry->Blink);
    }

    if (numItems == 100)
    {
        dprintf("Looks like we have an infinite loop @ %08x\n", ListHeadProxy);
    }
}

VOID PrintListFromListEntry(PVOID ListEntryPointer, ULONG ListEntryProxy, ULONG debugDetail)
{
    PrintListFromListEntryAndOffset(ListEntryPointer, ListEntryProxy, 0);
}

VOID PrintIRPListFromListEntry(PVOID IRPListEntryPointer, ULONG IRPListEntryProxy, ULONG debugDetail)
{
    PrintListFromListEntryAndOffset(IRPListEntryPointer, IRPListEntryProxy, 
                                        FIELD_OFFSET(IRP, Tail.Overlay.ListEntry));
}