mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
712 lines
15 KiB
712 lines
15 KiB
/*++
|
|
|
|
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);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|