pnpdump.c File Reference

#include <windows.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <ntddk.h>
#include <pshpack1.h>
#include <poppack.h>

Include dependency graph for pnpdump.c:

Go to the source code of this file.

Classes
struct	_CM_PNP_BIOS_DEVICE_NODE
struct	_CM_PNP_BIOS_INSTALLATION_CHECK
struct	_PNP_ID_NAME_

Typedefs
typedef struct _CM_PNP_BIOS_DEVICE_NODE	CM_PNP_BIOS_DEVICE_NODE
typedef struct _CM_PNP_BIOS_DEVICE_NODE *	PCM_PNP_BIOS_DEVICE_NODE
typedef struct _CM_PNP_BIOS_INSTALLATION_CHECK	CM_PNP_BIOS_INSTALLATION_CHECK
typedef struct _CM_PNP_BIOS_INSTALLATION_CHECK *	PCM_PNP_BIOS_INSTALLATION_CHECK
typedef struct _PNP_ID_NAME_	PNP_ID_NAME
typedef struct _PNP_ID_NAME_ *	PPNP_ID_NAME

Functions
static char *	GetDeviceName (char *PnpId)
LONG	GetPnpKey (PHKEY PnpKey)
static VOID	PnpDecodeIrq (unsigned char *Ptr)
static VOID	PnpDecodeDma (unsigned char *Ptr)
static VOID	PnpDecodeIoPort (unsigned char *Ptr)
static VOID	PnpDecodeFixedIoPort (unsigned char *Ptr)
static VOID	PnpDecodeMemory16 (unsigned char *Ptr)
static VOID	PnpDecodeMemory32 (unsigned char *Ptr)
static VOID	PnpDecodeFixedMemory (unsigned char *Ptr)
void	PrintDeviceData (PCM_PNP_BIOS_DEVICE_NODE DeviceNode)
int	main (int argc, char *argv[])

Variables
static char	Hex [] = "0123456789ABCDEF"
static PNP_ID_NAME	PnpName []

Typedef Documentation

CM_PNP_BIOS_DEVICE_NODE

typedef struct _CM_PNP_BIOS_DEVICE_NODE CM_PNP_BIOS_DEVICE_NODE

CM_PNP_BIOS_INSTALLATION_CHECK

typedef struct _CM_PNP_BIOS_INSTALLATION_CHECK CM_PNP_BIOS_INSTALLATION_CHECK

PCM_PNP_BIOS_DEVICE_NODE

typedef struct _CM_PNP_BIOS_DEVICE_NODE* PCM_PNP_BIOS_DEVICE_NODE

PCM_PNP_BIOS_INSTALLATION_CHECK

typedef struct _CM_PNP_BIOS_INSTALLATION_CHECK * PCM_PNP_BIOS_INSTALLATION_CHECK

PNP_ID_NAME

typedef struct _PNP_ID_NAME_ PNP_ID_NAME

PPNP_ID_NAME

typedef struct _PNP_ID_NAME_ * PPNP_ID_NAME

Function Documentation

GetDeviceName()

static char* GetDeviceName ( char *  PnpId )

static

Definition at line 240 of file pnpdump.c.

{
  PPNP_ID_NAME IdName;

  IdName = PnpName;
  while (IdName->PnpId != NULL)
    {
      if (!strcmp(IdName->PnpId, PnpId))
    return IdName->DeviceName;

      IdName++;
    }

  return "Unknown Device";
}

Referenced by PrintDeviceData().

GetPnpKey()

LONG GetPnpKey

(

PHKEY

PnpKey

)

Definition at line 258 of file pnpdump.c.

