static BOOLEAN
GetDisplayIdentifier(PWSTR Identifier,
ULONG IdentifierLength)
{
OBJECT_ATTRIBUTES ObjectAttributes;
UNICODE_STRING KeyName;
WCHAR Buffer[32];
HANDLE BusKey;
HANDLE BusInstanceKey;
HANDLE ControllerKey;
HANDLE ControllerInstanceKey;
ULONG BusInstance;
ULONG ControllerInstance;
ULONG BufferLength;
ULONG ReturnedLength;
PKEY_VALUE_PARTIAL_INFORMATION ValueInfo;
NTSTATUS Status;
DPRINT("GetDisplayIdentifier() called\n");
/* Open the bus key */
RtlInitUnicodeString(&KeyName,
L"\\Registry\\Machine\\HARDWARE\\Description\\System\\MultifunctionAdapter");
InitializeObjectAttributes(&ObjectAttributes,
&KeyName,
OBJ_CASE_INSENSITIVE,
NULL,
NULL);
Status = NtOpenKey(&BusKey,
KEY_ENUMERATE_SUB_KEYS,
&ObjectAttributes);
if (!NT_SUCCESS(Status))
{
DPRINT("NtOpenKey() failed (Status %lx)\n", Status);
return FALSE;
}
BusInstance = 0;
while (TRUE)
{
swprintf(Buffer, L"%lu", BusInstance);
RtlInitUnicodeString(&KeyName,
Buffer);
InitializeObjectAttributes(&ObjectAttributes,
&KeyName,
OBJ_CASE_INSENSITIVE,
BusKey,
NULL);
Status = NtOpenKey(&BusInstanceKey,
KEY_ENUMERATE_SUB_KEYS,
&ObjectAttributes);
if (!NT_SUCCESS(Status))
{
DPRINT("NtOpenKey() failed (Status %lx)\n", Status);
NtClose(BusKey);
return FALSE;
}
/* Open the controller type key */
RtlInitUnicodeString(&KeyName,
L"DisplayController");
InitializeObjectAttributes(&ObjectAttributes,
&KeyName,
OBJ_CASE_INSENSITIVE,
BusInstanceKey,
NULL);
Status = NtOpenKey(&ControllerKey,
KEY_ENUMERATE_SUB_KEYS,
&ObjectAttributes);
if (NT_SUCCESS(Status))
{
ControllerInstance = 0;
while (TRUE)
{
/* Open the pointer controller instance key */
swprintf(Buffer, L"%lu", ControllerInstance);
RtlInitUnicodeString(&KeyName,
Buffer);
InitializeObjectAttributes(&ObjectAttributes,
&KeyName,
OBJ_CASE_INSENSITIVE,
ControllerKey,
NULL);
Status = NtOpenKey(&ControllerInstanceKey,
KEY_QUERY_VALUE,
&ObjectAttributes);
if (!NT_SUCCESS(Status))
{
DPRINT("NtOpenKey() failed (Status %lx)\n", Status);
NtClose(ControllerKey);
NtClose(BusInstanceKey);
NtClose(BusKey);
return FALSE;
}
/* Get controller identifier */
RtlInitUnicodeString(&KeyName,
L"Identifier");
BufferLength = sizeof(KEY_VALUE_PARTIAL_INFORMATION) +
256 * sizeof(WCHAR);
ValueInfo = (KEY_VALUE_PARTIAL_INFORMATION*) RtlAllocateHeap(RtlGetProcessHeap(),
0,
BufferLength);
if (ValueInfo == NULL)
{
DPRINT("RtlAllocateHeap() failed\n");
NtClose(ControllerInstanceKey);
NtClose(ControllerKey);
NtClose(BusInstanceKey);
NtClose(BusKey);
return FALSE;
}
Status = NtQueryValueKey(ControllerInstanceKey,
&KeyName,
KeyValuePartialInformation,
ValueInfo,
BufferLength,
&ReturnedLength);
if (NT_SUCCESS(Status))
{
DPRINT("Identifier: %S\n", (PWSTR)ValueInfo->Data);
BufferLength = min(ValueInfo->DataLength / sizeof(WCHAR), IdentifierLength);
RtlCopyMemory (Identifier,
ValueInfo->Data,
BufferLength * sizeof(WCHAR));
Identifier[BufferLength] = 0;
RtlFreeHeap(RtlGetProcessHeap(),
0,
ValueInfo);
NtClose(ControllerInstanceKey);
NtClose(ControllerKey);
NtClose(BusInstanceKey);
NtClose(BusKey);
return TRUE;
}
NtClose(ControllerInstanceKey);
ControllerInstance++;
}
NtClose(ControllerKey);
}
NtClose(BusInstanceKey);
BusInstance++;
}
NtClose(BusKey);
return FALSE;
}
/*++
* @name GetDosDevicesProtection
*
* The GetDosDevicesProtection creates a security descriptor for the DOS Devices
* Object Directory.
*
* @param DosDevicesSd
* Pointer to the Security Descriptor to return.
*
* @return STATUS_SUCCESS in case of success, STATUS_UNSUCCESSFUL otherwise.
*
* @remarks Depending on the DOS Devices Protection Mode (set in the registry),
* regular users may or may not have full access to the directory.
*
*--*/
NTSTATUS
NTAPI
GetDosDevicesProtection(OUT PSECURITY_DESCRIPTOR DosDevicesSd)
{
SID_IDENTIFIER_AUTHORITY WorldAuthority = {SECURITY_WORLD_SID_AUTHORITY};
SID_IDENTIFIER_AUTHORITY CreatorAuthority = {SECURITY_CREATOR_SID_AUTHORITY};
SID_IDENTIFIER_AUTHORITY NtSidAuthority = {SECURITY_NT_AUTHORITY};
PSID WorldSid, CreatorSid, AdminSid, SystemSid;
UCHAR KeyValueBuffer[0x40];
PKEY_VALUE_PARTIAL_INFORMATION KeyValuePartialInfo;
UNICODE_STRING KeyName;
ULONG ProtectionMode = 0;
OBJECT_ATTRIBUTES ObjectAttributes;
PACL Dacl;
PACCESS_ALLOWED_ACE Ace;
HANDLE hKey;
NTSTATUS Status;
ULONG ResultLength, SidLength, AclLength;
/* Create the SD */
Status = RtlCreateSecurityDescriptor(DosDevicesSd, SECURITY_DESCRIPTOR_REVISION);
ASSERT(NT_SUCCESS(Status));
/* Initialize the System SID */
Status = RtlAllocateAndInitializeSid(&NtSidAuthority, 1,
SECURITY_LOCAL_SYSTEM_RID,
0, 0, 0, 0, 0, 0, 0,
&SystemSid);
ASSERT(NT_SUCCESS(Status));
/* Initialize the World SID */
Status = RtlAllocateAndInitializeSid(&WorldAuthority, 1,
SECURITY_WORLD_RID,
0, 0, 0, 0, 0, 0, 0,
&WorldSid);
ASSERT(NT_SUCCESS(Status));
/* Initialize the Admin SID */
Status = RtlAllocateAndInitializeSid(&NtSidAuthority, 2,
SECURITY_BUILTIN_DOMAIN_RID,
DOMAIN_ALIAS_RID_ADMINS,
0, 0, 0, 0, 0, 0,
&AdminSid);
ASSERT(NT_SUCCESS(Status));
/* Initialize the Creator SID */
Status = RtlAllocateAndInitializeSid(&CreatorAuthority, 1,
SECURITY_CREATOR_OWNER_RID,
0, 0, 0, 0, 0, 0, 0,
&CreatorSid);
ASSERT(NT_SUCCESS(Status));
/* Open the Session Manager Key */
RtlInitUnicodeString(&KeyName, SM_REG_KEY);
InitializeObjectAttributes(&ObjectAttributes,
&KeyName,
OBJ_CASE_INSENSITIVE,
NULL,
NULL);
Status = NtOpenKey(&hKey, KEY_READ, &ObjectAttributes);
if (NT_SUCCESS(Status))
{
/* Read the key value */
RtlInitUnicodeString(&KeyName, L"ProtectionMode");
Status = NtQueryValueKey(hKey,
&KeyName,
KeyValuePartialInformation,
KeyValueBuffer,
sizeof(KeyValueBuffer),
&ResultLength);
/* Make sure it's what we expect it to be */
KeyValuePartialInfo = (PKEY_VALUE_PARTIAL_INFORMATION)KeyValueBuffer;
if ((NT_SUCCESS(Status)) && (KeyValuePartialInfo->Type == REG_DWORD) &&
(*(PULONG)KeyValuePartialInfo->Data))
{
/* Save the Protection Mode */
ProtectionMode = *(PULONG)KeyValuePartialInfo->Data;
}
/* Close the handle */
NtClose(hKey);
}
/* Check the Protection Mode */
if (ProtectionMode & 3)
{
/* Calculate SID Lengths */
SidLength = RtlLengthSid(CreatorSid) + RtlLengthSid(SystemSid) +
RtlLengthSid(AdminSid);
AclLength = sizeof(ACL) + 3 * sizeof(ACCESS_ALLOWED_ACE) + SidLength;
/* Allocate memory for the DACL */
Dacl = RtlAllocateHeap(CsrHeap, HEAP_ZERO_MEMORY, AclLength);
ASSERT(Dacl != NULL);
/* Build the ACL and add 3 ACEs */
Status = RtlCreateAcl(Dacl, AclLength, ACL_REVISION2);
ASSERT(NT_SUCCESS(Status));
Status = RtlAddAccessAllowedAce(Dacl, ACL_REVISION, GENERIC_ALL, SystemSid);
ASSERT(NT_SUCCESS(Status));
Status = RtlAddAccessAllowedAce(Dacl, ACL_REVISION, GENERIC_ALL, AdminSid);
ASSERT(NT_SUCCESS(Status));
Status = RtlAddAccessAllowedAce(Dacl, ACL_REVISION, GENERIC_ALL, CreatorSid);
ASSERT(NT_SUCCESS(Status));
/* Edit the ACEs to make them inheritable */
Status = RtlGetAce(Dacl, 0, (PVOID*)&Ace);
ASSERT(NT_SUCCESS(Status));
Ace->Header.AceFlags |= OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE;
Status = RtlGetAce(Dacl, 1, (PVOID*)&Ace);
ASSERT(NT_SUCCESS(Status));
Ace->Header.AceFlags |= OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE;
Status = RtlGetAce(Dacl, 2, (PVOID*)&Ace);
ASSERT(NT_SUCCESS(Status));
Ace->Header.AceFlags |= OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE | INHERIT_ONLY_ACE;
/* Set this DACL with the SD */
Status = RtlSetDaclSecurityDescriptor(DosDevicesSd, TRUE, Dacl, FALSE);
ASSERT(NT_SUCCESS(Status));
goto Quickie;
}
else
{
/* Calculate SID Lengths */
SidLength = RtlLengthSid(WorldSid) + RtlLengthSid(SystemSid);
AclLength = sizeof(ACL) + 3 * sizeof(ACCESS_ALLOWED_ACE) + SidLength;
/* Allocate memory for the DACL */
Dacl = RtlAllocateHeap(CsrHeap, HEAP_ZERO_MEMORY, AclLength);
ASSERT(Dacl != NULL);
/* Build the ACL and add 3 ACEs */
Status = RtlCreateAcl(Dacl, AclLength, ACL_REVISION2);
ASSERT(NT_SUCCESS(Status));
Status = RtlAddAccessAllowedAce(Dacl, ACL_REVISION, GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE, WorldSid);
ASSERT(NT_SUCCESS(Status));
Status = RtlAddAccessAllowedAce(Dacl, ACL_REVISION, GENERIC_ALL, SystemSid);
ASSERT(NT_SUCCESS(Status));
Status = RtlAddAccessAllowedAce(Dacl, ACL_REVISION, GENERIC_ALL, WorldSid);
ASSERT(NT_SUCCESS(Status));
/* Edit the last ACE to make it inheritable */
Status = RtlGetAce(Dacl, 2, (PVOID*)&Ace);
ASSERT(NT_SUCCESS(Status));
Ace->Header.AceFlags |= OBJECT_INHERIT_ACE | CONTAINER_INHERIT_ACE | INHERIT_ONLY_ACE;
/* Set this DACL with the SD */
Status = RtlSetDaclSecurityDescriptor(DosDevicesSd, TRUE, Dacl, FALSE);
ASSERT(NT_SUCCESS(Status));
goto Quickie;
}
/* FIXME: failure cases! Fail: */
/* Free the memory */
RtlFreeHeap(CsrHeap, 0, Dacl);
/* FIXME: semi-failure cases! Quickie: */
Quickie:
/* Free the SIDs */
RtlFreeSid(CreatorSid);
RtlFreeSid(AdminSid);
RtlFreeSid(WorldSid);
RtlFreeSid(SystemSid);
/* Return */
return Status;
}
/***********************************************************************
* GetComputerNameW (KERNEL32.@)
*/
BOOL WINAPI GetComputerNameW(LPWSTR name,LPDWORD size)
{
UNICODE_STRING nameW;
OBJECT_ATTRIBUTES attr;
HANDLE hkey = INVALID_HANDLE_VALUE, hsubkey = INVALID_HANDLE_VALUE;
char buf[offsetof( KEY_VALUE_PARTIAL_INFORMATION, Data ) + (MAX_COMPUTERNAME_LENGTH + 1) * sizeof( WCHAR )];
DWORD len = sizeof( buf );
LPWSTR theName = (LPWSTR) (buf + offsetof( KEY_VALUE_PARTIAL_INFORMATION, Data ));
NTSTATUS st = STATUS_INVALID_PARAMETER;
DWORD err = ERROR_SUCCESS;
TRACE ("%p %p\n", name, size);
_init_attr ( &attr, &nameW );
RtlInitUnicodeString( &nameW, ComputerW );
if ( ( st = NtOpenKey( &hkey, KEY_READ, &attr ) ) != STATUS_SUCCESS )
{
err = RtlNtStatusToDosError ( st );
goto out;
}
attr.RootDirectory = hkey;
RtlInitUnicodeString( &nameW, ActiveComputerNameW );
if ( ( st = NtOpenKey( &hsubkey, KEY_READ, &attr ) ) != STATUS_SUCCESS )
{
err = RtlNtStatusToDosError ( st );
goto out;
}
RtlInitUnicodeString( &nameW, ComputerNameW );
if ( ( st = NtQueryValueKey( hsubkey, &nameW, KeyValuePartialInformation, buf, len, &len ) )
!= STATUS_SUCCESS )
{
err = RtlNtStatusToDosError ( st );
goto out;
}
len = (len -offsetof( KEY_VALUE_PARTIAL_INFORMATION, Data )) / sizeof (WCHAR) - 1;
TRACE ("ComputerName is %s (length %u)\n", debugstr_w ( theName ), len);
if ( *size < len + 1 )
{
*size = len + 1;
err = ERROR_BUFFER_OVERFLOW;
}
else
{
memcpy ( name, theName, len * sizeof (WCHAR) );
name[len] = 0;
*size = len;
}
out:
NtClose ( hsubkey );
NtClose ( hkey );
if ( err == ERROR_SUCCESS )
return TRUE;
else
{
SetLastError ( err );
WARN ( "Status %u reading computer name from registry\n", st );
return FALSE;
}
}
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
main(
int argc,
char *argv[]
)
{
NTSTATUS status;
OBJECT_ATTRIBUTES ObjectAttributes;
HANDLE BaseHandle;
HANDLE EventHandle;
PIO_APC_ROUTINE ApcRoutine;
//
// Process args
//
KeyName.MaximumLength = WORK_SIZE;
KeyName.Length = 0L;
KeyName.Buffer = &(workbuffer[0]);
processargs(argc, argv);
//
// Set up and open KeyPath
//
printf("rtnotify: starting\n");
InitializeObjectAttributes(
&ObjectAttributes,
&KeyName,
0,
(HANDLE)NULL,
NULL
);
ObjectAttributes.Attributes |= OBJ_CASE_INSENSITIVE;
status = NtOpenKey(
&BaseHandle,
KEY_NOTIFY,
&ObjectAttributes
);
if (!NT_SUCCESS(status)) {
printf("rtnotify: t0: %08lx\n", status);
exit(1);
}
EventHandle = (HANDLE)NULL;
if (UseEvent == TRUE) {
status = NtCreateEvent(
&EventHandle,
GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE,
NULL,
NotificationEvent,
FALSE
);
if (!NT_SUCCESS(status)) {
printf("rtnotify: t1: %08lx\n", status);
exit(1);
}
}
ApcRoutine = NULL;
if (UseApc) {
ApcRoutine = ApcTest;
}
printf("rtnotify:\n");
printf("\tUseEvent = %08lx\n", UseEvent);
printf("\tApcRoutine = %08lx\n", ApcRoutine);
printf("\tHold = %08lx\n", Hold);
printf("\tFilter = %08lx\n", Filter);
printf("\tWatchTree = %08lx\n", WatchTree);
while (TRUE) {
ApcSeen = FALSE;
printf("\nCallCount = %dt\n", CallCount);
CallCount++;
status = NtNotifyChangeKey(
BaseHandle,
EventHandle,
ApcRoutine,
(PVOID)1992, // arbitrary context value
&RtIoStatusBlock,
Filter,
WatchTree,
NULL,
0,
! Hold
);
exit(0);
if ( ! NT_SUCCESS(status)) {
printf("rtnotify: t2: %08lx\n", status);
exit(1);
}
if (Hold) {
printf("rtnotify: Synchronous Status = %08lx\n", RtIoStatusBlock.Status);
}
if (UseEvent) {
status = NtWaitForSingleObject(
EventHandle,
TRUE,
NULL
);
if (!NT_SUCCESS(status)) {
printf("rtnotify: t3: status = %08lx\n", status);
exit(1);
}
printf("rtnotify: Event Status = %08lx\n", RtIoStatusBlock.Status);
}
if (UseApc) {
while ((volatile)ApcSeen == FALSE) {
NtTestAlert();
}
}
}
NtClose(BaseHandle);
exit(0);
}
static
BOOLEAN
AddCodepageToRegistry(
IN PCWSTR ACPage,
IN PCWSTR OEMCPage,
IN PCWSTR MACCPage)
{
OBJECT_ATTRIBUTES ObjectAttributes;
UNICODE_STRING KeyName;
UNICODE_STRING ValueName;
HANDLE KeyHandle;
NTSTATUS Status;
// Open the nls codepage key
RtlInitUnicodeString(&KeyName,
L"SYSTEM\\CurrentControlSet\\Control\\NLS\\CodePage");
InitializeObjectAttributes(&ObjectAttributes,
&KeyName,
OBJ_CASE_INSENSITIVE,
GetRootKeyByPredefKey(HKEY_LOCAL_MACHINE, NULL),
NULL);
Status = NtOpenKey(&KeyHandle,
KEY_WRITE,
&ObjectAttributes);
if (!NT_SUCCESS(Status))
{
DPRINT1("NtOpenKey() failed (Status %lx)\n", Status);
return FALSE;
}
// Set ANSI codepage
RtlInitUnicodeString(&ValueName, L"ACP");
Status = NtSetValueKey(KeyHandle,
&ValueName,
0,
REG_SZ,
(PVOID)ACPage,
(wcslen(ACPage)+1) * sizeof(WCHAR));
if (!NT_SUCCESS(Status))
{
DPRINT1("NtSetValueKey() failed (Status %lx)\n", Status);
NtClose(KeyHandle);
return FALSE;
}
// Set OEM codepage
RtlInitUnicodeString(&ValueName, L"OEMCP");
Status = NtSetValueKey(KeyHandle,
&ValueName,
0,
REG_SZ,
(PVOID)OEMCPage,
(wcslen(OEMCPage)+1) * sizeof(WCHAR));
if (!NT_SUCCESS(Status))
{
DPRINT1("NtSetValueKey() failed (Status %lx)\n", Status);
NtClose(KeyHandle);
return FALSE;
}
// Set MAC codepage
RtlInitUnicodeString(&ValueName, L"MACCP");
Status = NtSetValueKey(KeyHandle,
&ValueName,
0,
REG_SZ,
(PVOID)MACCPage,
(wcslen(MACCPage)+1) * sizeof(WCHAR));
if (!NT_SUCCESS(Status))
{
DPRINT1("NtSetValueKey() failed (Status %lx)\n", Status);
NtClose(KeyHandle);
return FALSE;
}
NtClose(KeyHandle);
return TRUE;
}
void EnumerateKeyTest(void)
{
HANDLE hKey = NULL;
OBJECT_ATTRIBUTES ObjectAttributes;
NTSTATUS Status;
UNICODE_STRING KeyName = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\Software");
ULONG Index;
ULONG Length;
ULONG i;
KEY_BASIC_INFORMATION KeyInformation[5];
dprintf("Enumerate key '\\Registry\\Machine\\Software':\n");
InitializeObjectAttributes(&ObjectAttributes,
&KeyName,
OBJ_CASE_INSENSITIVE,
NULL,
NULL);
dprintf("NtOpenKey:\n");
Status = NtOpenKey(&hKey,
KEY_ALL_ACCESS,
&ObjectAttributes);
dprintf(" Status = %lx\n", Status);
if (!NT_SUCCESS(Status))
return;
dprintf("NtQueryKey:\n");
Status = NtQueryKey(hKey,
KeyBasicInformation,
&KeyInformation[0],
sizeof(KeyInformation),
&Length);
dprintf(" Status = %lx\n", Status);
if (NT_SUCCESS(Status))
{
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(NT_SUCCESS(Status))
{
Status = NtEnumerateKey(hKey,
Index,
KeyBasicInformation,
&KeyInformation[0],
sizeof(KeyInformation),
&Length);
if (NT_SUCCESS(Status))
{
dprintf("\tSubKey Name = ");
for (i = 0; i < KeyInformation[0].NameLength / 2; i++)
dprintf("%C", KeyInformation[0].Name[i]);
dprintf("\n");
}
Index++;
}
dprintf("NtClose:\n");
Status = NtClose(hKey);
dprintf(" Status = %lx\n", Status);
}
VOID
InstallDevice(
IN HINF hInf,
IN HANDLE hEnum,
IN HANDLE hServices,
IN LPCWSTR DeviceId)
{
UNICODE_STRING HardwareIDU = RTL_CONSTANT_STRING(L"HardwareID");
UNICODE_STRING CompatibleIDsU = RTL_CONSTANT_STRING(L"CompatibleIDs");
UNICODE_STRING DeviceIdU;
OBJECT_ATTRIBUTES ObjectAttributes;
LPCWSTR HardwareID;
PKEY_VALUE_PARTIAL_INFORMATION pPartialInformation = NULL;
HANDLE hDeviceKey;
ULONG ulRequired;
BOOLEAN bDriverInstalled = FALSE;
NTSTATUS Status;
RtlInitUnicodeString(&DeviceIdU, DeviceId);
InitializeObjectAttributes(&ObjectAttributes, &DeviceIdU, 0, hEnum, NULL);
Status = NtOpenKey(&hDeviceKey, KEY_QUERY_VALUE | KEY_SET_VALUE, &ObjectAttributes);
if (!NT_SUCCESS(Status))
{
DPRINT("Unable to open subkey '%S'\n", DeviceId);
return;
}
Status = NtQueryValueKey(
hDeviceKey,
&HardwareIDU,
KeyValuePartialInformation,
NULL,
0,
&ulRequired);
if (Status == STATUS_BUFFER_TOO_SMALL)
{
pPartialInformation = (PKEY_VALUE_PARTIAL_INFORMATION)RtlAllocateHeap(ProcessHeap, 0, ulRequired);
if (!pPartialInformation)
{
DPRINT1("RtlAllocateHeap() failed\n");
NtClose(hDeviceKey);
return;
}
Status = NtQueryValueKey(
hDeviceKey,
&HardwareIDU,
KeyValuePartialInformation,
pPartialInformation,
ulRequired,
&ulRequired);
}
if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
{
/* Nothing to do */
}
else if (!NT_SUCCESS(Status))
{
DPRINT1("NtQueryValueKey() failed with status 0x%08x\n", Status);
if (pPartialInformation)
RtlFreeHeap(ProcessHeap, 0, pPartialInformation);
NtClose(hDeviceKey);
return;
}
else if (pPartialInformation)
{
for (HardwareID = (LPCWSTR)pPartialInformation->Data;
(PUCHAR)HardwareID < pPartialInformation->Data + pPartialInformation->DataLength
&& *HardwareID
&& !bDriverInstalled;
HardwareID += wcslen(HardwareID) + 1)
{
bDriverInstalled = InstallDriver(hInf, hServices,hDeviceKey, DeviceId, HardwareID);
}
}
if (!bDriverInstalled)
{
if (pPartialInformation)
{
RtlFreeHeap(ProcessHeap, 0, pPartialInformation);
pPartialInformation = NULL;
}
Status = NtQueryValueKey(
hDeviceKey,
&CompatibleIDsU,
KeyValuePartialInformation,
NULL,
0,
&ulRequired);
if (Status == STATUS_BUFFER_TOO_SMALL)
{
pPartialInformation = (PKEY_VALUE_PARTIAL_INFORMATION)RtlAllocateHeap(ProcessHeap, 0, ulRequired);
if (!pPartialInformation)
{
DPRINT("RtlAllocateHeap() failed\n");
NtClose(hDeviceKey);
return;
}
Status = NtQueryValueKey(
hDeviceKey,
&CompatibleIDsU,
KeyValuePartialInformation,
pPartialInformation,
ulRequired,
&ulRequired);
}
if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
{
/* Nothing to do */
}
else if (!NT_SUCCESS(Status))
{
if (pPartialInformation)
RtlFreeHeap(ProcessHeap, 0, pPartialInformation);
NtClose(hDeviceKey);
DPRINT1("NtQueryValueKey() failed with status 0x%08x\n", Status);
return;
}
else if (pPartialInformation)
{
for (HardwareID = (LPCWSTR)pPartialInformation->Data;
(PUCHAR)HardwareID < pPartialInformation->Data + pPartialInformation->DataLength
&& *HardwareID
&& !bDriverInstalled;
HardwareID += wcslen(HardwareID) + 1)
{
bDriverInstalled = InstallDriver(hInf, hServices,hDeviceKey, DeviceId, HardwareID);
}
}
}
if (!bDriverInstalled)
DPRINT("No driver available for %S\n", DeviceId);
RtlFreeHeap(ProcessHeap, 0, pPartialInformation);
NtClose(hDeviceKey);
}
NTSTATUS
EventThread(IN LPVOID lpParameter)
{
UNICODE_STRING EnumU = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Enum");
UNICODE_STRING ServicesU = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Services");
PPLUGPLAY_EVENT_BLOCK PnpEvent;
OBJECT_ATTRIBUTES ObjectAttributes;
ULONG PnpEventSize;
HINF hInf;
HANDLE hEnum, hServices;
NTSTATUS Status;
hInf = *(HINF *)lpParameter;
InitializeObjectAttributes(&ObjectAttributes, &EnumU, OBJ_CASE_INSENSITIVE, NULL, NULL);
Status = NtOpenKey(&hEnum, KEY_QUERY_VALUE, &ObjectAttributes);
if (!NT_SUCCESS(Status))
{
DPRINT1("NtOpenKey('%wZ') failed with status 0x%08lx\n", &EnumU, Status);
return Status;
}
InitializeObjectAttributes(&ObjectAttributes, &ServicesU, OBJ_CASE_INSENSITIVE, NULL, NULL);
Status = NtCreateKey(&hServices, KEY_ALL_ACCESS, &ObjectAttributes, 0, NULL, 0, NULL);
if (!NT_SUCCESS(Status))
{
DPRINT1("NtCreateKey('%wZ') failed with status 0x%08lx\n", &ServicesU, Status);
NtClose(hEnum);
return Status;
}
PnpEventSize = 0x1000;
PnpEvent = (PPLUGPLAY_EVENT_BLOCK)RtlAllocateHeap(ProcessHeap, 0, PnpEventSize);
if (PnpEvent == NULL)
{
NtClose(hEnum);
NtClose(hServices);
return STATUS_NO_MEMORY;
}
for (;;)
{
DPRINT("Calling NtGetPlugPlayEvent()\n");
/* Wait for the next pnp event */
Status = NtGetPlugPlayEvent(0, 0, PnpEvent, PnpEventSize);
/* Resize the buffer for the PnP event if it's too small. */
if (Status == STATUS_BUFFER_TOO_SMALL)
{
PnpEventSize += 0x400;
RtlFreeHeap(ProcessHeap, 0, PnpEvent);
PnpEvent = (PPLUGPLAY_EVENT_BLOCK)RtlAllocateHeap(ProcessHeap, 0, PnpEventSize);
if (PnpEvent == NULL)
{
NtClose(hEnum);
NtClose(hServices);
return STATUS_NO_MEMORY;
}
continue;
}
if (!NT_SUCCESS(Status))
{
DPRINT("NtPlugPlayEvent() failed (Status %lx)\n", Status);
break;
}
/* Process the pnp event */
DPRINT("Received PnP Event\n");
if (IsEqualIID(&PnpEvent->EventGuid, (REFGUID)&GUID_DEVICE_ENUMERATED))
{
DPRINT("Device arrival event: %S\n", PnpEvent->TargetDevice.DeviceIds);
InstallDevice(hInf, hEnum, hServices, PnpEvent->TargetDevice.DeviceIds);
}
else
{
DPRINT("Unknown event\n");
}
/* Dequeue the current pnp event and signal the next one */
NtPlugPlayControl(PlugPlayControlUserResponse, NULL, 0);
}
RtlFreeHeap(ProcessHeap, 0, PnpEvent);
NtClose(hEnum);
NtClose(hServices);
return STATUS_SUCCESS;
}
VOID
ExpCheckSystemInfoWork (
IN PVOID Context
)
/*++
Routine Description:
Verifies registery data for various system information classes
is up to date.
Arguments:
Return Value:
--*/
{
static struct {
SYSTEM_INFORMATION_CLASS InformationLevel;
ULONG BufferSize;
} RegistryInformation[] = {
SystemBasicInformation, sizeof (SYSTEM_BASIC_INFORMATION),
SystemPowerInformation, sizeof (SYSTEM_POWER_INFORMATION),
SystemProcessorSpeedInformation, sizeof (SYSTEM_PROCESSOR_SPEED_INFORMATION),
0, 0
};
struct {
KEY_VALUE_PARTIAL_INFORMATION Key;
union {
SYSTEM_BASIC_INFORMATION BasicInformation;
SYSTEM_POWER_INFORMATION PowerSettings;
SYSTEM_PROCESSOR_SPEED_INFORMATION ProcessorSpeed;
};
} RegistryBuffer, QueryBuffer;
ULONG Index, BufferSize, disposition, length;
NTSTATUS Status;
OBJECT_ATTRIBUTES objectAttributes;
UNICODE_STRING unicodeString, ValueString;
HANDLE CurrentControlSet, SystemInformation, LevelInformation;
LARGE_INTEGER Interval;
BOOLEAN Rescan;
WCHAR wstr[10];
PAGED_CODE();
//
// Only one worked needed at a time needed to update the SystemInformation
// data in the registry
//
if (InterlockedIncrement (&ExpCheckSystemInfoBusy) != 0) {
return ;
}
RtlInitUnicodeString (&ValueString, ExpWstrSystemInformationValue);
//
// Open CurrentControlSet
//
InitializeObjectAttributes( &objectAttributes,
&CmRegistryMachineSystemCurrentControlSet,
OBJ_CASE_INSENSITIVE,
NULL,
NULL );
Status = NtOpenKey (&CurrentControlSet,
KEY_READ | KEY_WRITE,
&objectAttributes );
if (NT_SUCCESS(Status)) {
//
// Open SystemInformation
//
RtlInitUnicodeString( &unicodeString, ExpWstrSystemInformation );
InitializeObjectAttributes( &objectAttributes,
&unicodeString,
OBJ_CASE_INSENSITIVE,
CurrentControlSet,
NULL );
Status = NtCreateKey ( &SystemInformation,
KEY_READ | KEY_WRITE,
&objectAttributes,
0,
NULL,
REG_OPTION_VOLATILE,
&disposition );
NtClose (CurrentControlSet);
}
if (!NT_SUCCESS(Status)) {
InterlockedDecrement (&ExpCheckSystemInfoBusy);
return ;
}
//
// Loop and check SystemInformation data in registry
//
do {
Rescan = FALSE;
//
// Wait a moment
//
Interval.QuadPart = -3000000;
KeDelayExecutionThread (KernelMode, FALSE, &Interval);
//
// For now just check each SystemInformation level and update
// any level which is out of date
//
for (Index=0; RegistryInformation[Index].BufferSize; Index++) {
//
// Initialize registry data buffer
//
BufferSize = RegistryInformation[Index].BufferSize;
RtlZeroMemory (RegistryBuffer.Key.Data, BufferSize);
//
// Open appropiate SystemInformation level key
//
swprintf (wstr, L"%d", RegistryInformation[Index].InformationLevel);
RtlInitUnicodeString (&unicodeString, wstr);
InitializeObjectAttributes( &objectAttributes,
&unicodeString,
OBJ_CASE_INSENSITIVE,
SystemInformation,
NULL );
Status = NtCreateKey ( &LevelInformation,
KEY_READ | KEY_WRITE,
&objectAttributes,
0,
NULL,
REG_OPTION_VOLATILE,
&disposition );
//
// If key opened, read current data value from the registry
//
if (NT_SUCCESS(Status)) {
NtQueryValueKey (
LevelInformation,
&ValueString,
KeyValuePartialInformation,
&RegistryBuffer.Key,
sizeof (RegistryBuffer),
&length
);
}
//
// Query current SystemInformation data
//
Status = NtQuerySystemInformation (
RegistryInformation[Index].InformationLevel,
&QueryBuffer.Key.Data,
BufferSize,
NULL
);
//
// Check if current SystemInformation matches the registry
// information
//
if (NT_SUCCESS(Status) &&
!RtlEqualMemory (RegistryBuffer.Key.Data,
QueryBuffer.Key.Data,
BufferSize) ) {
//
// Did not match - update registry to current SystemInfomration
//
Status = NtSetValueKey (
LevelInformation,
&ValueString,
0L,
REG_BINARY,
QueryBuffer.Key.Data,
BufferSize
);
//
// Make notificant that this information level has changed
//
ExNotifyCallback (
ExCbSetSystemInformation,
(PVOID) RegistryInformation[Index].InformationLevel,
(PVOID) NULL
);
}
//
// Close this InformatiobLevel and check the next one
//
NtClose (LevelInformation);
}
//
// If no Rescan, remove our count from the busy flag
//
if (!Rescan &&
InterlockedDecrement (&ExpCheckSystemInfoBusy) >= 0) {
//
// Some other worker thread attempted to perform a scan. Reset
// counter to 1 and loop
//
ExInterlockedExchangeUlong ((PULONG) &ExpCheckSystemInfoBusy, 0, &ExpCheckSystemInfoLock);
Rescan = TRUE;
}
} while (Rescan);
//
// Cleanup
//
NtClose (SystemInformation);
}
/**********************************************************************
* get_nt_registry_version
*
* Fetch the version information from the NT-style registry keys.
*/
static BOOL get_nt_registry_version( RTL_OSVERSIONINFOEXW *version )
{
static const WCHAR version_keyW[] = {'M','a','c','h','i','n','e','\\',
'S','o','f','t','w','a','r','e','\\',
'M','i','c','r','o','s','o','f','t','\\',
'W','i','n','d','o','w','s',' ','N','T','\\',
'C','u','r','r','e','n','t','V','e','r','s','i','o','n',0};
static const WCHAR service_pack_keyW[] = {'M','a','c','h','i','n','e','\\',
'S','y','s','t','e','m','\\',
'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
'C','o','n','t','r','o','l','\\',
'W','i','n','d','o','w','s',0};
static const WCHAR product_keyW[] = {'M','a','c','h','i','n','e','\\',
'S','y','s','t','e','m','\\',
'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
'C','o','n','t','r','o','l','\\',
'P','r','o','d','u','c','t','O','p','t','i','o','n','s',0};
static const WCHAR CurrentBuildNumberW[] = {'C','u','r','r','e','n','t','B','u','i','l','d','N','u','m','b','e','r',0};
static const WCHAR CSDVersionW[] = {'C','S','D','V','e','r','s','i','o','n',0};
static const WCHAR CurrentVersionW[] = {'C','u','r','r','e','n','t','V','e','r','s','i','o','n',0};
static const WCHAR ProductTypeW[] = {'P','r','o','d','u','c','t','T','y','p','e',0};
static const WCHAR WinNTW[] = {'W','i','n','N','T',0};
static const WCHAR ServerNTW[] = {'S','e','r','v','e','r','N','T',0};
static const WCHAR LanmanNTW[] = {'L','a','n','m','a','n','N','T',0};
OBJECT_ATTRIBUTES attr;
UNICODE_STRING nameW, valueW;
HANDLE hkey, hkey2;
char tmp[64];
DWORD count;
BOOL ret = FALSE;
KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)tmp;
attr.Length = sizeof(attr);
attr.RootDirectory = 0;
attr.ObjectName = &nameW;
attr.Attributes = 0;
attr.SecurityDescriptor = NULL;
attr.SecurityQualityOfService = NULL;
RtlInitUnicodeString( &nameW, version_keyW );
if (NtOpenKey( &hkey, KEY_ALL_ACCESS, &attr )) return FALSE;
memset( version, 0, sizeof(*version) );
RtlInitUnicodeString( &valueW, CurrentVersionW );
if (!NtQueryValueKey( hkey, &valueW, KeyValuePartialInformation, tmp, sizeof(tmp)-1, &count ))
{
WCHAR *p, *str = (WCHAR *)info->Data;
str[info->DataLength / sizeof(WCHAR)] = 0;
p = strchrW( str, '.' );
if (p)
{
*p++ = 0;
version->dwMinorVersion = atoiW( p );
}
version->dwMajorVersion = atoiW( str );
}
if (version->dwMajorVersion) /* we got the main version, now fetch the other fields */
{
ret = TRUE;
version->dwPlatformId = VER_PLATFORM_WIN32_NT;
/* get build number */
RtlInitUnicodeString( &valueW, CurrentBuildNumberW );
if (!NtQueryValueKey( hkey, &valueW, KeyValuePartialInformation, tmp, sizeof(tmp)-1, &count ))
{
WCHAR *str = (WCHAR *)info->Data;
str[info->DataLength / sizeof(WCHAR)] = 0;
version->dwBuildNumber = atoiW( str );
}
/* get version description */
RtlInitUnicodeString( &valueW, CSDVersionW );
if (!NtQueryValueKey( hkey, &valueW, KeyValuePartialInformation, tmp, sizeof(tmp)-1, &count ))
{
DWORD len = min( info->DataLength, sizeof(version->szCSDVersion) - sizeof(WCHAR) );
memcpy( version->szCSDVersion, info->Data, len );
version->szCSDVersion[len / sizeof(WCHAR)] = 0;
}
/* get service pack version */
RtlInitUnicodeString( &nameW, service_pack_keyW );
if (!NtOpenKey( &hkey2, KEY_ALL_ACCESS, &attr ))
{
RtlInitUnicodeString( &valueW, CSDVersionW );
if (!NtQueryValueKey( hkey2, &valueW, KeyValuePartialInformation, tmp, sizeof(tmp), &count ))
{
if (info->DataLength >= sizeof(DWORD))
{
DWORD dw = *(DWORD *)info->Data;
version->wServicePackMajor = LOWORD(dw) >> 8;
version->wServicePackMinor = LOWORD(dw) & 0xff;
}
}
NTSTATUS
NTAPI
CreateBaseAcls(OUT PACL* Dacl,
OUT PACL* RestrictedDacl)
{
PSID SystemSid, WorldSid, RestrictedSid;
SID_IDENTIFIER_AUTHORITY NtAuthority = {SECURITY_NT_AUTHORITY};
SID_IDENTIFIER_AUTHORITY WorldAuthority = {SECURITY_WORLD_SID_AUTHORITY};
NTSTATUS Status;
#if 0 // Unused code
UCHAR KeyValueBuffer[0x40];
PKEY_VALUE_PARTIAL_INFORMATION KeyValuePartialInfo;
UNICODE_STRING KeyName;
ULONG ProtectionMode = 0;
#endif
ULONG AclLength;
#if 0 // Unused code
ULONG ResultLength;
HANDLE hKey;
OBJECT_ATTRIBUTES ObjectAttributes;
/* Open the Session Manager Key */
RtlInitUnicodeString(&KeyName, SM_REG_KEY);
InitializeObjectAttributes(&ObjectAttributes,
&KeyName,
OBJ_CASE_INSENSITIVE,
NULL,
NULL);
Status = NtOpenKey(&hKey, KEY_READ, &ObjectAttributes);
if (NT_SUCCESS(Status))
{
/* Read the key value */
RtlInitUnicodeString(&KeyName, L"ProtectionMode");
Status = NtQueryValueKey(hKey,
&KeyName,
KeyValuePartialInformation,
KeyValueBuffer,
sizeof(KeyValueBuffer),
&ResultLength);
/* Make sure it's what we expect it to be */
KeyValuePartialInfo = (PKEY_VALUE_PARTIAL_INFORMATION)KeyValueBuffer;
if ((NT_SUCCESS(Status)) && (KeyValuePartialInfo->Type == REG_DWORD) &&
(*(PULONG)KeyValuePartialInfo->Data))
{
/* Save the Protection Mode */
ProtectionMode = *(PULONG)KeyValuePartialInfo->Data;
}
/* Close the handle */
NtClose(hKey);
}
#endif
/* Allocate the System SID */
Status = RtlAllocateAndInitializeSid(&NtAuthority,
1, SECURITY_LOCAL_SYSTEM_RID,
0, 0, 0, 0, 0, 0, 0,
&SystemSid);
ASSERT(NT_SUCCESS(Status));
/* Allocate the World SID */
Status = RtlAllocateAndInitializeSid(&WorldAuthority,
1, SECURITY_WORLD_RID,
0, 0, 0, 0, 0, 0, 0,
&WorldSid);
ASSERT(NT_SUCCESS(Status));
/* Allocate the restricted SID */
Status = RtlAllocateAndInitializeSid(&NtAuthority,
1, SECURITY_RESTRICTED_CODE_RID,
0, 0, 0, 0, 0, 0, 0,
&RestrictedSid);
ASSERT(NT_SUCCESS(Status));
/* Allocate one ACL with 3 ACEs each for one SID */
AclLength = sizeof(ACL) + 3 * sizeof(ACCESS_ALLOWED_ACE) +
RtlLengthSid(SystemSid) +
RtlLengthSid(WorldSid) +
RtlLengthSid(RestrictedSid);
*Dacl = RtlAllocateHeap(BaseSrvHeap, 0, AclLength);
ASSERT(*Dacl != NULL);
/* Set the correct header fields */
Status = RtlCreateAcl(*Dacl, AclLength, ACL_REVISION2);
ASSERT(NT_SUCCESS(Status));
/* Give the appropriate rights to each SID */
/* FIXME: Should check SessionId/ProtectionMode */
Status = RtlAddAccessAllowedAce(*Dacl, ACL_REVISION2, DIRECTORY_QUERY | DIRECTORY_TRAVERSE | DIRECTORY_CREATE_OBJECT | DIRECTORY_CREATE_SUBDIRECTORY | READ_CONTROL, WorldSid);
ASSERT(NT_SUCCESS(Status));
Status = RtlAddAccessAllowedAce(*Dacl, ACL_REVISION2, DIRECTORY_ALL_ACCESS, SystemSid);
ASSERT(NT_SUCCESS(Status));
Status = RtlAddAccessAllowedAce(*Dacl, ACL_REVISION2, DIRECTORY_TRAVERSE, RestrictedSid);
ASSERT(NT_SUCCESS(Status));
/* Now allocate the restricted DACL */
*RestrictedDacl = RtlAllocateHeap(BaseSrvHeap, 0, AclLength);
ASSERT(*RestrictedDacl != NULL);
/* Initialize it */
Status = RtlCreateAcl(*RestrictedDacl, AclLength, ACL_REVISION2);
ASSERT(NT_SUCCESS(Status));
/* And add the same ACEs as before */
/* FIXME: Not really fully correct */
Status = RtlAddAccessAllowedAce(*RestrictedDacl, ACL_REVISION2, DIRECTORY_QUERY | DIRECTORY_TRAVERSE | DIRECTORY_CREATE_OBJECT | DIRECTORY_CREATE_SUBDIRECTORY | READ_CONTROL, WorldSid);
ASSERT(NT_SUCCESS(Status));
Status = RtlAddAccessAllowedAce(*RestrictedDacl, ACL_REVISION2, DIRECTORY_ALL_ACCESS, SystemSid);
ASSERT(NT_SUCCESS(Status));
Status = RtlAddAccessAllowedAce(*RestrictedDacl, ACL_REVISION2, DIRECTORY_TRAVERSE, RestrictedSid);
ASSERT(NT_SUCCESS(Status));
/* The SIDs are captured, can free them now */
RtlFreeSid(RestrictedSid);
RtlFreeSid(WorldSid);
RtlFreeSid(SystemSid);
return Status;
}
BOOL
GetDllList(VOID)
{
NTSTATUS Status;
OBJECT_ATTRIBUTES Attributes;
BOOL bRet = FALSE;
BOOL bLoad;
HANDLE hKey = NULL;
DWORD dwSize;
PKEY_VALUE_PARTIAL_INFORMATION kvpInfo = NULL;
UNICODE_STRING szKeyName = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\Software\\Microsoft\\Windows NT\\CurrentVersion\\Windows");
UNICODE_STRING szLoadName = RTL_CONSTANT_STRING(L"LoadAppInit_DLLs");
UNICODE_STRING szDllsName = RTL_CONSTANT_STRING(L"AppInit_DLLs");
InitializeObjectAttributes(&Attributes, &szKeyName, OBJ_CASE_INSENSITIVE, NULL, NULL);
Status = NtOpenKey(&hKey, KEY_READ, &Attributes);
if (NT_SUCCESS(Status))
{
dwSize = sizeof(KEY_VALUE_PARTIAL_INFORMATION) + sizeof(DWORD);
kvpInfo = HeapAlloc(GetProcessHeap(), 0, dwSize);
if (!kvpInfo)
goto end;
Status = NtQueryValueKey(hKey,
&szLoadName,
KeyValuePartialInformation,
kvpInfo,
dwSize,
&dwSize);
if (!NT_SUCCESS(Status))
goto end;
RtlMoveMemory(&bLoad,
kvpInfo->Data,
kvpInfo->DataLength);
HeapFree(GetProcessHeap(), 0, kvpInfo);
kvpInfo = NULL;
if (bLoad)
{
Status = NtQueryValueKey(hKey,
&szDllsName,
KeyValuePartialInformation,
NULL,
0,
&dwSize);
if (Status != STATUS_BUFFER_TOO_SMALL)
goto end;
kvpInfo = HeapAlloc(GetProcessHeap(), 0, dwSize);
if (!kvpInfo)
goto end;
Status = NtQueryValueKey(hKey,
&szDllsName,
KeyValuePartialInformation,
kvpInfo,
dwSize,
&dwSize);
if (NT_SUCCESS(Status))
{
LPWSTR lpBuffer = (LPWSTR)kvpInfo->Data;
if (*lpBuffer != UNICODE_NULL)
{
INT bytesToCopy, nullPos;
bytesToCopy = min(kvpInfo->DataLength, KEY_LENGTH * sizeof(WCHAR));
if (bytesToCopy != 0)
{
RtlMoveMemory(szAppInit,
kvpInfo->Data,
bytesToCopy);
nullPos = (bytesToCopy / sizeof(WCHAR)) - 1;
/* ensure string is terminated */
szAppInit[nullPos] = UNICODE_NULL;
bRet = TRUE;
}
}
}
}
}
end:
if (hKey)
NtClose(hKey);
if (kvpInfo)
HeapFree(GetProcessHeap(), 0, kvpInfo);
return bRet;
}
BOOLEAN
ProcessLocaleRegistry(PGENERIC_LIST List)
{
PGENERIC_LIST_ENTRY Entry;
PWCHAR LanguageId;
OBJECT_ATTRIBUTES ObjectAttributes;
UNICODE_STRING KeyName;
UNICODE_STRING ValueName;
HANDLE KeyHandle;
NTSTATUS Status;
Entry = GetCurrentListEntry(List);
if (Entry == NULL)
return FALSE;
LanguageId = (PWCHAR)GetListEntryUserData(Entry);
if (LanguageId == NULL)
return FALSE;
/* Skip first 4 zeroes */
if (wcslen(LanguageId) >= 4)
LanguageId += 4;
/* Open the NLS language key */
RtlInitUnicodeString(&KeyName,
L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Control\\NLS\\Language");
InitializeObjectAttributes(&ObjectAttributes,
&KeyName,
OBJ_CASE_INSENSITIVE,
NULL,
NULL);
Status = NtOpenKey(&KeyHandle,
KEY_SET_VALUE,
&ObjectAttributes);
if (!NT_SUCCESS(Status))
{
DPRINT1("NtOpenKey() failed (Status %lx)\n", Status);
return FALSE;
}
/* Set default language */
RtlInitUnicodeString(&ValueName,
L"Default");
Status = NtSetValueKey(KeyHandle,
&ValueName,
0,
REG_SZ,
(PVOID)LanguageId,
(wcslen(LanguageId) + 1) * sizeof(WCHAR));
if (!NT_SUCCESS(Status))
{
DPRINT1("NtSetValueKey() failed (Status %lx)\n", Status);
NtClose(KeyHandle);
return FALSE;
}
/* Set install language */
RtlInitUnicodeString(&ValueName,
L"InstallLanguage");
Status = NtSetValueKey (KeyHandle,
&ValueName,
0,
REG_SZ,
(PVOID)LanguageId,
(wcslen(LanguageId) + 1) * sizeof(WCHAR));
NtClose(KeyHandle);
if (!NT_SUCCESS(Status))
{
DPRINT1("NtSetValueKey() failed (Status %lx)\n", Status);
return FALSE;
}
return TRUE;
}
/*
* SfuBuildBotPath
*
* Purpose:
*
* Return full path to bot in both variants.
*
*/
BOOL SfuBuildBotPath(
_Inout_ PZA_BOT_PATH Context
)
{
BOOL cond = FALSE, bResult = FALSE;
OBJECT_ATTRIBUTES obja;
UNICODE_STRING ustr1, ustr2;
WCHAR szRegBuffer[MAX_PATH + 1];
HANDLE ProcessHeap;
HANDLE hKey = NULL;
NTSTATUS status;
KEY_VALUE_PARTIAL_INFORMATION *pki = NULL;
LPWSTR lpEnv;
ULONG memIO = 0;
LPWSTR lpLocalBotName, lpPFilesBotName;
PVOID Wow64Information = NULL;
GUID sfGUID;
if (Context == NULL)
return bResult;
ProcessHeap = RtlGetCurrentPeb()->ProcessHeap;
RtlSecureZeroMemory(&ustr1, sizeof(ustr1));
do {
if (!SfInitMD5())
break;
RtlSecureZeroMemory(&sfGUID, sizeof(sfGUID));
SfuCalcVolumeMD5((BYTE*)&sfGUID);
status = NtQueryInformationProcess(NtCurrentProcess(), ProcessWow64Information,
&Wow64Information, sizeof(PVOID), NULL);
if (!NT_SUCCESS(status))
break;
//query current user registry string
if (!NT_SUCCESS(RtlFormatCurrentUserKeyPath(&ustr1)))
break;
lpLocalBotName = Context->szBotPathLocal;
lpPFilesBotName = Context->szBotPathPFiles;
RtlSecureZeroMemory(&szRegBuffer, sizeof(szRegBuffer));
wsprintf(szRegBuffer, T_SHELL_FOLDERS_KEY, ustr1.Buffer);
RtlFreeUnicodeString(&ustr1);
//open User Shell Folders key to query Local AppData value
RtlSecureZeroMemory(&ustr2, sizeof(ustr2));
RtlInitUnicodeString(&ustr2, szRegBuffer);
InitializeObjectAttributes(&obja, &ustr2, OBJ_CASE_INSENSITIVE, NULL, NULL);
status = NtOpenKey(&hKey, KEY_READ, &obja);
if (!NT_SUCCESS(status))
break;
//query value size
RtlInitUnicodeString(&ustr2, T_LOCAL_APPDATA_VALUE);
NtQueryValueKey(hKey, &ustr2, KeyValuePartialInformation,
NULL, 0, &memIO);
if (memIO == 0)
break;
pki = RtlAllocateHeap(ProcessHeap, HEAP_ZERO_MEMORY, memIO);
if (pki == NULL)
break;
//query value
status = NtQueryValueKey(hKey, &ustr2, KeyValuePartialInformation,
pki, memIO, &memIO);
if (!NT_SUCCESS(status))
break;
RtlInitUnicodeString(&ustr2, (WCHAR*)pki->Data);
memIO = 0;
//expand environment variable inside value
RtlSecureZeroMemory(&szRegBuffer, sizeof(szRegBuffer));
ustr1.Buffer = szRegBuffer;
ustr1.Length = 0;
ustr1.MaximumLength = sizeof(szRegBuffer);
status = RtlExpandEnvironmentStrings_U(NULL, &ustr2, &ustr1, &memIO);
if (!NT_SUCCESS(status)) {
ustr1.Buffer = NULL;
break;
}
//build result string
_strcpy(lpLocalBotName, T_GLOBAL_LINK);
_strcat(lpLocalBotName, szRegBuffer);
wsprintf(_strend(lpLocalBotName), T_SIREFEF_DIRECTORY,
sfGUID.Data1, sfGUID.Data2, sfGUID.Data3,
sfGUID.Data4[0],
sfGUID.Data4[1],
sfGUID.Data4[2],
sfGUID.Data4[3],
sfGUID.Data4[4],
sfGUID.Data4[5],
sfGUID.Data4[6],
sfGUID.Data4[7]);
ustr1.Buffer = NULL;
_strcpy(lpPFilesBotName, T_GLOBAL_LINK);
if (Wow64Information == NULL) {
lpEnv = L"ProgramFiles=";
}
else {
lpEnv = L"ProgramFiles(x86)=";
}
RtlInitUnicodeString(&ustr2, lpEnv);
lpEnv = SfuQueryEnvironmentVariableOffset(&ustr2);
if (lpEnv) {
_strcat(lpPFilesBotName, lpEnv);
wsprintf(_strend(lpPFilesBotName), T_SIREFEF_DIRECTORY,
sfGUID.Data1, sfGUID.Data2, sfGUID.Data3,
sfGUID.Data4[0],
sfGUID.Data4[1],
sfGUID.Data4[2],
sfGUID.Data4[3],
sfGUID.Data4[4],
sfGUID.Data4[5],
sfGUID.Data4[6],
sfGUID.Data4[7]);
}
bResult = TRUE;
} while (cond);
if (hKey != NULL) {
NtClose(hKey);
}
if (ustr1.Buffer != NULL) {
RtlFreeUnicodeString(&ustr1);
}
if (pki != NULL) {
RtlFreeHeap(ProcessHeap, 0, pki);
}
return bResult;
}
VOID
SepAdtInitializeBounds(
VOID
)
/*++
Routine Description:
Queries the registry for the high and low water mark values for the
audit log. If they are not found or are unacceptable, returns without
modifying the current values, which are statically initialized.
Arguments:
None.
Return Value:
None.
--*/
{
HANDLE KeyHandle;
OBJECT_ATTRIBUTES ObjectAttributes;
UNICODE_STRING KeyName;
UNICODE_STRING ValueName;
NTSTATUS Status;
PSEP_AUDIT_BOUNDS AuditBounds;
PKEY_VALUE_PARTIAL_INFORMATION KeyValueInformation;
ULONG Length;
PAGED_CODE();
//
// Get the high and low water marks out of the registry.
//
RtlInitUnicodeString( &KeyName, L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\Lsa");
InitializeObjectAttributes(
&ObjectAttributes,
&KeyName,
OBJ_CASE_INSENSITIVE,
NULL,
NULL
);
Status = NtOpenKey(
&KeyHandle,
KEY_QUERY_VALUE,
&ObjectAttributes
);
if (!NT_SUCCESS( Status )) {
//
// Didn't work, take the defaults
//
return;
}
RtlInitUnicodeString( &ValueName, L"Bounds");
Length = sizeof( KEY_VALUE_PARTIAL_INFORMATION ) - sizeof( UCHAR ) + sizeof( SEP_AUDIT_BOUNDS );
KeyValueInformation = ExAllocatePool( PagedPool, Length );
if ( KeyValueInformation == NULL ) {
NtClose( KeyHandle );
return;
}
Status = NtQueryValueKey(
KeyHandle,
&ValueName,
KeyValuePartialInformation,
(PVOID)KeyValueInformation,
Length,
&Length
);
NtClose( KeyHandle );
if (!NT_SUCCESS( Status )) {
ExFreePool( KeyValueInformation );
return;
}
AuditBounds = (PSEP_AUDIT_BOUNDS) &KeyValueInformation->Data;
//
// Sanity check what we got back
//
if(!SepAdtValidateAuditBounds( AuditBounds->UpperBound, AuditBounds->LowerBound )) {
//
// The values we got back are not to our liking. Use the defaults.
//
ExFreePool( KeyValueInformation );
return;
}
//
// Take what we got from the registry.
//
SepAdtMaxListLength = AuditBounds->UpperBound;
SepAdtMinListLength = AuditBounds->LowerBound;
ExFreePool( KeyValueInformation );
return;
}
void
Dump(
HANDLE Handle
)
{
NTSTATUS status;
PKEY_BASIC_INFORMATION KeyInformation;
OBJECT_ATTRIBUTES ObjectAttributes;
ULONG NamePos;
ULONG index;
STRING enumname;
HANDLE WorkHandle;
ULONG ResultLength;
static char buffer[WORK_SIZE];
PUCHAR p;
KeyInformation = (PKEY_BASIC_INFORMATION)buffer;
NamePos = WorkName.Length;
//
// Print name of node we are about to dump out
//
print(&WorkName);
printf("::\n\n");
//
// Print out node's values
//
DumpValues(Handle);
//
// Enumerate node's children and apply ourselves to each one
//
for (index = 0; TRUE; index++) {
RtlZeroMemory(KeyInformation, WORK_SIZE);
status = NtEnumerateKey(
Handle,
index,
KeyBasicInformation,
KeyInformation,
WORK_SIZE,
&ResultLength
);
if (status == STATUS_NO_MORE_ENTRIES) {
WorkName.Length = NamePos;
return;
} else if (!NT_SUCCESS(status)) {
printf("rtdmp: dump1: status = %08lx\n", status);
exit(1);
}
enumname.Buffer = &(KeyInformation->Name[0]);
enumname.Length = KeyInformation->NameLength;
enumname.MaximumLength = KeyInformation->NameLength;
p = WorkName.Buffer;
p += WorkName.Length;
*p = '\\';
p++;
*p = '\0';
WorkName.Length += 2;
RtlAppendStringToString((PSTRING)&WorkName, (PSTRING)&enumname);
InitializeObjectAttributes(
&ObjectAttributes,
&enumname,
0,
Handle,
NULL
);
ObjectAttributes.Attributes |= OBJ_CASE_INSENSITIVE;
status = NtOpenKey(
&WorkHandle,
MAXIMUM_ALLOWED,
&ObjectAttributes
);
if (!NT_SUCCESS(status)) {
printf("rtdmp: dump2: %08lx\n", status);
exit(1);
}
Dump(WorkHandle);
NtClose(WorkHandle);
WorkName.Length = NamePos;
}
}
NTSTATUS
SepAdtInitializeCrashOnFail(
VOID
)
/*++
Routine Description:
Reads the registry to see if the user has told us to crash if an audit fails.
Arguments:
None.
Return Value:
STATUS_SUCCESS
--*/
{
HANDLE KeyHandle;
NTSTATUS Status;
NTSTATUS TmpStatus;
OBJECT_ATTRIBUTES Obja;
ULONG ResultLength;
UNICODE_STRING KeyName;
UNICODE_STRING ValueName;
CHAR KeyInfo[sizeof(KEY_VALUE_PARTIAL_INFORMATION) + sizeof(BOOLEAN)];
PKEY_VALUE_PARTIAL_INFORMATION pKeyInfo;
SepCrashOnAuditFail = FALSE;
//
// Check the value of the CrashOnAudit flag in the registry.
//
RtlInitUnicodeString( &KeyName, L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\Lsa");
InitializeObjectAttributes( &Obja,
&KeyName,
OBJ_CASE_INSENSITIVE,
NULL,
NULL
);
Status = NtOpenKey(
&KeyHandle,
KEY_QUERY_VALUE | KEY_SET_VALUE,
&Obja
);
if (Status == STATUS_OBJECT_NAME_NOT_FOUND) {
return( STATUS_SUCCESS );
}
RtlInitUnicodeString( &ValueName, CRASH_ON_AUDIT_FAIL_VALUE );
Status = NtQueryValueKey(
KeyHandle,
&ValueName,
KeyValuePartialInformation,
KeyInfo,
sizeof(KeyInfo),
&ResultLength
);
TmpStatus = NtClose(KeyHandle);
ASSERT(NT_SUCCESS(TmpStatus));
//
// If the key isn't there, don't turn on CrashOnFail.
//
if (NT_SUCCESS( Status )) {
pKeyInfo = (PKEY_VALUE_PARTIAL_INFORMATION)KeyInfo;
if ((UCHAR) *(pKeyInfo->Data) == LSAP_CRASH_ON_AUDIT_FAIL) {
SepCrashOnAuditFail = TRUE;
}
}
return( STATUS_SUCCESS );
}
/******************************************************************
* start_debugger
*
* Does the effective debugger startup according to 'format'
*/
static BOOL start_debugger(PEXCEPTION_POINTERS epointers, HANDLE hEvent)
{
OBJECT_ATTRIBUTES attr;
UNICODE_STRING nameW;
char *cmdline, *env, *p;
HANDLE hDbgConf;
DWORD bAuto = TRUE;
PROCESS_INFORMATION info;
STARTUPINFOA startup;
char* format = NULL;
BOOL ret = FALSE;
char buffer[256];
static const WCHAR AeDebugW[] = {'M','a','c','h','i','n','e','\\',
'S','o','f','t','w','a','r','e','\\',
'M','i','c','r','o','s','o','f','t','\\',
'W','i','n','d','o','w','s',' ','N','T','\\',
'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
'A','e','D','e','b','u','g',0};
static const WCHAR DebuggerW[] = {'D','e','b','u','g','g','e','r',0};
static const WCHAR AutoW[] = {'A','u','t','o',0};
format_exception_msg( epointers, buffer, sizeof(buffer) );
MESSAGE("wine: %s (thread %04x), starting debugger...\n", buffer, GetCurrentThreadId());
attr.Length = sizeof(attr);
attr.RootDirectory = 0;
attr.ObjectName = &nameW;
attr.Attributes = 0;
attr.SecurityDescriptor = NULL;
attr.SecurityQualityOfService = NULL;
RtlInitUnicodeString( &nameW, AeDebugW );
if (!NtOpenKey( &hDbgConf, KEY_ALL_ACCESS, &attr ))
{
char buffer[64];
KEY_VALUE_PARTIAL_INFORMATION *info;
DWORD format_size = 0;
RtlInitUnicodeString( &nameW, DebuggerW );
if (NtQueryValueKey( hDbgConf, &nameW, KeyValuePartialInformation,
NULL, 0, &format_size ) == STATUS_BUFFER_OVERFLOW)
{
char *data = HeapAlloc(GetProcessHeap(), 0, format_size);
NtQueryValueKey( hDbgConf, &nameW, KeyValuePartialInformation,
data, format_size, &format_size );
info = (KEY_VALUE_PARTIAL_INFORMATION *)data;
RtlUnicodeToMultiByteSize( &format_size, (WCHAR *)info->Data, info->DataLength );
format = HeapAlloc( GetProcessHeap(), 0, format_size+1 );
RtlUnicodeToMultiByteN( format, format_size, NULL,
(WCHAR *)info->Data, info->DataLength );
format[format_size] = 0;
if (info->Type == REG_EXPAND_SZ)
{
char* tmp;
/* Expand environment variable references */
format_size=ExpandEnvironmentStringsA(format,NULL,0);
tmp=HeapAlloc(GetProcessHeap(), 0, format_size);
ExpandEnvironmentStringsA(format,tmp,format_size);
HeapFree(GetProcessHeap(), 0, format);
format=tmp;
}
HeapFree( GetProcessHeap(), 0, data );
}
RtlInitUnicodeString( &nameW, AutoW );
if (!NtQueryValueKey( hDbgConf, &nameW, KeyValuePartialInformation,
buffer, sizeof(buffer)-sizeof(WCHAR), &format_size ))
{
info = (KEY_VALUE_PARTIAL_INFORMATION *)buffer;
if (info->Type == REG_DWORD) memcpy( &bAuto, info->Data, sizeof(DWORD) );
else if (info->Type == REG_SZ)
{
WCHAR *str = (WCHAR *)info->Data;
str[info->DataLength/sizeof(WCHAR)] = 0;
bAuto = atoiW( str );
}
}
NtClose(hDbgConf);
}
if (format)
{
cmdline = HeapAlloc(GetProcessHeap(), 0, strlen(format) + 2*20);
sprintf(cmdline, format, GetCurrentProcessId(), hEvent);
HeapFree(GetProcessHeap(), 0, format);
}
else
{
cmdline = HeapAlloc(GetProcessHeap(), 0, 80);
sprintf(cmdline, "winedbg --auto %d %ld",
GetCurrentProcessId(), (ULONG_PTR)hEvent);
}
if (!bAuto)
{
HMODULE mod = GetModuleHandleA( "user32.dll" );
MessageBoxA_funcptr pMessageBoxA = NULL;
if (mod) pMessageBoxA = (MessageBoxA_funcptr)GetProcAddress( mod, "MessageBoxA" );
if (pMessageBoxA)
{
static const char msg[] = ".\nDo you wish to debug it?";
char buffer[256];
format_exception_msg( epointers, buffer, sizeof(buffer)-sizeof(msg) );
strcat( buffer, msg );
if (pMessageBoxA( 0, buffer, "Exception raised", MB_YESNO | MB_ICONHAND ) == IDNO)
{
TRACE("Killing process\n");
goto EXIT;
}
}
}
/* make WINEDEBUG empty in the environment */
env = GetEnvironmentStringsA();
for (p = env; *p; p += strlen(p) + 1)
{
if (!memcmp( p, "WINEDEBUG=", sizeof("WINEDEBUG=")-1 ))
{
char *next = p + strlen(p);
char *end = next + 1;
while (*end) end += strlen(end) + 1;
memmove( p + sizeof("WINEDEBUG=") - 1, next, end + 1 - next );
break;
}
}
TRACE("Starting debugger %s\n", debugstr_a(cmdline));
memset(&startup, 0, sizeof(startup));
startup.cb = sizeof(startup);
startup.dwFlags = STARTF_USESHOWWINDOW;
startup.wShowWindow = SW_SHOWNORMAL;
ret = CreateProcessA(NULL, cmdline, NULL, NULL, TRUE, 0, env, NULL, &startup, &info);
FreeEnvironmentStringsA( env );
if (ret)
{
/* wait for debugger to come up... */
HANDLE handles[2];
CloseHandle(info.hThread);
handles[0]=hEvent;
handles[1]=info.hProcess;
WaitForMultipleObjects(2, handles, FALSE, INFINITE);
CloseHandle(info.hProcess);
}
else ERR("Couldn't start debugger (%s) (%d)\n"
"Read the Wine Developers Guide on how to set up winedbg or another debugger\n",
debugstr_a(cmdline), GetLastError());
EXIT:
HeapFree(GetProcessHeap(), 0, cmdline);
return ret;
}
BOOLEAN
SepAdtInitializePrivilegeAuditing(
VOID
)
/*++
Routine Description:
Checks to see if there is an entry in the registry telling us to do full privilege auditing
(which currently means audit everything we normall audit, plus backup and restore privileges).
Arguments:
None
Return Value:
BOOLEAN - TRUE if Auditing has been initialized correctly, else FALSE.
--*/
{
HANDLE KeyHandle;
NTSTATUS Status;
NTSTATUS TmpStatus;
OBJECT_ATTRIBUTES Obja;
ULONG ResultLength;
UNICODE_STRING KeyName;
UNICODE_STRING ValueName;
CHAR KeyInfo[sizeof(KEY_VALUE_PARTIAL_INFORMATION) + sizeof(BOOLEAN)];
PKEY_VALUE_PARTIAL_INFORMATION pKeyInfo;
BOOLEAN Verbose;
PAGED_CODE();
//
// Query the registry to set up the privilege auditing filter.
//
RtlInitUnicodeString( &KeyName, L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\Lsa");
InitializeObjectAttributes( &Obja,
&KeyName,
OBJ_CASE_INSENSITIVE,
NULL,
NULL
);
Status = NtOpenKey(
&KeyHandle,
KEY_QUERY_VALUE | KEY_SET_VALUE,
&Obja
);
if (!NT_SUCCESS( Status )) {
if (Status == STATUS_OBJECT_NAME_NOT_FOUND) {
return ( SepInitializePrivilegeFilter( FALSE ));
} else {
return( FALSE );
}
}
RtlInitUnicodeString( &ValueName, FULL_PRIVILEGE_AUDITING );
Status = NtQueryValueKey(
KeyHandle,
&ValueName,
KeyValuePartialInformation,
KeyInfo,
sizeof(KeyInfo),
&ResultLength
);
TmpStatus = NtClose(KeyHandle);
ASSERT(NT_SUCCESS(TmpStatus));
if (!NT_SUCCESS( Status )) {
Verbose = FALSE;
} else {
pKeyInfo = (PKEY_VALUE_PARTIAL_INFORMATION)KeyInfo;
Verbose = (BOOLEAN) *(pKeyInfo->Data);
}
return ( SepInitializePrivilegeFilter( Verbose ));
}
void test8(void)
{
OBJECT_ATTRIBUTES ObjectAttributes;
UNICODE_STRING KeyName;
NTSTATUS Status;
LONG dwError;
TOKEN_PRIVILEGES NewPrivileges;
HANDLE Token,hKey;
LUID Luid = {0};
BOOLEAN bRes;
Status=NtOpenProcessToken(GetCurrentProcess()
,TOKEN_ADJUST_PRIVILEGES,&Token);
// ,TOKEN_ADJUST_PRIVILEGES|TOKEN_QUERY,&Token);
dprintf("\t\t\t\tStatus =%x\n",Status);
// bRes=LookupPrivilegeValueA(NULL,SE_RESTORE_NAME,&Luid);
// dprintf("\t\t\t\tbRes =%x\n",bRes);
NewPrivileges.PrivilegeCount = 1;
NewPrivileges.Privileges[0].Luid = Luid;
// NewPrivileges.Privileges[0].Luid.u.LowPart=18;
// NewPrivileges.Privileges[0].Luid.u.HighPart=0;
NewPrivileges.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
// Status = NtAdjustPrivilegesToken(
bRes = AdjustTokenPrivileges(
Token,
FALSE,
&NewPrivileges,
0,
NULL,
NULL
);
dprintf("\t\t\t\tbRes =%x\n",bRes);
// Status=NtClose(Token);
// dprintf("\t\t\t\tStatus =%x\n",Status);
RtlRosInitUnicodeStringFromLiteral(&KeyName,L"test5");
InitializeObjectAttributes(&ObjectAttributes, &KeyName, OBJ_CASE_INSENSITIVE
, NULL, NULL);
Status = NtLoadKey((HANDLE)HKEY_LOCAL_MACHINE,&ObjectAttributes);
dprintf("\t\t\t\tStatus =%x\n",Status);
dwError=RegLoadKey(HKEY_LOCAL_MACHINE,"def"
,"test5");
dprintf("\t\t\t\tdwError =%x\n",dwError);
dprintf("NtOpenKey \\Registry\\Machine : ");
RtlRosInitUnicodeStringFromLiteral(&KeyName, L"\\Registry\\Machine");
InitializeObjectAttributes(&ObjectAttributes,
&KeyName,
OBJ_CASE_INSENSITIVE,
NULL,
NULL);
Status=NtOpenKey( &hKey, MAXIMUM_ALLOWED, &ObjectAttributes);
dprintf("\t\t\tStatus =%x\n",Status);
RtlRosInitUnicodeStringFromLiteral(&KeyName,L"test5");
InitializeObjectAttributes(&ObjectAttributes, &KeyName, OBJ_CASE_INSENSITIVE
, NULL, NULL);
Status = NtLoadKey(hKey,&ObjectAttributes);
dprintf("\t\t\t\tStatus =%x\n",Status);
}
/***********************************************************************
* TIME_GetSpecificTimeZoneInfo
*
* Returns time zone information for the given time zone and year.
*
* PARAMS
* key_name [in] The time zone name.
* year [in] The year, if Dynamic DST is used.
* dynamic [in] Whether to use Dynamic DST.
* result [out] The time zone information.
*
* RETURNS
* TRUE if successful.
*/
static BOOL TIME_GetSpecificTimeZoneInfo( const WCHAR *key_name, WORD year,
BOOL dynamic, DYNAMIC_TIME_ZONE_INFORMATION *tzinfo )
{
static const WCHAR Dynamic_DstW[] = { 'D','y','n','a','m','i','c',' ','D','S','T',0 };
static const WCHAR fmtW[] = { '%','d',0 };
static const WCHAR stdW[] = { 'S','t','d',0 };
static const WCHAR dltW[] = { 'D','l','t',0 };
static const WCHAR tziW[] = { 'T','Z','I',0 };
HANDLE time_zone_key, dynamic_dst_key;
OBJECT_ATTRIBUTES attr;
UNICODE_STRING nameW;
WCHAR yearW[16];
BOOL got_reg_data = FALSE;
struct tz_reg_data
{
LONG bias;
LONG std_bias;
LONG dlt_bias;
SYSTEMTIME std_date;
SYSTEMTIME dlt_date;
} tz_data;
if (!TIME_GetSpecificTimeZoneKey( key_name, &time_zone_key ))
return FALSE;
if (!reg_query_value( time_zone_key, stdW, REG_SZ, tzinfo->StandardName, sizeof(tzinfo->StandardName)) ||
!reg_query_value( time_zone_key, dltW, REG_SZ, tzinfo->DaylightName, sizeof(tzinfo->DaylightName)))
{
NtClose( time_zone_key );
return FALSE;
}
lstrcpyW(tzinfo->TimeZoneKeyName, key_name);
if (dynamic)
{
attr.Length = sizeof(attr);
attr.RootDirectory = time_zone_key;
attr.ObjectName = &nameW;
attr.Attributes = 0;
attr.SecurityDescriptor = NULL;
attr.SecurityQualityOfService = NULL;
RtlInitUnicodeString( &nameW, Dynamic_DstW );
if (!NtOpenKey( &dynamic_dst_key, KEY_READ, &attr ))
{
sprintfW( yearW, fmtW, year );
got_reg_data = reg_query_value( dynamic_dst_key, yearW, REG_BINARY, &tz_data, sizeof(tz_data) );
NtClose( dynamic_dst_key );
}
}
if (!got_reg_data)
{
if (!reg_query_value( time_zone_key, tziW, REG_BINARY, &tz_data, sizeof(tz_data) ))
{
NtClose( time_zone_key );
return FALSE;
}
}
tzinfo->Bias = tz_data.bias;
tzinfo->StandardBias = tz_data.std_bias;
tzinfo->DaylightBias = tz_data.dlt_bias;
tzinfo->StandardDate = tz_data.std_date;
tzinfo->DaylightDate = tz_data.dlt_date;
tzinfo->DynamicDaylightTimeDisabled = !dynamic;
NtClose( time_zone_key );
return TRUE;
}
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);
}
NTSTATUS
LsapAdtInitializeCrashOnFail(
VOID
)
/*++
Routine Description:
Reads the registry to see if the user has told us to crash if an audit fails.
Arguments:
None.
Return Value:
STATUS_SUCCESS
--*/
{
HANDLE KeyHandle;
NTSTATUS Status;
NTSTATUS TmpStatus;
OBJECT_ATTRIBUTES Obja;
ULONG ResultLength;
UNICODE_STRING KeyName;
UNICODE_STRING ValueName;
CHAR KeyInfo[sizeof(KEY_VALUE_PARTIAL_INFORMATION) + sizeof(BOOLEAN)];
PKEY_VALUE_PARTIAL_INFORMATION pKeyInfo;
//
// Check the value of the CrashOnAudit key.
//
RtlInitUnicodeString( &KeyName, L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\Lsa");
InitializeObjectAttributes( &Obja,
&KeyName,
OBJ_CASE_INSENSITIVE,
NULL,
NULL
);
Status = NtOpenKey(
&KeyHandle,
KEY_QUERY_VALUE | KEY_SET_VALUE,
&Obja
);
if (Status == STATUS_OBJECT_NAME_NOT_FOUND) {
LsapCrashOnAuditFail = FALSE;
return( STATUS_SUCCESS );
}
RtlInitUnicodeString( &ValueName, CRASH_ON_AUDIT_FAIL_VALUE );
Status = NtQueryValueKey(
KeyHandle,
&ValueName,
KeyValuePartialInformation,
KeyInfo,
sizeof(KeyInfo),
&ResultLength
);
TmpStatus = NtClose(KeyHandle);
ASSERT(NT_SUCCESS(TmpStatus));
//
// If it's not found, don't enable CrashOnFail.
//
if (!NT_SUCCESS( Status )) {
LsapCrashOnAuditFail = FALSE;
} else {
//
// Check the value of the CrashOnFail value. If it is 1, we
// crash on audit fail. If it is two, we only allow admins to
// logon.
//
pKeyInfo = (PKEY_VALUE_PARTIAL_INFORMATION)KeyInfo;
if (*(pKeyInfo->Data) == LSAP_CRASH_ON_AUDIT_FAIL) {
LsapCrashOnAuditFail = TRUE;
} else if (*(pKeyInfo->Data) == LSAP_ALLOW_ADIMIN_LOGONS_ONLY) {
LsapAllowAdminLogonsOnly = TRUE;
}
}
if ( LsapCrashOnAuditFail ) {
BOOLEAN WasEnabled;
Status = RtlAdjustPrivilege(
SE_SHUTDOWN_PRIVILEGE,
TRUE,
FALSE,
&WasEnabled
);
//
// This had better work.
//
ASSERT(NT_SUCCESS(Status));
return( Status );
}
return( STATUS_SUCCESS );
}
/*
* propOpenCurrentObject
*
* Purpose:
*
* Opens currently viewed object depending on type
*
*/
BOOL propOpenCurrentObject(
_In_ PROP_OBJECT_INFO *Context,
_Inout_ PHANDLE phObject,
_In_ ACCESS_MASK DesiredAccess
)
{
BOOL bResult;
HANDLE hObject, hDirectory;
NTSTATUS status;
UNICODE_STRING ustr;
OBJECT_ATTRIBUTES obja;
IO_STATUS_BLOCK iost;
bResult = FALSE;
if (Context == NULL) {
return bResult;
}
//we don't know who is it
if (Context->TypeIndex == TYPE_UNKNOWN) {
SetLastError(ERROR_UNSUPPORTED_TYPE);
return bResult;
}
if (phObject == NULL) {
SetLastError(ERROR_OBJECT_NOT_FOUND);
return bResult;
}
if (Context->lpObjectName == NULL) {
SetLastError(ERROR_OBJECT_NOT_FOUND);
return bResult;
}
if (Context->lpCurrentObjectPath == NULL) {
SetLastError(ERROR_OBJECT_NOT_FOUND);
return bResult;
}
//ports not supported
if (
(Context->TypeIndex == TYPE_PORT) ||
(Context->TypeIndex == TYPE_FLTCOMM_PORT) ||
(Context->TypeIndex == TYPE_FLTCONN_PORT) ||
(Context->TypeIndex == TYPE_WAITABLEPORT)
)
{
SetLastError(ERROR_UNSUPPORTED_TYPE);
return bResult;
}
hDirectory = NULL;
if (DesiredAccess == 0) {
DesiredAccess = 1;
}
//handle directory type
if (Context->TypeIndex == TYPE_DIRECTORY) {
//if this is root, then root hDirectory = NULL
if (_strcmpi(Context->lpObjectName, L"\\") != 0) {
//else open directory that holds this object
hDirectory = supOpenDirectoryForObject(Context->lpObjectName, Context->lpCurrentObjectPath);
if (hDirectory == NULL) {
SetLastError(ERROR_OBJECT_NOT_FOUND);
return bResult;
}
}
//open object in directory
RtlSecureZeroMemory(&ustr, sizeof(ustr));
RtlInitUnicodeString(&ustr, Context->lpObjectName);
InitializeObjectAttributes(&obja, &ustr, OBJ_CASE_INSENSITIVE, hDirectory, NULL);
hObject = NULL;
status = NtOpenDirectoryObject(&hObject, DesiredAccess, &obja); //DIRECTORY_QUERY for query
SetLastError(RtlNtStatusToDosError(status));
bResult = ((NT_SUCCESS(status)) && (hObject != NULL));
if (bResult && phObject) {
*phObject = hObject;
}
//dont forget to close directory handle if it was opened
if (hDirectory != NULL) {
NtClose(hDirectory);
}
return bResult;
}
//handle window station type
if (Context->TypeIndex == TYPE_WINSTATION) {
hObject = OpenWindowStation(Context->lpObjectName, FALSE, DesiredAccess); //WINSTA_READATTRIBUTES for query
bResult = (hObject != NULL);
if (bResult && phObject) {
*phObject = hObject;
}
return bResult;
}
//handle desktop type
if (Context->TypeIndex == TYPE_DESKTOP) {
hObject = OpenDesktop(Context->lpObjectName, 0, FALSE, DesiredAccess); //DESKTOP_READOBJECTS for query
bResult = (hObject != NULL);
if (bResult && phObject) {
*phObject = hObject;
}
return bResult;
}
//open directory which current object belongs
hDirectory = supOpenDirectoryForObject(Context->lpObjectName, Context->lpCurrentObjectPath);
if (hDirectory == NULL) {
SetLastError(ERROR_OBJECT_NOT_FOUND);
return bResult;
}
RtlSecureZeroMemory(&ustr, sizeof(ustr));
RtlInitUnicodeString(&ustr, Context->lpObjectName);
InitializeObjectAttributes(&obja, &ustr, OBJ_CASE_INSENSITIVE, hDirectory, NULL);
status = STATUS_UNSUCCESSFUL;
hObject = NULL;
//handle supported objects
switch (Context->TypeIndex) {
case TYPE_DEVICE: //FILE_OBJECT
status = NtCreateFile(&hObject, DesiredAccess, &obja, &iost, NULL, 0,
FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_OPEN, 0, NULL, 0);//generic access rights
break;
case TYPE_MUTANT:
status = NtOpenMutant(&hObject, DesiredAccess, &obja); //MUTANT_QUERY_STATE for query
break;
case TYPE_KEY:
status = NtOpenKey(&hObject, DesiredAccess, &obja); //KEY_QUERY_VALUE for query
break;
case TYPE_SEMAPHORE:
status = NtOpenSemaphore(&hObject, DesiredAccess, &obja); //SEMAPHORE_QUERY_STATE for query
break;
case TYPE_TIMER:
status = NtOpenTimer(&hObject, DesiredAccess, &obja); //TIMER_QUERY_STATE for query
break;
case TYPE_EVENT:
status = NtOpenEvent(&hObject, DesiredAccess, &obja); //EVENT_QUERY_STATE for query
break;
case TYPE_EVENTPAIR:
status = NtOpenEventPair(&hObject, DesiredAccess, &obja); //generic access
break;
case TYPE_SYMLINK:
status = NtOpenSymbolicLinkObject(&hObject, DesiredAccess, &obja); //SYMBOLIC_LINK_QUERY for query
break;
case TYPE_IOCOMPLETION:
status = NtOpenIoCompletion(&hObject, DesiredAccess, &obja); //IO_COMPLETION_QUERY_STATE for query
break;
case TYPE_SECTION:
status = NtOpenSection(&hObject, DesiredAccess, &obja); //SECTION_QUERY for query
break;
case TYPE_JOB:
status = NtOpenJobObject(&hObject, DesiredAccess, &obja); //JOB_OBJECT_QUERY for query
break;
}
SetLastError(RtlNtStatusToDosError(status));
NtClose(hDirectory);
bResult = ((NT_SUCCESS(status)) && (hObject != NULL));
if (bResult && phObject) {
*phObject = hObject;
}
return bResult;
}
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;
}
VOID
DoTest(
HANDLE RootKey
)
{
NTSTATUS rc;
STRING String1;
UCHAR Value1[] = "This string is value 1.";
UCHAR Value2[] = "Value 2 is represented by this string.";
HANDLE Handle1;
HANDLE Handle2;
ULONG ValueLength;
ULONG Type;
LARGE_INTEGER Time;
//
// Create parent node
//
DbgPrint("Part1\n");
RtlInitString(&String1, "Test1");
rc = NtCreateKey(
RootKey,
&String1,
0,
NULL,
GENERIC_READ|GENERIC_WRITE,
&Handle1
);
if (!NT_SUCCESS(rc)) {
DbgPrint("1:CreateKey failed rc = %08lx", rc);
return;
}
//
// Set data into parent
//
DbgPrint("Part2\n");
rc = NtSetValueKey(
Handle1,
1, // type
Value1,
strlen(Value1)
);
if (!NT_SUCCESS(rc)) {
DbgPrint("2:SetValueKey failed rc = %08lx", rc);
return;
}
//
// Query and compare data from parent
//
DbgPrint("Part2b\n");
ValueLength = MAX_VALUE;
rc = NtQueryValueKey(
Handle1,
&Type,
ValueBuffer,
&ValueLength,
&Time
);
if (!NT_SUCCESS(rc)) {
DbgPrint("2b:QueryValueKey failed rc = %08lx", rc);
return;
}
if (ValueLength != (ULONG)strlen(Value1)) {
DbgPrint("2b1:Wrong value length\n");
return;
} else if (RtlCompareMemory(
ValueBuffer, Value1, ValueLength) != ValueLength) {
DbgPrint("2b2:Wrong value\n");
return;
} else if (Type != 1) {
DbgPrint("2b3:Wrong type\n");
return;
}
//
// Close parent
//
DbgPrint("Part3\n");
NtCloseKey(Handle1);
if (!NT_SUCCESS(rc)) {
DbgPrint("3:CloseKey failed rc = %08lx", rc);
return;
}
//
// Reopen parent
//
DbgPrint("Part4\n");
rc = NtOpenKey(
RootKey,
&String1,
0,
GENERIC_READ|GENERIC_WRITE,
&Handle1
);
if (!NT_SUCCESS(rc)) {
DbgPrint("4:OpenKey failed rc = %08lx", rc);
return;
}
//
// Create child
//
DbgPrint("Part5\n");
RtlInitString(&String1, "Test2");
rc = NtCreateKey(
Handle1,
&String1,
0,
NULL,
GENERIC_READ|GENERIC_WRITE,
&Handle2
);
if (!NT_SUCCESS(rc)) {
DbgPrint("5:CreateKey failed rc = %08lx", rc);
return;
}
//
// Set data into child
//
DbgPrint("Part6\n");
rc = NtSetValueKey(
Handle2,
2, // type
Value2,
strlen(Value2)
);
if (!NT_SUCCESS(rc)) {
DbgPrint("6:SetValueKey failed rc = %08lx", rc);
return;
}
//
// Query and compare data from child
//
DbgPrint("Part7\n");
ValueLength = MAX_VALUE;
rc = NtQueryValueKey(
Handle2,
&Type,
ValueBuffer,
&ValueLength,
&Time
);
if (!NT_SUCCESS(rc)) {
DbgPrint("7:QueryValueKey failed rc = %08lx", rc);
return;
}
if (ValueLength != (ULONG)strlen(Value2)) {
DbgPrint("7.1:Wrong value length\n");
return;
} else if (RtlCompareMemory(
ValueBuffer, Value2, ValueLength) != ValueLength) {
DbgPrint("7.2:Wrong value\n");
return;
} else if (Type != 2) {
DbgPrint("7.3:Wrong type\n");
return;
}
//
// Query and compare data from parent again
//
DbgPrint("Part8\n");
ValueLength = MAX_VALUE;
rc = NtQueryValueKey(
Handle1,
&Type,
ValueBuffer,
&ValueLength,
&Time
);
if (!NT_SUCCESS(rc)) {
DbgPrint("8:QueryValueKey failed rc = %08lx", rc);
return;
}
if (ValueLength != (ULONG)strlen(Value1)) {
DbgPrint("8.1:Wrong value length\n");
return;
} else if (RtlCompareMemory(
ValueBuffer, Value1, ValueLength) != ValueLength) {
DbgPrint("8.2:Wrong value\n");
return;
} else if (Type != 1) {
DbgPrint("8.3:Wrong type\n");
return;
}
//
// Reset parent data
//
DbgPrint("Part9\n");
rc = NtSetValueKey(
Handle1,
1, // type
Value2,
strlen(Value2)
);
if (!NT_SUCCESS(rc)) {
DbgPrint("9:SetValueKey failed rc = %08lx", rc);
return;
}
//
// Query and compare reset data
//
DbgPrint("Part10\n");
ValueLength = MAX_VALUE;
rc = NtQueryValueKey(
Handle1,
&Type,
ValueBuffer,
&ValueLength,
&Time
);
if (!NT_SUCCESS(rc)) {
DbgPrint("10:QueryValueKey failed rc = %08lx", rc);
return;
}
if (ValueLength != (ULONG)strlen(Value2)) {
DbgPrint("10.1:Wrong value length\n");
return;
} else if (RtlCompareMemory(
ValueBuffer, Value2, ValueLength) != ValueLength) {
DbgPrint("10.2:Wrong value\n");
return;
} else if (Type != 1) {
DbgPrint("10.3:Wrong type\n");
return;
}
//
// Close off handles and return
//
DbgPrint("Part11\n");
rc = NtCloseKey(Handle1);
if (!NT_SUCCESS(rc)) {
DbgPrint("11:CloseKey failed rc = %08lx", rc);
return;
}
DbgPrint("Part12\n");
rc = NtCloseKey(Handle2);
if (!NT_SUCCESS(rc)) {
DbgPrint("12:CloseKey failed rc = %08lx", rc);
return;
}
return;
}
static void find_reg_tz_info(RTL_DYNAMIC_TIME_ZONE_INFORMATION *tzi)
{
static const WCHAR Time_ZonesW[] = { 'M','a','c','h','i','n','e','\\',
'S','o','f','t','w','a','r','e','\\',
'M','i','c','r','o','s','o','f','t','\\',
'W','i','n','d','o','w','s',' ','N','T','\\',
'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
'T','i','m','e',' ','Z','o','n','e','s',0 };
static const WCHAR Dynamic_DstW[] = { 'D','y','n','a','m','i','c',' ','D','S','T',0 };
static const WCHAR fmtW[] = { '%','d',0 };
HANDLE hkey;
ULONG idx;
OBJECT_ATTRIBUTES attr, attrDynamic;
UNICODE_STRING nameW, nameDynamicW;
WCHAR buf[128], yearW[16];
sprintfW(yearW, fmtW, tzi->DaylightDate.wYear);
attrDynamic.Length = sizeof(attrDynamic);
attrDynamic.RootDirectory = 0; /* will be replaced later */
attrDynamic.ObjectName = &nameDynamicW;
attrDynamic.Attributes = 0;
attrDynamic.SecurityDescriptor = NULL;
attrDynamic.SecurityQualityOfService = NULL;
RtlInitUnicodeString(&nameDynamicW, Dynamic_DstW);
attr.Length = sizeof(attr);
attr.RootDirectory = 0;
attr.ObjectName = &nameW;
attr.Attributes = 0;
attr.SecurityDescriptor = NULL;
attr.SecurityQualityOfService = NULL;
RtlInitUnicodeString(&nameW, Time_ZonesW);
if (NtOpenKey(&hkey, KEY_READ, &attr))
{
WARN("Unable to open the time zones key\n");
return;
}
idx = 0;
nameW.Buffer = buf;
nameW.Length = sizeof(buf);
nameW.MaximumLength = sizeof(buf);
while (!RtlpNtEnumerateSubKey(hkey, &nameW, idx++))
{
static const WCHAR stdW[] = { 'S','t','d',0 };
static const WCHAR dltW[] = { 'D','l','t',0 };
static const WCHAR tziW[] = { 'T','Z','I',0 };
RTL_DYNAMIC_TIME_ZONE_INFORMATION reg_tzi;
HANDLE hSubkey, hSubkeyDynamicDST;
BOOL is_dynamic = FALSE;
struct tz_reg_data
{
LONG bias;
LONG std_bias;
LONG dlt_bias;
RTL_SYSTEM_TIME std_date;
RTL_SYSTEM_TIME dlt_date;
} tz_data;
attr.Length = sizeof(attr);
attr.RootDirectory = hkey;
attr.ObjectName = &nameW;
attr.Attributes = 0;
attr.SecurityDescriptor = NULL;
attr.SecurityQualityOfService = NULL;
if (NtOpenKey(&hSubkey, KEY_READ, &attr))
{
WARN("Unable to open subkey %s\n", debugstr_wn(nameW.Buffer, nameW.Length/sizeof(WCHAR)));
continue;
}
#define get_value(hkey, name, type, data, len) \
if (!reg_query_value(hkey, name, type, data, len)) \
{ \
WARN("can't read data from %s\n", debugstr_w(name)); \
NtClose(hkey); \
continue; \
}
get_value(hSubkey, stdW, REG_SZ, reg_tzi.StandardName, sizeof(reg_tzi.StandardName));
get_value(hSubkey, dltW, REG_SZ, reg_tzi.DaylightName, sizeof(reg_tzi.DaylightName));
memcpy(reg_tzi.TimeZoneKeyName, nameW.Buffer, nameW.Length);
reg_tzi.TimeZoneKeyName[nameW.Length/sizeof(WCHAR)] = 0;
/* Check for Dynamic DST entry first */
attrDynamic.RootDirectory = hSubkey;
if (!NtOpenKey(&hSubkeyDynamicDST, KEY_READ, &attrDynamic))
{
is_dynamic = reg_query_value(hSubkeyDynamicDST, yearW, REG_BINARY, &tz_data, sizeof(tz_data));
NtClose(hSubkeyDynamicDST);
}
if (!is_dynamic)
get_value(hSubkey, tziW, REG_BINARY, &tz_data, sizeof(tz_data));
#undef get_value
reg_tzi.Bias = tz_data.bias;
reg_tzi.StandardBias = tz_data.std_bias;
reg_tzi.DaylightBias = tz_data.dlt_bias;
reg_tzi.StandardDate = tz_data.std_date;
reg_tzi.DaylightDate = tz_data.dlt_date;
TRACE("%s: bias %d\n", debugstr_wn(nameW.Buffer, nameW.Length/sizeof(WCHAR)), reg_tzi.Bias);
TRACE("std (d/m/y): %u/%02u/%04u day of week %u %u:%02u:%02u.%03u bias %d\n",
reg_tzi.StandardDate.wDay, reg_tzi.StandardDate.wMonth,
reg_tzi.StandardDate.wYear, reg_tzi.StandardDate.wDayOfWeek,
reg_tzi.StandardDate.wHour, reg_tzi.StandardDate.wMinute,
reg_tzi.StandardDate.wSecond, reg_tzi.StandardDate.wMilliseconds,
reg_tzi.StandardBias);
TRACE("dst (d/m/y): %u/%02u/%04u day of week %u %u:%02u:%02u.%03u bias %d\n",
reg_tzi.DaylightDate.wDay, reg_tzi.DaylightDate.wMonth,
reg_tzi.DaylightDate.wYear, reg_tzi.DaylightDate.wDayOfWeek,
reg_tzi.DaylightDate.wHour, reg_tzi.DaylightDate.wMinute,
reg_tzi.DaylightDate.wSecond, reg_tzi.DaylightDate.wMilliseconds,
reg_tzi.DaylightBias);
NtClose(hSubkey);
if (match_tz_info(tzi, ®_tzi))
{
*tzi = reg_tzi;
NtClose(hkey);
return;
}
/* reset len */
nameW.Length = sizeof(buf);
nameW.MaximumLength = sizeof(buf);
}
NtClose(hkey);
FIXME("Can't find matching timezone information in the registry for "
"bias %d, std (d/m/y): %u/%02u/%04u, dlt (d/m/y): %u/%02u/%04u\n",
tzi->Bias,
tzi->StandardDate.wDay, tzi->StandardDate.wMonth, tzi->StandardDate.wYear,
tzi->DaylightDate.wDay, tzi->DaylightDate.wMonth, tzi->DaylightDate.wYear);
}
/******************************************************************************
* SetComputerNameW [KERNEL32.@]
*
* Set a new NetBIOS name for the local computer.
*
* PARAMS
* lpComputerName [I] Address of new computer name
*
* RETURNS
* Success: TRUE
* Failure: FALSE
*/
BOOL WINAPI SetComputerNameW( LPCWSTR lpComputerName )
{
UNICODE_STRING nameW;
OBJECT_ATTRIBUTES attr;
HANDLE hkey = INVALID_HANDLE_VALUE, hsubkey = INVALID_HANDLE_VALUE;
int plen = strlenW ( lpComputerName );
int i;
NTSTATUS st = STATUS_INTERNAL_ERROR;
if (get_use_dns_option())
{
/* This check isn't necessary, but may help debugging problems. */
WARN( "Disabled by Wine Configuration.\n" );
WARN( "Set \"UseDnsComputerName\" = \"N\" in HKCU\\Software\\Wine\\Network to enable.\n" );
SetLastError ( ERROR_ACCESS_DENIED );
return FALSE;
}
TRACE( "%s\n", debugstr_w (lpComputerName) );
/* Check parameter */
if ( plen > MAX_COMPUTERNAME_LENGTH )
goto out;
/* This is NT behaviour. Win 95/98 would coerce characters. */
for ( i = 0; i < plen; i++ )
{
WCHAR wc = lpComputerName[i];
if ( wc != netbios_char( wc ) )
goto out;
}
_init_attr ( &attr, &nameW );
RtlInitUnicodeString (&nameW, ComputerW);
if ( ( st = NtOpenKey( &hkey, KEY_ALL_ACCESS, &attr ) ) != STATUS_SUCCESS )
goto out;
attr.RootDirectory = hkey;
RtlInitUnicodeString( &nameW, ComputerNameW );
if ( ( st = NtOpenKey( &hsubkey, KEY_ALL_ACCESS, &attr ) ) != STATUS_SUCCESS )
goto out;
if ( ( st = NtSetValueKey( hsubkey, &nameW, 0, REG_SZ, lpComputerName, ( plen + 1) * sizeof(WCHAR) ) )
!= STATUS_SUCCESS )
goto out;
out:
NtClose( hsubkey );
NtClose( hkey );
if ( st == STATUS_SUCCESS )
{
TRACE( "ComputerName changed\n" );
return TRUE;
}
else
{
SetLastError ( RtlNtStatusToDosError ( st ) );
WARN ( "status %u\n", st );
return FALSE;
}
}
static BOOLEAN
IsAcpiComputer(VOID)
{
UNICODE_STRING MultiKeyPathU = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\HARDWARE\\DESCRIPTION\\System\\MultifunctionAdapter");
UNICODE_STRING IdentifierU = RTL_CONSTANT_STRING(L"Identifier");
UNICODE_STRING AcpiBiosIdentifier = RTL_CONSTANT_STRING(L"ACPI BIOS");
OBJECT_ATTRIBUTES ObjectAttributes;
PKEY_BASIC_INFORMATION pDeviceInformation = NULL;
ULONG DeviceInfoLength = sizeof(KEY_BASIC_INFORMATION) + 50 * sizeof(WCHAR);
PKEY_VALUE_PARTIAL_INFORMATION pValueInformation = NULL;
ULONG ValueInfoLength = sizeof(KEY_VALUE_PARTIAL_INFORMATION) + 50 * sizeof(WCHAR);
ULONG RequiredSize;
ULONG IndexDevice = 0;
UNICODE_STRING DeviceName, ValueName;
HANDLE hDevicesKey = NULL;
HANDLE hDeviceKey = NULL;
NTSTATUS Status;
BOOLEAN ret = FALSE;
InitializeObjectAttributes(&ObjectAttributes, &MultiKeyPathU, OBJ_CASE_INSENSITIVE, NULL, NULL);
Status = NtOpenKey(&hDevicesKey, KEY_ENUMERATE_SUB_KEYS, &ObjectAttributes);
if (!NT_SUCCESS(Status))
{
DPRINT("NtOpenKey() failed with status 0x%08lx\n", Status);
goto cleanup;
}
pDeviceInformation = RtlAllocateHeap(RtlGetProcessHeap(), 0, DeviceInfoLength);
if (!pDeviceInformation)
{
DPRINT("RtlAllocateHeap() failed\n");
Status = STATUS_NO_MEMORY;
goto cleanup;
}
pValueInformation = RtlAllocateHeap(RtlGetProcessHeap(), 0, ValueInfoLength);
if (!pDeviceInformation)
{
DPRINT("RtlAllocateHeap() failed\n");
Status = STATUS_NO_MEMORY;
goto cleanup;
}
while (TRUE)
{
Status = NtEnumerateKey(hDevicesKey, IndexDevice, KeyBasicInformation, pDeviceInformation, DeviceInfoLength, &RequiredSize);
if (Status == STATUS_NO_MORE_ENTRIES)
break;
else if (Status == STATUS_BUFFER_OVERFLOW || Status == STATUS_BUFFER_TOO_SMALL)
{
RtlFreeHeap(RtlGetProcessHeap(), 0, pDeviceInformation);
DeviceInfoLength = RequiredSize;
pDeviceInformation = RtlAllocateHeap(RtlGetProcessHeap(), 0, DeviceInfoLength);
if (!pDeviceInformation)
{
DPRINT("RtlAllocateHeap() failed\n");
Status = STATUS_NO_MEMORY;
goto cleanup;
}
Status = NtEnumerateKey(hDevicesKey, IndexDevice, KeyBasicInformation, pDeviceInformation, DeviceInfoLength, &RequiredSize);
}
if (!NT_SUCCESS(Status))
{
DPRINT("NtEnumerateKey() failed with status 0x%08lx\n", Status);
goto cleanup;
}
IndexDevice++;
/* Open device key */
DeviceName.Length = DeviceName.MaximumLength = pDeviceInformation->NameLength;
DeviceName.Buffer = pDeviceInformation->Name;
InitializeObjectAttributes(&ObjectAttributes, &DeviceName, OBJ_CASE_INSENSITIVE, hDevicesKey, NULL);
Status = NtOpenKey(
&hDeviceKey,
KEY_QUERY_VALUE,
&ObjectAttributes);
if (!NT_SUCCESS(Status))
{
DPRINT("NtOpenKey() failed with status 0x%08lx\n", Status);
goto cleanup;
}
/* Read identifier */
Status = NtQueryValueKey(hDeviceKey, &IdentifierU, KeyValuePartialInformation, pValueInformation, ValueInfoLength, &RequiredSize);
if (Status == STATUS_BUFFER_OVERFLOW || Status == STATUS_BUFFER_TOO_SMALL)
{
RtlFreeHeap(RtlGetProcessHeap(), 0, pValueInformation);
ValueInfoLength = RequiredSize;
pValueInformation = RtlAllocateHeap(RtlGetProcessHeap(), 0, ValueInfoLength);
if (!pValueInformation)
{
DPRINT("RtlAllocateHeap() failed\n");
Status = STATUS_NO_MEMORY;
goto cleanup;
}
Status = NtQueryValueKey(hDeviceKey, &IdentifierU, KeyValuePartialInformation, pValueInformation, ValueInfoLength, &RequiredSize);
}
if (!NT_SUCCESS(Status))
{
DPRINT("NtQueryValueKey() failed with status 0x%08lx\n", Status);
goto nextdevice;
}
else if (pValueInformation->Type != REG_SZ)
{
DPRINT("Wrong registry type: got 0x%lx, expected 0x%lx\n", pValueInformation->Type, REG_SZ);
goto nextdevice;
}
ValueName.Length = ValueName.MaximumLength = pValueInformation->DataLength;
ValueName.Buffer = (PWCHAR)pValueInformation->Data;
if (ValueName.Length >= sizeof(WCHAR) && ValueName.Buffer[ValueName.Length / sizeof(WCHAR) - 1] == UNICODE_NULL)
ValueName.Length -= sizeof(WCHAR);
if (RtlCompareUnicodeString(&ValueName, &AcpiBiosIdentifier, FALSE) == 0)
{
DPRINT("Found ACPI BIOS\n");
ret = TRUE;
goto cleanup;
}
nextdevice:
NtClose(hDeviceKey);
hDeviceKey = NULL;
}
cleanup:
if (pDeviceInformation)
RtlFreeHeap(RtlGetProcessHeap(), 0, pDeviceInformation);
if (pValueInformation)
RtlFreeHeap(RtlGetProcessHeap(), 0, pValueInformation);
if (hDevicesKey)
NtClose(hDevicesKey);
if (hDeviceKey)
NtClose(hDeviceKey);
return ret;
}
