able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/wmi/enumguid/print.c

712 lines
15 KiB
C
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
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);
}
}

Reference in a new issue Copy permalink