712 lines
15 KiB
C
712 lines
15 KiB
C
/*++
|
||
|
||
Copyright (c) 1997-1999 Microsoft Corporation
|
||
|
||
Revision History:
|
||
|
||
--*/
|
||
|
||
/************STARTDOC*********************************************************
|
||
*
|
||
* print.c
|
||
*
|
||
* This file contains the functions print specific WMI structures
|
||
* out to stdout.
|
||
*
|
||
*
|
||
* Modification History:
|
||
* --------------------
|
||
*
|
||
* Drew McDaniel (drewm) - Sept. 16, 1997 - Original Source
|
||
*
|
||
*
|
||
*************ENDDOC**********************************************************/
|
||
#include <windows.h>
|
||
#include <stdio.h>
|
||
#include <stdlib.h>
|
||
#include <ole2.h>
|
||
#include <wmium.h>
|
||
#include <tchar.h>
|
||
#include "print.h"
|
||
|
||
// Defined constants
|
||
//
|
||
|
||
// Modular Data
|
||
//
|
||
|
||
|
||
// Function Prototypes
|
||
//
|
||
|
||
|
||
//+----------------------------------------------------------
|
||
//
|
||
// Function: PrintGuid
|
||
//
|
||
// Descrip: Prints a singe guid. Does not print the end
|
||
// new line or cariage return
|
||
//
|
||
// Returns: VOID
|
||
//
|
||
// Notes: Does not print end cariage return or new line
|
||
//
|
||
// History: 09/16/97 drewm Created
|
||
//-----------------------------------------------------------
|
||
VOID
|
||
PrintGuid(
|
||
LPGUID lpGuid
|
||
)
|
||
{
|
||
printf("0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x",
|
||
lpGuid->Data1,
|
||
lpGuid->Data2,
|
||
lpGuid->Data3,
|
||
lpGuid->Data4[0],
|
||
lpGuid->Data4[1],
|
||
lpGuid->Data4[2],
|
||
lpGuid->Data4[3],
|
||
lpGuid->Data4[4],
|
||
lpGuid->Data4[5],
|
||
lpGuid->Data4[6],
|
||
lpGuid->Data4[7]);
|
||
}
|
||
|
||
/*
|
||
VOID
|
||
PrintClassInfoHeader(
|
||
PMOFCLASSINFO pMofClassInfo
|
||
)
|
||
{
|
||
printf("Guid: ");
|
||
PrintGuid(&(pMofClassInfo->Guid));
|
||
printf("\n");
|
||
|
||
_tprintf(__T("Name: %s\n"), pMofClassInfo->Name);
|
||
_tprintf(__T("Description: %s\n"), pMofClassInfo->Description);
|
||
printf("Language ID: %u\n", pMofClassInfo->Language);
|
||
printf("Flags: 0x%x\n", pMofClassInfo->Flags);
|
||
printf("Version: %u\n", pMofClassInfo->Version);
|
||
printf("\n");
|
||
}
|
||
|
||
|
||
|
||
|
||
VOID
|
||
PrintDataItem(
|
||
PMOFDATAITEM lpDataItem
|
||
)
|
||
{
|
||
_tprintf(__T("Name: %s\n"), lpDataItem->Name);
|
||
_tprintf(__T("Description: %s\n"), lpDataItem->Description);
|
||
printf("Data Type: ");
|
||
PrintDataType(lpDataItem->DataType);
|
||
printf("\n");
|
||
printf("Version: %u\n", lpDataItem->Version);
|
||
printf("Size: 0x%x\n", lpDataItem->SizeInBytes);
|
||
printf("Flags: 0x%x\n", lpDataItem->Flags);
|
||
printf("Embedded Class Guid: ");
|
||
PrintGuid(&(lpDataItem->EmbeddedClassGuid));
|
||
printf("\n");
|
||
if (lpDataItem->Flags & MOFDI_FLAG_FIXED_ARRAY)
|
||
{
|
||
printf("Fixed array elements: %u\n", lpDataItem->FixedArrayElements);
|
||
}
|
||
if (lpDataItem->Flags & MOFDI_FLAG_VARIABLE_ARRAY)
|
||
{
|
||
printf("Variable length size ID: %u\n", lpDataItem->VariableArraySizeId);
|
||
}
|
||
|
||
|
||
}
|
||
|
||
VOID
|
||
PrintClassQualifier(
|
||
LPTSTR lpQualifier,
|
||
MOFHANDLE hMofHandle
|
||
)
|
||
{
|
||
BYTE Buffer[MAX_NAME_LENGTH];
|
||
DWORD dwBufferSize = MAX_NAME_LENGTH;
|
||
DWORD dwRet;
|
||
MOFDATATYPE MofDataType;
|
||
|
||
dwRet = WmiMofQueryClassQualifier( hMofHandle,
|
||
lpQualifier,
|
||
&MofDataType,
|
||
&dwBufferSize,
|
||
Buffer);
|
||
if (dwRet != ERROR_SUCCESS)
|
||
{
|
||
printf("WmiMofQueryClassQualifier failed. (%u)\n", dwRet);
|
||
exit (0);
|
||
}
|
||
|
||
switch( MofDataType )
|
||
{
|
||
case MOFInt32:
|
||
case MOFUInt32:
|
||
case MOFInt64:
|
||
case MOFUInt64:
|
||
case MOFInt16:
|
||
case MOFUInt16:
|
||
_tprintf(__T("%s: %u\n"), lpQualifier, Buffer);
|
||
break;
|
||
case MOFChar:
|
||
case MOFString:
|
||
case MOFWChar:
|
||
_tprintf(__T("%s: %s\n"), lpQualifier, Buffer);
|
||
break;
|
||
case MOFByte:
|
||
_tprintf(__T("%s: Unsupported type MOFByte\n"), lpQualifier);
|
||
break;
|
||
case MOFDate:
|
||
_tprintf(__T("%s: Unsupported type MOFDate\n"), lpQualifier);
|
||
break;
|
||
case MOFBoolean:
|
||
if (*Buffer == TRUE)
|
||
{
|
||
_tprintf(__T("%s: TRUE\n"), lpQualifier);
|
||
}
|
||
else
|
||
{
|
||
_tprintf(__T("%s: FALSE\n"), lpQualifier);
|
||
}
|
||
break;
|
||
case MOFEmbedded:
|
||
_tprintf(__T("%s: Unsupported type MOFEmbedded\n"), lpQualifier);
|
||
break;
|
||
case MOFUnknown:
|
||
_tprintf(__T("%s: Unsupported type MOFUnknown\n"), lpQualifier);
|
||
break;
|
||
default:
|
||
printf("Invalid Data Type\n");
|
||
}
|
||
|
||
|
||
}
|
||
|
||
VOID
|
||
PrintDataType(
|
||
MOFDATATYPE E_DataType
|
||
)
|
||
{
|
||
switch( E_DataType )
|
||
{
|
||
case MOFInt32:
|
||
printf("MOFInt32");
|
||
break;
|
||
case MOFUInt32:
|
||
printf("MOFUInt32");
|
||
break;
|
||
case MOFInt64:
|
||
printf("MOFInt64");
|
||
break;
|
||
case MOFUInt64:
|
||
printf("MOFUInt64");
|
||
break;
|
||
case MOFInt16:
|
||
printf("MOFInt16");
|
||
break;
|
||
case MOFUInt16:
|
||
printf("MOFUInt16");
|
||
break;
|
||
case MOFChar:
|
||
printf("MOFChar");
|
||
break;
|
||
case MOFByte:
|
||
printf("MOFByte");
|
||
break;
|
||
case MOFWChar:
|
||
printf("MOFWChar");
|
||
break;
|
||
case MOFDate:
|
||
printf("MOFDate");
|
||
break;
|
||
case MOFBoolean:
|
||
printf("MOFBoolean");
|
||
break;
|
||
case MOFEmbedded:
|
||
printf("MOFEmbedded");
|
||
break;
|
||
case MOFString:
|
||
printf("MOFString");
|
||
break;
|
||
case MOFUnknown:
|
||
printf("Unknown");
|
||
break;
|
||
default:
|
||
printf("Invalid Data Type\n");
|
||
}
|
||
}
|
||
*/
|
||
|
||
VOID ClearScreen()
|
||
{
|
||
UINT i;
|
||
|
||
for (i = 0; i < 40; i++)
|
||
{
|
||
printf("\n");
|
||
}
|
||
}
|
||
|
||
|
||
|
||
VOID
|
||
WaitForUser()
|
||
{
|
||
printf("Hit Enter to Continue\n");
|
||
getchar ();
|
||
getchar ();
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
//+----------------------------------------------------------
|
||
//
|
||
// Function: PrintDescription
|
||
//
|
||
// Descrip: Prints the description of the selected guid
|
||
//
|
||
// Returns: VOID
|
||
//
|
||
// Notes: If there is an error in opening or printing
|
||
// the description, an error message an error
|
||
// code will be printed instead of the description.
|
||
//
|
||
// History: 09/16/97 drewm Created
|
||
//-----------------------------------------------------------
|
||
VOID PrintDescription(
|
||
LPGUID lpGuid
|
||
)
|
||
{
|
||
DWORD dwRet;
|
||
USHORT LangID;
|
||
PMOFCLASSINFO pMofClassInfo;
|
||
MOFHANDLE MofClassHandle;
|
||
|
||
|
||
// Make the language ID
|
||
//
|
||
// LangID = MAKELANGID( LANG_ENGLISH, SUBLANG_ENGLISH_US);
|
||
LangID = MAKELANGID( LANG_NEUTRAL, SUBLANG_NEUTRAL);
|
||
|
||
|
||
// Get the class ID
|
||
//
|
||
dwRet = WmiMofOpenClassInfo( lpGuid,
|
||
LangID,
|
||
&(pMofClassInfo),
|
||
&MofClassHandle);
|
||
if (dwRet != ERROR_SUCCESS)
|
||
{
|
||
printf("Unable to open MofClassInfo handle (%u)\n", dwRet);
|
||
return;
|
||
}
|
||
|
||
_tprintf(__T("%s\n"), pMofClassInfo->Description);
|
||
|
||
WmiMofCloseClassInfo( MofClassHandle, pMofClassInfo );
|
||
}
|
||
*/
|
||
|
||
|
||
|
||
|
||
|
||
//+----------------------------------------------------------
|
||
//
|
||
// Function: PrintHeader
|
||
//
|
||
// Descrip: Prints a wnode header structure.
|
||
//
|
||
// Returns: VOID
|
||
//
|
||
// Notes: None
|
||
//
|
||
// History: 04/08/97 drewm Created
|
||
//-----------------------------------------------------------
|
||
VOID
|
||
PrintHeader(
|
||
IN WNODE_HEADER Header
|
||
)
|
||
{
|
||
SYSTEMTIME sysTime;
|
||
FILETIME fileTime;
|
||
FILETIME localFileTime;
|
||
|
||
|
||
// Convert the file time
|
||
//
|
||
fileTime.dwLowDateTime = Header.TimeStamp.LowPart;
|
||
fileTime.dwHighDateTime = Header.TimeStamp.HighPart;
|
||
|
||
FileTimeToLocalFileTime( &fileTime,
|
||
&localFileTime );
|
||
|
||
FileTimeToSystemTime( &localFileTime,
|
||
&sysTime);
|
||
|
||
|
||
// Print the info
|
||
//
|
||
printf("Buffer Size: 0x%x\n"
|
||
"Provider Id: 0x%x\n"
|
||
"Version : %u\n"
|
||
"Linkage : 0x%x\n"
|
||
"Time Stamp : %u:%02u %u\\%u\\%u\n"
|
||
"Guid : 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n"
|
||
"Flags : 0x%02x\n",
|
||
Header.BufferSize,
|
||
Header.ProviderId,
|
||
Header.Version,
|
||
Header.Linkage,
|
||
sysTime.wHour,
|
||
sysTime.wMinute,
|
||
sysTime.wMonth,
|
||
sysTime.wDay,
|
||
sysTime.wYear,
|
||
Header.Guid.Data1,
|
||
Header.Guid.Data2,
|
||
Header.Guid.Data3,
|
||
Header.Guid.Data4[0],
|
||
Header.Guid.Data4[1],
|
||
Header.Guid.Data4[2],
|
||
Header.Guid.Data4[3],
|
||
Header.Guid.Data4[4],
|
||
Header.Guid.Data4[5],
|
||
Header.Guid.Data4[6],
|
||
Header.Guid.Data4[7],
|
||
Header.Flags );
|
||
|
||
// Print readable flags
|
||
//
|
||
if (Header.Flags & WNODE_FLAG_ALL_DATA)
|
||
{
|
||
printf("WNODE_FLAG_ALL_DATA\n");
|
||
}
|
||
|
||
if (Header.Flags & WNODE_FLAG_SINGLE_INSTANCE)
|
||
{
|
||
printf("WNODE_FLAG_SINGLE_INSTANCE\n");
|
||
}
|
||
|
||
if (Header.Flags & WNODE_FLAG_SINGLE_ITEM)
|
||
{
|
||
printf("WNODE_FLAG_SINGLE_ITEM\n");
|
||
}
|
||
|
||
if (Header.Flags & WNODE_FLAG_EVENT_ITEM)
|
||
{
|
||
printf("WNODE_FLAG_EVENT_ITEM\n");
|
||
}
|
||
|
||
if (Header.Flags & WNODE_FLAG_FIXED_INSTANCE_SIZE)
|
||
{
|
||
printf("WNODE_FLAG_FIXED_INSTANCE_SIZE\n");
|
||
}
|
||
|
||
if (Header.Flags & WNODE_FLAG_TOO_SMALL)
|
||
{
|
||
printf("WNODE_FLAG_TOO_SMALL\n");
|
||
}
|
||
|
||
if (Header.Flags & WNODE_FLAG_INSTANCES_SAME)
|
||
{
|
||
printf("WNODE_FLAG_INSTANCES_SAME\n");
|
||
}
|
||
|
||
if (Header.Flags & WNODE_FLAG_INTERNAL)
|
||
{
|
||
printf("WNODE_FLAG_INTERNAL\n");
|
||
}
|
||
|
||
if (Header.Flags & WNODE_FLAG_USE_TIMESTAMP)
|
||
{
|
||
printf("WNODE_FLAG_USE_TIMESTAMP\n");
|
||
}
|
||
|
||
if (Header.Flags & WNODE_FLAG_TRACED_GUID)
|
||
{
|
||
printf("WNODE_FLAG_TRACED_GUID\n");
|
||
}
|
||
|
||
if (Header.Flags & WNODE_FLAG_EVENT_REFERENCE)
|
||
{
|
||
printf("WNODE_FLAG_EVENT_REFERENCE\n");
|
||
}
|
||
|
||
if (Header.Flags & WNODE_FLAG_ANSI_INSTANCENAMES)
|
||
{
|
||
printf("WNODE_FLAG_ANSI_INSTANCENAMES\n");
|
||
}
|
||
|
||
if (Header.Flags & WNODE_FLAG_METHOD_ITEM)
|
||
{
|
||
printf("WNODE_FLAG_METHOD_ITEM\n");
|
||
}
|
||
|
||
if (Header.Flags & WNODE_FLAG_PDO_INSTANCE_NAMES)
|
||
{
|
||
printf("WNODE_FLAG_PDO_INSTANCE_NAMES\n");
|
||
}
|
||
|
||
|
||
printf("\n");
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
//+----------------------------------------------------------
|
||
//
|
||
// Function: PrintAllData
|
||
//
|
||
// Descrip: Prints a WNODE_ALL_DATA structure.
|
||
//
|
||
// Returns: VOID
|
||
//
|
||
// Notes: None
|
||
//
|
||
// History: 04/08/97 drewm Created
|
||
//-----------------------------------------------------------
|
||
VOID
|
||
PrintAllData(
|
||
IN PWNODE_ALL_DATA Wnode
|
||
)
|
||
{
|
||
DWORD dwInstanceNum;
|
||
DWORD dwByteCount;
|
||
DWORD dwFlags;
|
||
DWORD dwStructureNum = 1;
|
||
DWORD dwTemp;
|
||
DWORD dwInstanceSize;
|
||
LPDWORD lpdwNameOffsets;
|
||
PBYTE lpbyteData;
|
||
BOOL bFixedSize = FALSE;
|
||
USHORT usNameLength;
|
||
WCHAR lpNameW[MAX_NAME_LENGTH];
|
||
CHAR lpName[MAX_NAME_LENGTH];
|
||
|
||
|
||
|
||
|
||
printf("\n\n");
|
||
|
||
do{
|
||
printf("\n\nPrinting WNODE_ALL_DATA structure %d.\n", dwStructureNum++);
|
||
PrintHeader(Wnode->WnodeHeader);
|
||
|
||
|
||
dwFlags = Wnode->WnodeHeader.Flags;
|
||
if ( ! (dwFlags & WNODE_FLAG_ALL_DATA)) {
|
||
printf("Not a WNODE_ALL_DATA structure\n");
|
||
return;
|
||
}
|
||
|
||
// Check for fixed instance size
|
||
//
|
||
if ( dwFlags & WNODE_FLAG_FIXED_INSTANCE_SIZE )
|
||
{
|
||
dwInstanceSize = Wnode->FixedInstanceSize;
|
||
bFixedSize = TRUE;
|
||
lpbyteData = OffsetToPtr((PBYTE)Wnode, Wnode->DataBlockOffset);
|
||
printf("Fixed size: 0x%x\n", dwInstanceSize);
|
||
}
|
||
|
||
|
||
// Get a pointer to the array of offsets to the instance names
|
||
//
|
||
lpdwNameOffsets = (LPDWORD) OffsetToPtr(Wnode, Wnode->OffsetInstanceNameOffsets);
|
||
|
||
|
||
// Print out each instance name and data. The name will always be
|
||
// in UNICODE so it needs to be translated to ASCII before it can be
|
||
// printed out.
|
||
//
|
||
for ( dwInstanceNum = 0; dwInstanceNum < Wnode->InstanceCount; dwInstanceNum++)
|
||
{
|
||
printf("Instance %d\n", 1 + dwInstanceNum);
|
||
PrintCountedString( (LPTSTR)
|
||
OffsetToPtr( Wnode,
|
||
lpdwNameOffsets[dwInstanceNum]) );
|
||
|
||
// Length and offset for variable data
|
||
//
|
||
if ( !bFixedSize)
|
||
{
|
||
dwInstanceSize = Wnode->OffsetInstanceDataAndLength[dwInstanceNum].
|
||
LengthInstanceData;
|
||
printf("Data size 0x%x\n", dwInstanceSize);
|
||
lpbyteData = (PBYTE) OffsetToPtr(
|
||
(PBYTE)Wnode,
|
||
Wnode->OffsetInstanceDataAndLength[dwInstanceNum].
|
||
OffsetInstanceData);
|
||
}
|
||
|
||
printf("Data:");
|
||
|
||
for ( dwByteCount = 0; dwByteCount < dwInstanceSize;)
|
||
{
|
||
|
||
// Print data in groups of DWORDS but allow for single bytes.
|
||
//
|
||
if ( (dwByteCount % 16) == 0)
|
||
{
|
||
printf("\n");
|
||
}
|
||
|
||
if ( (dwByteCount % 4) == 0)
|
||
{
|
||
printf(" 0x");
|
||
}
|
||
|
||
dwTemp = *((LPDWORD)lpbyteData);
|
||
printf("%08x", dwTemp );
|
||
lpbyteData += sizeof(DWORD);
|
||
dwByteCount += sizeof(DWORD);
|
||
|
||
} // for cByteCount
|
||
|
||
printf("\n\n");
|
||
|
||
} // for cInstanceNum
|
||
|
||
|
||
// Update Wnode to point to next node
|
||
//
|
||
if ( Wnode->WnodeHeader.Linkage != 0)
|
||
{
|
||
Wnode = (PWNODE_ALL_DATA) OffsetToPtr( Wnode, Wnode->WnodeHeader.Linkage);
|
||
}
|
||
else
|
||
{
|
||
Wnode = 0;
|
||
}
|
||
|
||
}while(Wnode != 0);
|
||
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
//+----------------------------------------------------------
|
||
//
|
||
// Function: PrintSingleInstance
|
||
//
|
||
// Descrip: Prints a WNODE_SINGLE_INSTANCE structure.
|
||
//
|
||
// Returns: VOID
|
||
//
|
||
// Notes: None
|
||
//
|
||
// History: 04/08/97 drewm Created
|
||
//-----------------------------------------------------------
|
||
VOID PrintSingleInstance(
|
||
IN PWNODE_SINGLE_INSTANCE Wnode
|
||
)
|
||
{
|
||
DWORD dwByteCount;
|
||
DWORD dwFlags;
|
||
LPDWORD lpdwData;
|
||
USHORT usNameLength;
|
||
WCHAR lpNameW[MAX_NAME_LENGTH];
|
||
CHAR lpName[MAX_NAME_LENGTH];
|
||
|
||
dwFlags = Wnode->WnodeHeader.Flags;
|
||
|
||
|
||
if ( ! (dwFlags & WNODE_FLAG_SINGLE_INSTANCE))
|
||
{
|
||
printf("Not a WNODE_SINGLE_INSTANCE structure\n");
|
||
return;
|
||
}
|
||
|
||
printf("\nPrinting WNODE_SINGLE_INSTANCE.\n");
|
||
PrintHeader(Wnode->WnodeHeader);
|
||
|
||
|
||
|
||
// Print name or index number
|
||
//
|
||
if ( dwFlags & WNODE_FLAG_STATIC_INSTANCE_NAMES )
|
||
{
|
||
printf("Instance index: %d\n", Wnode->InstanceIndex);
|
||
}
|
||
usNameLength = * (USHORT *) OffsetToPtr(Wnode, Wnode->OffsetInstanceName);
|
||
printf("Name length 0x%x\n", usNameLength);
|
||
usNameLength /= 2;
|
||
PrintCountedString( (LPTSTR) OffsetToPtr( Wnode,
|
||
Wnode->OffsetInstanceName) );
|
||
|
||
|
||
// wcscpy(lpNameW, (LPWSTR) (OffsetToPtr(Wnode, Wnode->OffsetInstanceName )
|
||
// + sizeof(USHORT)));
|
||
// wcsncpy( lpNameW + usNameLength, L" ", 2);
|
||
// wcstombs( lpName, lpNameW, 300);
|
||
// printf("%s\n", lpName);
|
||
|
||
|
||
|
||
// Print out the Data
|
||
//
|
||
printf("Data:\n");
|
||
printf("Data Size: 0x%x\n", Wnode->SizeDataBlock);
|
||
lpdwData = (PULONG) OffsetToPtr(Wnode, Wnode->DataBlockOffset);
|
||
|
||
for ( dwByteCount = 0; dwByteCount < Wnode->SizeDataBlock; dwByteCount+= sizeof(ULONG))
|
||
{
|
||
if ( (dwByteCount % 16) == 0)
|
||
{
|
||
printf("\n");
|
||
}
|
||
|
||
printf("0x%08x ", *lpdwData );
|
||
lpdwData++;
|
||
|
||
}
|
||
|
||
|
||
printf("\n");
|
||
|
||
|
||
} // PrintSingleInstance
|
||
|
||
VOID
|
||
PrintCountedString(
|
||
LPTSTR lpString
|
||
)
|
||
{
|
||
SHORT usNameLength;
|
||
LPTSTR lpStringPlusNull;
|
||
|
||
usNameLength = * (USHORT *) lpString;
|
||
|
||
lpStringPlusNull = (LPTSTR) malloc ( usNameLength + sizeof(TCHAR) );
|
||
if (lpStringPlusNull != NULL)
|
||
{
|
||
lpString = (LPTSTR) ((PBYTE)lpString + sizeof(USHORT));
|
||
if (MyIsTextUnicode(lpString))
|
||
{
|
||
usNameLength /= 2;
|
||
}
|
||
_tcsncpy( lpStringPlusNull, lpString, usNameLength );
|
||
|
||
_tcscpy( lpStringPlusNull + usNameLength, __T("") );
|
||
_tprintf(__T("%s\n"), lpStringPlusNull);
|
||
|
||
free(lpStringPlusNull);
|
||
}
|
||
|
||
}
|
||
|
||
|
||
|
||
|