{
  LONG lError;
  char szBuffer[80];
  HKEY hAdapterKey;
  HKEY hBusKey;
  DWORD dwBus;
  DWORD dwType;
  DWORD dwSize;

  *PnpKey = 0;

  lError = RegOpenKey(HKEY_LOCAL_MACHINE,
              "HARDWARE\\DESCRIPTION\\System\\MultifunctionAdapter",
              &hAdapterKey);
  if (lError != ERROR_SUCCESS)
    return 0;

  /* Enumerate buses */
  for (dwBus = 0; ; dwBus++)
    {
      sprintf(szBuffer, "%lu", dwBus);

      lError = RegOpenKey(hAdapterKey,
              szBuffer,
              &hBusKey);
      if (lError != ERROR_SUCCESS)
    {
      RegCloseKey(hAdapterKey);
      return lError;
    }

      dwSize = 80;
      lError = RegQueryValueEx(hBusKey,
                   "Identifier",
                   NULL,
                   &dwType,
                   (LPBYTE)szBuffer,
                   &dwSize);
      if (lError != ERROR_SUCCESS)
    {
      RegCloseKey(hBusKey);
      RegCloseKey(hAdapterKey);
      return lError;
    }

      if (dwType == REG_SZ && stricmp(szBuffer, "pnp bios") == 0)
    {
      *PnpKey = hBusKey;
      RegCloseKey(hAdapterKey);
      return ERROR_SUCCESS;
    }

      RegCloseKey(hBusKey);
    }

  return 1;
}

Referenced by main().

main()

int main	(	int argc	,
		char *	argv[]
	)

hosttype.c Copyright (C) 2002 by Brian Palmer brian.nosp@m.p@sg.nosp@m.inet..nosp@m.com

Definition at line 670 of file pnpdump.c.

{
  LONG lError;
  HKEY hPnpKey;
  DWORD dwType;
  DWORD dwSize;
  BOOL Ask;
  PCM_FULL_RESOURCE_DESCRIPTOR lpBuffer;
  PCM_PNP_BIOS_INSTALLATION_CHECK lpPnpInst;
  PCM_PNP_BIOS_DEVICE_NODE lpDevNode;
  DWORD dwDataSize;
  DWORD dwResourceSize;

  hPnpKey = 0;

  Ask = TRUE;
  if (argc >1 && (!strcmp(argv[1],"/S") || !strcmp(argv[1],"/s")))
    {
      Ask = FALSE;
    }

  if (argc >1 && !strcmp(argv[1],"/?"))
    {
      printf("This utility prints the PnP-nodes from the registry\n");
      printf("\"/s\" prevents the \"Press any key\"\n\n");
      return 0;
    }

  lError = GetPnpKey(&hPnpKey);
  if (lError != ERROR_SUCCESS)
    {
      printf("Failed to get PnP-BIOS key\n");
      return 0;
    }

  if (hPnpKey != 0)
    {
      printf("Found PnP-BIOS key\n");
    }

  /* Allocate buffer */
  dwSize = 2048;
  lpBuffer = malloc(dwSize);
  if (lpBuffer == NULL)
    {
      printf("Error: malloc() failed\n");
      RegCloseKey(hPnpKey);
      return 0;
    }

  do
    {
      lError = RegQueryValueEx(hPnpKey,
                   "Configuration Data",
                   NULL,
                   &dwType,
                   (LPBYTE)lpBuffer,
                   &dwSize);
      if (lError == ERROR_MORE_DATA)
        {
          lpBuffer = realloc(lpBuffer, dwSize);
          if (lpBuffer == NULL)
            {
              printf("Error: realloc() of %u bytes failed\n", (unsigned) dwSize);
              RegCloseKey(hPnpKey);
              return 0;
            }
        }
    }
  while (lError == ERROR_MORE_DATA);
  if (lError != ERROR_SUCCESS)
    {
      printf("Failed to read 'Configuration Data' value\n");
      free(lpBuffer);
      RegCloseKey(hPnpKey);
      return 0;
    }

//  printf ("Data size: %lu\n", dwSize);

  RegCloseKey(hPnpKey);

//  printf("Resource count %lu\n", lpBuffer->PartialResourceList.Count);

  if (lpBuffer->PartialResourceList.Count == 0)
    {
      printf("Invalid resource count!\n");
      free(lpBuffer);
      return 0;
    }

//  printf("lpBuffer %p\n", lpBuffer);

  dwResourceSize = lpBuffer->PartialResourceList.PartialDescriptors[0].u.DeviceSpecificData.DataSize;
//  printf("ResourceSize: %lu\n", dwResourceSize);

  lpPnpInst = (PCM_PNP_BIOS_INSTALLATION_CHECK)
    ((ULONG_PTR)(&lpBuffer->PartialResourceList.PartialDescriptors[0]) +
      sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR));

