void EnumerateValueTest(void)
{
KEY_VALUE_FULL_INFORMATION KeyValueInformation[5];
OBJECT_ATTRIBUTES ObjectAttributes;
UNICODE_STRING KeyName = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\Software\\testkey");
ULONG Index,Length,i;
HANDLE hKey = NULL;
NTSTATUS Status;
dprintf("Open key '\\Registry\\Machine\\Software\\testkey':\n");
InitializeObjectAttributes(&ObjectAttributes,
&KeyName,
OBJ_CASE_INSENSITIVE,
NULL,
NULL);
Status=NtOpenKey(&hKey,
MAXIMUM_ALLOWED,
&ObjectAttributes);
dprintf(" Status = %lx\n", Status);
if (!NT_SUCCESS(Status))
return;
dprintf("Enumerate values:\n");
Index = 0;
while (Status == STATUS_SUCCESS)
{
Status = NtEnumerateValueKey(hKey,
Index++,
KeyValueFullInformation,
&KeyValueInformation[0],
sizeof(KeyValueInformation),
&Length);
if (Status == STATUS_SUCCESS)
{
dprintf(" Value:DO=%d, DL=%d, NL=%d, Name = ",
KeyValueInformation[0].DataOffset,
KeyValueInformation[0].DataLength,
KeyValueInformation[0].NameLength);
for (i = 0; i < KeyValueInformation[0].NameLength / 2; i++)
dprintf("%C", KeyValueInformation[0].Name[i]);
dprintf(", Type = %d\n", KeyValueInformation[0].Type);
if (KeyValueInformation[0].Type == REG_SZ)
dprintf(" Value = %S\n",
((char*)&KeyValueInformation[0]+KeyValueInformation[0].DataOffset));
if (KeyValueInformation[0].Type == REG_DWORD)
dprintf(" Value = %X\n",
*((DWORD*)((char*)&KeyValueInformation[0]+KeyValueInformation[0].DataOffset)));
}
}
dprintf("NtClose:\n");
Status = NtClose(hKey);
dprintf(" Status = %lx\n", Status);
}
NTSTATUS WINAPI SafeNtEnumerateValueKey(
HANDLE KeyHandle,
ULONG Index,
KEY_VALUE_INFORMATION_CLASS KeyValueInformationClass,
PVOID KeyValueInformation,
ULONG Length,
PULONG ResultLength
)
{
NTSTATUS rc;
if (CheckOldFunction(&OldNtEnumerateValueKey))
rc=OldNtEnumerateValueKey(KeyHandle,Index,KeyValueInformationClass,KeyValueInformation,Length,ResultLength);
else
rc=NtEnumerateValueKey(KeyHandle,Index,KeyValueInformationClass,KeyValueInformation,Length,ResultLength);
return rc;
}
/* IO_pp_init
*
* Read the ppdev entries from wine.conf, open the device and check
* for necessary IOCTRL
* Report verbose about possible errors
*/
char IO_pp_init(void)
{
char name[80];
char buffer[256];
HANDLE root, hkey;
int i,idx=0,fd,res,userbase,nports=0;
char * timeout;
char ret=1;
int lasterror;
OBJECT_ATTRIBUTES attr;
UNICODE_STRING nameW;
static const WCHAR configW[] = {'S','o','f','t','w','a','r','e','\\',
'W','i','n','e','\\','V','D','M','\\','p','p','d','e','v',0};
TRACE("\n");
RtlOpenCurrentUser( KEY_ALL_ACCESS, &root );
attr.Length = sizeof(attr);
attr.RootDirectory = root;
attr.ObjectName = &nameW;
attr.Attributes = 0;
attr.SecurityDescriptor = NULL;
attr.SecurityQualityOfService = NULL;
RtlInitUnicodeString( &nameW, configW );
/* @@ Wine registry key: HKCU\Software\Wine\VDM\ppdev */
if (NtOpenKey( &hkey, KEY_ALL_ACCESS, &attr )) hkey = 0;
NtClose( root );
if (!hkey) return 1;
for (;;)
{
DWORD total_size, len;
char temp[256];
KEY_VALUE_FULL_INFORMATION *info = (KEY_VALUE_FULL_INFORMATION *)temp;
if (NtEnumerateValueKey( hkey, idx, KeyValueFullInformation,
temp, sizeof(temp), &total_size )) break;
if (info->Type != REG_SZ) break;
RtlUnicodeToMultiByteN( name, sizeof(name)-1, &len, info->Name, info->NameLength );
name[len] = 0;
RtlUnicodeToMultiByteN( buffer, sizeof(buffer)-1, &len,
(WCHAR *)(temp + info->DataOffset), total_size-info->DataOffset );
buffer[len] = 0;
idx++;
if(nports >4)
{
FIXME("Make the PPDeviceList larger than 5 elements\n");
break;
}
TRACE("Device '%s' at virtual userbase '%s'\n", buffer,name);
timeout = strchr(buffer,',');
if (timeout)
*timeout++=0;
fd=open(buffer,O_RDWR);
lasterror=errno;
if (fd == -1)
{
WARN("Configuration: No access to %s Cause: %s\n",buffer,strerror(lasterror));
WARN("Rejecting configuration item\n");
if (lasterror == ENODEV)
ERR("Is the ppdev module loaded?\n");
continue;
}
userbase = strtol(name, NULL, 16);
if ( errno == ERANGE)
{
WARN("Configuration: Invalid base %s for %s\n",name,buffer);
WARN("Rejecting configuration item\n");
continue;
}
if (ioctl (fd,PPCLAIM,0))
{
ERR("PPCLAIM rejected %s\n",buffer);
ERR("Perhaps the device is already in use or nonexistent\n");
continue;
}
if (nports > 0)
{
for (i=0; i<= nports; i++)
{
if (PPDeviceList[i].userbase == userbase)
{
WARN("Configuration: %s uses the same virtual ports as %s\n",
buffer,PPDeviceList[0].devicename);
WARN("Configuration: Rejecting configuration item\n");
userbase = 0;
break;
}
}
if (!userbase) continue;
}
/* Check for the minimum required IOCTLS */
if ((ioctl(fd,PPRDATA,&res))||
(ioctl(fd,PPRSTATUS,&res))||
(ioctl(fd,PPRCONTROL,&res)))
{
ERR("PPUSER IOCTL not available for parport device %s\n",buffer);
continue;
}
if (ioctl (fd,PPRELEASE,0))
{
ERR("PPRELEASE rejected %s\n",buffer);
ERR("Perhaps the device is already in use or nonexistent\n");
continue;
}
PPDeviceList[nports].devicename = malloc(sizeof(buffer)+1);
if (!PPDeviceList[nports].devicename)
{
ERR("No (more) space for devicename\n");
break;
}
strcpy(PPDeviceList[nports].devicename,buffer);
PPDeviceList[nports].fd = fd;
PPDeviceList[nports].userbase = userbase;
PPDeviceList[nports].lastaccess=GetTickCount();
if (timeout)
{
PPDeviceList[nports].timeout = strtol(timeout, NULL, 10);
if (errno == ERANGE)
{
WARN("Configuration: Invalid timeout %s in configuration for %s, Setting to 0\n",
timeout,buffer);
PPDeviceList[nports].timeout = 0;
}
}
else
PPDeviceList[nports].timeout = 0;
nports++;
}
TRACE("found %d ports\n",nports);
NtClose( hkey );
PPDeviceNum= nports;
if (nports > 1)
/* sort in ascending order for userbase for faster access */
qsort (PPDeviceList,PPDeviceNum,sizeof(PPDeviceStruct),IO_pp_sort);
if (nports)
ret=0;
for (idx= 0;idx<PPDeviceNum; idx++)
TRACE("found device %s userbase %x fd %x timeout %d\n",
PPDeviceList[idx].devicename, PPDeviceList[idx].userbase,
PPDeviceList[idx].fd,PPDeviceList[idx].timeout);
/* FIXME:
register a timer callback perhaps every 30 seconds to release unused ports
Set lastaccess = 0 as indicator when port was released
*/
return ret;
}
void
_CRTAPI1 main(int, char *)
{
NTSTATUS status;
OBJECT_ATTRIBUTES ObjectAttributes;
UNICODE_STRING KeyName;
UNICODE_STRING KeyName2;
UNICODE_STRING ClassName;
UNICODE_STRING ClassName2;
UNICODE_STRING ValueName;
UNICODE_STRING ValueName2;
HANDLE BaseHandle;
HANDLE Testhand1;
ULONG Disposition;
LARGE_INTEGER CompTime;
ULONG buffer[100];
ULONG bufsize = sizeof(ULONG) * 100;
PKEY_NODE_INFORMATION NodeInformation;
PKEY_VALUE_FULL_INFORMATION KeyValueInformation;
PKEY_VALUE_BASIC_INFORMATION KeyValueBasic;
ULONG ResultLength;
PUCHAR datastring = "Some simple ascii data for use as a value";
PUCHAR datastring2 = "Some more not so simple data $#";
ULONG expected;
PVOID tp;
printf("rtmisc1: starting\n");
NodeInformation = (PKEY_NODE_INFORMATION)&(buffer[0]);
KeyValueInformation = (PKEY_VALUE_FULL_INFORMATION)&(buffer[0]);
KeyValueBasic = (PKEY_VALUE_BASIC_INFORMATION)&(buffer[0]);
//
// t0: Perform all operations against a base node, open it here.
//
RtlInitUnicodeString(
&KeyName,
L"\\REGISTRY\\MACHINE\\TEST"
);
InitializeObjectAttributes(
&ObjectAttributes,
&KeyName,
0,
(HANDLE)NULL,
NULL
);
ObjectAttributes.Attributes |= OBJ_CASE_INSENSITIVE;
status = NtOpenKey(
&BaseHandle,
MAXIMUM_ALLOWED,
&ObjectAttributes
);
if (!NT_SUCCESS(status)) {
printf("rtmisc1: t0: %08lx\n", status);
goto punt;
}
//
// t1: Create a key with class and title index
//
RtlInitUnicodeString(
&ClassName,
L"t1 Class Name"
);
RtlInitUnicodeString(
&KeyName,
L"first_test_node"
);
InitializeObjectAttributes(
&ObjectAttributes,
&KeyName,
0,
BaseHandle,
NULL
);
ObjectAttributes.Attributes |= OBJ_CASE_INSENSITIVE;
NtQuerySystemTime(&CompTime);
// printf("ClassName@%08lx KeyName@%08lx\n",
// ClassName.Buffer, KeyName.Buffer);
status = NtCreateKey(
&Testhand1,
MAXIMUM_ALLOWED,
&ObjectAttributes,
TITLE_INDEX_1,
&ClassName,
0,
&Disposition
);
if (!NT_SUCCESS(status)) {
printf("rtmisc1: t1: %08lx\n", status);
goto punt;
}
if (Disposition != REG_CREATED_NEW_KEY) {
printf("rtmisc1: t1a: got old key, expected to create new one\n");
failure++;
}
//
// t2: See if we can get data back, and if it makes sense
//
RtlZeroMemory(NodeInformation, bufsize);
status = NtQueryKey(
Testhand1,
KeyNodeInformation,
NodeInformation,
bufsize,
&ResultLength
);
if (!NT_SUCCESS(status)) {
printf("rtmisc1: t2a: %08lx\n", status);
goto punt;
}
if (ResultLength != 80) {
printf("rtmisc1: t2i: expect 80, ResultLength = %d\n", ResultLength);
failure++;
}
NameClassAndTitle(
NodeInformation,
ClassName,
TITLE_INDEX_1,
KeyName,
CompTime,
FALSE, // time must be >= CompTime
"rtmisc1: t2b: "
);
CompTime = NodeInformation->LastWriteTime;
status = NtClose(Testhand1);
if (!NT_SUCCESS(status)) {
printf("rtmisc1: t2c: %08lx\n");
goto punt;
}
//
// t3: Reopen the key with create, see if data still there.
//
status = NtCreateKey(
&Testhand1,
MAXIMUM_ALLOWED,
&ObjectAttributes,
TITLE_INDEX_1,
&ClassName,
0,
&Disposition
);
if (!NT_SUCCESS(status)) {
printf("rtmisc1: t3: %08lx\n", status);
goto punt;
}
if (Disposition != REG_OPENED_EXISTING_KEY) {
printf("rtmisc1: t3a failure\n");
failure++;
}
RtlZeroMemory(NodeInformation, bufsize);
status = NtQueryKey(
Testhand1,
KeyNodeInformation,
NodeInformation,
bufsize,
&ResultLength
);
if (!NT_SUCCESS(status)) {
printf("rtmisc1: t3b: %08lx\n", status);
goto punt;
}
NameClassAndTitle(
NodeInformation,
ClassName,
TITLE_INDEX_1,
KeyName,
CompTime,
FALSE, // time must be >= CompTime
"rtmisc1: t3c: "
);
status = NtClose(Testhand1);
if (!NT_SUCCESS(status)) {
printf("rtmisc1: t3d: %08lx\n");
goto punt;
}
//
// t4: Reopen the key with open, see if data still there.
//
status = NtOpenKey(
&Testhand1,
MAXIMUM_ALLOWED,
&ObjectAttributes
);
if (!NT_SUCCESS(status)) {
printf("rtmisc1: t4: %08lx\n", status);
goto punt;
}
RtlZeroMemory(NodeInformation, bufsize);
status = NtQueryKey(
Testhand1,
KeyNodeInformation,
NodeInformation,
bufsize,
&ResultLength
);
if (!NT_SUCCESS(status)) {
printf("rtmisc1: t4a: %08lx\n", status);
goto punt;
}
NameClassAndTitle(
NodeInformation,
ClassName,
TITLE_INDEX_1,
KeyName,
CompTime,
FALSE, // time must be >= CompTime
"rtmisc1: t4b: "
);
// status = NtClose(Testhand1);
// if (!NT_SUCCESS(status)) {
// printf("rtmisc1: t4c: %08lx\n");
// exit(1);
// }
//
// t5: Create a value
//
RtlInitUnicodeString(
&ValueName,
L"the very first value stored in the registry"
);
status = NtSetValueKey(
Testhand1,
&ValueName,
TITLE_INDEX_2,
TYPE_1,
datastring,
strlen(datastring)+1
);
if (!NT_SUCCESS(status)) {
printf("rtmisc1: t5: %08lx\n", status);
failure++;
}
//
// t6: Read the value back
//
RtlZeroMemory(KeyValueInformation, bufsize);
status = NtQueryValueKey(
Testhand1,
&ValueName,
KeyValueFullInformation,
KeyValueInformation,
bufsize,
&ResultLength
);
if (!NT_SUCCESS(status)) {
printf("rtmisc1: t6: %08lx\n", status);
goto punt;
}
expected = FIELD_OFFSET(KEY_VALUE_FULL_INFORMATION, Name) +
ValueName.Length + strlen(datastring) + 1;
if (ResultLength != expected) {
printf("rtmisc1: t6a: expected = %08lx actual = %08lx",
expected, ResultLength);
failure++;
}
if ( (KeyValueInformation->TitleIndex != TITLE_INDEX_2) ||
(KeyValueInformation->Type != TYPE_1) ||
(KeyValueInformation->NameLength != ValueName.Length) ||
(KeyValueInformation->DataLength != strlen(datastring)+1))
{
printf("rtmisc1: t6b: wrong description data\n");
failure++;
}
tp = (PWSTR)&(KeyValueInformation->Name[0]);
if (wcsncmp(ValueName.Buffer, tp, (ValueName.Length/sizeof(WCHAR))) != 0) {
printf("rtmisc1: t6c: wrong name\n");
expectstring(
ValueName.Buffer,
(ValueName.Length/sizeof(WCHAR)),
(PWSTR)&(KeyValueInformation->Name[0]),
(KeyValueInformation->NameLength/sizeof(WCHAR))
);
failure++;
}
tp = (PUCHAR)KeyValueInformation + KeyValueInformation->DataOffset;
if (strcmp(tp, datastring) != 0) {
printf("rtmisc1: t6d: wrong data\n");
printf("expected '%s', got '%s'\n", datastring, tp);
failure++;
}
//
// t7: Create a second value
//
RtlInitUnicodeString(
&ValueName2,
L"the second value stored in the registry"
);
status = NtSetValueKey(
Testhand1,
&ValueName2,
TITLE_INDEX_3,
TYPE_2,
datastring2,
strlen(datastring2)+1
);
if (!NT_SUCCESS(status)) {
printf("rtmisc1: t7: %08lx\n", status);
failure++;
}
//
// t8: Read the second value back (short form)
//
RtlZeroMemory(KeyValueBasic, bufsize);
status = NtQueryValueKey(
Testhand1,
&ValueName2,
KeyValueBasicInformation,
KeyValueBasic,
bufsize,
&ResultLength
);
if (!NT_SUCCESS(status)) {
printf("rtmisc1: t8: %08lx\n", status);
goto punt;
}
expected = FIELD_OFFSET(KEY_VALUE_BASIC_INFORMATION, Name) +
ValueName2.Length;
if (ResultLength != expected) {
printf("rtmisc1: t8a: expected = %08lx actual = %08lx",
expected, ResultLength);
failure++;
}
if ( (KeyValueBasic->TitleIndex != TITLE_INDEX_3) ||
(KeyValueBasic->Type != TYPE_2) ||
(KeyValueBasic->NameLength != ValueName2.Length))
{
printf("rtmisc1: t8b: wrong description data\n");
failure++;
}
tp = (PWSTR)&(KeyValueBasic->Name[0]);
if (wcsncmp(ValueName2.Buffer, tp, (ValueName2.Length/sizeof(WCHAR))) != 0) {
printf("rtmisc1: t8c: wrong name\n");
expectstring(
ValueName2.Buffer,
(ValueName2.Length/sizeof(WCHAR)),
(PWSTR)&(KeyValueBasic->Name[0]),
(KeyValueBasic->NameLength/sizeof(WCHAR))
);
failure++;
}
//
// t9: Enumerate the values (short form)
//
RtlZeroMemory(KeyValueBasic, bufsize);
status = NtEnumerateValueKey(
Testhand1,
0, // Index
KeyValueBasicInformation,
KeyValueBasic,
bufsize,
&ResultLength
);
if (!NT_SUCCESS(status)) {
printf("rtmisc1: t9: %08lx\n", status);
goto punt;
}
expected = FIELD_OFFSET(KEY_VALUE_BASIC_INFORMATION, Name) +
ValueName.Length;
if (ResultLength != expected) {
printf("rtmisc1: t9a: expected = %08lx actual = %08lx",
expected, ResultLength);
failure++;
}
if (KeyValueBasic->NameLength != ValueName.Length)
{
printf("rtmisc1: t9b: wrong description data\n");
failure++;
}
tp = (PWSTR)&(KeyValueBasic->Name[0]);
if (wcsncmp(ValueName.Buffer, tp, (ValueName.Length/sizeof(WCHAR))) != 0) {
printf("rtmisc1: t9c: wrong name\n");
expectstring(
ValueName.Buffer,
(ValueName.Length/sizeof(WCHAR)),
(PWSTR)&(KeyValueBasic->Name[0]),
(KeyValueBasic->NameLength/sizeof(WCHAR))
);
failure++;
}
RtlZeroMemory(KeyValueBasic, bufsize);
status = NtEnumerateValueKey(
Testhand1,
1, // Index
KeyValueBasicInformation,
KeyValueBasic,
bufsize,
&ResultLength
);
if (!NT_SUCCESS(status)) {
printf("rtmisc1: t9d: %08lx\n", status);
goto punt;
}
expected = FIELD_OFFSET(KEY_VALUE_BASIC_INFORMATION, Name) +
ValueName2.Length;
if (ResultLength != expected) {
printf("rtmisc1: t9e: expected = %08lx actual = %08lx",
expected, ResultLength);
failure++;
}
if (KeyValueBasic->NameLength != ValueName2.Length)
{
printf("rtmisc1: t9f: wrong description data\n");
failure++;
}
tp = (PWSTR)&(KeyValueBasic->Name[0]);
if (wcsncmp(ValueName2.Buffer, tp, (ValueName2.Length/sizeof(WCHAR))) != 0) {
printf("rtmisc1: t9g: wrong name\n");
expectstring(
ValueName2.Buffer,
(ValueName2.Length/sizeof(WCHAR)),
(PWSTR)&(KeyValueBasic->Name[0]),
(KeyValueBasic->NameLength/sizeof(WCHAR))
);
failure++;
}
status = NtEnumerateValueKey(
Testhand1,
2, // Index
KeyValueBasicInformation,
KeyValueBasic,
bufsize,
&ResultLength
);
if (status != STATUS_NO_MORE_ENTRIES) {
printf("rtmisc1: t9h: %08lx\n", status);
goto punt;
}
//
// t10: create a second subkey and ennumerate the subkeys
//
status = NtClose(Testhand1);
if (!NT_SUCCESS(status)) {
printf("rtmisc1: t10a: %08lx\n", status);
failure++;
}
RtlInitUnicodeString(
&ClassName2,
L"t2 Class Name"
);
RtlInitUnicodeString(
&KeyName2,
L"second_test_node"
);
InitializeObjectAttributes(
&ObjectAttributes,
&KeyName2,
0,
BaseHandle,
NULL
);
ObjectAttributes.Attributes |= OBJ_CASE_INSENSITIVE;
status = NtCreateKey(
&Testhand1,
MAXIMUM_ALLOWED,
&ObjectAttributes,
TITLE_INDEX_2,
&ClassName2,
0,
&Disposition
);
if (!NT_SUCCESS(status)) {
printf("rtmisc1: t10b: %08lx\n", status);
goto punt;
}
if (Disposition != REG_CREATED_NEW_KEY) {
printf("rtmisc1: t10c: got old key, expected to create new one\n");
failure++;
}
//
// See if we can get data back, and if it makes sense
//
RtlZeroMemory(NodeInformation, bufsize);
status = NtQueryKey(
Testhand1,
KeyNodeInformation,
NodeInformation,
bufsize,
&ResultLength
);
if (!NT_SUCCESS(status)) {
printf("rtmisc1: t10d: %08lx\n", status);
goto punt;
}
CompTime = NodeInformation->LastWriteTime;
NameClassAndTitle(
NodeInformation,
ClassName2,
TITLE_INDEX_2,
KeyName2,
CompTime,
TRUE,
"rtmisc1: t10e: "
);
status = NtClose(Testhand1);
if (!NT_SUCCESS(status)) {
printf("rtmisc1: t10f: %08lx\n");
goto punt;
}
RtlZeroMemory(NodeInformation, bufsize);
status = NtEnumerateKey(
BaseHandle,
0,
KeyNodeInformation,
NodeInformation,
bufsize,
&ResultLength
);
if (!NT_SUCCESS(status)) {
printf("rtmisc1: t10g: %08lx\n", status);
failure++;
}
CompTime = NodeInformation->LastWriteTime;
NameClassAndTitle(
NodeInformation,
ClassName,
TITLE_INDEX_1,
KeyName,
CompTime,
TRUE,
"rtmisc1: t10h: "
);
RtlZeroMemory(NodeInformation, bufsize);
status = NtEnumerateKey(
BaseHandle,
1,
KeyNodeInformation,
NodeInformation,
bufsize,
&ResultLength
);
if (!NT_SUCCESS(status)) {
printf("rtmisc1: t10i: %08lx\n", status);
failure++;
}
CompTime = NodeInformation->LastWriteTime;
NameClassAndTitle(
NodeInformation,
ClassName2,
TITLE_INDEX_2,
KeyName2,
CompTime,
TRUE,
"rtmisc1: t10j: "
);
status = NtEnumerateKey(
BaseHandle,
2,
KeyNodeInformation,
NodeInformation,
bufsize,
&ResultLength
);
if (status != STATUS_NO_MORE_ENTRIES) {
printf("rtmisc1: t10k: %08lx\n", status);
failure++;
}
//
// Summary report
//
if (!failure) {
printf("rtmisc1: success");
exit(0);
} else {
printf("rtmisc1: failed, %d failures\n", failure);
exit(1);
}
punt:
failure++;
printf("rtmisc1: failed, %d failures\n", failure);
exit(1);
}
void test9(void)
{
HANDLE hKey = NULL, hKey1;
OBJECT_ATTRIBUTES ObjectAttributes;
NTSTATUS Status;
UNICODE_STRING KeyName = RTL_CONSTANT_STRING(L"\\Registry");
ULONG Index,Length,i;
KEY_BASIC_INFORMATION KeyInformation[5];
KEY_VALUE_FULL_INFORMATION KeyValueInformation[5];
dprintf("NtOpenKey \\Registry : ");
InitializeObjectAttributes(&ObjectAttributes,
&KeyName,
OBJ_CASE_INSENSITIVE,
NULL,
NULL);
Status=NtOpenKey( &hKey1, MAXIMUM_ALLOWED, &ObjectAttributes);
dprintf("\t\t\t\tStatus =%x\n",Status);
if (Status == 0) {
dprintf("NtQueryKey : ");
Status = NtQueryKey(hKey1, KeyBasicInformation, &KeyInformation[0], sizeof(KeyInformation), &Length);
dprintf("\t\t\t\t\tStatus =%x\n",Status);
if (Status == STATUS_SUCCESS) {
dprintf("\tKey Name = ");
for (i=0;i<KeyInformation[0].NameLength/2;i++)
dprintf("%C",KeyInformation[0].Name[i]);
dprintf("\n");
}
dprintf("NtEnumerateKey : \n");
Index = 0;
while (Status == STATUS_SUCCESS) {
Status = NtEnumerateKey(hKey1,Index++,KeyBasicInformation,&KeyInformation[0], sizeof(KeyInformation),&Length);
if (Status == STATUS_SUCCESS) {
dprintf("\tSubKey Name = ");
for (i = 0; i < KeyInformation[0].NameLength / 2; i++)
dprintf("%C",KeyInformation[0].Name[i]);
dprintf("\n");
}
}
dprintf("NtClose : ");
Status = NtClose( hKey1 );
dprintf("\t\t\t\t\tStatus =%x\n",Status);
}
NtClose(hKey); // RobD - hKey unused so-far, should this have been hKey1 ???
dprintf("NtOpenKey \\Registry\\Machine : ");
RtlRosInitUnicodeStringFromLiteral(&KeyName, L"\\Registry\\Machine");
InitializeObjectAttributes(&ObjectAttributes,
&KeyName,
OBJ_CASE_INSENSITIVE,
NULL,
NULL);
Status = NtOpenKey(&hKey1, MAXIMUM_ALLOWED, &ObjectAttributes);
dprintf("\t\t\tStatus =%x\n",Status);
//Status of c0000001 opening \Registry\Machine\System\CurrentControlSet\Services\Tcpip\Linkage
// dprintf("NtOpenKey System\\CurrentControlSet\\Services\\Tcpip : ");
// RtlRosInitUnicodeStringFromLiteral(&KeyName, L"System\\CurrentControlSet\\Services\\Tcpip");
#if 1
dprintf("NtOpenKey System\\ControlSet001\\Services\\Tcpip\\Parameters : ");
RtlRosInitUnicodeStringFromLiteral(&KeyName, L"System\\ControlSet001\\Services\\Tcpip\\Parameters");
#else
dprintf("NtOpenKey System\\CurrentControlSet\\Services\\Tcpip : ");
RtlRosInitUnicodeStringFromLiteral(&KeyName, L"System\\CurrentControlSet\\Services\\Tcpip");
#endif
InitializeObjectAttributes(&ObjectAttributes, &KeyName, OBJ_CASE_INSENSITIVE, hKey1 , NULL);
Status = NtOpenKey(&hKey, KEY_READ , &ObjectAttributes);
dprintf("\t\t\tStatus =%x\n",Status);
if (Status == 0) {
dprintf("NtQueryValueKey : ");
RtlRosInitUnicodeStringFromLiteral(&KeyName, L"NameServer");
Status = NtQueryValueKey(hKey, &KeyName, KeyValueFullInformation, &KeyValueInformation[0], sizeof(KeyValueInformation), &Length);
dprintf("\t\t\t\tStatus =%x\n",Status);
if (Status == STATUS_SUCCESS) {
dprintf("\tValue:DO=%d, DL=%d, NL=%d, Name = "
,KeyValueInformation[0].DataOffset
,KeyValueInformation[0].DataLength
,KeyValueInformation[0].NameLength);
for (i = 0; i < 10 && i < KeyValueInformation[0].NameLength / 2; i++)
dprintf("%C", KeyValueInformation[0].Name[i]);
dprintf("\n");
dprintf("\t\tType = %d\n", KeyValueInformation[0].Type);
if (KeyValueInformation[0].Type == REG_SZ)
//dprintf("\t\tValue = %S\n", KeyValueInformation[0].Name + 1 + KeyValueInformation[0].NameLength / 2);
dprintf("\t\tValue = %S\n", KeyValueInformation[0].Name + KeyValueInformation[0].NameLength / 2);
}
dprintf("NtEnumerateValueKey : \n");
Index = 0;
while (Status == STATUS_SUCCESS) {
Status = NtEnumerateValueKey(hKey, Index++, KeyValueFullInformation, &KeyValueInformation[0], sizeof(KeyValueInformation), &Length);
if (Status == STATUS_SUCCESS) {
dprintf("\tValue:DO=%d, DL=%d, NL=%d, Name = "
,KeyValueInformation[0].DataOffset
,KeyValueInformation[0].DataLength
,KeyValueInformation[0].NameLength);
for (i = 0; i < KeyValueInformation[0].NameLength / 2; i++)
dprintf("%C", KeyValueInformation[0].Name[i]);
dprintf(", Type = %d\n", KeyValueInformation[0].Type);
if (KeyValueInformation[0].Type == REG_SZ)
dprintf("\t\tValue = %S\n", ((char*)&KeyValueInformation[0]+KeyValueInformation[0].DataOffset));
if (KeyValueInformation[0].Type == REG_DWORD)
dprintf("\t\tValue = %X\n", *((DWORD*)((char*)&KeyValueInformation[0]+KeyValueInformation[0].DataOffset)));
}
}
dprintf("NtClose : ");
Status = NtClose(hKey);
dprintf("\t\t\t\t\tStatus =%x\n", Status);
}
NtClose(hKey1);
}
void
DumpValues(
HANDLE Handle
)
{
NTSTATUS status;
static char tempbuffer[WORK_SIZE];
PKEY_VALUE_FULL_INFORMATION KeyValueInformation;
ULONG index;
ULONG ResultLength;
PULONG p;
ULONG i;
UNICODE_STRING valname;
KeyValueInformation = (PKEY_VALUE_FULL_INFORMATION)tempbuffer;
for (index = 0; TRUE; index++) {
RtlZeroMemory(KeyValueInformation, WORK_SIZE);
status = NtEnumerateValueKey(
Handle,
index,
KeyValueFullInformation,
KeyValueInformation,
WORK_SIZE,
&ResultLength
);
if (status == STATUS_NO_MORE_ENTRIES) {
return;
} else if (!NT_SUCCESS(status)) {
printf("rtdmp: dumpvalues: status = %08lx\n", status);
exit(1);
}
printf("\t");
valname.Length = KeyValueInformation->NameLength;
valname.MaximumLength = KeyValueInformation->NameLength;
valname.Buffer = (PWSTR)&(KeyValueInformation->Name[0]);
printf("'");
print(&valname);
printf("'\n");
printf(
"\ttitle index = %d\ttype = ",
KeyValueInformation->TitleIndex
);
switch( KeyValueInformation->Type ) {
case REG_NONE:
printf("NONE\n\tValue = 0x%x",
*((PULONG)KeyValueInformation + KeyValueInformation->DataOffset));
break;
case REG_SZ:
printf("REG_SZ\n\tValue = '%ws'",
((PUCHAR)KeyValueInformation + KeyValueInformation->DataOffset));
break;
case REG_BINARY:
printf("REG_BINARY\n\tValue = (%lx)\n", KeyValueInformation->DataLength);
p = (PULONG)KeyValueInformation + KeyValueInformation->DataOffset;
i = 1;
while (i <= KeyValueInformation->DataLength) {
printf( " %08lx", *p++ );
if ((i % 8) == 0) {
printf( "\n" );
}
i += sizeof( ULONG );
}
break;
// case REG_DWORD:
case REG_DWORD_LITTLE_ENDIAN:
printf("REG_DWORD\n\tValue = 0x%lx",
*((PULONG)KeyValueInformation + KeyValueInformation->DataOffset));
break;
case REG_DWORD_BIG_ENDIAN:
printf("REG_DWORD_BIG_ENDIAN\n\tValue = 0x%lx",
*((PULONG)KeyValueInformation + KeyValueInformation->DataOffset));
break;
}
printf("\n\n");
}
}
static BOOLEAN
InitializeFmIfsOnce(void)
{
OBJECT_ATTRIBUTES ObjectAttributes;
UNICODE_STRING RegistryPath
= RTL_CONSTANT_STRING(L"\\REGISTRY\\Machine\\SOFTWARE\\ReactOS\\ReactOS\\CurrentVersion\\IFS");
HANDLE hKey = NULL;
PKEY_VALUE_FULL_INFORMATION Buffer;
ULONG BufferSize = sizeof(KEY_VALUE_FULL_INFORMATION) + MAX_PATH;
ULONG RequiredSize;
ULONG i = 0;
UNICODE_STRING Name;
UNICODE_STRING Data;
NTSTATUS Status;
InitializeListHead(&ProviderListHead);
/* Read IFS providers from HKLM\SOFTWARE\ReactOS\ReactOS\CurrentVersion\IFS */
InitializeObjectAttributes(&ObjectAttributes, &RegistryPath, 0, NULL, NULL);
Status = NtOpenKey(&hKey, KEY_QUERY_VALUE, &ObjectAttributes);
if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
return TRUE;
else if (!NT_SUCCESS(Status))
return FALSE;
Buffer = (PKEY_VALUE_FULL_INFORMATION)RtlAllocateHeap(
RtlGetProcessHeap(),
0,
BufferSize);
if (!Buffer)
{
NtClose(hKey);
return FALSE;
}
while (TRUE)
{
Status = NtEnumerateValueKey(
hKey,
i++,
KeyValueFullInformation,
Buffer,
BufferSize,
&RequiredSize);
if (Status == STATUS_BUFFER_OVERFLOW)
continue;
else if (!NT_SUCCESS(Status))
break;
else if (Buffer->Type != REG_SZ)
continue;
Name.Length = Name.MaximumLength = Buffer->NameLength;
Name.Buffer = Buffer->Name;
Data.Length = Data.MaximumLength = Buffer->DataLength;
Data.Buffer = (PWCHAR)((ULONG_PTR)Buffer + Buffer->DataOffset);
if (Data.Length > sizeof(WCHAR) && Data.Buffer[Data.Length / sizeof(WCHAR) - 1] == UNICODE_NULL)
Data.Length -= sizeof(WCHAR);
AddProvider(&Name, Data.Buffer);
}
NtClose(hKey);
RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
return TRUE;
}
static VOID RemoveAppCompatEntry(
_In_ HANDLE ParentKey
)
{
static PH_STRINGREF keyName = PH_STRINGREF_INIT(L"ProcessHacker.exe");
ULONG bufferLength;
KEY_FULL_INFORMATION fullInfo;
memset(&fullInfo, 0, sizeof(KEY_FULL_INFORMATION));
if (!NT_SUCCESS(NtQueryKey(
ParentKey,
KeyFullInformation,
&fullInfo,
sizeof(KEY_FULL_INFORMATION),
&bufferLength
)))
{
return;
}
for (ULONG i = 0; i < fullInfo.Values; i++)
{
PPH_STRING value;
PKEY_VALUE_FULL_INFORMATION buffer;
bufferLength = sizeof(KEY_VALUE_FULL_INFORMATION);
buffer = PhAllocate(bufferLength);
memset(buffer, 0, bufferLength);
if (NT_SUCCESS(NtEnumerateValueKey(
ParentKey,
i,
KeyValueFullInformation,
buffer,
bufferLength,
&bufferLength
)))
{
PhFree(buffer);
break;
}
//bufferLength = bufferLength;
buffer = PhReAllocate(buffer, bufferLength);
memset(buffer, 0, bufferLength);
if (!NT_SUCCESS(NtEnumerateValueKey(
ParentKey,
i,
KeyValueFullInformation,
buffer,
bufferLength,
&bufferLength
)))
{
PhFree(buffer);
break;
}
if (value = PhCreateStringEx(buffer->Name, buffer->NameLength))
{
UNICODE_STRING us;
PhStringRefToUnicodeString(&value->sr, &us);
if (PhEndsWithStringRef(&value->sr, &keyName, TRUE))
{
NtDeleteValueKey(ParentKey, &us);
}
PhDereferenceObject(value);
}
PhFree(buffer);
}
}
