2361 lines
67 KiB
C
2361 lines
67 KiB
C
/*++
|
|
|
|
Copyright (c) 1997-1999 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
dcapi.c
|
|
|
|
Abstract:
|
|
|
|
WMI data consumer api set
|
|
|
|
Author:
|
|
|
|
16-Jan-1997 AlanWar
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "wmiump.h"
|
|
|
|
#ifndef MEMPHIS
|
|
#include <aclapi.h>
|
|
#endif
|
|
|
|
ULONG
|
|
WMIAPI
|
|
WmiOpenBlock(
|
|
IN GUID *DataBlockGuid,
|
|
IN ULONG DesiredAccess,
|
|
OUT WMIHANDLE *DataBlockHandle
|
|
)
|
|
/*+++
|
|
|
|
Routine Description:
|
|
|
|
This routine prepares for accessing data items contained within the data
|
|
block represented by the guid passed. If successful it returns a handle
|
|
that can be used to query and set data blocks maintained by data providers
|
|
that have registered the guid. Any data providers that had registered the
|
|
guid as expensive will receive a request to enable collection of data for
|
|
the guid if collection was not previously enabled.
|
|
|
|
Arguments:
|
|
|
|
DataBlockGuid - Pointer to guid that represents the data block
|
|
|
|
DesiredAccess - Specifies the type of access to the object. Not used on
|
|
Windows 98
|
|
|
|
*DataBlockHandle - If successful returns a handle to the data block
|
|
|
|
Return Value:
|
|
|
|
Returns ERROR_SUCCESS or an error code.
|
|
|
|
---*/
|
|
{
|
|
ULONG Status;
|
|
HANDLE KernelHandle;
|
|
GUID Guid;
|
|
ULONG Ioctl;
|
|
|
|
WmipInitProcessHeap();
|
|
|
|
//
|
|
// Validate the passed parameters
|
|
//
|
|
if ((DataBlockGuid == NULL) ||
|
|
(DataBlockHandle == NULL))
|
|
{
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return(ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
if ((DesiredAccess & WMIGUID_NOTIFICATION) &&
|
|
((DesiredAccess & (WMIGUID_QUERY | WMIGUID_SET | WMIGUID_EXECUTE)) != 0))
|
|
{
|
|
//
|
|
// If you want to open the guid for notifications then it cannot
|
|
// be opened for query and set operations
|
|
//
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return(ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
try
|
|
{
|
|
*DataBlockHandle = NULL;
|
|
Guid = *DataBlockGuid;
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return(ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
if (DesiredAccess == 0)
|
|
{
|
|
DesiredAccess = ( WMIGUID_QUERY | WMIGUID_SET | WMIGUID_EXECUTE );
|
|
}
|
|
|
|
//
|
|
// Obtain a handle for the guid only if it is registered
|
|
//
|
|
if (DesiredAccess & WMIGUID_NOTIFICATION)
|
|
{
|
|
//
|
|
// Opening a handle strictly for notifications
|
|
//
|
|
Ioctl = IOCTL_WMI_OPEN_GUID_FOR_EVENTS;
|
|
} else {
|
|
//
|
|
// Otherwise we assume that opening for query/set
|
|
//
|
|
Ioctl = IOCTL_WMI_OPEN_GUID_FOR_QUERYSET;
|
|
}
|
|
Status = WmipOpenKernelGuid(&Guid,
|
|
DesiredAccess,
|
|
&KernelHandle,
|
|
Ioctl);
|
|
|
|
if (Status == ERROR_SUCCESS)
|
|
{
|
|
//
|
|
// if we were able to open the guid then try to return the handle
|
|
//
|
|
try
|
|
{
|
|
*DataBlockHandle = KernelHandle;
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
CloseHandle(KernelHandle);
|
|
Status = ERROR_INVALID_PARAMETER;
|
|
}
|
|
}
|
|
|
|
SetLastError(Status);
|
|
return(Status);
|
|
}
|
|
|
|
ULONG
|
|
WMIAPI
|
|
WmiCloseBlock(
|
|
IN WMIHANDLE DataBlockHandle
|
|
)
|
|
/*+++
|
|
|
|
Routine Description:
|
|
|
|
This routine terminates all access to the data block managed by the
|
|
data block handle passed and free any resources associated with it. Any
|
|
data providers that were providing data blocks for this handle and were
|
|
marked as expensive to collect will receive a collection disable request
|
|
if this is the last handle to the data block to close.
|
|
|
|
Arguments:
|
|
|
|
DataBlockHandle - Handle of data block to which access is closed
|
|
|
|
Return Value:
|
|
|
|
Returns ERROR_SUCCESS or an error code.
|
|
|
|
---*/
|
|
{
|
|
ULONG Status;
|
|
BOOL Ok;
|
|
|
|
WmipInitProcessHeap();
|
|
|
|
try
|
|
{
|
|
Ok = CloseHandle(DataBlockHandle);
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
//
|
|
// We may get an invalid handle exception and if so we catch it here
|
|
// and just return an error
|
|
//
|
|
return(ERROR_INVALID_HANDLE);
|
|
}
|
|
|
|
if (Ok)
|
|
{
|
|
Status = ERROR_SUCCESS;
|
|
} else {
|
|
Status = GetLastError();
|
|
}
|
|
return(Status);
|
|
}
|
|
|
|
ULONG
|
|
WMIAPI
|
|
WmiQueryAllDataA(
|
|
IN WMIHANDLE DataBlockHandle,
|
|
IN OUT ULONG *BufferSize,
|
|
OUT LPVOID Buffer
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
ANSI thunk to WMIQueryAllDataW
|
|
|
|
NOTE: This api will not translate any unicode strings in the data block
|
|
from unicode to ANSI, but will translate the InstanceName string.
|
|
--*/
|
|
{
|
|
ULONG Status;
|
|
|
|
Status = WmiQueryAllDataW(DataBlockHandle,
|
|
BufferSize,
|
|
Buffer);
|
|
|
|
if (Status == ERROR_SUCCESS)
|
|
{
|
|
Status = WmipConvertWADToAnsi((PWNODE_ALL_DATA)Buffer);
|
|
}
|
|
|
|
return(Status);
|
|
}
|
|
|
|
|
|
ULONG
|
|
WMIAPI
|
|
WmiQueryAllDataW(
|
|
IN WMIHANDLE DataBlockHandle,
|
|
IN OUT ULONG *InOutBufferSize,
|
|
OUT LPVOID OutBuffer
|
|
)
|
|
/*+++
|
|
|
|
Routine Description:
|
|
|
|
This routine allows a data consumer to query for all data items of
|
|
all instances of a data block. WMI will call all data providers that
|
|
registered for the guid represented by DataBlockHandle with a query all
|
|
data request. Each data provider will fill a WNODE_ALL_DATA with all
|
|
of its instances of the data block. WMI will link each of the
|
|
WNODE_ALL_DATA structures by placing the offset from the current
|
|
WNODE_ALL_DATA struccture to the next WNODE_ALL_DATA in the Linkage
|
|
field in the WNODE_HEADER. A value of 0 in the Linkage field indicates
|
|
that the WNODE_ALL_DATA is the last in the chain.
|
|
|
|
|
|
Arguments:
|
|
|
|
DataBlockHandle - Handle to data block being queried
|
|
|
|
*InOutBufferSize - on entry has the maximum size available in Buffer.
|
|
If ERROR_BUFFER_TOO_SMALL is returned then returns the size
|
|
of buffer needed to return data. The minimum valid buffer
|
|
size that can be passed is sizeof(WNODE_TOO_SMALL).
|
|
|
|
OutBuffer - If ERROR_SUCCESS is returned then the buffer contains a
|
|
WNODE_ALL_DATA for the data block.
|
|
|
|
Return Value:
|
|
|
|
Returns ERROR_SUCCESS or an error code.
|
|
|
|
---*/
|
|
{
|
|
ULONG SizeNeeded;
|
|
PWNODE_HEADER Wnode;
|
|
WNODE_ALL_DATA WnodeAllData;
|
|
PWNODE_TOO_SMALL WnodeTooSmall = (PWNODE_TOO_SMALL)&WnodeAllData;
|
|
ULONG Status;
|
|
LPVOID Buffer;
|
|
ULONG RetSize;
|
|
ULONG BufferSize;
|
|
LPVOID BufferAllocated;
|
|
|
|
WmipInitProcessHeap();
|
|
|
|
//
|
|
// Validate passed Parameters
|
|
//
|
|
try
|
|
{
|
|
BufferSize = *InOutBufferSize;
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return(ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
if (BufferSize >= 0x80000000)
|
|
{
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return(ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
//
|
|
// If Buffer is not specified or is too small then we can only return
|
|
// the size needed.
|
|
//
|
|
if ((OutBuffer == NULL) || (BufferSize < sizeof(WNODE_ALL_DATA)))
|
|
{
|
|
Buffer = (LPVOID)WnodeTooSmall;
|
|
BufferSize = sizeof(WNODE_ALL_DATA);
|
|
BufferAllocated = NULL;
|
|
} else {
|
|
Buffer = WmipAlloc(BufferSize);
|
|
if (Buffer == NULL)
|
|
{
|
|
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
|
|
return(ERROR_NOT_ENOUGH_MEMORY);
|
|
}
|
|
BufferAllocated = Buffer;
|
|
}
|
|
|
|
//
|
|
// Build the wnode and pass down to KM for execution
|
|
//
|
|
Wnode = (PWNODE_HEADER)Buffer;
|
|
WmipBuildWnodeHeader(Wnode,
|
|
sizeof(WNODE_HEADER),
|
|
WNODE_FLAG_ALL_DATA,
|
|
DataBlockHandle);
|
|
|
|
Status = WmipSendWmiRequest(
|
|
WMI_GET_ALL_DATA,
|
|
Wnode,
|
|
sizeof(WNODE_HEADER),
|
|
Wnode,
|
|
BufferSize,
|
|
&RetSize);
|
|
|
|
if ((Status == ERROR_SUCCESS) &&
|
|
( (RetSize < sizeof(WNODE_HEADER)) ||
|
|
(RetSize < Wnode->BufferSize)))
|
|
{
|
|
//
|
|
// If we return success, but the output size is incorrect then we
|
|
// flag an error. If this occurs then it indicates some problem
|
|
// in the WMI KM code.
|
|
//
|
|
WmipAssert(FALSE);
|
|
Status = ERROR_WMI_DP_FAILED;
|
|
}
|
|
|
|
if (Status == ERROR_SUCCESS)
|
|
{
|
|
if (Wnode->Flags & WNODE_FLAG_INTERNAL)
|
|
{
|
|
//
|
|
// If this is an internal guid, try the call internally
|
|
//
|
|
Wnode->Flags &= ~WNODE_FLAG_INTERNAL;
|
|
Status = WmipInternalProvider(WmiGetAllData,
|
|
Wnode,
|
|
BufferSize,
|
|
Wnode,
|
|
&RetSize);
|
|
|
|
if (Status != ERROR_SUCCESS)
|
|
{
|
|
goto done;
|
|
}
|
|
}
|
|
|
|
if (Wnode->Flags & WNODE_FLAG_TOO_SMALL)
|
|
{
|
|
//
|
|
// There is not enough room to complete the query so we
|
|
// remember how much the data provider needs and then add
|
|
// in how much WMI needs for the instance names.
|
|
|
|
SizeNeeded = ((PWNODE_TOO_SMALL)Wnode)->SizeNeeded;
|
|
Status = ERROR_INSUFFICIENT_BUFFER;
|
|
} else {
|
|
//
|
|
// We had enough room so report the size we used
|
|
//
|
|
SizeNeeded = RetSize;
|
|
|
|
if (Wnode == (PWNODE_HEADER)WnodeTooSmall)
|
|
{
|
|
Status = ERROR_INSUFFICIENT_BUFFER;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Copy back into the caller's buffer the BufferSize and the Buffer
|
|
//
|
|
try
|
|
{
|
|
*InOutBufferSize = SizeNeeded;
|
|
if ((Status == ERROR_SUCCESS) &&
|
|
(Wnode != (PWNODE_HEADER)WnodeTooSmall))
|
|
{
|
|
memcpy(OutBuffer, Buffer, SizeNeeded);
|
|
Status = ERROR_SUCCESS;
|
|
}
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
Status = ERROR_INVALID_PARAMETER;
|
|
}
|
|
}
|
|
|
|
done:
|
|
if (BufferAllocated != NULL)
|
|
{
|
|
WmipFree(BufferAllocated);
|
|
}
|
|
|
|
SetLastError(Status);
|
|
return(Status);
|
|
}
|
|
|
|
ULONG
|
|
WMIAPI
|
|
WmiQueryAllDataMultipleA(
|
|
IN WMIHANDLE *HandleList,
|
|
IN ULONG HandleCount,
|
|
IN OUT ULONG *InOutBufferSize,
|
|
OUT LPVOID OutBuffer
|
|
)
|
|
{
|
|
ULONG Status;
|
|
|
|
WmipInitProcessHeap();
|
|
|
|
Status = WmiQueryAllDataMultipleW(HandleList,
|
|
HandleCount,
|
|
InOutBufferSize,
|
|
OutBuffer);
|
|
|
|
if ((Status == ERROR_SUCCESS) && (*InOutBufferSize > 0))
|
|
{
|
|
Status = WmipConvertWADToAnsi((PWNODE_ALL_DATA)OutBuffer);
|
|
}
|
|
|
|
return(Status);
|
|
}
|
|
|
|
ULONG
|
|
WMIAPI
|
|
WmiQueryAllDataMultipleW(
|
|
IN WMIHANDLE *HandleList,
|
|
IN ULONG HandleCount,
|
|
IN OUT ULONG *InOutBufferSize,
|
|
OUT LPVOID OutBuffer
|
|
)
|
|
{
|
|
PWMIQADMULTIPLE QadMultiple;
|
|
ULONG RetSize;
|
|
ULONG QadMultipleSize;
|
|
ULONG i;
|
|
ULONG OutBufferSize;
|
|
ULONG Status;
|
|
WNODE_TOO_SMALL WnodeTooSmall;
|
|
PWNODE_HEADER Wnode;
|
|
|
|
WmipInitProcessHeap();
|
|
|
|
if ((HandleCount != 0) && (HandleCount < QUERYMULIPLEHANDLELIMIT))
|
|
{
|
|
QadMultipleSize = sizeof(WMIQADMULTIPLE) +
|
|
((HandleCount-1) * sizeof(HANDLE3264));
|
|
|
|
QadMultiple = WmipAlloc(QadMultipleSize);
|
|
if (QadMultiple != NULL)
|
|
{
|
|
QadMultiple->HandleCount = HandleCount;
|
|
try
|
|
{
|
|
for (i = 0; i < HandleCount; i++)
|
|
{
|
|
WmipSetHandle3264(QadMultiple->Handles[i], HandleList[i]);
|
|
}
|
|
OutBufferSize = *InOutBufferSize;
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
WmipFree(QadMultiple);
|
|
SetLastError(ERROR_NOACCESS);
|
|
return(ERROR_NOACCESS);
|
|
}
|
|
|
|
if (OutBufferSize < sizeof(WNODE_ALL_DATA))
|
|
{
|
|
Wnode = (PWNODE_HEADER)&WnodeTooSmall;
|
|
OutBufferSize = sizeof(WNODE_TOO_SMALL);
|
|
} else {
|
|
Wnode = (PWNODE_HEADER)OutBuffer;
|
|
}
|
|
|
|
Status = WmipSendWmiKMRequest(NULL,
|
|
IOCTL_WMI_QAD_MULTIPLE,
|
|
QadMultiple,
|
|
QadMultipleSize,
|
|
Wnode,
|
|
OutBufferSize,
|
|
&RetSize,
|
|
NULL);
|
|
|
|
WmipFree(QadMultiple);
|
|
|
|
if (Status == ERROR_SUCCESS)
|
|
{
|
|
if (Wnode->Flags & WNODE_FLAG_TOO_SMALL)
|
|
{
|
|
RetSize = ((PWNODE_TOO_SMALL)(Wnode))->SizeNeeded;
|
|
Status = ERROR_INSUFFICIENT_BUFFER;
|
|
} else if (Wnode == (PWNODE_HEADER)&WnodeTooSmall) {
|
|
Status = ERROR_INSUFFICIENT_BUFFER;
|
|
}
|
|
|
|
try
|
|
{
|
|
*InOutBufferSize = RetSize;
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
Status = ERROR_NOACCESS;
|
|
}
|
|
}
|
|
} else {
|
|
Status = ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
} else {
|
|
Status = ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
SetLastError(Status);
|
|
return(Status);
|
|
}
|
|
|
|
ULONG
|
|
WMIAPI
|
|
WmiQuerySingleInstanceA(
|
|
IN WMIHANDLE DataBlockHandle,
|
|
IN LPCSTR InstanceName,
|
|
IN OUT ULONG *BufferSize,
|
|
OUT LPVOID Buffer
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
ANSI thunk to WMIQuerySingleInstanceW
|
|
|
|
NOTE: This api will not translate any unicode strings in the data block
|
|
from unicode to ANSI, but will translate the InstanceName string.
|
|
--*/
|
|
{
|
|
LPWSTR InstanceNameUnicode;
|
|
ULONG Status;
|
|
PWNODE_SINGLE_INSTANCE Wnode;
|
|
PWCHAR Ptr;
|
|
|
|
WmipInitProcessHeap();
|
|
|
|
InstanceNameUnicode = NULL;
|
|
Status = AnsiToUnicode(InstanceName, &InstanceNameUnicode);
|
|
if (Status == ERROR_SUCCESS)
|
|
{
|
|
Status = WmiQuerySingleInstanceW(DataBlockHandle,
|
|
InstanceNameUnicode,
|
|
BufferSize,
|
|
Buffer);
|
|
|
|
if (Status == ERROR_SUCCESS)
|
|
{
|
|
//
|
|
// Convert Instance name from unicode back to ANSI. We assume
|
|
// that the ansi size will never be larger than the unicode size
|
|
// so we can convert in place.
|
|
Wnode = (PWNODE_SINGLE_INSTANCE)Buffer;
|
|
Ptr = (PWCHAR)(((PUCHAR)Buffer) + Wnode->OffsetInstanceName);
|
|
Status = WmipCountedUnicodeToCountedAnsi(Ptr, (PCHAR)Ptr);
|
|
if (Status != ERROR_SUCCESS)
|
|
{
|
|
SetLastError(Status);
|
|
} else {
|
|
Wnode->WnodeHeader.Flags |= WNODE_FLAG_ANSI_INSTANCENAMES;
|
|
}
|
|
}
|
|
|
|
if (InstanceNameUnicode != NULL)
|
|
{
|
|
WmipFree(InstanceNameUnicode);
|
|
}
|
|
}
|
|
return(Status);
|
|
}
|
|
|
|
ULONG
|
|
WMIAPI
|
|
WmiQuerySingleInstanceW(
|
|
IN WMIHANDLE DataBlockHandle,
|
|
IN LPCWSTR InstanceName,
|
|
IN OUT ULONG *InOutBufferSize,
|
|
OUT LPVOID OutBuffer
|
|
)
|
|
/*+++
|
|
|
|
Routine Description:
|
|
|
|
This routine will query a single data provider for the values of a single
|
|
instance of the data block represented by the DataBlockHandle. WMI will
|
|
determine the appropriate data provider to which to send a query single
|
|
instance request and if successful return a WNODE_SINGLE_INSTANCE to
|
|
the caller.
|
|
|
|
Arguments:
|
|
|
|
DataBlockHandle - Handle to data block to query
|
|
|
|
InstanceName - name of the instance for which data is being queried
|
|
|
|
*BufferSize - on entry has the maximum size available in pBuffer. If
|
|
ERROR_BUFFER_TOO_SMALL is returned then returns the size of
|
|
buffer needed to return data. The minimum valid buffer
|
|
size that can be passed is sizeof(WNODE_TOO_SMALL).
|
|
|
|
Buffer - If ERROR_SUCCESS is returned then the buffer contains a
|
|
WNODE_SINGLE_ITEM for the data block.
|
|
|
|
Return Value:
|
|
|
|
Returns ERROR_SUCCESS or an error code.
|
|
|
|
---*/
|
|
{
|
|
PWNODE_SINGLE_INSTANCE Wnode;
|
|
ULONG Status, ReturnStatus;
|
|
PWCHAR WnodePtr;
|
|
ULONG BufferNeeded;
|
|
ULONG BufferSize;
|
|
LPVOID Buffer;
|
|
ULONG RetSize;
|
|
ULONG InstanceNameLen;
|
|
|
|
WmipInitProcessHeap();
|
|
|
|
//
|
|
// Validate input parameters
|
|
//
|
|
if ((InstanceName == NULL) ||
|
|
(InOutBufferSize == NULL))
|
|
{
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return(ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
//
|
|
// Calculate the size of the buffer needed to build the WNODE to send
|
|
// to the driver. We add up the WNODE_SINGLE_INSTANCE header, the
|
|
// instance name length and text and pad it out to an 8 byte boundry
|
|
//
|
|
try
|
|
{
|
|
InstanceNameLen = wcslen(InstanceName) * sizeof(WCHAR);
|
|
BufferSize = *InOutBufferSize;
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return(ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
//
|
|
// Make sure we have a resonable buffer size
|
|
//
|
|
if (BufferSize >= 0x80000000)
|
|
{
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return(ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
BufferNeeded = (FIELD_OFFSET(WNODE_SINGLE_INSTANCE,
|
|
VariableData) +
|
|
InstanceNameLen +
|
|
sizeof(USHORT) + 7) & ~7;
|
|
|
|
//
|
|
// if user passed a NULL buffer or one that is smaller than the
|
|
// size needed to hold the WNODE then we allocate a small buffer on
|
|
// its behalf and call to obtain the size needed.
|
|
if ((OutBuffer == NULL) ||
|
|
(BufferSize < BufferNeeded))
|
|
{
|
|
BufferSize = BufferNeeded;
|
|
}
|
|
|
|
Buffer = WmipAlloc(BufferSize);
|
|
if (Buffer == NULL)
|
|
{
|
|
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
|
|
return(ERROR_NOT_ENOUGH_MEMORY);
|
|
}
|
|
|
|
//
|
|
// Build WNODE we want to send to the DP
|
|
//
|
|
Wnode = (PWNODE_SINGLE_INSTANCE)Buffer;
|
|
memset(Wnode, 0, FIELD_OFFSET(WNODE_SINGLE_INSTANCE,
|
|
VariableData));
|
|
WmipBuildWnodeHeader(&Wnode->WnodeHeader,
|
|
BufferNeeded,
|
|
WNODE_FLAG_SINGLE_INSTANCE,
|
|
DataBlockHandle);
|
|
|
|
Wnode->OffsetInstanceName = FIELD_OFFSET(WNODE_SINGLE_INSTANCE,
|
|
VariableData);
|
|
Wnode->DataBlockOffset = BufferNeeded;
|
|
|
|
//
|
|
// Copy InstanceName into the WnodeSingleInstance for the query.
|
|
//
|
|
WnodePtr = (PWCHAR)OffsetToPtr(Wnode, Wnode->OffsetInstanceName);
|
|
*WnodePtr++ = (USHORT)InstanceNameLen;
|
|
try
|
|
{
|
|
memcpy(WnodePtr, InstanceName, InstanceNameLen);
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
WmipFree(Buffer);
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return(ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
Status = WmipSendWmiRequest(
|
|
WMI_GET_SINGLE_INSTANCE,
|
|
(PWNODE_HEADER)Wnode,
|
|
BufferNeeded,
|
|
Wnode,
|
|
BufferSize,
|
|
&RetSize);
|
|
|
|
if (Status == ERROR_SUCCESS)
|
|
{
|
|
//
|
|
// Successful return, we either have success or a buffer too small
|
|
//
|
|
if ((RetSize < sizeof(WNODE_HEADER) ||
|
|
((RetSize >= sizeof(ULONG)) &&
|
|
(RetSize < Wnode->WnodeHeader.BufferSize))))
|
|
{
|
|
//
|
|
// if we get an incosistent WNODE back this may indicate a
|
|
// problem with the WMI KM code
|
|
//
|
|
Status = ERROR_WMI_DP_FAILED;
|
|
WmipAssert(FALSE);
|
|
} else {
|
|
if (Wnode->WnodeHeader.Flags & WNODE_FLAG_INTERNAL)
|
|
{
|
|
//
|
|
// If this is an internal guid, try the call internally
|
|
//
|
|
Wnode->WnodeHeader.Flags &= ~WNODE_FLAG_INTERNAL;
|
|
Wnode->WnodeHeader.BufferSize = BufferNeeded;
|
|
Status = WmipInternalProvider( WmiGetSingleInstance,
|
|
(PWNODE_HEADER)Wnode,
|
|
BufferSize,
|
|
Wnode,
|
|
&RetSize);
|
|
|
|
if (Status != ERROR_SUCCESS)
|
|
{
|
|
goto done;
|
|
}
|
|
}
|
|
|
|
if (Wnode->WnodeHeader.Flags & WNODE_FLAG_TOO_SMALL)
|
|
{
|
|
//
|
|
// Our buffer was too small so try to return the size needed
|
|
//
|
|
Status = ERROR_INSUFFICIENT_BUFFER;
|
|
try
|
|
{
|
|
*InOutBufferSize = ((PWNODE_TOO_SMALL)Wnode)->SizeNeeded;
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
Status = ERROR_INVALID_PARAMETER;
|
|
}
|
|
} else {
|
|
//
|
|
// We have a result from our query so we just copy back
|
|
// the results.
|
|
//
|
|
try
|
|
{
|
|
if (*InOutBufferSize >= RetSize)
|
|
{
|
|
memcpy(OutBuffer, Wnode, RetSize);
|
|
} else {
|
|
Status = ERROR_INSUFFICIENT_BUFFER;
|
|
}
|
|
*InOutBufferSize = RetSize;
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
Status = ERROR_INVALID_PARAMETER;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
done:
|
|
WmipFree(Buffer);
|
|
|
|
SetLastError(Status);
|
|
return(Status);
|
|
}
|
|
|
|
ULONG
|
|
WMIAPI
|
|
WmiQuerySingleInstanceMultipleW(
|
|
IN WMIHANDLE *HandleList,
|
|
IN LPCWSTR *InstanceNames,
|
|
IN ULONG HandleCount,
|
|
IN OUT ULONG *InOutBufferSize,
|
|
OUT LPVOID OutBuffer
|
|
)
|
|
{
|
|
ULONG Status;
|
|
WNODE_TOO_SMALL WnodeTooSmall;
|
|
ULONG i;
|
|
ULONG OutBufferSize;
|
|
ULONG QsiMultipleSize;
|
|
ULONG Len;
|
|
PWMIQSIMULTIPLE QsiMultiple;
|
|
PWNODE_HEADER Wnode;
|
|
ULONG RetSize;
|
|
HANDLE Handle;
|
|
|
|
WmipInitProcessHeap();
|
|
|
|
if ((HandleCount != 0) && (HandleCount < QUERYMULIPLEHANDLELIMIT))
|
|
{
|
|
QsiMultipleSize = sizeof(WMIQSIMULTIPLE) +
|
|
((HandleCount-1)*sizeof(WMIQSIINFO));
|
|
|
|
QsiMultiple = WmipAlloc(QsiMultipleSize);
|
|
if (QsiMultiple != NULL)
|
|
{
|
|
try
|
|
{
|
|
OutBufferSize = *InOutBufferSize;
|
|
|
|
QsiMultiple->QueryCount = HandleCount;
|
|
for (i = 0; i < HandleCount; i++)
|
|
{
|
|
Handle = HandleList[i];
|
|
|
|
WmipSetHandle3264(QsiMultiple->QsiInfo[i].Handle, Handle);
|
|
#if defined(_WIN64)
|
|
QsiMultiple->QsiInfo[i].InstanceName.Buffer = (PWSTR)InstanceNames[i];
|
|
#else
|
|
QsiMultiple->QsiInfo[i].InstanceName.Dummy = (ULONG64)(IntToPtr(PtrToInt(InstanceNames[i])));
|
|
#endif
|
|
|
|
Len = wcslen(InstanceNames[i]) * sizeof(WCHAR);
|
|
QsiMultiple->QsiInfo[i].InstanceName.Length = (USHORT)Len;
|
|
QsiMultiple->QsiInfo[i].InstanceName.MaximumLength = (USHORT)Len;
|
|
}
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
WmipFree(QsiMultiple);
|
|
SetLastError(ERROR_NOACCESS);
|
|
return(ERROR_NOACCESS);
|
|
}
|
|
|
|
if (OutBufferSize < sizeof(WNODE_TOO_SMALL))
|
|
{
|
|
Wnode = (PWNODE_HEADER)&WnodeTooSmall;
|
|
OutBufferSize = sizeof(WNODE_TOO_SMALL);
|
|
} else {
|
|
Wnode = (PWNODE_HEADER)OutBuffer;
|
|
}
|
|
|
|
Status = WmipSendWmiKMRequest(NULL,
|
|
IOCTL_WMI_QSI_MULTIPLE,
|
|
QsiMultiple,
|
|
QsiMultipleSize,
|
|
Wnode,
|
|
OutBufferSize,
|
|
&RetSize,
|
|
NULL);
|
|
|
|
WmipFree(QsiMultiple);
|
|
|
|
if (Status == ERROR_SUCCESS)
|
|
{
|
|
if (Wnode->Flags & WNODE_FLAG_TOO_SMALL)
|
|
{
|
|
RetSize = ((PWNODE_TOO_SMALL)(Wnode))->SizeNeeded;
|
|
Status = ERROR_INSUFFICIENT_BUFFER;
|
|
}
|
|
|
|
try
|
|
{
|
|
*InOutBufferSize = RetSize;
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
Status = ERROR_NOACCESS;
|
|
}
|
|
}
|
|
} else {
|
|
Status = ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
} else {
|
|
Status = ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
SetLastError(Status);
|
|
return(Status);
|
|
}
|
|
|
|
ULONG
|
|
WMIAPI
|
|
WmiQuerySingleInstanceMultipleA(
|
|
IN WMIHANDLE *HandleList,
|
|
IN LPCSTR *InstanceNames,
|
|
IN ULONG HandleCount,
|
|
IN OUT ULONG *InOutBufferSize,
|
|
OUT LPVOID OutBuffer
|
|
)
|
|
{
|
|
ULONG Status;
|
|
ULONG Linkage;
|
|
PWNODE_SINGLE_INSTANCE Wnode;
|
|
PWCHAR Ptr;
|
|
PWCHAR *UnicodeInstanceNames;
|
|
ULONG UnicodeInstanceNamesSize;
|
|
ULONG i;
|
|
|
|
WmipInitProcessHeap();
|
|
|
|
if ((HandleCount != 0) && (HandleCount < QUERYMULIPLEHANDLELIMIT))
|
|
{
|
|
UnicodeInstanceNamesSize = HandleCount * sizeof(PWCHAR);
|
|
UnicodeInstanceNames = WmipAlloc(UnicodeInstanceNamesSize);
|
|
if (UnicodeInstanceNames != NULL)
|
|
{
|
|
memset(UnicodeInstanceNames, 0, UnicodeInstanceNamesSize);
|
|
for (i = 0; i < HandleCount; i++)
|
|
{
|
|
Status = AnsiToUnicode(InstanceNames[i],
|
|
&UnicodeInstanceNames[i]);
|
|
if (Status != ERROR_SUCCESS)
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
}
|
|
|
|
Status = WmiQuerySingleInstanceMultipleW(HandleList,
|
|
UnicodeInstanceNames,
|
|
HandleCount,
|
|
InOutBufferSize,
|
|
OutBuffer);
|
|
|
|
if ((Status == ERROR_SUCCESS) && (*InOutBufferSize > 0))
|
|
{
|
|
Linkage = 1;
|
|
Wnode = (PWNODE_SINGLE_INSTANCE)OutBuffer;
|
|
while ((Status == ERROR_SUCCESS) && (Linkage != 0))
|
|
{
|
|
Ptr = (PWCHAR)OffsetToPtr(Wnode, Wnode->OffsetInstanceName);
|
|
Status = WmipCountedUnicodeToCountedAnsi(Ptr, (PCHAR)Ptr);
|
|
Linkage = Wnode->WnodeHeader.Linkage;
|
|
Wnode = (PWNODE_SINGLE_INSTANCE)OffsetToPtr(Wnode, Linkage);
|
|
}
|
|
}
|
|
|
|
Cleanup:
|
|
for (i = 0; i < HandleCount; i++)
|
|
{
|
|
if (UnicodeInstanceNames[i] != NULL)
|
|
{
|
|
if (UnicodeInstanceNames[i] != NULL)
|
|
{
|
|
WmipFree(UnicodeInstanceNames[i]);
|
|
}
|
|
}
|
|
}
|
|
WmipFree(UnicodeInstanceNames);
|
|
} else {
|
|
Status = ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
} else {
|
|
Status = ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
SetLastError(Status);
|
|
return(Status);
|
|
}
|
|
|
|
ULONG
|
|
WMIAPI
|
|
WmiSetSingleInstanceA(
|
|
IN WMIHANDLE DataBlockHandle,
|
|
IN LPCSTR InstanceName,
|
|
IN ULONG Version,
|
|
IN ULONG ValueBufferSize,
|
|
IN LPVOID ValueBuffer
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
ANSI thunk to WMISetSingleInstanceW
|
|
|
|
NOTE: This api will not translate any fields in the returned WNODE
|
|
from unicode to ANSI.
|
|
--*/
|
|
{
|
|
ULONG Status;
|
|
LPWSTR InstanceNameUnicode;
|
|
|
|
WmipInitProcessHeap();
|
|
|
|
InstanceNameUnicode = NULL;
|
|
Status = AnsiToUnicode(InstanceName, &InstanceNameUnicode);
|
|
if (Status == ERROR_SUCCESS)
|
|
{
|
|
Status = WmiSetSingleInstanceW(DataBlockHandle,
|
|
InstanceNameUnicode,
|
|
Version,
|
|
ValueBufferSize,
|
|
ValueBuffer);
|
|
if (InstanceNameUnicode != NULL)
|
|
{
|
|
WmipFree(InstanceNameUnicode);
|
|
}
|
|
}
|
|
return(Status);
|
|
}
|
|
|
|
ULONG
|
|
WMIAPI
|
|
WmiSetSingleInstanceW(
|
|
IN WMIHANDLE DataBlockHandle,
|
|
IN LPCWSTR InstanceName,
|
|
IN ULONG Version,
|
|
IN ULONG ValueBufferSize,
|
|
IN LPVOID ValueBuffer
|
|
)
|
|
/*+++
|
|
|
|
Routine Description:
|
|
|
|
This routine will send a set single instance request to the appropriate
|
|
data provider to request changing all data items for a single instances
|
|
of a data block. A data provider is free to silently ignore any change
|
|
requests or only change some data items within an instance.
|
|
|
|
Arguments:
|
|
|
|
DataBlockHandle - Handle to data block
|
|
|
|
InstanceName - name of the instance for which data is being set
|
|
|
|
Version - specifies the version of the data block being passed in
|
|
ValueBuffer
|
|
|
|
ValueBufferSize - on entry has the size of the data block containing the
|
|
new values for the instance of the data block passed in
|
|
ValueBuffer
|
|
|
|
ValueBuffer - passes new values for instance
|
|
|
|
Return Value:
|
|
|
|
Returns ERROR_SUCCESS or an error code.
|
|
|
|
---*/
|
|
{
|
|
PWNODE_SINGLE_INSTANCE Wnode;
|
|
ULONG InstanceNameLen;
|
|
ULONG Status;
|
|
PWCHAR WnodePtr;
|
|
ULONG BufferSize;
|
|
ULONG RetSize;
|
|
|
|
WmipInitProcessHeap();
|
|
|
|
//
|
|
// Validate input parameters
|
|
if ((InstanceName == NULL) ||
|
|
(ValueBuffer == NULL))
|
|
{
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return(ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
try
|
|
{
|
|
InstanceNameLen = wcslen(InstanceName) * sizeof(WCHAR);
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return(ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
//
|
|
// The WNODE_SINGLE_INSTANCE that we need to send to the data provider
|
|
// must be large enough to hold the WNODE, the instance name of the
|
|
// item being set, padding so that the data block is on a 8 byte
|
|
// boundry and space for the new data block.
|
|
BufferSize = FIELD_OFFSET(WNODE_SINGLE_INSTANCE, VariableData) +
|
|
InstanceNameLen + sizeof(USHORT) + ValueBufferSize + 7;
|
|
|
|
Wnode = WmipAlloc(BufferSize);
|
|
if (Wnode == NULL)
|
|
{
|
|
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
|
|
return(ERROR_NOT_ENOUGH_MEMORY);
|
|
}
|
|
|
|
//
|
|
// Build WNODE we want to send to the DP
|
|
//
|
|
memset(Wnode, 0, FIELD_OFFSET(WNODE_SINGLE_INSTANCE, VariableData));
|
|
WmipBuildWnodeHeader(&Wnode->WnodeHeader,
|
|
BufferSize,
|
|
WNODE_FLAG_SINGLE_INSTANCE,
|
|
DataBlockHandle);
|
|
Wnode->WnodeHeader.Version = Version;
|
|
|
|
Wnode->SizeDataBlock = ValueBufferSize;
|
|
Wnode->OffsetInstanceName = FIELD_OFFSET(WNODE_SINGLE_INSTANCE,
|
|
VariableData);
|
|
|
|
WnodePtr = (PWCHAR)OffsetToPtr(Wnode, Wnode->OffsetInstanceName);
|
|
*WnodePtr++ = (USHORT)InstanceNameLen;
|
|
|
|
Wnode->DataBlockOffset = (Wnode->OffsetInstanceName +
|
|
InstanceNameLen + sizeof(USHORT) + 7) & ~7;
|
|
|
|
try
|
|
{
|
|
memcpy(WnodePtr, InstanceName, InstanceNameLen);
|
|
memcpy((PCHAR)Wnode + Wnode->DataBlockOffset,
|
|
ValueBuffer,
|
|
ValueBufferSize);
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
WmipFree(Wnode);
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return(ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
//
|
|
// Send down the set request and reprot the results
|
|
//
|
|
Status = WmipSendWmiRequest(
|
|
WMI_SET_SINGLE_INSTANCE,
|
|
(PWNODE_HEADER)Wnode,
|
|
BufferSize,
|
|
Wnode,
|
|
ValueBufferSize,
|
|
&RetSize);
|
|
WmipFree(Wnode);
|
|
SetLastError(Status);
|
|
return(Status);
|
|
}
|
|
|
|
ULONG
|
|
WMIAPI
|
|
WmiSetSingleItemA(
|
|
IN WMIHANDLE DataBlockHandle,
|
|
IN LPCSTR InstanceName,
|
|
IN ULONG DataItemId,
|
|
IN ULONG Version,
|
|
IN ULONG ValueBufferSize,
|
|
IN LPVOID ValueBuffer
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
ANSI thunk to WMISetSingleItemA
|
|
|
|
NOTE: This api will not translate any fields in the returned WNODE
|
|
from unicode to ANSI.
|
|
--*/
|
|
{
|
|
ULONG Status;
|
|
LPWSTR InstanceNameUnicode;
|
|
|
|
WmipInitProcessHeap();
|
|
|
|
InstanceNameUnicode = NULL;
|
|
Status = AnsiToUnicode(InstanceName, &InstanceNameUnicode);
|
|
if (Status == ERROR_SUCCESS)
|
|
{
|
|
Status = WmiSetSingleItemW(DataBlockHandle,
|
|
InstanceNameUnicode,
|
|
DataItemId,
|
|
Version,
|
|
ValueBufferSize,
|
|
ValueBuffer);
|
|
if (InstanceNameUnicode != NULL)
|
|
{
|
|
WmipFree(InstanceNameUnicode);
|
|
}
|
|
}
|
|
return(Status);
|
|
}
|
|
|
|
ULONG
|
|
WMIAPI
|
|
WmiSetSingleItemW(
|
|
IN WMIHANDLE DataBlockHandle,
|
|
IN LPCWSTR InstanceName,
|
|
IN ULONG DataItemId,
|
|
IN ULONG Version,
|
|
IN ULONG ValueBufferSize,
|
|
IN LPVOID ValueBuffer
|
|
)
|
|
/*+++
|
|
|
|
Routine Description:
|
|
|
|
This routine will send a set single item request to the appropriate data
|
|
provider to request changing a specific data item within a specific
|
|
instance of a data block. A data provider can silently ignore a change
|
|
request.
|
|
|
|
Arguments:
|
|
|
|
DataBlockHandle - Handle to data block
|
|
|
|
InstanceName - name of the instance for which data is being set
|
|
|
|
Version - specifies the version of the data block being passed in
|
|
ValueBuffer
|
|
|
|
DataItemId - Data item id of item to set
|
|
|
|
ValueBufferSize - on entry has the size of the new value for the
|
|
data item which is passed in pBuffer.
|
|
|
|
ValueBuffer - passes new value for data item
|
|
|
|
Return Value:
|
|
|
|
Returns ERROR_SUCCESS or an error code.
|
|
|
|
---*/
|
|
{
|
|
PWNODE_SINGLE_ITEM Wnode;
|
|
ULONG InstanceNameLen;
|
|
ULONG Status;
|
|
PBYTE WnodeBuffer;
|
|
PWCHAR WnodePtr;
|
|
ULONG BufferSize;
|
|
ULONG RetSize;
|
|
|
|
WmipInitProcessHeap();
|
|
|
|
//
|
|
// Validate passed parameters
|
|
//
|
|
if ((InstanceName == NULL) ||
|
|
(ValueBuffer == NULL))
|
|
{
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return(ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
try
|
|
{
|
|
InstanceNameLen = wcslen(InstanceName) * sizeof(WCHAR);
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return(ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
BufferSize = FIELD_OFFSET(WNODE_SINGLE_ITEM, VariableData) +
|
|
InstanceNameLen + sizeof(USHORT) +
|
|
ValueBufferSize + 7;
|
|
|
|
Wnode = WmipAlloc(BufferSize);
|
|
if (Wnode == NULL)
|
|
{
|
|
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
|
|
return(ERROR_NOT_ENOUGH_MEMORY);
|
|
}
|
|
|
|
//
|
|
// Build WNODE we want to send to the DP
|
|
memset(Wnode, 0, FIELD_OFFSET(WNODE_SINGLE_ITEM, VariableData));
|
|
WmipBuildWnodeHeader(&Wnode->WnodeHeader,
|
|
BufferSize,
|
|
WNODE_FLAG_SINGLE_ITEM,
|
|
DataBlockHandle);
|
|
Wnode->WnodeHeader.Version = Version;
|
|
|
|
Wnode->ItemId = DataItemId;
|
|
Wnode->SizeDataItem = ValueBufferSize;
|
|
|
|
Wnode->OffsetInstanceName = FIELD_OFFSET(WNODE_SINGLE_ITEM,VariableData);
|
|
Wnode->DataBlockOffset = (Wnode->OffsetInstanceName +
|
|
InstanceNameLen + sizeof(USHORT) + 7) & ~7;
|
|
|
|
WnodePtr = (PWCHAR)OffsetToPtr(Wnode, Wnode->OffsetInstanceName);
|
|
*WnodePtr++ = (USHORT)InstanceNameLen;
|
|
try
|
|
{
|
|
memcpy(WnodePtr, InstanceName, InstanceNameLen);
|
|
memcpy((PCHAR)Wnode + Wnode->DataBlockOffset,
|
|
ValueBuffer,
|
|
ValueBufferSize);
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
Status = ERROR_INVALID_PARAMETER;
|
|
WmipFree(Wnode);
|
|
SetLastError(Status);
|
|
return(Status);
|
|
}
|
|
|
|
//
|
|
// Send down the request and report the result
|
|
//
|
|
Status = WmipSendWmiRequest(
|
|
WMI_SET_SINGLE_ITEM,
|
|
(PWNODE_HEADER)Wnode,
|
|
BufferSize,
|
|
Wnode,
|
|
ValueBufferSize,
|
|
&RetSize);
|
|
|
|
WmipFree(Wnode);
|
|
|
|
SetLastError(Status);
|
|
return(Status);
|
|
}
|
|
|
|
ULONG
|
|
WMIAPI
|
|
WmiExecuteMethodA(
|
|
IN WMIHANDLE MethodDataBlockHandle,
|
|
IN LPCSTR MethodInstanceName,
|
|
IN ULONG MethodId,
|
|
IN ULONG InputValueBufferSize,
|
|
IN LPVOID InputValueBuffer,
|
|
IN OUT ULONG *OutputBufferSize,
|
|
OUT PVOID OutputBuffer
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
ANSI thunk to WmiExecuteMethodW
|
|
|
|
NOTE: This api will not translate any fields in the returned WNODE
|
|
from unicode to ANSI.
|
|
--*/
|
|
{
|
|
ULONG Status;
|
|
LPWSTR MethodInstanceNameUnicode;
|
|
LPWSTR InputInstanceNameUnicode;
|
|
PWCHAR Ptr;
|
|
|
|
WmipInitProcessHeap();
|
|
|
|
if (MethodInstanceName == NULL)
|
|
{
|
|
return(ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
MethodInstanceNameUnicode = NULL;
|
|
Status = AnsiToUnicode(MethodInstanceName,
|
|
&MethodInstanceNameUnicode);
|
|
if (Status == ERROR_SUCCESS)
|
|
{
|
|
Status = WmiExecuteMethodW(MethodDataBlockHandle,
|
|
MethodInstanceNameUnicode,
|
|
MethodId,
|
|
InputValueBufferSize,
|
|
InputValueBuffer,
|
|
OutputBufferSize,
|
|
OutputBuffer);
|
|
|
|
if (MethodInstanceNameUnicode != NULL)
|
|
{
|
|
WmipFree(MethodInstanceNameUnicode);
|
|
}
|
|
}
|
|
|
|
return(Status);
|
|
}
|
|
|
|
ULONG
|
|
WMIAPI
|
|
WmiExecuteMethodW(
|
|
IN WMIHANDLE MethodDataBlockHandle,
|
|
IN LPCWSTR MethodInstanceName,
|
|
IN ULONG MethodId,
|
|
IN ULONG InputValueBufferSize,
|
|
IN LPVOID InputValueBuffer,
|
|
IN OUT ULONG *OutputBufferSize,
|
|
OUT PVOID OutputBuffer
|
|
)
|
|
/*+++
|
|
|
|
Routine Description:
|
|
|
|
This routine will invoke a method on a WMI data provider. A method is a
|
|
call to have the data provider do something rather than a query or a
|
|
set. A WNODE_SINGLE_INSTANCE is built as the input parameters to a
|
|
method and a WNODE_SINGLE_INSTANCE is returned as output from a method.
|
|
|
|
Arguments:
|
|
|
|
MethodDataBlockHandle - Handle to data block that contains method
|
|
|
|
MethodInstanceName - Name of instance of data block on which the method
|
|
should be executed.
|
|
|
|
MethodId - Id value that specifies which method within the guid to
|
|
execute.
|
|
|
|
InputValueBufferSize - on entry has the size of the data block containing the
|
|
values for the instance of the data block passed in
|
|
ValueBuffer that serves as the input parameters
|
|
|
|
InputValueBuffer - passes new values for instance that serves as the
|
|
input parameters. This can be NULL if there is no input
|
|
|
|
*OutputBufferSize - on entry has the maxiumum size in bytes that can be
|
|
written into Buffer and on return contains the actual
|
|
number of bytes written into Buffer. This can be NULL
|
|
if no output is expected to be returned, however if output
|
|
is returned the caller will not know how large a buffer
|
|
is needed to return it.
|
|
|
|
OutputBuffer - buffer in which to return the output WNODE_SINGLE_INSTANCE.
|
|
This can be NULL if there is no output WNODE or the
|
|
caller wants to determine the size needed for the
|
|
output WNODE.
|
|
|
|
Return Value:
|
|
|
|
Returns ERROR_SUCCESS or an error code.
|
|
|
|
---*/
|
|
{
|
|
PWNODE_METHOD_ITEM MethodWnode;
|
|
PWNODE_HEADER WnodeHeader;
|
|
ULONG MethodInstanceNameLen;
|
|
ULONG MethodWnodeSize, MethodWnodeOffset;
|
|
ULONG Status;
|
|
ULONG BufferSize;
|
|
PWCHAR InstanceNamePtr;
|
|
ULONG OutSize;
|
|
PUCHAR DataPtr;
|
|
ULONG BaseMethodWnodeSize;
|
|
ULONG RetSize;
|
|
|
|
WmipInitProcessHeap();
|
|
|
|
//
|
|
// Validate input parameters
|
|
if ((MethodInstanceName == NULL) ||
|
|
((InputValueBuffer == NULL) &&
|
|
(InputValueBufferSize != 0)))
|
|
{
|
|
//
|
|
// All input parameters must be specifies or all input parameters
|
|
// must NOT be specified.
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return(ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
//
|
|
// Caller can pass a NULL output buffer when he only wants to get the
|
|
// size needed for the output buffer or the method returns a void.
|
|
//
|
|
if (OutputBuffer == NULL)
|
|
{
|
|
BufferSize = 0;
|
|
} else {
|
|
if (OutputBufferSize != NULL)
|
|
{
|
|
try
|
|
{
|
|
BufferSize = *OutputBufferSize;
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return(ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
if (BufferSize >= 0x80000000)
|
|
{
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return(ERROR_INVALID_PARAMETER);
|
|
}
|
|
} else {
|
|
//
|
|
// OutputBuffer is specified, but OutBufferSize is not specified
|
|
//
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return(ERROR_INVALID_PARAMETER);
|
|
}
|
|
}
|
|
|
|
try
|
|
{
|
|
MethodInstanceNameLen = wcslen(MethodInstanceName) *
|
|
sizeof(WCHAR);
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return(ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
//
|
|
// We need to allocate a buffer that is large enough for the
|
|
// WNODE_METHOD_ITEM that contains the method call and any data passed
|
|
// into the method
|
|
|
|
//
|
|
// Compute the size of the WNODE that can be returned from the provider
|
|
BaseMethodWnodeSize = (FIELD_OFFSET(WNODE_METHOD_ITEM, VariableData) +
|
|
MethodInstanceNameLen + sizeof(USHORT) + 7) & ~7;
|
|
|
|
OutSize = BaseMethodWnodeSize + BufferSize;
|
|
|
|
//
|
|
// Make sure we allocate enough room for the larger of the input or
|
|
// output buffers.
|
|
if (InputValueBufferSize > BufferSize)
|
|
{
|
|
BufferSize = InputValueBufferSize;
|
|
}
|
|
MethodWnodeSize = BaseMethodWnodeSize + BufferSize;
|
|
|
|
MethodWnode = (PWNODE_METHOD_ITEM)WmipAlloc(MethodWnodeSize);
|
|
if (MethodWnode == NULL)
|
|
{
|
|
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
|
|
return(ERROR_NOT_ENOUGH_MEMORY);
|
|
}
|
|
|
|
//
|
|
// Build WNODE_METHOD_ITEM containing method being called
|
|
//
|
|
memset(MethodWnode, 0, FIELD_OFFSET(WNODE_METHOD_ITEM, VariableData));
|
|
MethodWnode->MethodId = MethodId;
|
|
MethodWnode->OffsetInstanceName = FIELD_OFFSET(WNODE_METHOD_ITEM,
|
|
VariableData);
|
|
MethodWnode->DataBlockOffset = BaseMethodWnodeSize;
|
|
InstanceNamePtr = (PWCHAR)OffsetToPtr(MethodWnode,
|
|
MethodWnode->OffsetInstanceName);
|
|
*InstanceNamePtr++ = (USHORT)MethodInstanceNameLen;
|
|
try
|
|
{
|
|
memcpy(InstanceNamePtr,
|
|
MethodInstanceName,
|
|
MethodInstanceNameLen);
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
WmipFree(MethodWnode);
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return(ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
if (InputValueBuffer != NULL)
|
|
{
|
|
MethodWnode->SizeDataBlock = InputValueBufferSize;
|
|
DataPtr = (PUCHAR)OffsetToPtr(MethodWnode,
|
|
MethodWnode->DataBlockOffset);
|
|
try
|
|
{
|
|
memcpy(DataPtr, InputValueBuffer, InputValueBufferSize);
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
WmipFree(MethodWnode);
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return(ERROR_INVALID_PARAMETER);
|
|
}
|
|
}
|
|
|
|
WmipBuildWnodeHeader(&MethodWnode->WnodeHeader,
|
|
MethodWnode->DataBlockOffset +
|
|
MethodWnode->SizeDataBlock,
|
|
WNODE_FLAG_METHOD_ITEM,
|
|
MethodDataBlockHandle);
|
|
|
|
Status = WmipSendWmiRequest(
|
|
WMI_EXECUTE_METHOD,
|
|
(PWNODE_HEADER)MethodWnode,
|
|
MethodWnode->WnodeHeader.BufferSize,
|
|
MethodWnode,
|
|
OutSize,
|
|
&RetSize);
|
|
|
|
if ((Status == ERROR_SUCCESS) &&
|
|
((RetSize < sizeof(WNODE_TOO_SMALL) ||
|
|
((RetSize >= sizeof(ULONG)) &&
|
|
(RetSize < MethodWnode->WnodeHeader.BufferSize)))))
|
|
{
|
|
Status = ERROR_WMI_DP_FAILED;
|
|
WmipAssert(FALSE);
|
|
}
|
|
|
|
if (Status == ERROR_SUCCESS)
|
|
{
|
|
WnodeHeader = (PWNODE_HEADER)MethodWnode;
|
|
if (WnodeHeader->Flags & WNODE_FLAG_TOO_SMALL)
|
|
{
|
|
Status = ERROR_INSUFFICIENT_BUFFER;
|
|
if (OutputBufferSize != NULL)
|
|
{
|
|
try
|
|
{
|
|
*OutputBufferSize = ((PWNODE_TOO_SMALL)WnodeHeader)->SizeNeeded -
|
|
BaseMethodWnodeSize;
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
Status = ERROR_INVALID_PARAMETER;
|
|
}
|
|
}
|
|
} else {
|
|
//
|
|
// Success, return results to caller
|
|
//
|
|
try
|
|
{
|
|
if (OutputBufferSize != NULL)
|
|
{
|
|
if (*OutputBufferSize >= MethodWnode->SizeDataBlock)
|
|
{
|
|
if (OutputBuffer != NULL)
|
|
{
|
|
DataPtr = (PUCHAR)OffsetToPtr(MethodWnode,
|
|
MethodWnode->DataBlockOffset);
|
|
memcpy(OutputBuffer,
|
|
DataPtr,
|
|
MethodWnode->SizeDataBlock);
|
|
}
|
|
} else {
|
|
Status = ERROR_INSUFFICIENT_BUFFER;
|
|
}
|
|
|
|
*OutputBufferSize = MethodWnode->SizeDataBlock;
|
|
} else if (MethodWnode->SizeDataBlock != 0) {
|
|
Status = ERROR_INSUFFICIENT_BUFFER;
|
|
}
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
Status = ERROR_INVALID_PARAMETER;
|
|
}
|
|
}
|
|
}
|
|
|
|
WmipFree(MethodWnode);
|
|
|
|
SetLastError(Status);
|
|
return(Status);
|
|
}
|
|
|
|
void
|
|
WMIAPI
|
|
WmiFreeBuffer(
|
|
IN PVOID Buffer
|
|
)
|
|
/*+++
|
|
|
|
Routine Description:
|
|
|
|
This routine frees a buffer allocated by WMI. This routine is typically
|
|
used by applications that receive events via the Window message
|
|
notification mechanism.
|
|
|
|
Arguments:
|
|
|
|
Buffer is a buffer returned by WMI that the app wishes to free
|
|
|
|
Return Value:
|
|
|
|
---*/
|
|
{
|
|
WmipInitProcessHeap();
|
|
|
|
if (Buffer != NULL)
|
|
{
|
|
WmipDebugPrint(("WMI: WMIFreeBuffer(%x)\n", Buffer));
|
|
WmipFree(Buffer);
|
|
} else {
|
|
WmipDebugPrint(("WMI: NULL passed to WMIFreeBuffer\n"));
|
|
}
|
|
}
|
|
|
|
ULONG
|
|
WMIAPI
|
|
WmiNotificationRegistrationA(
|
|
IN LPGUID Guid,
|
|
IN BOOLEAN Enable,
|
|
IN PVOID DeliveryInfo,
|
|
IN ULONG_PTR DeliveryContext,
|
|
IN ULONG Flags
|
|
)
|
|
/*+++
|
|
|
|
Routine Description:
|
|
|
|
ANSI thunk to NotificationRegistration
|
|
|
|
Return Value:
|
|
|
|
Returns ERROR_SUCCESS or an error code
|
|
|
|
---*/
|
|
{
|
|
return(WmipNotificationRegistration(Guid,
|
|
Enable,
|
|
DeliveryInfo,
|
|
DeliveryContext,
|
|
0,
|
|
Flags,
|
|
TRUE));
|
|
|
|
}
|
|
|
|
ULONG
|
|
WMIAPI
|
|
WmiNotificationRegistrationW(
|
|
IN LPGUID Guid,
|
|
IN BOOLEAN Enable,
|
|
IN PVOID DeliveryInfo,
|
|
IN ULONG_PTR DeliveryContext,
|
|
IN ULONG Flags
|
|
)
|
|
/*+++
|
|
|
|
Routine Description:
|
|
|
|
This routine allows a data consumer to register or unregister for
|
|
notification of events fired by WMI data providers. Notifications are
|
|
delivered via callbackor via a posted meesage to a window.
|
|
|
|
Arguments:
|
|
|
|
Guid is pointer to the guid whose events are being registered for
|
|
|
|
Enable is TRUE if enabling notifications else FALSE. If FALSE the
|
|
Destination and DestinationInformation parameters are ignored.
|
|
|
|
DeliveryInfo has the callback function pointer or window handle to which
|
|
to deliver the notifications for the guid.
|
|
|
|
DeliveryContext has a context value or additional information to use
|
|
when delivering the notification.
|
|
|
|
Flags are a set of flags that define how the notification is delivered.
|
|
DeliveryInfo and DeliveryContext have different meanings depending
|
|
upon the value in Flags:
|
|
|
|
NOTIFICATION_WINDOW_HANDLE is set when notifications for the guid
|
|
are to be delivered by posting a message to the window handle
|
|
passed in DeliveryInfo. The message posted is the value that
|
|
is returned from the call to
|
|
RegisterWindowMessage(WMINOTIFICATIONWINDOWMESSAGE) with the
|
|
wParam set to the pointer to the Wnode containing the notification
|
|
and lParam set to the context value passed in DeliveryContext.
|
|
The caller MUST free the Wnode passed in wParam by calling
|
|
WMIFreeBuffer.
|
|
|
|
NOTIFICATION_CALLBACK_DIRECT is set when notifications for the
|
|
guid are to be delivered by direct callback. Whenever a
|
|
notification arrives WMI creates a new thread dedicated to
|
|
calling the callback function with the notification. This
|
|
mechanism provides the shortest latency from notification firing
|
|
to notification delivery, although it is the most expensive
|
|
mechanism. The callback function pointer is passed in DeliveryInfo
|
|
and must conform to the prototype described by the type
|
|
NOTIFICATIONCALLBACK. The context value passed in the callback
|
|
is specified by the DeliveryContext parameter. WMI does not
|
|
serialize calling the callback function so it must be reentrant.
|
|
|
|
NOTIFICATION_CALLBACK_QUEUED is set when notifications for the
|
|
guid are to be delivered by a queued callback. Whenever a
|
|
notification arrives WMI places it at the end of an internal
|
|
queue. A single thread monitors this queue and calls the callback
|
|
function serially for each notification in the queue. This
|
|
mechanism provides low overhead for event delivery, however
|
|
notification delivery can be delayed if the callback function
|
|
for an earlier notification does not complete quickly.
|
|
The callback function pointer is passed in DeliveryInfo
|
|
and must conform to the prototype described by the type
|
|
NOTIFICATIONCALLBACK. The context value passed in the callback
|
|
is specified by the DeliveryContext parameter. WMI does
|
|
serialize calling the callback function so it need not be
|
|
reentrant provided it is not also used for
|
|
NOTIFICATION_CALLBACK_DIRECT notififications. NOTE THAT THIS
|
|
IS NOT YET IMPLEMENTED.
|
|
|
|
NOTIFICATION_TRACE_FLAG is set when the caller wishes to enable
|
|
trace logging in the data provider for the guid. DeliveryInfo
|
|
specifies the trace logger handle to be passed to the data
|
|
provider. DeliveryContext is not used. No notifications are
|
|
generated to the caller when this flag is set.
|
|
|
|
|
|
Note that all of the above flags are mutually exclusive.
|
|
|
|
Return Value:
|
|
|
|
Returns ERROR_SUCCESS or an error code
|
|
|
|
---*/
|
|
{
|
|
return(WmipNotificationRegistration(Guid,
|
|
Enable,
|
|
DeliveryInfo,
|
|
DeliveryContext,
|
|
0,
|
|
Flags,
|
|
FALSE));
|
|
|
|
}
|
|
|
|
// TODO: Make WmiFile
|
|
|
|
ULONG
|
|
WMIAPI
|
|
WmiFileHandleToInstanceNameA(
|
|
IN WMIHANDLE DataBlockHandle,
|
|
IN HANDLE FileHandle,
|
|
IN OUT ULONG *NumberCharacters,
|
|
OUT PCHAR InstanceNames
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
ANSI thunk to WMIFileHandleToInstanceNameW
|
|
|
|
--*/
|
|
{
|
|
ULONG Status;
|
|
PWCHAR InstanceNamesUnicode;
|
|
PWCHAR WCharPtr;
|
|
PCHAR Ansi, AnsiPtr;
|
|
ULONG AnsiLen, AnsiSize;
|
|
ULONG CharAvailable, CharReturned;
|
|
ULONG AnsiStringSize;
|
|
|
|
WmipInitProcessHeap();
|
|
|
|
CharAvailable = *NumberCharacters;
|
|
CharReturned = CharAvailable;
|
|
|
|
do
|
|
{
|
|
//
|
|
// We loop until we call with a buffer big enough to return
|
|
// the entire list of instance names.
|
|
InstanceNamesUnicode = WmipAlloc(CharReturned * sizeof(WCHAR));
|
|
|
|
if (InstanceNamesUnicode == NULL)
|
|
{
|
|
Status = ERROR_NOT_ENOUGH_MEMORY;
|
|
SetLastError(Status);
|
|
return(Status);
|
|
}
|
|
|
|
Status = WmiFileHandleToInstanceNameW(DataBlockHandle,
|
|
FileHandle,
|
|
&CharReturned,
|
|
InstanceNamesUnicode);
|
|
|
|
if (Status != ERROR_INSUFFICIENT_BUFFER)
|
|
{
|
|
break;
|
|
}
|
|
|
|
WmipFree(InstanceNamesUnicode);
|
|
} while (TRUE);
|
|
|
|
//
|
|
// CONSIDER: MB Strings
|
|
if (Status == ERROR_SUCCESS)
|
|
{
|
|
//
|
|
// Determine the size needed for the ansi buffer
|
|
WCharPtr = InstanceNamesUnicode;
|
|
AnsiSize = 1;
|
|
while (*WCharPtr != UNICODE_NULL)
|
|
{
|
|
Status = AnsiSizeForUnicodeString(WCharPtr, &AnsiStringSize);
|
|
if (Status != ERROR_SUCCESS)
|
|
{
|
|
goto Done;
|
|
}
|
|
|
|
AnsiSize += AnsiStringSize;
|
|
WCharPtr += wcslen(WCharPtr)+1;
|
|
}
|
|
|
|
//
|
|
// CONSIDER: MB String
|
|
if (AnsiSize > CharAvailable)
|
|
{
|
|
Status = ERROR_INSUFFICIENT_BUFFER;
|
|
} else {
|
|
//
|
|
// Copy the list of unicode strings to ansi strings. End of list
|
|
// is double NULL.
|
|
AnsiPtr = InstanceNames;
|
|
try
|
|
{
|
|
AnsiPtr[0] = 0;
|
|
AnsiPtr[1] = 0;
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
Status = ERROR_NOACCESS;
|
|
goto Done;
|
|
}
|
|
WCharPtr = InstanceNamesUnicode;
|
|
while (*WCharPtr != UNICODE_NULL)
|
|
{
|
|
try
|
|
{
|
|
Status = UnicodeToAnsi(WCharPtr, &AnsiPtr, &AnsiLen);
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
Status = ERROR_NOACCESS;
|
|
}
|
|
|
|
if (Status != ERROR_SUCCESS)
|
|
{
|
|
break;
|
|
}
|
|
AnsiPtr += AnsiLen;
|
|
*AnsiPtr = 0;
|
|
WCharPtr += wcslen(WCharPtr)+1;
|
|
}
|
|
}
|
|
|
|
Done:
|
|
try
|
|
{
|
|
*NumberCharacters = AnsiSize;
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
Status = ERROR_NOACCESS;
|
|
}
|
|
}
|
|
|
|
WmipFree(InstanceNamesUnicode);
|
|
|
|
SetLastError(Status);
|
|
return(Status);
|
|
}
|
|
|
|
ULONG
|
|
WMIAPI
|
|
WmiFileHandleToInstanceNameW(
|
|
IN WMIHANDLE DataBlockHandle,
|
|
IN HANDLE FileHandle,
|
|
IN OUT ULONG *NumberCharacters,
|
|
OUT PWCHAR InstanceNames
|
|
)
|
|
/*+++
|
|
|
|
Routine Description:
|
|
|
|
This routine will return all of the WMI instance names provided for a
|
|
data block within the device stack targeted by a file handle. Note
|
|
that not all data providers will support this functionality.
|
|
|
|
Arguments:
|
|
|
|
DataBlockHandle - Handle to data block
|
|
|
|
FileHandle - handle to a device whose stack is targeted
|
|
|
|
*NumberCharacters - On entry has maximum size in characters of Buffer. If
|
|
ERROR_BUFFER_TOO_SMALL is returned then it returns with the number
|
|
of character needed.
|
|
|
|
InstanceNames - if successful, returns with a list of single null
|
|
terminated strings which are the WMI instance names. The last instance
|
|
name is double null terminated
|
|
|
|
Return Value:
|
|
|
|
ERROR_SUCCESS or an error code
|
|
---*/
|
|
{
|
|
PWMIFHTOINSTANCENAME FhToInstanceName;
|
|
ULONG RetSize;
|
|
ULONG Status;
|
|
WCHAR LocalInstanceNames[2];
|
|
ULONG BufferSize;
|
|
ULONG SizeNeeded;
|
|
WCHAR Suffix[MAX_PATH];
|
|
ULONG SuffixLen, CharsNeeded;
|
|
|
|
WmipInitProcessHeap();
|
|
|
|
BufferSize = *NumberCharacters;
|
|
|
|
//
|
|
// Start off by assuming that there is only one instance name and so
|
|
// only alloc space for that.
|
|
//
|
|
SizeNeeded = FIELD_OFFSET(WMIFHTOINSTANCENAME, InstanceNames) +
|
|
(MAX_PATH * sizeof(WCHAR));
|
|
Again:
|
|
FhToInstanceName = WmipAlloc(SizeNeeded + sizeof(WCHAR));
|
|
if (FhToInstanceName == NULL)
|
|
{
|
|
return(ERROR_NOT_ENOUGH_MEMORY);
|
|
|
|
}
|
|
|
|
WmipSetHandle3264(FhToInstanceName->FileHandle, FileHandle);
|
|
WmipSetHandle3264(FhToInstanceName->KernelHandle, DataBlockHandle);
|
|
|
|
Status = WmipSendWmiKMRequest(NULL,
|
|
IOCTL_WMI_TRANSLATE_FILE_HANDLE,
|
|
FhToInstanceName,
|
|
FIELD_OFFSET(WMIFHTOINSTANCENAME,
|
|
InstanceNames),
|
|
FhToInstanceName,
|
|
SizeNeeded,
|
|
&RetSize,
|
|
NULL);
|
|
if (Status == ERROR_SUCCESS)
|
|
{
|
|
if (RetSize == sizeof(ULONG))
|
|
{
|
|
//
|
|
// If buffer passed was too small then try with a bigger buffer
|
|
//
|
|
SizeNeeded = FhToInstanceName->SizeNeeded + sizeof(WCHAR);
|
|
WmipFree(FhToInstanceName);
|
|
goto Again;
|
|
} else {
|
|
if ((RetSize < sizeof(WMIFHTOINSTANCENAME)) ||
|
|
(RetSize < (ULONG)(FhToInstanceName->InstanceNameLength +
|
|
FIELD_OFFSET(WMIFHTOINSTANCENAME, InstanceNames))))
|
|
{
|
|
//
|
|
// WMI KM returned a bogus size which should not happen
|
|
//
|
|
Status = ERROR_WMI_DP_FAILED;
|
|
WmipAssert(FALSE);
|
|
} else {
|
|
|
|
//
|
|
// Copy the results back to the users buffer if
|
|
// there is enough space
|
|
//
|
|
SuffixLen = swprintf(Suffix, L"_%d",
|
|
FhToInstanceName->BaseIndex);
|
|
|
|
try
|
|
{
|
|
CharsNeeded = (FhToInstanceName->InstanceNameLength /
|
|
sizeof(WCHAR)) + SuffixLen + 1;
|
|
|
|
*NumberCharacters = CharsNeeded;
|
|
if (BufferSize >= FhToInstanceName->InstanceNameLength)
|
|
{
|
|
wcscpy(InstanceNames,
|
|
&FhToInstanceName->InstanceNames[0]);
|
|
wcscat(InstanceNames, Suffix);
|
|
InstanceNames[CharsNeeded-2] = UNICODE_NULL;
|
|
}
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
Status = ERROR_INVALID_PARAMETER;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
WmipFree(FhToInstanceName);
|
|
SetLastError(Status);
|
|
|
|
return(Status);
|
|
|
|
}
|
|
|
|
ULONG
|
|
WMIAPI
|
|
WmiEnumerateGuids(
|
|
OUT LPGUID GuidList,
|
|
IN OUT ULONG *InOutGuidCount
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine will enumerate all of the guids that are
|
|
registered with WMI.
|
|
|
|
Arguments:
|
|
|
|
GuidList is a pointer to an array of guids that is returned with the
|
|
|
|
*GuidCount on entry is the number of guids that can be written to
|
|
GuidList and if ERROR_SUCCESS is returned it has the actual number
|
|
of guids written to GuidList. If ERROR_MORE_DATA is returned
|
|
it has the total number of guids that are available to be returned.
|
|
|
|
|
|
Return Value:
|
|
|
|
ERROR_SUCCESS if all guids returned, ERROR_MORE_DATA if not all guids
|
|
were returned or another error code on error
|
|
|
|
--*/
|
|
{
|
|
ULONG Status;
|
|
PWMIGUIDLISTINFO GuidListInfo;
|
|
ULONG GuidCount;
|
|
ULONG SizeNeeded;
|
|
ULONG RetSize;
|
|
ULONG i;
|
|
|
|
WmipInitProcessHeap();
|
|
|
|
try
|
|
{
|
|
GuidCount = *InOutGuidCount;
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return(ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
if ((GuidList == NULL) && (GuidCount != 0))
|
|
{
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return(ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
//
|
|
// Allocate space for returning guids
|
|
//
|
|
SizeNeeded = FIELD_OFFSET(WMIGUIDLISTINFO, GuidList) +
|
|
GuidCount * sizeof(WMIGUIDPROPERTIES);
|
|
|
|
GuidListInfo = WmipAlloc(SizeNeeded);
|
|
if (GuidListInfo != NULL)
|
|
{
|
|
Status = WmipSendWmiKMRequest(NULL,
|
|
IOCTL_WMI_ENUMERATE_GUIDS,
|
|
GuidListInfo,
|
|
SizeNeeded,
|
|
GuidListInfo,
|
|
SizeNeeded,
|
|
&RetSize,
|
|
NULL);
|
|
|
|
if (Status == ERROR_SUCCESS)
|
|
{
|
|
if ((RetSize < FIELD_OFFSET(WMIGUIDLISTINFO, GuidList)) ||
|
|
(RetSize < (FIELD_OFFSET(WMIGUIDLISTINFO, GuidList) +
|
|
GuidListInfo->ReturnedGuidCount * sizeof(WMIGUIDPROPERTIES))))
|
|
{
|
|
//
|
|
// WMI KM returned to us a bad size which should not happen
|
|
//
|
|
Status = ERROR_WMI_DP_FAILED;
|
|
WmipAssert(FALSE);
|
|
} else {
|
|
try
|
|
{
|
|
for (i = 0; i < GuidListInfo->ReturnedGuidCount; i++)
|
|
{
|
|
GuidList[i] = GuidListInfo->GuidList[i].Guid;
|
|
}
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
Status = ERROR_NOACCESS;
|
|
}
|
|
|
|
try
|
|
{
|
|
//
|
|
// Return the total guid count which is also the actual
|
|
// guid count if we returned all guids correctly
|
|
//
|
|
*InOutGuidCount = GuidListInfo->TotalGuidCount;
|
|
if (GuidListInfo->ReturnedGuidCount != GuidListInfo->TotalGuidCount)
|
|
{
|
|
//
|
|
// If we did not return all of the guids, change
|
|
// return status to something more appropriate
|
|
//
|
|
Status = ERROR_MORE_DATA;
|
|
}
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
Status = ERROR_INVALID_PARAMETER;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
WmipFree(GuidListInfo);
|
|
} else {
|
|
Status = ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
|
|
SetLastError(Status);
|
|
return(Status);
|
|
}
|
|
|
|
ULONG
|
|
WMIAPI
|
|
WmiDevInstToInstanceNameA(
|
|
OUT PCHAR InstanceName,
|
|
IN ULONG InstanceNameLength,
|
|
IN PCHAR DevInst,
|
|
IN ULONG InstanceIndex
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine will convert a device instance name and an instance index
|
|
into a WMI instance name.
|
|
|
|
Arguments:
|
|
|
|
InstanceName is a pointer to a buffer that returns with the WMI instance
|
|
name if the buffer is large enough
|
|
|
|
InstanceNameLength has the number of characters that can be written into
|
|
InstanceName
|
|
|
|
DevInst is the Device Instance Name
|
|
|
|
InstanceIndex is the instance index
|
|
|
|
Return Value:
|
|
|
|
number of characters that compose the WMI instance name
|
|
|
|
--*/
|
|
{
|
|
CHAR Temp[MAX_PATH];
|
|
ULONG SizeNeeded;
|
|
|
|
WmipInitProcessHeap();
|
|
|
|
sprintf(Temp, "_%d", InstanceIndex);
|
|
SizeNeeded = strlen(Temp) + strlen(DevInst) + 1;
|
|
if (InstanceNameLength >= SizeNeeded)
|
|
{
|
|
strcpy(InstanceName, DevInst);
|
|
strcat(InstanceName, Temp);
|
|
}
|
|
return(SizeNeeded);
|
|
}
|
|
|
|
ULONG
|
|
WMIAPI
|
|
WmiDevInstToInstanceNameW(
|
|
OUT PWCHAR InstanceName,
|
|
IN ULONG InstanceNameLength,
|
|
IN PWCHAR DevInst,
|
|
IN ULONG InstanceIndex
|
|
)
|
|
{
|
|
WCHAR Temp[MAX_PATH];
|
|
ULONG SizeNeeded;
|
|
|
|
WmipInitProcessHeap();
|
|
|
|
swprintf(Temp, L"_%d", InstanceIndex);
|
|
SizeNeeded = wcslen(Temp) + wcslen(DevInst) + 1;
|
|
if (InstanceNameLength >= SizeNeeded)
|
|
{
|
|
wcscpy(InstanceName, DevInst);
|
|
wcscat(InstanceName, Temp);
|
|
}
|
|
return(SizeNeeded);
|
|
}
|
|
|
|
ULONG
|
|
WMIAPI
|
|
WmiQueryGuidInformation(
|
|
IN WMIHANDLE DataBlockHandle,
|
|
OUT PWMIGUIDINFORMATION GuidInfo
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine will query information about a specific guid based upon
|
|
the guid handle passed
|
|
|
|
Arguments:
|
|
|
|
GuidHandle is the handle to the GUID whose information is being queried
|
|
|
|
GuidInfo returns with the guid information
|
|
|
|
Return Value:
|
|
|
|
ERROR_SUCCESS or error code
|
|
|
|
--*/
|
|
{
|
|
WMIQUERYGUIDINFO QueryGuidInfo;
|
|
ULONG Status;
|
|
ULONG RetSize;
|
|
|
|
WmipInitProcessHeap();
|
|
|
|
WmipSetHandle3264(QueryGuidInfo.KernelHandle, DataBlockHandle);
|
|
Status = WmipSendWmiKMRequest(NULL,
|
|
IOCTL_WMI_QUERY_GUID_INFO,
|
|
&QueryGuidInfo,
|
|
sizeof(QueryGuidInfo),
|
|
&QueryGuidInfo,
|
|
sizeof(QueryGuidInfo),
|
|
&RetSize,
|
|
NULL);
|
|
|
|
if (Status == ERROR_SUCCESS)
|
|
{
|
|
if (RetSize == sizeof(QueryGuidInfo))
|
|
{
|
|
try
|
|
{
|
|
GuidInfo->IsExpensive = QueryGuidInfo.IsExpensive;
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
SetLastError(ERROR_NOACCESS);
|
|
return(ERROR_NOACCESS);
|
|
}
|
|
} else {
|
|
//
|
|
// WMI KM returned an invalid size which should not happen
|
|
//
|
|
Status = ERROR_WMI_DP_FAILED;
|
|
WmipAssert(FALSE);
|
|
}
|
|
}
|
|
|
|
SetLastError(Status);
|
|
return(Status);
|
|
}
|
|
|
|
|
|
|
|
ULONG
|
|
WMIAPI
|
|
WmiReceiveNotificationsW(
|
|
IN ULONG HandleCount,
|
|
IN HANDLE *HandleList,
|
|
IN NOTIFICATIONCALLBACK Callback,
|
|
IN ULONG_PTR DeliveryContext
|
|
)
|
|
{
|
|
return(WmipReceiveNotifications(HandleCount,
|
|
HandleList,
|
|
Callback,
|
|
DeliveryContext,
|
|
FALSE,
|
|
RECEIVE_ACTION_NONE,
|
|
NULL,
|
|
NULL));
|
|
}
|
|
|
|
ULONG
|
|
WMIAPI
|
|
WmiReceiveNotificationsA(
|
|
IN ULONG HandleCount,
|
|
IN HANDLE *HandleList,
|
|
IN NOTIFICATIONCALLBACK Callback,
|
|
IN ULONG_PTR DeliveryContext
|
|
)
|
|
{
|
|
return(WmipReceiveNotifications(HandleCount,
|
|
HandleList,
|
|
Callback,
|
|
DeliveryContext,
|
|
TRUE,
|
|
RECEIVE_ACTION_NONE,
|
|
NULL,
|
|
NULL));
|
|
}
|
|
|