//  printf("lpPnpInst %p\n", lpPnpInst);

  printf("Signature '%.4s'\n", lpPnpInst->Signature);
  if (strncmp((PCHAR)lpPnpInst->Signature, "$PnP", 4))
    {
      printf("Error: Invalid PnP signature\n");
      free(lpBuffer);
      return 0;
    }

//  printf("InstCheck length: %lu\n", lpPnpInst->Length);

  dwDataSize = sizeof(CM_PNP_BIOS_INSTALLATION_CHECK);
  lpDevNode = (PCM_PNP_BIOS_DEVICE_NODE)((DWORD)lpPnpInst + sizeof(CM_PNP_BIOS_INSTALLATION_CHECK));

  if (lpDevNode->Size == 0)
    {
      printf("Error: Device node size is zero!\n");
      return 0;
    }

#if 0
      printf("Node: %x  Size %hu (0x%hx)\n",
          lpDevNode->Node,
          lpDevNode->Size,
          lpDevNode->Size);

  printf("Done.\n");
return 0;
#endif


  while (dwDataSize < dwResourceSize)
    {
      if (lpDevNode->Size == 0)
    break;

      printf("Node: %x  Size %hu (0x%hx)\n",
         lpDevNode->Node,
         lpDevNode->Size,
         lpDevNode->Size);

      dwDataSize += lpDevNode->Size;
      lpDevNode = (PCM_PNP_BIOS_DEVICE_NODE)((DWORD)lpDevNode + lpDevNode->Size);
    }

  if (Ask)
    {
      printf("\n Press any key...\n");
      getch();
    }
  else
    {
      printf("\n");
    }

  dwDataSize = sizeof(CM_PNP_BIOS_INSTALLATION_CHECK);
  lpDevNode = (PCM_PNP_BIOS_DEVICE_NODE)((DWORD)lpPnpInst + sizeof(CM_PNP_BIOS_INSTALLATION_CHECK));

  while (dwDataSize < dwResourceSize)
    {
      if (lpDevNode->Size == 0)
    break;

      PrintDeviceData(lpDevNode);

      if (Ask)
        {
          printf("\n Press any key...\n");
          getch();
        }
      else
        {
          printf("\n");
        }

      dwDataSize += lpDevNode->Size;
      lpDevNode = (PCM_PNP_BIOS_DEVICE_NODE)((DWORD)lpDevNode + lpDevNode->Size);
    }

  free(lpBuffer);

  return 0;
}

PnpDecodeDma()

static VOID PnpDecodeDma ( unsigned char *  Ptr )

static

Definition at line 343 of file pnpdump.c.

{
  unsigned char DmaChannel;
  unsigned char DmaStatus;
  int i;

  DmaChannel = *Ptr;
  Ptr++;
  DmaStatus = *Ptr;

  printf("      DMAs:");

  for (i = 0; i < 8; i++)
    {
      if (DmaChannel & (1 << i))
    {
      printf(" %u", i);
    }
    }

  printf("\n");
}

Referenced by PrintDeviceData().

PnpDecodeFixedIoPort()

static VOID PnpDecodeFixedIoPort ( unsigned char *  Ptr )

static

Definition at line 396 of file pnpdump.c.

{
  USHORT IoPort;
  UCHAR Length;

  IoPort = *Ptr;
  Ptr++;
  IoPort += (*Ptr << 8);
  Ptr++;
  Length = *Ptr;

  printf("  Fixed I/O Port descriptor\n");
  printf("    PortBase 0x%hx  Length 0x%x\n",
     IoPort, Length);

#if 0
  if (Length == 1)
    {
      printf("  Fixed location I/O Port descriptor: 0x%x\n",
         IoPort);
    }
  else
    {
      printf("  Fixed location I/O Port descriptor: 0x%x - 0x%x\n",
         IoPort,
         IoPort + Length - 1);
    }
#endif
}

Referenced by PrintDeviceData().

PnpDecodeFixedMemory()

