BOOLEAN CmpNoWrite;
BOOLEAN CmpWasSetupBoot;
BOOLEAN CmpProfileLoaded;
+BOOLEAN CmpNoVolatileCreates;
ULONG CmpTraceLevel = 0;
extern LONG CmpFlushStarveWriters;
/* FUNCTIONS ******************************************************************/
+BOOLEAN
+NTAPI
+CmpLinkKeyToHive(
+ _In_z_ PCWSTR LinkKeyName,
+ _In_z_ PCWSTR TargetKeyName)
+{
+ NTSTATUS Status;
+ OBJECT_ATTRIBUTES ObjectAttributes;
+ UNICODE_STRING KeyName;
+ HANDLE LinkKeyHandle;
+ ULONG Disposition;
+
+ PAGED_CODE();
+
+ /* Initialize the object attributes */
+ RtlInitUnicodeString(&KeyName, LinkKeyName);
+ InitializeObjectAttributes(&ObjectAttributes,
+ &KeyName,
+ OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
+ NULL,
+ NULL);
+
+ /* Create the link key */
+ Status = ZwCreateKey(&LinkKeyHandle,
+ KEY_CREATE_LINK,
+ &ObjectAttributes,
+ 0,
+ NULL,
+ REG_OPTION_VOLATILE | REG_OPTION_CREATE_LINK,
+ &Disposition);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("CM: CmpLinkKeyToHive: couldn't create %S, Status = 0x%lx\n",
+ LinkKeyName, Status);
+ return FALSE;
+ }
+
+ /* Check if the new key was actually created */
+ if (Disposition != REG_CREATED_NEW_KEY)
+ {
+ DPRINT1("CM: CmpLinkKeyToHive: %S already exists!\n", LinkKeyName);
+ ZwClose(LinkKeyHandle);
+ return FALSE;
+ }
+
+ /* Set the target key name as link target */
+ RtlInitUnicodeString(&KeyName, TargetKeyName);
+ Status = ZwSetValueKey(LinkKeyHandle,
+ &CmSymbolicLinkValueName,
+ 0,
+ REG_LINK,
+ KeyName.Buffer,
+ KeyName.Length);
+
+ /* Close the link key handle */
+ ObCloseHandle(LinkKeyHandle, KernelMode);
+
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("CM: CmpLinkKeyToHive: couldn't create symbolic link for %S, Status = 0x%lx\n",
+ TargetKeyName, Status);
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
VOID
NTAPI
CmpDeleteKeyObject(PVOID DeletedObject)
CmpLockRegistry();
/* Make sure this is a valid key body */
- if (KeyBody->Type == '20yk')
+ if (KeyBody->Type == CM_KEY_BODY_TYPE)
{
/* Get the KCB */
Kcb = KeyBody->KeyControlBlock;
if (SystemHandleCount > 1) return;
/* Make sure we're a valid key body */
- if (KeyBody->Type == '20yk')
+ if (KeyBody->Type == CM_KEY_BODY_TYPE)
{
/* Don't do anything if we don't have a notify block */
if (!KeyBody->NotifyBlock) return;
((Length < (*ReturnLength)) && (BytesToCopy < sizeof(WCHAR))))
{
/* Free the buffer allocated by CmpConstructName */
- ExFreePool(KeyName);
+ ExFreePoolWithTag(KeyName, TAG_CM);
/* Return buffer length failure without writing anything there because nothing fits */
return STATUS_INFO_LENGTH_MISMATCH;
BytesToCopy);
/* Null terminate it */
- ObjectNameInfo->Name.Buffer[BytesToCopy / sizeof(WCHAR)] = 0;
+ ObjectNameInfo->Name.Buffer[BytesToCopy / sizeof(WCHAR)] = UNICODE_NULL;
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
_SEH2_END;
/* Free the buffer allocated by CmpConstructName */
- ExFreePool(KeyName);
+ ExFreePoolWithTag(KeyName, TAG_CM);
/* Return status */
return Status;
}
/* Initialize the hive */
- Status = CmpInitializeHive((PCMHIVE*)&NewHive,
+ Status = CmpInitializeHive(&NewHive,
Operation,
HiveFlags,
FileType,
LogHandle,
NULL,
HiveName,
- 0);
+ CheckFlags);
if (!NT_SUCCESS(Status))
{
/* Fail */
/* Success, return hive */
*Hive = NewHive;
- /* ROS: Init root key cell and prepare the hive */
- if (Operation == HINIT_CREATE) CmCreateRootNode(&NewHive->Hive, L"");
-
/* Duplicate the hive name */
NewHive->FileFullPath.Buffer = ExAllocatePoolWithTag(PagedPool,
HiveName->Length,
HiveName->Buffer,
HiveName->Length);
NewHive->FileFullPath.Length = HiveName->Length;
- NewHive->FileFullPath.MaximumLength = HiveName->MaximumLength;
+ NewHive->FileFullPath.MaximumLength = HiveName->Length;
}
/* Return success */
{
OBJECT_ATTRIBUTES ObjectAttributes;
UNICODE_STRING KeyName, ValueName = { 0, 0, NULL };
- HANDLE KeyHandle;
+ HANDLE KeyHandle = NULL;
NTSTATUS Status;
ASSERT(LoaderBlock != NULL);
CmpLoadOptions.Length);
if (!NT_SUCCESS(Status)) goto Quickie;
- /* Setup value name for system boot device */
+ /* Setup value name for system boot device in ARC format */
RtlInitUnicodeString(&KeyName, L"SystemBootDevice");
- RtlCreateUnicodeStringFromAsciiz(&ValueName, LoaderBlock->NtBootPathName);
+ RtlCreateUnicodeStringFromAsciiz(&ValueName, LoaderBlock->ArcBootDeviceName);
Status = NtSetValueKey(KeyHandle,
&KeyName,
0,
RtlFreeUnicodeString(&ValueName);
/* Close the key and return */
- NtClose(KeyHandle);
+ if (KeyHandle) NtClose(KeyHandle);
/* Return the status */
return (ExpInTextModeSetup ? STATUS_SUCCESS : Status);
}
+static
+NTSTATUS
+INIT_FUNCTION
+CmpCreateHardwareProfile(HANDLE ControlSetHandle)
+{
+ OBJECT_ATTRIBUTES ObjectAttributes;
+ UNICODE_STRING KeyName;
+ HANDLE ProfilesHandle = NULL;
+ HANDLE ProfileHandle = NULL;
+ ULONG Disposition;
+ NTSTATUS Status;
+
+ DPRINT("CmpCreateHardwareProfile()\n");
+
+ /* Create the Hardware Profiles key */
+ RtlInitUnicodeString(&KeyName, L"Hardware Profiles");
+ InitializeObjectAttributes(&ObjectAttributes,
+ &KeyName,
+ OBJ_CASE_INSENSITIVE,
+ ControlSetHandle,
+ NULL);
+ Status = NtCreateKey(&ProfilesHandle,
+ KEY_ALL_ACCESS,
+ &ObjectAttributes,
+ 0,
+ NULL,
+ 0,
+ &Disposition);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("Creating the Hardware Profile key failed\n");
+ goto done;
+ }
+
+ /* Sanity check */
+ ASSERT(Disposition == REG_CREATED_NEW_KEY);
+
+ /* Create the 0000 key */
+ RtlInitUnicodeString(&KeyName, L"0000");
+ InitializeObjectAttributes(&ObjectAttributes,
+ &KeyName,
+ OBJ_CASE_INSENSITIVE,
+ ProfilesHandle,
+ NULL);
+ Status = NtCreateKey(&ProfileHandle,
+ KEY_ALL_ACCESS,
+ &ObjectAttributes,
+ 0,
+ NULL,
+ 0,
+ &Disposition);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("Creating the Hardware Profile\\0000 key failed\n");
+ goto done;
+ }
+
+ /* Sanity check */
+ ASSERT(Disposition == REG_CREATED_NEW_KEY);
+
+done:
+ if (ProfilesHandle)
+ NtClose(ProfilesHandle);
+
+ if (ProfileHandle)
+ NtClose(ProfileHandle);
+
+ DPRINT("CmpCreateHardwareProfile() done\n");
+
+ return Status;
+}
+
NTSTATUS
NTAPI
INIT_FUNCTION
OBJECT_ATTRIBUTES ObjectAttributes;
CHAR ValueInfoBuffer[128];
PKEY_VALUE_FULL_INFORMATION ValueInfo;
- CHAR Buffer[128];
WCHAR UnicodeBuffer[128];
HANDLE SelectHandle, KeyHandle, ConfigHandle = NULL, ProfileHandle = NULL;
HANDLE ParentHandle = NULL;
ULONG ControlSet, HwProfile;
- ANSI_STRING TempString;
NTSTATUS Status;
ULONG ResultLength, Disposition;
PLOADER_PARAMETER_EXTENSION LoaderExtension;
&Disposition);
if (!NT_SUCCESS(Status)) return Status;
+ /* Create the Hardware Profile keys */
+ Status = CmpCreateHardwareProfile(KeyHandle);
+ if (!NT_SUCCESS(Status))
+ return Status;
+
/* Don't need the handle */
ZwClose(KeyHandle);
/* Sanity check */
ASSERT(Disposition == REG_CREATED_NEW_KEY);
- /* Initialize the symbolic link name */
- sprintf(Buffer,
- "\\Registry\\Machine\\System\\ControlSet%03ld",
- ControlSet);
- RtlInitAnsiString(&TempString, Buffer);
-
- /* Create a Unicode string out of it */
- KeyName.MaximumLength = sizeof(UnicodeBuffer);
- KeyName.Buffer = UnicodeBuffer;
- Status = RtlAnsiStringToUnicodeString(&KeyName, &TempString, FALSE);
+ /* Initialize the target link name */
+ RtlStringCbPrintfW(UnicodeBuffer, sizeof(UnicodeBuffer),
+ L"\\Registry\\Machine\\System\\ControlSet%03ld",
+ ControlSet);
+ RtlInitUnicodeString(&KeyName, UnicodeBuffer);
/* Set the value */
Status = NtSetValueKey(KeyHandle,
if (!NT_SUCCESS(Status))
{
/* Cleanup and exit */
- ConfigHandle = 0;
+ ConfigHandle = NULL;
goto Cleanup;
}
- /* Now get the current config */
- RtlInitUnicodeString(&KeyName, L"CurrentConfig");
- Status = NtQueryValueKey(ConfigHandle,
- &KeyName,
- KeyValueFullInformation,
- ValueInfoBuffer,
- sizeof(ValueInfoBuffer),
- &ResultLength);
-
- /* Set pointer to buffer */
- ValueInfo = (PKEY_VALUE_FULL_INFORMATION)ValueInfoBuffer;
-
- /* Check if we failed or got a non DWORD-value */
- if (!(NT_SUCCESS(Status)) || (ValueInfo->Type != REG_DWORD)) goto Cleanup;
-
- /* Get the hadware profile */
- HwProfile = *(PULONG)((PUCHAR)ValueInfo + ValueInfo->DataOffset);
+ /* ReactOS Hack: Hard-code current to 001 for SetupLdr */
+ if (!LoaderBlock->RegistryBase)
+ {
+ HwProfile = 0;
+ }
+ else
+ {
+ /* Now get the current config */
+ RtlInitUnicodeString(&KeyName, L"CurrentConfig");
+ Status = NtQueryValueKey(ConfigHandle,
+ &KeyName,
+ KeyValueFullInformation,
+ ValueInfoBuffer,
+ sizeof(ValueInfoBuffer),
+ &ResultLength);
+
+ /* Set pointer to buffer */
+ ValueInfo = (PKEY_VALUE_FULL_INFORMATION)ValueInfoBuffer;
+
+ /* Check if we failed or got a non DWORD-value */
+ if (!(NT_SUCCESS(Status)) || (ValueInfo->Type != REG_DWORD)) goto Cleanup;
+
+ /* Get the hadware profile */
+ HwProfile = *(PULONG)((PUCHAR)ValueInfo + ValueInfo->DataOffset);
+ }
/* Open the hardware profile key */
RtlInitUnicodeString(&KeyName,
if (!NT_SUCCESS(Status))
{
/* Exit and clean up */
- ParentHandle = 0;
+ ParentHandle = NULL;
goto Cleanup;
}
/* Build the profile name */
- sprintf(Buffer, "%04ld", HwProfile);
- RtlInitAnsiString(&TempString, Buffer);
-
- /* Convert it to Unicode */
- KeyName.MaximumLength = sizeof(UnicodeBuffer);
- KeyName.Buffer = UnicodeBuffer;
- Status = RtlAnsiStringToUnicodeString(&KeyName,
- &TempString,
- FALSE);
- ASSERT(Status == STATUS_SUCCESS);
+ RtlStringCbPrintfW(UnicodeBuffer, sizeof(UnicodeBuffer),
+ L"%04ld", HwProfile);
+ RtlInitUnicodeString(&KeyName, UnicodeBuffer);
/* Open the associated key */
InitializeObjectAttributes(&ObjectAttributes,
LoaderExtension = LoaderBlock->Extension;
if (LoaderExtension)
{
- ASSERTMSG("ReactOS doesn't support NTLDR Profiles yet!\n", FALSE);
+ DPRINT("ReactOS doesn't support NTLDR Profiles yet!\n");
}
/* Create the current hardware profile key */
ASSERT(Disposition == REG_CREATED_NEW_KEY);
/* Create the profile name */
- sprintf(Buffer,
- "\\Registry\\Machine\\System\\CurrentControlSet\\"
- "Hardware Profiles\\%04ld",
- HwProfile);
- RtlInitAnsiString(&TempString, Buffer);
-
- /* Convert it to Unicode */
- KeyName.MaximumLength = sizeof(UnicodeBuffer);
- KeyName.Buffer = UnicodeBuffer;
- Status = RtlAnsiStringToUnicodeString(&KeyName,
- &TempString,
- FALSE);
- ASSERT(STATUS_SUCCESS == Status);
+ RtlStringCbPrintfW(UnicodeBuffer, sizeof(UnicodeBuffer),
+ L"\\Registry\\Machine\\System\\CurrentControlSet\\"
+ L"Hardware Profiles\\%04ld",
+ HwProfile);
+ RtlInitUnicodeString(&KeyName, UnicodeBuffer);
/* Set it */
Status = NtSetValueKey(KeyHandle,
if (ProfileHandle) NtClose(ProfileHandle);
if (ParentHandle) NtClose(ParentHandle);
+ DPRINT("CmpCreateControlSet() done\n");
+
/* Return success */
return STATUS_SUCCESS;
}
if (HiveBase)
{
/* Import it */
- ((PHBASE_BLOCK)HiveBase)->Length = LoaderBlock->RegistryLength;
- Status = CmpInitializeHive((PCMHIVE*)&SystemHive,
+ Status = CmpInitializeHive(&SystemHive,
HINIT_MEMORY,
HIVE_NOLAZYFLUSH,
HFILE_TYPE_LOG,
RtlInitUnicodeString(&KeyName, L"\\Registry\\Machine\\SYSTEM");
Status = CmpLinkHiveToMaster(&KeyName,
NULL,
- (PCMHIVE)SystemHive,
+ SystemHive,
Allocate,
SecurityDescriptor);
/* Free the security descriptor */
- ExFreePoolWithTag(SecurityDescriptor, TAG_CM);
+ ExFreePoolWithTag(SecurityDescriptor, TAG_CMSD);
if (!NT_SUCCESS(Status)) return FALSE;
/* Add the hive to the hive list */
- CmpMachineHiveList[3].CmHive = (PCMHIVE)SystemHive;
+ CmpMachineHiveList[3].CmHive = SystemHive;
/* Success! */
return TRUE;
ObjectTypeInitializer.QueryNameProcedure = CmpQueryKeyName;
ObjectTypeInitializer.CloseProcedure = CmpCloseKeyObject;
ObjectTypeInitializer.SecurityRequired = TRUE;
+ ObjectTypeInitializer.InvalidAttributes = OBJ_EXCLUSIVE | OBJ_PERMANENT;
/* Create it */
return ObCreateObjectType(&Name, &ObjectTypeInitializer, NULL, &CmpKeyObjectType);
{
UNICODE_STRING KeyName;
PCM_KEY_NODE KeyCell;
- LARGE_INTEGER SystemTime;
PAGED_CODE();
/* Initialize the node name and allocate it */
if (!KeyCell) return FALSE;
/* Setup the cell */
- KeyCell->Signature = (USHORT)CM_KEY_NODE_SIGNATURE;
+ KeyCell->Signature = CM_KEY_NODE_SIGNATURE;
KeyCell->Flags = KEY_HIVE_ENTRY | KEY_NO_DELETE;
- KeQuerySystemTime(&SystemTime);
- KeyCell->LastWriteTime = SystemTime;
+ KeQuerySystemTime(&KeyCell->LastWriteTime);
KeyCell->Parent = HCELL_NIL;
KeyCell->SubKeyCounts[Stable] = 0;
KeyCell->SubKeyCounts[Volatile] = 0;
KeyCell->MaxValueDataLen = 0;
/* Copy the name (this will also set the length) */
- KeyCell->NameLength = CmpCopyName(Hive, (PWCHAR)KeyCell->Name, &KeyName);
+ KeyCell->NameLength = CmpCopyName(Hive, KeyCell->Name, &KeyName);
- /* Check if the name was compressed */
+ /* Check if the name was compressed and set the flag if so */
if (KeyCell->NameLength < KeyName.Length)
- {
- /* Set the flag */
KeyCell->Flags |= KEY_COMP_NAME;
- }
/* Return success */
HvReleaseCell(Hive, *Index);
&KeyName,
OBJ_CASE_INSENSITIVE,
NULL,
- NULL);
+ SecurityDescriptor);
Status = ObCreateObject(KernelMode,
CmpKeyObjectType,
&ObjectAttributes,
0,
0,
(PVOID*)&RootKey);
- ExFreePoolWithTag(SecurityDescriptor, TAG_CM);
+ ExFreePoolWithTag(SecurityDescriptor, TAG_CMSD);
if (!NT_SUCCESS(Status)) return FALSE;
/* Sanity check, and get the key cell */
NULL,
0,
&KeyName);
- if (!Kcb) return FALSE;
+ if (!Kcb)
+ {
+ ObDereferenceObject(RootKey);
+ return FALSE;
+ }
/* Initialize the object */
RootKey->KeyControlBlock = Kcb;
- RootKey->Type = '20yk';
+ RootKey->Type = CM_KEY_BODY_TYPE;
RootKey->NotifyBlock = NULL;
RootKey->ProcessID = PsGetCurrentProcessId();
0,
NULL,
&CmpRegistryRootHandle);
- if (!NT_SUCCESS(Status)) return FALSE;
+ if (!NT_SUCCESS(Status))
+ {
+ ObDereferenceObject(RootKey);
+ return FALSE;
+ }
/* Reference the key again so that we never lose it */
Status = ObReferenceObjectByHandle(CmpRegistryRootHandle,
KernelMode,
(PVOID*)&RootKey,
NULL);
- if (!NT_SUCCESS(Status)) return FALSE;
+ if (!NT_SUCCESS(Status))
+ {
+ ObDereferenceObject(RootKey);
+ return FALSE;
+ }
/* Completely sucessful */
return TRUE;
NTSTATUS
NTAPI
-CmpGetRegistryPath(IN PWCHAR ConfigPath)
+CmpGetRegistryPath(OUT PWCHAR ConfigPath)
{
OBJECT_ATTRIBUTES ObjectAttributes;
NTSTATUS Status;
/* Check if we are booted in setup */
if (ExpInTextModeSetup)
{
+ DPRINT1("CmpGetRegistryPath TextMode setup HACK!!\n");
+
/* Setup the object attributes */
InitializeObjectAttributes(&ObjectAttributes,
&KeyName,
- OBJ_CASE_INSENSITIVE,
+ OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
NULL,
NULL);
/* Open the key */
/* Add registry path */
wcscat(ConfigPath, L"\\System32\\Config\\");
+ DPRINT1("CmpGetRegistryPath: ConfigPath = '%S'\n", ConfigPath);
+
/* Done */
return STATUS_SUCCESS;
}
{
WCHAR FileBuffer[MAX_PATH], RegBuffer[MAX_PATH], ConfigPath[MAX_PATH];
UNICODE_STRING TempName, FileName, RegName;
- ULONG FileStart, i, ErrorResponse, WorkerCount, Length;
- //ULONG RegStart;
+ ULONG i, ErrorResponse, WorkerCount, Length;
+ USHORT FileStart;
ULONG PrimaryDisposition, SecondaryDisposition, ClusterSize;
PCMHIVE CmHive;
- HANDLE PrimaryHandle, LogHandle;
+ HANDLE PrimaryHandle = NULL, LogHandle = NULL;
NTSTATUS Status = STATUS_SUCCESS;
PVOID ErrorParameters;
PAGED_CODE();
CmpMachineHiveList[i].ThreadStarted = TRUE;
/* Build the file name and registry name strings */
- RtlInitEmptyUnicodeString(&FileName, FileBuffer, MAX_PATH);
- RtlInitEmptyUnicodeString(&RegName, RegBuffer, MAX_PATH);
+ RtlInitEmptyUnicodeString(&FileName, FileBuffer, sizeof(FileBuffer));
+ RtlInitEmptyUnicodeString(&RegName, RegBuffer, sizeof(RegBuffer));
/* Now build the system root path */
CmpGetRegistryPath(ConfigPath);
RtlInitUnicodeString(&TempName, ConfigPath);
- RtlAppendStringToString((PSTRING)&FileName, (PSTRING)&TempName);
+ RtlAppendUnicodeStringToString(&FileName, &TempName);
FileStart = FileName.Length;
/* And build the registry root path */
RtlInitUnicodeString(&TempName, L"\\REGISTRY\\");
- RtlAppendStringToString((PSTRING)&RegName, (PSTRING)&TempName);
- //RegStart = RegName.Length;
+ RtlAppendUnicodeStringToString(&RegName, &TempName);
/* Build the base name */
RtlInitUnicodeString(&TempName, CmpMachineHiveList[i].BaseName);
- RtlAppendStringToString((PSTRING)&RegName, (PSTRING)&TempName);
+ RtlAppendUnicodeStringToString(&RegName, &TempName);
/* Check if this is a child of the root */
- if (RegName.Buffer[RegName.Length / sizeof(WCHAR) - 1] == '\\')
+ if (RegName.Buffer[RegName.Length / sizeof(WCHAR) - 1] == OBJ_NAME_PATH_SEPARATOR)
{
/* Then setup the whole name */
RtlInitUnicodeString(&TempName, CmpMachineHiveList[i].Name);
- RtlAppendStringToString((PSTRING)&RegName, (PSTRING)&TempName);
+ RtlAppendUnicodeStringToString(&RegName, &TempName);
}
/* Now add the rest of the file name */
RtlInitUnicodeString(&TempName, CmpMachineHiveList[i].Name);
FileName.Length = FileStart;
- RtlAppendStringToString((PSTRING)&FileName, (PSTRING)&TempName);
+ RtlAppendUnicodeStringToString(&FileName, &TempName);
if (!CmpMachineHiveList[i].CmHive)
{
/* We need to allocate a new hive structure */
UNICODE_STRING TempName, FileName, RegName;
HANDLE Thread;
NTSTATUS Status;
- ULONG RegStart, i;
+ ULONG i;
+ USHORT RegStart;
PSECURITY_DESCRIPTOR SecurityDescriptor;
PAGED_CODE();
CmpNoWrite = FALSE;
/* Build the file name and registry name strings */
- RtlInitEmptyUnicodeString(&FileName, FileBuffer, MAX_PATH);
- RtlInitEmptyUnicodeString(&RegName, RegBuffer, MAX_PATH);
+ RtlInitEmptyUnicodeString(&FileName, FileBuffer, sizeof(FileBuffer));
+ RtlInitEmptyUnicodeString(&RegName, RegBuffer, sizeof(RegBuffer));
/* Now build the system root path */
CmpGetRegistryPath(ConfigPath);
RtlInitUnicodeString(&TempName, ConfigPath);
- RtlAppendStringToString((PSTRING)&FileName, (PSTRING)&TempName);
+ RtlAppendUnicodeStringToString(&FileName, &TempName);
/* And build the registry root path */
RtlInitUnicodeString(&TempName, L"\\REGISTRY\\");
- RtlAppendStringToString((PSTRING)&RegName, (PSTRING)&TempName);
+ RtlAppendUnicodeStringToString(&RegName, &TempName);
RegStart = RegName.Length;
/* Setup the event to synchronize workers */
/* Build the base name */
RegName.Length = RegStart;
RtlInitUnicodeString(&TempName, CmpMachineHiveList[i].BaseName);
- RtlAppendStringToString((PSTRING)&RegName, (PSTRING)&TempName);
+ RtlAppendUnicodeStringToString(&RegName, &TempName);
/* Check if this is a child of the root */
- if (RegName.Buffer[RegName.Length / sizeof(WCHAR) - 1] == '\\')
+ if (RegName.Buffer[RegName.Length / sizeof(WCHAR) - 1] == OBJ_NAME_PATH_SEPARATOR)
{
/* Then setup the whole name */
RtlInitUnicodeString(&TempName, CmpMachineHiveList[i].Name);
- RtlAppendStringToString((PSTRING)&RegName, (PSTRING)&TempName);
+ RtlAppendUnicodeStringToString(&RegName, &TempName);
}
/* Now link the hive to its master */
/* Check if we created a new hive */
if (CmpMachineHiveList[i].CmHive2)
{
- /* TODO: Add to HiveList key */
+ /* Add to HiveList key */
+ CmpAddToHiveFileList(CmpMachineHiveList[i].CmHive2);
}
}
/* Get rid of the SD */
- ExFreePoolWithTag(SecurityDescriptor, TAG_CM);
+ ExFreePoolWithTag(SecurityDescriptor, TAG_CMSD);
- /* FIXME: Link SECURITY to SAM */
+ /* Link SECURITY to SAM */
+ CmpLinkKeyToHive(L"\\Registry\\Machine\\Security\\SAM",
+ L"\\Registry\\Machine\\SAM\\SAM");
- /* FIXME: Link S-1-5-18 to .Default */
+ /* Link S-1-5-18 to .Default */
+ CmpNoVolatileCreates = FALSE;
+ CmpLinkKeyToHive(L"\\Registry\\User\\S-1-5-18",
+ L"\\Registry\\User\\.Default");
+ CmpNoVolatileCreates = TRUE;
}
BOOLEAN
}
/* Build the master hive */
- Status = CmpInitializeHive((PCMHIVE*)&CmiVolatileHive,
+ Status = CmpInitializeHive(&CmiVolatileHive,
HINIT_CREATE,
HIVE_VOLATILE,
HFILE_TYPE_PRIMARY,
/* Create the default security descriptor */
SecurityDescriptor = CmpHiveRootSecurityDescriptor();
- /* Create '\Registry\Machine' key. */
+ /* Create '\Registry\Machine' key */
RtlInitUnicodeString(&KeyName, L"\\REGISTRY\\MACHINE");
InitializeObjectAttributes(&ObjectAttributes,
&KeyName,
/* Close the handle */
NtClose(KeyHandle);
- /* Create '\Registry\User' key. */
+ /* Create '\Registry\User' key */
RtlInitUnicodeString(&KeyName, L"\\REGISTRY\\USER");
InitializeObjectAttributes(&ObjectAttributes,
&KeyName,
/* Close the handle */
NtClose(KeyHandle);
+ /* After this point, do not allow creating keys in the master hive */
+ CmpNoVolatileCreates = TRUE;
+
/* Initialize the system hive */
if (!CmpInitializeSystemHive(KeLoaderBlock))
{
KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 7, 0, 0);
}
- /* Create the 'CurrentControlSet' link. */
+ /* Create the 'CurrentControlSet' link */
Status = CmpCreateControlSet(KeLoaderBlock);
if (!NT_SUCCESS(Status))
{
}
/* Create the hardware hive */
- Status = CmpInitializeHive((PCMHIVE*)&HardwareHive,
+ Status = CmpInitializeHive(&HardwareHive,
HINIT_CREATE,
HIVE_VOLATILE,
HFILE_TYPE_PRIMARY,
}
/* Add the hive to the hive list */
- CmpMachineHiveList[0].CmHive = (PCMHIVE)HardwareHive;
+ CmpMachineHiveList[0].CmHive = HardwareHive;
/* Attach it to the machine key */
RtlInitUnicodeString(&KeyName, L"\\Registry\\Machine\\HARDWARE");
Status = CmpLinkHiveToMaster(&KeyName,
NULL,
- (PCMHIVE)HardwareHive,
+ HardwareHive,
TRUE,
SecurityDescriptor);
if (!NT_SUCCESS(Status))
KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 1, 12, Status, 0);
}
- /* FIXME: Add to HiveList key */
+ /* Add to HiveList key */
+ CmpAddToHiveFileList(HardwareHive);
/* Free the security descriptor */
- ExFreePoolWithTag(SecurityDescriptor, TAG_CM);
+ ExFreePoolWithTag(SecurityDescriptor, TAG_CMSD);
/* Fill out the Hardware key with the ARC Data from the Loader */
Status = CmpInitializeHardwareConfiguration(KeLoaderBlock);
PLIST_ENTRY NextEntry, OldEntry;
PBOOT_DRIVER_NODE DriverNode;
PAGED_CODE();
-
+
/* Parse the current list */
NextEntry = DriverList->Flink;
while (NextEntry != DriverList)
{
/* Get the driver node */
DriverNode = CONTAINING_RECORD(NextEntry, BOOT_DRIVER_NODE, ListEntry.Link);
-
+
/* Get the next entry now, since we're going to free it later */
OldEntry = NextEntry;
NextEntry = NextEntry->Flink;
-
+
/* Was there a name? */
if (DriverNode->Name.Buffer)
{
/* Free it */
CmpFree(DriverNode->Name.Buffer, DriverNode->Name.Length);
}
-
+
/* Was there a registry path? */
if (DriverNode->ListEntry.RegistryPath.Buffer)
{
CmpFree(DriverNode->ListEntry.RegistryPath.Buffer,
DriverNode->ListEntry.RegistryPath.MaximumLength);
}
-
+
/* Was there a file path? */
if (DriverNode->ListEntry.FilePath.Buffer)
{
CmpFree(DriverNode->ListEntry.FilePath.Buffer,
DriverNode->ListEntry.FilePath.MaximumLength);
}
-
+
/* Now free the node, and move on */
CmpFree(OldEntry, sizeof(BOOT_DRIVER_NODE));
}
/* Initialize the driver list */
InitializeListHead(&DriverList);
-
+
/* Open the system hive key */
RtlInitUnicodeString(&KeyName, L"\\Registry\\Machine\\System");
InitializeObjectAttributes(&ObjectAttributes,
NULL);
Status = NtOpenKey(&KeyHandle, KEY_READ, &ObjectAttributes);
if (!NT_SUCCESS(Status)) return NULL;
-
+
/* Reference the key object to get the root hive/cell to access directly */
Status = ObReferenceObjectByHandle(KeyHandle,
KEY_QUERY_VALUE,
NtClose(KeyHandle);
return NULL;
}
-
+
/* Do all this under the registry lock */
CmpLockRegistryExclusive();
-
+
/* Get the hive and key cell */
Hive = KeyBody->KeyControlBlock->KeyHive;
RootCell = KeyBody->KeyControlBlock->KeyCell;
-
+
/* Open the current control set key */
RtlInitUnicodeString(&KeyName, L"Current");
ControlCell = CmpFindControlSet(Hive, RootCell, &KeyName, &AutoSelect);
if (ControlCell == HCELL_NIL) goto EndPath;
-
+
/* Find all system drivers */
Success = CmpFindDrivers(Hive, ControlCell, SystemLoad, NULL, &DriverList);
if (!Success) goto EndPath;
-
+
/* Sort by group/tag */
if (!CmpSortDriverList(Hive, ControlCell, &DriverList)) goto EndPath;
-
+
/* Remove circular dependencies (cycles) and sort */
if (!CmpResolveDriverDependencies(&DriverList)) goto EndPath;
-
+
/* Loop the list to count drivers */
for (i = 0, NextEntry = DriverList.Flink;
NextEntry != &DriverList;
i++, NextEntry = NextEntry->Flink);
-
+
/* Allocate the array */
ServicePath = ExAllocatePool(NonPagedPool, (i + 1) * sizeof(PUNICODE_STRING));
if (!ServicePath) KeBugCheckEx(CONFIG_INITIALIZATION_FAILED, 2, 1, 0, 0);
-
+
/* Loop the driver list */
for (i = 0, NextEntry = DriverList.Flink;
NextEntry != &DriverList;
&DriverEntry->RegistryPath,
ServicePath[i]);
}
-
+
/* Terminate the list */
ServicePath[i] = NULL;
-
+
EndPath:
/* Free the driver list if we had one */
if (!IsListEmpty(&DriverList)) CmpFreeDriverList(Hive, &DriverList);
-
+
/* Unlock the registry */
CmpUnlockRegistry();
-
+
/* Close the key handle and dereference the object, then return the path */
ObDereferenceObject(KeyBody);
NtClose(KeyHandle);
CmpDoFlushAll(TRUE);
CmpFlushOnLockRelease = FALSE;
}
+ else
+ {
+ /* Lazy flush the registry */
+ CmpLazyFlush();
+ }
/* Release the lock and leave the critical region */
ExReleaseResourceLite(&CmpRegistryLock);
/* Get hash indexes */
Index1 = GET_HASH_INDEX(ConvKey1);
Index2 = GET_HASH_INDEX(ConvKey2);
- ASSERT((GET_HASH_ENTRY(CmpCacheTable, ConvKey2).Owner == KeGetCurrentThread()) ||
+ ASSERT((GET_HASH_ENTRY(CmpCacheTable, ConvKey2)->Owner == KeGetCurrentThread()) ||
(CmpTestRegistryLockExclusive()));
/* See which one is highest */
if (Index1 < Index2)
{
/* Grab them in the proper order */
- ASSERT((GET_HASH_ENTRY(CmpCacheTable, ConvKey1).Owner == KeGetCurrentThread()) ||
+ ASSERT((GET_HASH_ENTRY(CmpCacheTable, ConvKey1)->Owner == KeGetCurrentThread()) ||
(CmpTestRegistryLockExclusive()));
CmpReleaseKcbLockByKey(ConvKey2);
CmpReleaseKcbLockByKey(ConvKey1);
/* Release the first one first, then the second */
if (Index1 != Index2)
{
- ASSERT((GET_HASH_ENTRY(CmpCacheTable, ConvKey1).Owner == KeGetCurrentThread()) ||
+ ASSERT((GET_HASH_ENTRY(CmpCacheTable, ConvKey1)->Owner == KeGetCurrentThread()) ||
(CmpTestRegistryLockExclusive()));
CmpReleaseKcbLockByKey(ConvKey1);
}
NTAPI
CmShutdownSystem(VOID)
{
+ PLIST_ENTRY ListEntry;
+ PCMHIVE Hive;
+
/* Kill the workers */
if (!CmFirstTime) CmpShutdownWorkers();
/* Flush all hives */
CmpLockRegistryExclusive();
CmpDoFlushAll(TRUE);
+
+ /* Close all hive files */
+ ListEntry = CmpHiveListHead.Flink;
+ while (ListEntry != &CmpHiveListHead)
+ {
+ Hive = CONTAINING_RECORD(ListEntry, CMHIVE, HiveList);
+
+ CmpCloseHiveFiles(Hive);
+
+ ListEntry = ListEntry->Flink;
+ }
+
CmpUnlockRegistry();
}
NTAPI
CmpSetVersionData(VOID)
{
+ NTSTATUS Status;
OBJECT_ATTRIBUTES ObjectAttributes;
UNICODE_STRING KeyName;
UNICODE_STRING ValueName;
UNICODE_STRING ValueData;
+ ANSI_STRING TempString;
HANDLE SoftwareKeyHandle = NULL;
HANDLE MicrosoftKeyHandle = NULL;
HANDLE WindowsNtKeyHandle = NULL;
HANDLE CurrentVersionKeyHandle = NULL;
- WCHAR Buffer[128];
- NTSTATUS Status;
+ WCHAR Buffer[128]; // Buffer large enough to contain a full ULONG in decimal
+ // representation, and the full 'CurrentType' string.
- /* Open the 'CurrentVersion' key */
- RtlInitUnicodeString(&KeyName,
- L"\\REGISTRY\\MACHINE\\SOFTWARE");
+ /*
+ * Open the 'HKLM\Software\Microsoft\Windows NT\CurrentVersion' key
+ * (create the intermediate subkeys if needed).
+ */
+ RtlInitUnicodeString(&KeyName, L"\\REGISTRY\\MACHINE\\SOFTWARE");
InitializeObjectAttributes(&ObjectAttributes,
&KeyName,
- OBJ_CASE_INSENSITIVE,
+ OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
NULL,
NULL);
-
Status = NtCreateKey(&SoftwareKeyHandle,
KEY_CREATE_SUB_KEY,
&ObjectAttributes,
return;
}
- /* Open the 'CurrentVersion' key */
- RtlInitUnicodeString(&KeyName,
- L"Microsoft");
-
+ RtlInitUnicodeString(&KeyName, L"Microsoft");
InitializeObjectAttributes(&ObjectAttributes,
&KeyName,
- OBJ_CASE_INSENSITIVE,
+ OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
SoftwareKeyHandle,
NULL);
-
Status = NtCreateKey(&MicrosoftKeyHandle,
KEY_CREATE_SUB_KEY,
&ObjectAttributes,
if (!NT_SUCCESS(Status))
{
DPRINT1("Failed to create key %wZ (Status: %08lx)\n", &KeyName, Status);
- goto done;
+ goto Quit;
}
- /* Open the 'CurrentVersion' key */
- RtlInitUnicodeString(&KeyName,
- L"Windows NT");
-
+ RtlInitUnicodeString(&KeyName, L"Windows NT");
InitializeObjectAttributes(&ObjectAttributes,
&KeyName,
- OBJ_CASE_INSENSITIVE,
+ OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
MicrosoftKeyHandle,
NULL);
-
Status = NtCreateKey(&WindowsNtKeyHandle,
KEY_CREATE_SUB_KEY,
&ObjectAttributes,
if (!NT_SUCCESS(Status))
{
DPRINT1("Failed to create key %wZ (Status: %08lx)\n", &KeyName, Status);
- goto done;
+ goto Quit;
}
- /* Open the 'CurrentVersion' key */
- RtlInitUnicodeString(&KeyName,
- L"CurrentVersion");
-
+ RtlInitUnicodeString(&KeyName, L"CurrentVersion");
InitializeObjectAttributes(&ObjectAttributes,
&KeyName,
- OBJ_CASE_INSENSITIVE,
+ OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
WindowsNtKeyHandle,
NULL);
-
Status = NtCreateKey(&CurrentVersionKeyHandle,
KEY_CREATE_SUB_KEY | KEY_SET_VALUE,
&ObjectAttributes,
if (!NT_SUCCESS(Status))
{
DPRINT1("Failed to create key %wZ (Status: %08lx)\n", &KeyName, Status);
- goto done;
+ goto Quit;
}
- /* Set the 'CurrentType' value */
- RtlInitUnicodeString(&ValueName,
- L"CurrentType");
+ /* Set the 'CurrentVersion' value */
+ RtlInitUnicodeString(&ValueName, L"CurrentVersion");
+ NtSetValueKey(CurrentVersionKeyHandle,
+ &ValueName,
+ 0,
+ REG_SZ,
+ CmVersionString.Buffer,
+ CmVersionString.Length + sizeof(WCHAR));
+
+ /* Set the 'CurrentBuildNumber' value */
+ RtlInitUnicodeString(&ValueName, L"CurrentBuildNumber");
+ RtlInitEmptyUnicodeString(&ValueData, Buffer, sizeof(Buffer));
+ RtlIntegerToUnicodeString(NtBuildNumber & 0xFFFF, 10, &ValueData);
+ NtSetValueKey(CurrentVersionKeyHandle,
+ &ValueName,
+ 0,
+ REG_SZ,
+ ValueData.Buffer,
+ ValueData.Length + sizeof(WCHAR));
+
+ /* Set the 'BuildLab' value */
+ RtlInitUnicodeString(&ValueName, L"BuildLab");
+ RtlInitAnsiString(&TempString, NtBuildLab);
+ Status = RtlAnsiStringToUnicodeString(&ValueData, &TempString, FALSE);
+ if (NT_SUCCESS(Status))
+ {
+ NtSetValueKey(CurrentVersionKeyHandle,
+ &ValueName,
+ 0,
+ REG_SZ,
+ ValueData.Buffer,
+ ValueData.Length + sizeof(WCHAR));
+ }
+ /* Set the 'CurrentType' value */
+ RtlInitUnicodeString(&ValueName, L"CurrentType");
+ RtlStringCbPrintfW(Buffer, sizeof(Buffer),
+ L"%s %s",
#ifdef CONFIG_SMP
- wcscpy(Buffer, L"Multiprocessor");
+ L"Multiprocessor"
#else
- wcscpy(Buffer, L"Uniprocessor");
+ L"Uniprocessor"
#endif
-
- wcscat(Buffer, L" ");
-
+ ,
#if (DBG == 1)
- wcscat(Buffer, L"Checked");
+ L"Checked"
#else
- wcscat(Buffer, L"Free");
+ L"Free"
#endif
-
- RtlInitUnicodeString(&ValueData,
- Buffer);
-
+ );
+ RtlInitUnicodeString(&ValueData, Buffer);
NtSetValueKey(CurrentVersionKeyHandle,
&ValueName,
0,
ValueData.Buffer,
ValueData.Length + sizeof(WCHAR));
-done:;
+ /* Set the 'CSDVersion' value */
+ RtlInitUnicodeString(&ValueName, L"CSDVersion");
+ if (CmCSDVersionString.Length != 0)
+ {
+ NtSetValueKey(CurrentVersionKeyHandle,
+ &ValueName,
+ 0,
+ REG_SZ,
+ CmCSDVersionString.Buffer,
+ CmCSDVersionString.Length + sizeof(WCHAR));
+ }
+ else
+ {
+ NtDeleteValueKey(CurrentVersionKeyHandle, &ValueName);
+ }
+
+ /* Set the 'CSDBuildNumber' value */
+ RtlInitUnicodeString(&ValueName, L"CSDBuildNumber");
+ if (CmNtSpBuildNumber != 0)
+ {
+ RtlInitEmptyUnicodeString(&ValueData, Buffer, sizeof(Buffer));
+ RtlIntegerToUnicodeString(CmNtSpBuildNumber, 10, &ValueData);
+ NtSetValueKey(CurrentVersionKeyHandle,
+ &ValueName,
+ 0,
+ REG_SZ,
+ ValueData.Buffer,
+ ValueData.Length + sizeof(WCHAR));
+ }
+ else
+ {
+ NtDeleteValueKey(CurrentVersionKeyHandle, &ValueName);
+ }
+
+ /* Set the 'SystemRoot' value */
+ RtlInitUnicodeString(&ValueName, L"SystemRoot");
+ NtSetValueKey(CurrentVersionKeyHandle,
+ &ValueName,
+ 0,
+ REG_SZ,
+ NtSystemRoot.Buffer,
+ NtSystemRoot.Length + sizeof(WCHAR));
+
+Quit:
/* Close the keys */
if (CurrentVersionKeyHandle != NULL)
NtClose(CurrentVersionKeyHandle);