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

1500 lines
42 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1997-1999 Microsoft Corporation
Module Name:
dc1.c
Abstract:
data consumer test
Author:
16-Jan-1997 AlanWar
Revision History:
--*/
#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <windows.h>
#include <ole2.h>
#include <stdio.h>
#include <stdlib.h>
#define MEMPHIS
#include "wmium.h"
#include "wmiumkm.h"
#define OffsetToPtr(Base, Offset) ((PBYTE)((PBYTE)Base + Offset))
typedef struct tagTESTGUID TESTGUID;
GUID BotDynGuid = {0xce5b1020,0x8ea9,0x11d0,0xa4, 0xec, 0x00, 0xa0, 0xc9,0x06,0x29,0x10};
GUID TopDynGuid = {0xce5b1023,0x8ea9,0x11d0,0xa4, 0xec, 0x00, 0xa0, 0xc9,0x06,0x29,0x10};
GUID RSIGuid = {0xce5b1023,0x8ea9,0x11d0,0xa4, 0xec, 0x00, 0xa0, 0xc9,0x06,0x29,0x10};
GUID RSBGuid = {0xce5b1024,0x8ea9,0x11d0,0xa4, 0xec, 0x00, 0xa0, 0xc9,0x06,0x29,0x10};
// both
GUID SIGuid = {0xce5b1021,0x8ea9,0x11d0,0xa4, 0xec, 0x00, 0xa0, 0xc9,0x06,0x29,0x10};
GUID SBGuid = {0xce5b1022,0x8ea9,0x11d0,0xa4, 0xec, 0x00, 0xa0, 0xc9,0x06,0x29,0x10};
GUID UnRegGuid = {0xce5b1025,0x8ea9,0x11d0,0xa4, 0xec, 0x00, 0xa0, 0xc9,0x06,0x29,0x10};
GUID GuidNull =
{ 0x0, 0x0, 0x0, { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 } };
ULONG BufferSize = 4096;
BYTE Buffer[4096];
void EventCallbackRoutine0(PWNODE_HEADER WnodeHeader, ULONG Context);
void EventCallbackRoutine1(PWNODE_HEADER WnodeHeader, ULONG Context);
void EventCallbackRoutine2(PWNODE_HEADER WnodeHeader, ULONG Context);
void EventCallbackRoutine3(PWNODE_HEADER WnodeHeader, ULONG Context);
void EventCallbackRoutine4(PWNODE_HEADER WnodeHeader, ULONG Context);
typedef BOOLEAN (*QADVALIDATION)(
TESTGUID *TestGuid,
PVOID Buffer,
ULONG BufferSize
);
typedef ULONG (*QSINSET)(
TESTGUID *TestGuid,
PULONG *DataList,
PULONG DataListSize,
PBYTE *ValueBuffer,
ULONG *ValueBufferSize,
ULONG Instance
);
typedef ULONG (*QSITSET)(
TESTGUID *TestGuid,
PULONG *DataList,
PULONG DataListSize,
PBYTE *ValueBuffer,
ULONG *ValueBufferSize,
ULONG Instance,
ULONG ItemId
);
typedef BOOLEAN (*QSINTVALIDATION)(
TESTGUID *TestGuid,
PULONG *DataList,
PULONG DataListSize,
PVOID Buffer,
ULONG BufferSize,
ULONG Instance
);
typedef PWCHAR (*GETINSTANCENAME)(
TESTGUID *TestGuid,
ULONG Instance
);
typedef struct tagTESTGUID
{
LPGUID Guid;
HANDLE Handle;
PULONG DataListSize;
PULONG *InitDataList;
PULONG *SINDataList;
PULONG *SITDataList;
PWCHAR *InstanceNames;
QADVALIDATION QADValidation;
ULONG QADFlags;
ULONG InstanceCount;
GETINSTANCENAME GetInstanceName;
ULONG QSINTFlags;
QSINTVALIDATION QSINTValidation;
QSINSET QSINSet;
ULONG ItemCount;
QSITSET QSITSet;
ULONG EventsSent;
ULONG EventsReceived;
NOTIFICATIONCALLBACK NotificationCallback;
} TESTGUID;
//
// Common validation/set routines
ULONG QSINSet(
TESTGUID *TestGuid,
PULONG *DataList,
PULONG DataListSize,
PBYTE *ValueBuffer,
ULONG *ValueBufferSize,
ULONG Instance
)
{
*ValueBuffer = (PBYTE)DataList[Instance];
*ValueBufferSize = DataListSize[Instance];
return(ERROR_SUCCESS);
}
BOOLEAN QSINTValidate(
TESTGUID *TestGuid,
PULONG *DataList,
PULONG DataListSize,
PVOID Buffer,
ULONG BufferSize,
ULONG Instance
)
{
PWNODE_SINGLE_INSTANCE Wnode = Buffer;
PULONG Data;
PULONG NameOffsets;
PWCHAR Name;
ULONG NameLen;
if ((Wnode->WnodeHeader.BufferSize == 0) ||
(Wnode->WnodeHeader.ProviderId == 0) ||
(Wnode->WnodeHeader.Version != 1) ||
#ifndef MEMPHIS
(Wnode->WnodeHeader.TimeStamp.HighPart == 0) ||
(Wnode->WnodeHeader.TimeStamp.LowPart == 0) ||
#endif
(memcmp(&Wnode->WnodeHeader.Guid, TestGuid->Guid, sizeof(GUID)) != 0) ||
(Wnode->WnodeHeader.Flags != TestGuid->QSINTFlags) ||
(Wnode->SizeDataBlock != DataListSize[Instance]))
{
return(FALSE);
}
Data = (ULONG *)OffsetToPtr(Wnode, Wnode->DataBlockOffset);
if (memcmp(Data, DataList[Instance], DataListSize[Instance]) != 0)
{
return(FALSE);
}
Name = (PWCHAR)OffsetToPtr(Wnode, Wnode->OffsetInstanceName);
NameLen = wcslen(TestGuid->InstanceNames[Instance]) * sizeof(WCHAR);
if (((*Name != NameLen) && (*Name != NameLen+sizeof(WCHAR))) ||
(memcmp(++Name, TestGuid->InstanceNames[Instance], NameLen) != 0))
{
return(FALSE);
}
return(TRUE);
}
ULONG QSITSet(
TESTGUID *TestGuid,
PULONG *DataList,
PULONG DataListSize,
PBYTE *ValueBuffer,
ULONG *ValueBufferSize,
ULONG Instance,
ULONG ItemId
)
{
*ValueBuffer = (PBYTE)(DataList[Instance] + ItemId);
*ValueBufferSize = sizeof(ULONG);
return(ERROR_SUCCESS);
}
PWCHAR GetInstanceName(
TESTGUID *TestGuid,
ULONG Instance
)
{
return(TestGuid->InstanceNames[Instance]);
}
//
// Guid 20
ULONG Values20Init_1[4] = { 1,2,3,4};
ULONG Values20Init_2[4] = { 5,6,7,8};
PULONG Values20Init_List[4] =
{
Values20Init_1,
Values20Init_2,
Values20Init_1,
Values20Init_2
};
ULONG Values20_Size[4] = { 0x10,0x10,0x10,0x10 };
ULONG Values20_1[4] = { 0x11111111,0x22222222,0x33333333,0x44444444};
ULONG Values20_2[4] = { 0x55555555,0x66666666,0x77777777,0x88888888};
ULONG Values20_3[4] = { 0x12345678,0x23456789,0x3456789A,0x456789AB};
ULONG Values20_4[4] = { 0x56789ABC,0x6789ABCD,0x789ABCDE,0x89ABCDEF};
PULONG Values20_List[4] =
{
Values20_1,
Values20_2,
Values20_3,
Values20_4
};
ULONG Values20T_1[4] = { 0x1000,0x2000,0x3000,0x4000};
ULONG Values20T_2[4] = { 0x50000000,0x60000000,0x70000000,0x80000000};
ULONG Values20T_3[4] = { 0x90000000,0xA0000000,0xB0000000,0xC0000000};
ULONG Values20T_4[4] = { 0x0000D000,0x0000E000,0x0000F000,0x00000000};
PULONG Values20T_List[4] =
{
Values20_1,
Values20_2,
Values20_3,
Values20_4
};
PWCHAR InstanceName20[4] =
{
L"InstanceX",
L"InstanceY",
L"InstanceA",
L"InstanceB"
};
BOOLEAN QADValidate20(
TESTGUID *TestGuid,
PVOID Buffer,
ULONG BufferSize
)
{
PWNODE_ALL_DATA Wnode = Buffer;
PULONG Data;
PULONG NameOffsets;
PWCHAR Name;
ULONG NameLen;
ULONG i;
if ((Wnode->WnodeHeader.BufferSize == 0) ||
(Wnode->WnodeHeader.ProviderId == 0) ||
(Wnode->WnodeHeader.Version != 1) ||
#ifndef MEMPHIS
(Wnode->WnodeHeader.TimeStamp.HighPart == 0) ||
(Wnode->WnodeHeader.TimeStamp.LowPart == 0) ||
#endif
(memcmp(&Wnode->WnodeHeader.Guid, TestGuid->Guid, sizeof(GUID)) != 0) ||
(Wnode->WnodeHeader.Flags != TestGuid->QADFlags) ||
(Wnode->InstanceCount != 2) ||
(Wnode->FixedInstanceSize != 0x10))
{
return(FALSE);
}
Data = (ULONG *)OffsetToPtr(Wnode, Wnode->DataBlockOffset);
for (i = 0; i < 2; i++)
{
if (memcmp(Data, TestGuid->InitDataList[i], TestGuid->DataListSize[i]) != 0)
{
return(FALSE);
}
Data += 4;
}
NameOffsets = (ULONG *)OffsetToPtr(Wnode, Wnode->OffsetInstanceNameOffsets);
for (i = 0; i < 2; i++)
{
Name = (PWCHAR)OffsetToPtr(Wnode, *NameOffsets++);
NameLen = wcslen(TestGuid->InstanceNames[i]) * sizeof(WCHAR);
if (((*Name != NameLen) && (*Name != NameLen+sizeof(WCHAR))) ||
((memcmp(++Name, TestGuid->InstanceNames[i], NameLen) != 0) &&
(memcmp(Name, TestGuid->InstanceNames[i+2], NameLen) != 0)))
{
return(FALSE);
}
}
//
// Get second wnode in chain
if (Wnode->WnodeHeader.Linkage == 0)
{
return(FALSE);
}
Wnode = (PWNODE_ALL_DATA)OffsetToPtr(Wnode, Wnode->WnodeHeader.Linkage);
if ((Wnode->WnodeHeader.BufferSize == 0) ||
(Wnode->WnodeHeader.ProviderId == 0) ||
(Wnode->WnodeHeader.Version != 1) ||
#ifndef MEMPHIS
(Wnode->WnodeHeader.TimeStamp.HighPart == 0) ||
(Wnode->WnodeHeader.TimeStamp.LowPart == 0) ||
#endif
(memcmp(&Wnode->WnodeHeader.Guid, TestGuid->Guid, sizeof(GUID)) != 0) ||
(Wnode->WnodeHeader.Flags != TestGuid->QADFlags) ||
(Wnode->InstanceCount != 2) ||
(Wnode->FixedInstanceSize != 0x10))
{
return(FALSE);
}
Data = (ULONG *)OffsetToPtr(Wnode, Wnode->DataBlockOffset);
for (i = 2; i < 4; i++)
{
if (memcmp(Data, TestGuid->InitDataList[i], TestGuid->DataListSize[i]) != 0)
{
return(FALSE);
}
Data += 4;
}
NameOffsets = (ULONG *)OffsetToPtr(Wnode, Wnode->OffsetInstanceNameOffsets);
for (i = 2; i < 4; i++)
{
Name = (PWCHAR)OffsetToPtr(Wnode, *NameOffsets++);
NameLen = wcslen(TestGuid->InstanceNames[i]) * sizeof(WCHAR);
if (((*Name != NameLen) && (*Name != NameLen+sizeof(WCHAR))) ||
((memcmp(++Name, TestGuid->InstanceNames[i], NameLen) != 0) &&
(memcmp(Name, TestGuid->InstanceNames[i-2], NameLen) != 0)))
{
return(FALSE);
}
}
if (Wnode->WnodeHeader.Linkage != 0)
{
return(FALSE);
}
return(TRUE);
}
//
// Guid 21
PWCHAR InstanceName21[4] =
{
L"InstanceX",
L"InstanceY",
L"InstanceA",
L"InstanceB"
};
//
// Guid 22
PWCHAR InstanceName22[4] =
{
L"Instance2",
L"Instance3",
L"Instance0",
L"Instance1"
};
//
// Guid 23
PWCHAR InstanceName23[4] =
{
L"InstanceA",
L"InstanceB"
};
BOOLEAN QADValidate23(
TESTGUID *TestGuid,
PVOID Buffer,
ULONG BufferSize
)
{
PWNODE_ALL_DATA Wnode = Buffer;
PULONG Data;
PULONG NameOffsets;
PWCHAR Name;
ULONG NameLen;
ULONG i;
if ((Wnode->WnodeHeader.BufferSize == 0) ||
(Wnode->WnodeHeader.ProviderId == 0) ||
(Wnode->WnodeHeader.Version != 1) ||
#ifndef MEMPHIS
(Wnode->WnodeHeader.TimeStamp.HighPart == 0) ||
(Wnode->WnodeHeader.TimeStamp.LowPart == 0) ||
#endif
(memcmp(&Wnode->WnodeHeader.Guid, TestGuid->Guid, sizeof(GUID)) != 0) ||
(Wnode->WnodeHeader.Flags != TestGuid->QADFlags) ||
(Wnode->InstanceCount != 2) ||
(Wnode->FixedInstanceSize != 0x10))
{
return(FALSE);
}
Data = (ULONG *)OffsetToPtr(Wnode, Wnode->DataBlockOffset);
for (i = 0; i < 2; i++)
{
if (memcmp(Data, TestGuid->InitDataList[i], TestGuid->DataListSize[i]) != 0)
{
return(FALSE);
}
Data += 4;
}
NameOffsets = (ULONG *)OffsetToPtr(Wnode, Wnode->OffsetInstanceNameOffsets);
for (i = 0; i < 2; i++)
{
Name = (PWCHAR)OffsetToPtr(Wnode, *NameOffsets++);
NameLen = wcslen(TestGuid->InstanceNames[i]) * sizeof(WCHAR);
if (((*Name != NameLen) && (*Name != NameLen+sizeof(WCHAR))) ||
(memcmp(++Name, TestGuid->InstanceNames[i], NameLen) != 0))
{
return(FALSE);
}
}
if (Wnode->WnodeHeader.Linkage != 0)
{
return(FALSE);
}
return(TRUE);
}
//
// Guid 24
PWCHAR InstanceName24[4] =
{
L"Instance0",
L"Instance1"
};
#define TestCount 5
TESTGUID TestList[TestCount] = {
{
&BotDynGuid,
0,
Values20_Size,
Values20Init_List,
Values20_List,
Values20T_List,
InstanceName20,
QADValidate20,
(WNODE_FLAG_ALL_DATA | WNODE_FLAG_FIXED_INSTANCE_SIZE),
4,
GetInstanceName,
WNODE_FLAG_SINGLE_INSTANCE,
QSINTValidate,
QSINSet,
4,
QSITSet,
0,
0,
EventCallbackRoutine0
},
{
&SIGuid,
0,
Values20_Size,
Values20Init_List,
Values20_List,
Values20T_List,
InstanceName21,
QADValidate20,
(WNODE_FLAG_ALL_DATA | WNODE_FLAG_FIXED_INSTANCE_SIZE | WNODE_FLAG_STATIC_INSTANCE_NAMES),
4,
GetInstanceName,
WNODE_FLAG_SINGLE_INSTANCE | WNODE_FLAG_STATIC_INSTANCE_NAMES,
QSINTValidate,
QSINSet,
4,
QSITSet,
0,
0,
EventCallbackRoutine1
},
{
&SBGuid,
0,
Values20_Size,
Values20Init_List,
Values20_List,
Values20T_List,
InstanceName22,
QADValidate20,
(WNODE_FLAG_ALL_DATA | WNODE_FLAG_FIXED_INSTANCE_SIZE | WNODE_FLAG_STATIC_INSTANCE_NAMES),
4,
GetInstanceName,
WNODE_FLAG_SINGLE_INSTANCE | WNODE_FLAG_STATIC_INSTANCE_NAMES,
QSINTValidate,
QSINSet,
4,
QSITSet,
0,
0,
EventCallbackRoutine2
},
{
&RSIGuid,
0,
Values20_Size,
Values20Init_List,
Values20_List,
Values20T_List,
InstanceName23,
QADValidate23,
(WNODE_FLAG_ALL_DATA | WNODE_FLAG_FIXED_INSTANCE_SIZE | WNODE_FLAG_STATIC_INSTANCE_NAMES),
2,
GetInstanceName,
WNODE_FLAG_SINGLE_INSTANCE | WNODE_FLAG_STATIC_INSTANCE_NAMES,
QSINTValidate,
QSINSet,
4,
QSITSet,
0,
0,
EventCallbackRoutine3
},
{
&RSBGuid,
0,
Values20_Size,
Values20Init_List,
Values20_List,
Values20T_List,
InstanceName24,
QADValidate23,
(WNODE_FLAG_ALL_DATA | WNODE_FLAG_FIXED_INSTANCE_SIZE | WNODE_FLAG_STATIC_INSTANCE_NAMES),
2,
GetInstanceName,
WNODE_FLAG_SINGLE_INSTANCE | WNODE_FLAG_STATIC_INSTANCE_NAMES,
QSINTValidate,
QSINSet,
4,
QSITSet,
0,
0,
EventCallbackRoutine4
},
};
ULONG QADTest(
ULONG FirstTestNumber,
ULONG LastTestNumber
)
{
ULONG i;
ULONG Status;
for (i = FirstTestNumber; i < LastTestNumber; i++)
{
Status = WMIOpenBlock(NULL,
TestList[i].Guid,
&TestList[i].Handle);
if (Status != ERROR_SUCCESS)
{
printf("Error: QADTest: Couldn't open Handle %d %x\n", i, Status);
TestList[i].Handle = (HANDLE)NULL;
}
}
for (i = FirstTestNumber; i < LastTestNumber;i++)
{
if (TestList[i].Handle != (HANDLE)NULL)
{
BufferSize = sizeof(Buffer);
Status = WMIQueryAllData(TestList[i].Handle,
&BufferSize,
Buffer);
if (Status == ERROR_SUCCESS)
{
if (! (*TestList[i].QADValidation)(&TestList[i], Buffer, BufferSize))
{
printf("ERROR: QADValidation %d failed\n", i);
}
} else {
printf("Error TestList WMIQueryAllData %d failed %x\n", i, Status);
}
}
}
for (i = FirstTestNumber; i < LastTestNumber;i++)
{
if (TestList[i].Handle != (HANDLE)NULL)
{
WMICloseBlock(TestList[i].Handle);
}
}
return(ERROR_SUCCESS);
}
ULONG QSINTest(
ULONG FirstTestNumber,
ULONG LastTestNumber
)
{
ULONG i,j;
ULONG Status;
ULONG InstanceCount;
PWCHAR InstanceName;
PBYTE ValueBuffer;
ULONG ValueBufferSize;
for (i = FirstTestNumber; i < LastTestNumber; i++)
{
Status = WMIOpenBlock(NULL,
TestList[i].Guid,
&TestList[i].Handle);
if (Status != ERROR_SUCCESS)
{
printf("Error: QSINTest: Couldn't open Handle %d %x\n", i, Status);
TestList[i].Handle = (HANDLE)NULL;
}
InstanceCount = TestList[i].InstanceCount;
for (j = 0; j < InstanceCount; j++)
{
InstanceName = ((*TestList[i].GetInstanceName)(&TestList[i], j));
//
// Initial value check
BufferSize = sizeof(Buffer);
Status = WMIQuerySingleInstance(TestList[i].Handle,
InstanceName,
&BufferSize,
Buffer);
if (Status == ERROR_SUCCESS)
{
if (! (*TestList[i].QSINTValidation)(&TestList[i],
TestList[i].InitDataList,
TestList[i].DataListSize,
Buffer, BufferSize, j))
{
printf("ERROR: QSINTest Init %d/%d Validation failed %x\n", i,j,Status);
}
} else {
printf("Error QSINTest WMIQuerySingleInstance %d/%d failed %x\n", i, j, Status);
}
//
// Set new values
(*TestList[i].QSINSet)(&TestList[i],
TestList[i].SINDataList,
TestList[i].DataListSize,
&ValueBuffer, &ValueBufferSize, j);
Status = WMISetSingleInstance(TestList[i].Handle,
InstanceName,
1,
ValueBufferSize,
ValueBuffer);
if (Status != ERROR_SUCCESS)
{
printf("ERROR: QSINTest WMISetSingleInstance %d/%d failed %x\n", i,j,Status);
}
//
// Check new values set properly
BufferSize = sizeof(Buffer);
Status = WMIQuerySingleInstance(TestList[i].Handle,
InstanceName,
&BufferSize,
Buffer);
if (Status == ERROR_SUCCESS)
{
if (!(*TestList[i].QSINTValidation)(&TestList[i],
TestList[i].SINDataList,
TestList[i].DataListSize,
Buffer, BufferSize, j))
{
printf("ERROR: QSINTTest %d/%d Validation # 2 failed %x\n", i,j,Status);
}
} else {
printf("ERROR: QSINTest: WMIQuerySingleInstance %d/%d failed %x\n", i,j,Status);
}
//
// Reset to initial values
(*TestList[i].QSINSet)(&TestList[i],
TestList[i].InitDataList,
TestList[i].DataListSize,
&ValueBuffer, &ValueBufferSize, j);
Status = WMISetSingleInstance(TestList[i].Handle,
InstanceName,
1,
ValueBufferSize,
ValueBuffer);
if (Status != ERROR_SUCCESS)
{
printf("ERROR: QSINTTest WMISetSingleInstance Init %d/%d failed %x\n", i,j,Status);
}
//
// Check reset to initial values
BufferSize = sizeof(Buffer);
Status = WMIQuerySingleInstance(TestList[i].Handle,
InstanceName,
&BufferSize,
Buffer);
if (Status == ERROR_SUCCESS)
{
if (!(*TestList[i].QSINTValidation)(&TestList[i],
TestList[i].InitDataList,
TestList[i].DataListSize,
Buffer, BufferSize, j))
{
printf("ERROR: QSINT %d/%d Validation #2 failed %x\n", i,j,Status);
}
} else {
printf("ERROR: WMIQuerySingleInstance # 2 %d/%d failed %x\n", i,j,Status);
}
}
}
for (i = FirstTestNumber; i < LastTestNumber;i++)
{
if (TestList[i].Handle != (HANDLE)NULL)
{
WMICloseBlock(TestList[i].Handle);
}
}
return(ERROR_SUCCESS);
}
ULONG QSITTest(
ULONG FirstTestNumber,
ULONG LastTestNumber
)
{
ULONG i,j,k;
ULONG Status;
ULONG InstanceCount;
PWCHAR InstanceName;
ULONG ItemCount;
PBYTE ValueBuffer;
ULONG ValueBufferSize;
for (i = FirstTestNumber; i < LastTestNumber; i++)
{
Status = WMIOpenBlock(NULL,
TestList[i].Guid,
&TestList[i].Handle);
if (Status != ERROR_SUCCESS)
{
printf("Error: QSITTest: Couldn't open Handle %d %x\n", i, Status);
TestList[i].Handle = (HANDLE)NULL;
}
InstanceCount = TestList[i].InstanceCount;
for (j = 0; j < InstanceCount; j++)
{
InstanceName = (*TestList[i].GetInstanceName)(&TestList[i],j);
//
// Set new values
ItemCount = TestList[i].ItemCount;
for (k = 0; k < ItemCount; k++)
{
(*TestList[i].QSITSet)(&TestList[i],
TestList[i].SITDataList,
TestList[i].DataListSize,
&ValueBuffer, &ValueBufferSize, j,k);
Status = WMISetSingleItem(TestList[i].Handle,
InstanceName,
k,
1,
ValueBufferSize,
ValueBuffer);
if (Status != ERROR_SUCCESS)
{
printf("ERROR: QSIT WMISetSingleItem %d/%d/%d failed %x\n", i,j,k,Status);
}
}
//
// Check new values set properly
BufferSize = sizeof(Buffer);
Status = WMIQuerySingleInstance(TestList[i].Handle,
InstanceName,
&BufferSize,
Buffer);
if (Status == ERROR_SUCCESS)
{
if (!(*TestList[i].QSINTValidation)(&TestList[i],
TestList[i].SITDataList,
TestList[i].DataListSize,
Buffer, BufferSize, j))
{
printf("ERROR: QSIT %d/%d Validation failed %x\n", i,j,Status);
}
} else {
printf("ERROR: QSIT %d/%d QMIQuerySingleInstance failed %x\n", i,j,Status);
}
//
// Reset to initial values
(*TestList[i].QSINSet)(&TestList[i],
TestList[i].InitDataList,
TestList[i].DataListSize,
&ValueBuffer, &ValueBufferSize, j);
Status = WMISetSingleInstance(TestList[i].Handle,
InstanceName,
1,
ValueBufferSize,
ValueBuffer);
if (Status != ERROR_SUCCESS)
{
printf("ERROR: QSIT WMISetSingleInstance %d/%d failed %x\n", i,j,Status);
}
//
// Check reset to initial values
BufferSize = sizeof(Buffer);
Status = WMIQuerySingleInstance(TestList[i].Handle,
InstanceName,
&BufferSize,
Buffer);
if (Status == ERROR_SUCCESS)
{
if (!(*TestList[i].QSINTValidation)(&TestList[i],
TestList[i].InitDataList,
TestList[i].DataListSize,
Buffer, BufferSize, j))
{
printf("ERROR: QSIT %d/%d Validation # 2 failed %x\n", i,j,Status);
}
} else {
printf("ERROR: QSIT WMISetSingleInstance # 2 %d/%d failed %x\n", i,j,Status);
}
}
}
for (i = FirstTestNumber; i < LastTestNumber;i++)
{
if (TestList[i].Handle != (HANDLE)NULL)
{
WMICloseBlock(TestList[i].Handle);
}
}
return(ERROR_SUCCESS);
}
#define EventDeviceName TEXT("\\\\.\\STBTest")
#define EventInstanceName L"InstanceA"
ULONG EventsReceived, EventsSent;
ULONG GlobalEventsReceived, GlobalEventsSent;
void GlobalEventCallbackRoutine(PWNODE_HEADER WnodeHeader, ULONG Context)
{
PULONG Data;
PWNODE_SINGLE_INSTANCE Wnode = (PWNODE_SINGLE_INSTANCE)WnodeHeader;
PWCHAR Name;
ULONG NameLen;
GlobalEventsReceived++;
if (Context != 0x12345678)
{
printf("Event validate failed - context\n");
}
if ((Wnode->WnodeHeader.BufferSize == 0) ||
(Wnode->WnodeHeader.ProviderId == 0) ||
(Wnode->WnodeHeader.Version != 1) ||
#ifndef MEMPHIS
(Wnode->WnodeHeader.TimeStamp.HighPart == 0) ||
(Wnode->WnodeHeader.TimeStamp.LowPart == 0) ||
#endif
(Wnode->WnodeHeader.Flags != (WNODE_FLAG_EVENT_ITEM | WNODE_FLAG_SINGLE_INSTANCE)) ||
(Wnode->SizeDataBlock != 4))
{
printf("Global Event validation failed #1\n");
return;
}
Data = (ULONG *)OffsetToPtr(Wnode, Wnode->DataBlockOffset);
// if (Data[0] != Wnode->WnodeHeader.Linkage)
// {
// printf("Global Event validation failed #2\n");
// return;
// }
Name = (PWCHAR)OffsetToPtr(Wnode, Wnode->OffsetInstanceName);
NameLen = wcslen(EventInstanceName) * sizeof(WCHAR);
if (((*Name != NameLen) && (*Name != NameLen+sizeof(WCHAR))) ||
(memcmp(++Name, EventInstanceName, NameLen) != 0))
{
printf("Global Event validation failed #3\n");
}
}
void EventCallbackRoutine0(PWNODE_HEADER WnodeHeader, ULONG Context)
{
PULONG Data;
PWNODE_SINGLE_INSTANCE Wnode = (PWNODE_SINGLE_INSTANCE)WnodeHeader;
PWCHAR Name;
ULONG NameLen;
if (Context != 0xABCDEF01)
{
printf("Event validate failed - context\n");
}
TestList[0].EventsReceived++;
if ((Wnode->WnodeHeader.BufferSize == 0) ||
(Wnode->WnodeHeader.ProviderId == 0) ||
(Wnode->WnodeHeader.Version != 1) ||
#ifndef MEMPHIS
(Wnode->WnodeHeader.TimeStamp.HighPart == 0) ||
(Wnode->WnodeHeader.TimeStamp.LowPart == 0) ||
#endif
(memcmp(&Wnode->WnodeHeader.Guid, &BotDynGuid, sizeof(GUID)) != 0) ||
(Wnode->WnodeHeader.Flags != (WNODE_FLAG_EVENT_ITEM | WNODE_FLAG_SINGLE_INSTANCE)) ||
(Wnode->SizeDataBlock != 4))
{
printf("Event validation failed #1\n");
}
Data = (ULONG *)OffsetToPtr(Wnode, Wnode->DataBlockOffset);
// if (Data[0] != Wnode->WnodeHeader.Linkage)
// {
// printf("Event validation failed #2\n");
// }
// Name = (PWCHAR)OffsetToPtr(Wnode, Wnode->OffsetInstanceName);
// NameLen = wcslen(EventInstanceName) * sizeof(WCHAR);
//
// if (((*Name != NameLen) && (*Name != NameLen+sizeof(WCHAR))) ||
// (memcmp(++Name, EventInstanceName, NameLen) != 0))
// {
// printf("Event validation failed #3\n");
// }
}
void EventCallbackRoutine1(PWNODE_HEADER WnodeHeader, ULONG Context)
{
PULONG Data;
PWNODE_SINGLE_INSTANCE Wnode = (PWNODE_SINGLE_INSTANCE)WnodeHeader;
PWCHAR Name;
ULONG NameLen;
if (Context != 0xABCDEF01)
{
printf("Event validate failed - context\n");
}
TestList[1].EventsReceived++;
if ((Wnode->WnodeHeader.BufferSize == 0) ||
(Wnode->WnodeHeader.ProviderId == 0) ||
(Wnode->WnodeHeader.Version != 1) ||
#ifndef MEMPHIS
(Wnode->WnodeHeader.TimeStamp.HighPart == 0) ||
(Wnode->WnodeHeader.TimeStamp.LowPart == 0) ||
#endif
(memcmp(&Wnode->WnodeHeader.Guid, &SIGuid, sizeof(GUID)) != 0) ||
(Wnode->WnodeHeader.Flags != (WNODE_FLAG_EVENT_ITEM | WNODE_FLAG_SINGLE_INSTANCE)) ||
(Wnode->SizeDataBlock != 4))
{
printf("Event validation failed #1\n");
}
Data = (ULONG *)OffsetToPtr(Wnode, Wnode->DataBlockOffset);
// if (Data[0] != Wnode->WnodeHeader.Linkage)
// {
// printf("Event validation failed #2\n");
// }
Name = (PWCHAR)OffsetToPtr(Wnode, Wnode->OffsetInstanceName);
NameLen = wcslen(EventInstanceName) * sizeof(WCHAR);
if (((*Name != NameLen) && (*Name != NameLen+sizeof(WCHAR))) ||
(memcmp(++Name, EventInstanceName, NameLen) != 0))
{
printf("Event validation failed #3\n");
}
}
void EventCallbackRoutine2(PWNODE_HEADER WnodeHeader, ULONG Context)
{
PULONG Data;
PWNODE_SINGLE_INSTANCE Wnode = (PWNODE_SINGLE_INSTANCE)WnodeHeader;
PWCHAR Name;
ULONG NameLen;
if (Context != 0xABCDEF01)
{
printf("Event validate failed - context\n");
}
TestList[2].EventsReceived++;
if ((Wnode->WnodeHeader.BufferSize == 0) ||
(Wnode->WnodeHeader.ProviderId == 0) ||
(Wnode->WnodeHeader.Version != 1) ||
#ifndef MEMPHIS
(Wnode->WnodeHeader.TimeStamp.HighPart == 0) ||
(Wnode->WnodeHeader.TimeStamp.LowPart == 0) ||
#endif
(memcmp(&Wnode->WnodeHeader.Guid, &SBGuid, sizeof(GUID)) != 0) ||
(Wnode->WnodeHeader.Flags != (WNODE_FLAG_EVENT_ITEM | WNODE_FLAG_SINGLE_INSTANCE)) ||
(Wnode->SizeDataBlock != 4))
{
printf("Event validation failed #1\n");
}
Data = (ULONG *)OffsetToPtr(Wnode, Wnode->DataBlockOffset);
// if (Data[0] != Wnode->WnodeHeader.Linkage)
// {
// printf("Event validation failed #2\n");
// }
Name = (PWCHAR)OffsetToPtr(Wnode, Wnode->OffsetInstanceName);
NameLen = wcslen(EventInstanceName) * sizeof(WCHAR);
if (((*Name != NameLen) && (*Name != NameLen+sizeof(WCHAR))) ||
(memcmp(++Name, EventInstanceName, NameLen) != 0))
{
printf("Event validation failed #3\n");
}
}
void EventCallbackRoutine3(PWNODE_HEADER WnodeHeader, ULONG Context)
{
PULONG Data;
PWNODE_SINGLE_INSTANCE Wnode = (PWNODE_SINGLE_INSTANCE)WnodeHeader;
PWCHAR Name;
ULONG NameLen;
if (Context != 0xABCDEF01)
{
printf("Event validate failed - context\n");
}
TestList[3].EventsReceived++;
if ((Wnode->WnodeHeader.BufferSize == 0) ||
(Wnode->WnodeHeader.ProviderId == 0) ||
(Wnode->WnodeHeader.Version != 1) ||
#ifndef MEMPHIS
(Wnode->WnodeHeader.TimeStamp.HighPart == 0) ||
(Wnode->WnodeHeader.TimeStamp.LowPart == 0) ||
#endif
(memcmp(&Wnode->WnodeHeader.Guid, &RSIGuid, sizeof(GUID)) != 0) ||
(Wnode->WnodeHeader.Flags != (WNODE_FLAG_EVENT_ITEM | WNODE_FLAG_SINGLE_INSTANCE)) ||
(Wnode->SizeDataBlock != 4))
{
printf("Event validation failed #1\n");
}
Data = (ULONG *)OffsetToPtr(Wnode, Wnode->DataBlockOffset);
// if (Data[0] != Wnode->WnodeHeader.Linkage)
// {
// printf("Event validation failed #2\n");
// }
Name = (PWCHAR)OffsetToPtr(Wnode, Wnode->OffsetInstanceName);
NameLen = wcslen(EventInstanceName) * sizeof(WCHAR);
if (((*Name != NameLen) && (*Name != NameLen+sizeof(WCHAR))) ||
(memcmp(++Name, EventInstanceName, NameLen) != 0))
{
printf("Event validation failed #3\n");
}
}
void EventCallbackRoutine4(PWNODE_HEADER WnodeHeader, ULONG Context)
{
PULONG Data;
PWNODE_SINGLE_INSTANCE Wnode = (PWNODE_SINGLE_INSTANCE)WnodeHeader;
PWCHAR Name;
ULONG NameLen;
if (Context != 0xABCDEF01)
{
printf("Event validate failed - context\n");
}
TestList[4].EventsReceived++;
if ((Wnode->WnodeHeader.BufferSize == 0) ||
(Wnode->WnodeHeader.ProviderId == 0) ||
(Wnode->WnodeHeader.Version != 1) ||
#ifndef MEMPHIS
(Wnode->WnodeHeader.TimeStamp.HighPart == 0) ||
(Wnode->WnodeHeader.TimeStamp.LowPart == 0) ||
#endif
(memcmp(&Wnode->WnodeHeader.Guid, &RSBGuid, sizeof(GUID)) != 0) ||
(Wnode->WnodeHeader.Flags != (WNODE_FLAG_EVENT_ITEM | WNODE_FLAG_SINGLE_INSTANCE)) ||
(Wnode->SizeDataBlock != 4))
{
printf("Event validation failed #1\n");
}
Data = (ULONG *)OffsetToPtr(Wnode, Wnode->DataBlockOffset);
// if (Data[0] != Wnode->WnodeHeader.Linkage)
// {
// printf("Event validation failed #2\n");
// }
Name = (PWCHAR)OffsetToPtr(Wnode, Wnode->OffsetInstanceName);
NameLen = wcslen(EventInstanceName) * sizeof(WCHAR);
if (((*Name != NameLen) && (*Name != NameLen+sizeof(WCHAR))) ||
(memcmp(++Name, EventInstanceName, NameLen) != 0))
{
printf("Event validation failed #3\n");
}
}
void EventTest(
ULONG Unused1,
ULONG Unused2
)
{
HANDLE STBHandle;
BOOLEAN f;
ULONG retsize;
ULONG Status;
ULONG WnodeEventSize;
PWNODE_SINGLE_INSTANCE Wnode;
PWCHAR InstanceNamePtr;
PULONG DataPtr;
ULONG i,j;
ULONG Size;
HANDLE DataBlockHandle;
Status = WMIOpenBlock(NULL,
&SIGuid,
&DataBlockHandle);
if (Status != ERROR_SUCCESS)
{
printf("ERROR: Couldn't open data block %x\n", Status);
return;
}
Size = sizeof(WNODE_SINGLE_INSTANCE) +
sizeof(EventInstanceName) + sizeof(WCHAR) +
1 * sizeof(ULONG);
Wnode = malloc(Size);
if (Wnode == NULL)
{
printf("ERROR: couldn't alloc mem for event\n");
return;
}
STBHandle = CreateFile(
EventDeviceName,
GENERIC_READ | GENERIC_WRITE,
0,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL
);
if (STBHandle == (HANDLE)-1)
{
printf("ERROR - couldn't open Event device file %x\n",
GetLastError());
free(Wnode);
return;
}
Status = WMINotificationRegistration(&GuidNull,
TRUE,
GlobalEventCallbackRoutine,
0x12345678,
NULL,
0,
0);
if (Status != ERROR_SUCCESS)
{
printf("ERROR: WMINotificationRegistration Global Enable failed %x\n", Status);
}
for (j = 0; j < TestCount; j++)
{
Status = WMINotificationRegistration(TestList[j].Guid,
TRUE,
TestList[j].NotificationCallback,
0xABCDEF01,
NULL,
0,
0);
if (Status != ERROR_SUCCESS)
{
printf("ERROR: WMINotificationRegistration Enable %d failed %x\n", j, Status);
free(Wnode);
goto done;
}
}
Wnode->WnodeHeader.BufferSize = Size;
Wnode->WnodeHeader.TimeStamp.LowPart = 1;
Wnode->WnodeHeader.TimeStamp.HighPart = 1;
Wnode->WnodeHeader.Flags = WNODE_FLAG_SINGLE_INSTANCE | WNODE_FLAG_EVENT_ITEM | WNODE_FLAG_STATIC_INSTANCE_NAMES;
Wnode->WnodeHeader.Version = 1;
// InstanceNamePtr = (PWCHAR)(&Wnode->VariableData);
// *InstanceNamePtr = sizeof(EventInstanceName);
// wcscpy(InstanceNamePtr + 1, EventInstanceName);
// DataPtr = (ULONG *)((PBYTE)InstanceNamePtr + sizeof(EventInstanceName) + sizeof(WCHAR));
// Wnode->OffsetInstanceName = (ULONG)((ULONG)InstanceNamePtr - (ULONG)Wnode);
DataPtr = (ULONG *)&Wnode->VariableData;
Wnode->SizeDataBlock = 4;
Wnode->DataBlockOffset = (ULONG)((ULONG)DataPtr - (ULONG)Wnode );
EventsSent = 0;
EventsReceived = 0;
GlobalEventsSent = 0;
GlobalEventsReceived = 0;
for (i = 0; i < 25; i++)
{
DataPtr[0] = i;
for (j = 0; j < TestCount; j++)
{
memcpy(&Wnode->WnodeHeader.Guid, TestList[j].Guid, sizeof(GUID));
Wnode->InstanceIndex = i % 5;
f = DeviceIoControl( STBHandle,
IOCTL_WMI_GENERATE_EVENT,
Wnode,
Wnode->WnodeHeader.BufferSize,
NULL,
0,
&retsize,
NULL);
if (! f)
{
printf("ERROR: DeviceIoCOntrol(EventGen) failed %x\n", Wnode);
} else {
TestList[j].EventsSent++;
GlobalEventsSent++;
}
Sleep(1000);
}
}
//
// Send event for unregistered guid
memcpy(&Wnode->WnodeHeader.Guid, &UnRegGuid, sizeof(GUID));
Wnode->WnodeHeader.Linkage = i;
DataPtr[0] = i;
f = DeviceIoControl( STBHandle,
IOCTL_WMI_GENERATE_EVENT,
Wnode,
Wnode->WnodeHeader.BufferSize,
NULL,
0,
&retsize,
NULL);
if (! f)
{
printf("ERROR: DeviceIoCOntrol(EventGen) failed\n");
} else {
GlobalEventsSent++;
}
Sleep(10000);
for (j = 0; j < TestCount; j++)
{
Status = WMINotificationRegistration(TestList[j].Guid,
FALSE,
NULL,
0,
NULL,
0,
0);
if (Status != ERROR_SUCCESS)
{
printf("ERROR: WMINotificationRegistration disable %d failed %x\n", j, Status);
}
}
Status = WMINotificationRegistration(&GuidNull,
FALSE,
NULL,
0,
NULL,
0,
0);
if (Status != ERROR_SUCCESS)
{
printf("ERROR: WMINotificationRegistration disable GuidNull failed %x\n", Status);
}
free(Wnode);
for (j = 0; j < TestCount; j++)
{
if (TestList[j].EventsReceived != TestList[j].EventsSent)
{
printf("Error - Sent %d events, but received %d for %d\n",
TestList[j].EventsSent, TestList[j].EventsReceived, j);
}
printf("Error - Sent %d events, but received %d for %d\n",
TestList[j].EventsSent, TestList[j].EventsReceived, j);
}
if (GlobalEventsReceived != GlobalEventsSent)
{
printf("Error - Sent %d global events, but received %d\n",
GlobalEventsSent, GlobalEventsReceived);
}
printf("Error - Sent %d global events, but received %d\n",
GlobalEventsSent, GlobalEventsReceived);
done:
WMICloseBlock(DataBlockHandle);
CloseHandle(STBHandle);
}
typedef ULONG (*THREADFUNC)(
ULONG FirstTestNumber,
ULONG LastTestNumber
);
typedef struct
{
THREADFUNC ThreadFunc;
ULONG FirstTestNumber;
ULONG LastTestNumber;
} LAUNCHCTX, *PLAUNCHCTX;
ULONG LaunchThreadProc(PVOID Context)
{
PLAUNCHCTX LaunchCtx = (PLAUNCHCTX)Context;
(*LaunchCtx->ThreadFunc)(LaunchCtx->FirstTestNumber,
LaunchCtx->LastTestNumber);
return(0);
}
void LaunchThread(
THREADFUNC ThreadFunc,
ULONG FirstTestNumber,
ULONG LastTestNumber
)
{
PLAUNCHCTX LaunchCtx;
HANDLE ThreadHandle;
LaunchCtx = (PLAUNCHCTX)malloc(sizeof(LAUNCHCTX));
if (LaunchCtx != NULL)
{
LaunchCtx->ThreadFunc = ThreadFunc;
LaunchCtx->FirstTestNumber = FirstTestNumber;
LaunchCtx->LastTestNumber = LastTestNumber;
ThreadHandle = CreateThread(NULL,
0,
LaunchThreadProc,
&LaunchCtx,
0,
NULL);
if (ThreadHandle != NULL)
{
CloseHandle(ThreadHandle);
}
}
}
int _cdecl main(int argc, char *argv[])
{
printf("At Main in DC1\n");
QADTest(0, TestCount);
QSINTest(0, TestCount);
QSITTest(0, TestCount);
EventTest(0, TestCount);
return(ERROR_SUCCESS);
}
Reference in a new issue Copy permalink