static VOID PnpDecodeFixedMemory ( unsigned char *  Ptr )

static

Definition at line 518 of file pnpdump.c.

{
  UCHAR Info;
  ULONG Base;
  ULONG Length;

  Info = *Ptr;
  Ptr++;

  Base = *Ptr;
  Ptr++;
  Base += (*Ptr << 8);
  Ptr++;
  Base += (*Ptr << 16);
  Ptr++;
  Base += (*Ptr << 24);
  Ptr++;

  Length = *Ptr;
  Ptr++;
  Length += (*Ptr << 8);
  Ptr++;
  Length += (*Ptr << 16);
  Ptr++;
  Length += (*Ptr << 24);

  printf("  32-Bit fixed location memory range descriptor\n");
  printf("    Base 0x%lx  Length 0x%lx  Flags 0x%02x\n",
     Base, Length, Info);
}

Referenced by PrintDeviceData().

PnpDecodeIoPort()

static VOID PnpDecodeIoPort ( unsigned char *  Ptr )

static

Definition at line 368 of file pnpdump.c.

{
  USHORT MinBase;
  USHORT MaxBase;
  UCHAR Align;
  UCHAR Length;

  // Info = *Ptr;
  Ptr++;
  MinBase = *Ptr;
  Ptr++;
  MinBase += (*Ptr << 8);
  Ptr++;
  MaxBase = *Ptr;
  Ptr++;
  MaxBase += (*Ptr << 8);
  Ptr++;
  Align = *Ptr;
  Ptr++;
  Length = *Ptr;

  printf("  I/O Port descriptor\n");
  printf("    MinBase 0x%x  MaxBase 0x%x  Align %u  Length %u\n",
     MinBase, MaxBase, Align, Length);
}

Referenced by PrintDeviceData().

PnpDecodeIrq()

static VOID PnpDecodeIrq ( unsigned char *  Ptr )

static

Definition at line 319 of file pnpdump.c.

{
  USHORT IrqMask;
  int i;

  IrqMask = *Ptr;
  Ptr++;
  IrqMask |= (*Ptr << 8);

  printf("      IRQs:");

  for (i = 0; i < 16; i++)
    {
      if (IrqMask & (1 << i))
    {
      printf(" %u", i);
    }
    }

  printf("\n");
}

Referenced by PrintDeviceData().

PnpDecodeMemory16()

static VOID PnpDecodeMemory16 ( unsigned char *  Ptr )

static

Definition at line 428 of file pnpdump.c.

{
  UCHAR Info;
  USHORT MinBase;
  USHORT MaxBase;
  USHORT Align;
  USHORT Length;

  Info = *Ptr;
  Ptr++;

  MinBase = *Ptr;
  Ptr++;
  MinBase += (*Ptr << 8);
  Ptr++;

  MaxBase = *Ptr;
  Ptr++;
  MaxBase += (*Ptr << 8);
  Ptr++;

  Align = *Ptr;
  Ptr++;
  Align += (*Ptr << 8);
  Ptr++;

  Length = *Ptr;
  Ptr++;
  Length += (*Ptr << 8);

  printf("  16-Bit memory range descriptor\n");
  printf("    MinBase 0x%hx  MaxBase 0x%hx  Align 0x%hx  Length 0x%hx  Flags 0x%02x\n",
     MinBase, MaxBase, Align,Length, Info);
}

Referenced by PrintDeviceData().

PnpDecodeMemory32()

static VOID PnpDecodeMemory32 ( unsigned char *  Ptr )

static

Definition at line 465 of file pnpdump.c.

{
  UCHAR Info;
  ULONG MinBase;
  ULONG MaxBase;
  ULONG Align;
  ULONG Length;

  Info = *Ptr;
  Ptr++;

  MinBase = *Ptr;
  Ptr++;
  MinBase += (*Ptr << 8);
  Ptr++;
  MinBase += (*Ptr << 16);
  Ptr++;
  MinBase += (*Ptr << 24);
  Ptr++;

  MaxBase = *Ptr;
  Ptr++;
  MaxBase += (*Ptr << 8);
  Ptr++;
  MaxBase += (*Ptr << 16);
  Ptr++;
  MaxBase += (*Ptr << 24);
  Ptr++;

  Align = *Ptr;
  Ptr++;
  Align += (*Ptr << 8);
  Ptr++;
  Align += (*Ptr << 16);
  Ptr++;
  Align += (*Ptr << 24);
  Ptr++;

  Length = *Ptr;
  Ptr++;
  Length += (*Ptr << 8);
  Ptr++;
  Length += (*Ptr << 16);
  Ptr++;
  Length += (*Ptr << 24);

  printf("  32-Bit memory range descriptor\n");
  printf("    MinBase 0x%lx  MaxBase 0x%lx  Align 0x%lx  Length 0x%lx  Flags 0x%02x\n",
     MinBase, MaxBase, Align,Length, Info);
}

Referenced by PrintDeviceData().

PrintDeviceData()

void PrintDeviceData

(

PCM_PNP_BIOS_DEVICE_NODE

DeviceNode

)

Definition at line 550 of file pnpdump.c.

{
  char PnpId[8];
  unsigned char *Ptr;
  unsigned int TagSize;
  unsigned int TagType;

  unsigned char Id[4];

  printf ("Node: %x  Size %hu (0x%hx)\n",
      DeviceNode->Node,
      DeviceNode->Size,
      DeviceNode->Size);

  memcpy(Id, &DeviceNode->ProductId, 4);

  PnpId[0] = ((Id[0] >> 2) & 0x1F) + 0x40;
  PnpId[1] = ((Id[0] << 3) & 0x18) +
         ((Id[1] >> 5) & 0x07) + 0x40;
  PnpId[2] = (Id[1] & 0x1F) + 0x40;

  PnpId[3] = Hex[(Id[2] >> 4) & 0xF];
  PnpId[4] = Hex[Id[2] & 0x0F];

  PnpId[5] = Hex[(Id[3] >> 4) & 0x0F];
  PnpId[6] = Hex[Id[3] & 0x0F];
  PnpId[7] = 0;

  printf("  '%s' (%s)\n",
     PnpId, GetDeviceName(PnpId));

  if (DeviceNode->Size > sizeof(CM_PNP_BIOS_DEVICE_NODE))
    {
      Ptr = (unsigned char *)(DeviceNode + 1);
      while (TRUE)
    {
      if (*Ptr & 0x80)
        {
          TagType = *Ptr & 0x7F;
          Ptr++;
          TagSize = *Ptr;
          Ptr++;
          TagSize += (*Ptr << 16);
          Ptr++;


          switch (TagType)
        {
          case 1:
            PnpDecodeMemory16(Ptr);
            break;

          case 5:
            PnpDecodeMemory32(Ptr);
            break;

          case 6:
            PnpDecodeFixedMemory(Ptr);
            break;

          default:
            printf("      Large tag: type %u  size %u\n",
               TagType,
               TagSize);
            break;
        }
        }
      else
        {
          TagType = (*Ptr >> 3) & 0x0F;
          TagSize = *Ptr & 0x07;
          Ptr++;

          switch (TagType)
        {
          case 2:
            printf("      Logical device ID\n");
            break;

          case 3:
            printf("      Compatible device ID\n");
            break;

          case 4:
            PnpDecodeIrq(Ptr);
            break;

          case 5:
            PnpDecodeDma(Ptr);
            break;

          case 8:
            PnpDecodeIoPort(Ptr);
            break;

          case 9:
            PnpDecodeFixedIoPort(Ptr);
            break;

          case 0x0F: /* end tag */
            break;

          default:
            printf("      Small tag: type %u  size %u\n",
               TagType,
               TagSize);
            break;
        }

          /* end tag */
          if (TagType == 0x0F)
        break;
        }

      Ptr = Ptr + TagSize;
    }
    }
}

Referenced by main().

Variable Documentation

Hex

char Hex[] = "0123456789ABCDEF"

static

Definition at line 50 of file pnpdump.c.

Referenced by PrintDeviceData().

PnpName

PNP_ID_NAME PnpName[]

static

Definition at line 52 of file pnpdump.c.

Referenced by CompareProductName(), FindProductName(), and GetDeviceName().