Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-05-30 06:28:34 +00:00
Code Issues Projects Releases Packages Wiki Activity

[MKHIVE][CMAKE] Make mkhive a bit more flexible, so that it can generate only specific hives on-demand (and not all of them always at once).

Browse source 
This commit is needed for building a single bootcd registry hive. It will also enable 1-st stage setup to have a proper registry present as done on Windows.
CORE-13347

[CMAKE]
Note that the mkhive commands should really depend on the generated UTF16 INF files since the latter are those that are actually used as input for mkhive.
Otherwise, the mkhive calls & the UTF16 INF file conversion is not serialized and we can generate "corrupted" hives due to the fact that mkhive is using
INF files that are in the process of being (and therefore, only partially) generated.

svn path=/branches/setup_improvements/; revision=74741
svn path=/branches/setup_improvements/; revision=74749
This commit is contained in:
Hermès Bélusca-Maïto 2017-06-02 00:34:10 +00:00
parent 287d35b84d
commit 84d2264d9b
No known key found for this signature in database
GPG key ID: 3B2539C65E7B93D0
5 changed files with 276 additions and 162 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

63
sdk/cmake/CMakeMacros.cmake
View file

@ -808,43 +808,66 @@ function(create_registry_hives)
NO_CAB NO_CAB
FOR bootcd regtest) FOR bootcd regtest)
# livecd hives # BootCD setup system hive
add_custom_command(
OUTPUT ${CMAKE_BINARY_DIR}/boot/bootdata/SETUPREG.HIV
COMMAND native-mkhive -h:SETUPREG -d:${CMAKE_BINARY_DIR}/boot/bootdata ${CMAKE_BINARY_DIR}/boot/bootdata/hivesys_utf16.inf
DEPENDS native-mkhive ${CMAKE_BINARY_DIR}/boot/bootdata/hivesys_utf16.inf)
add_custom_target(bootcd_hives
DEPENDS ${CMAKE_BINARY_DIR}/boot/bootdata/SETUPREG.HIV)
add_cd_file(
FILE ${CMAKE_BINARY_DIR}/boot/bootdata/SETUPREG.HIV
TARGET bootcd_hives
DESTINATION reactos
NO_CAB
FOR bootcd regtest)
# LiveCD hives
list(APPEND _livecd_inf_files list(APPEND _livecd_inf_files
${_registry_inf} ${_registry_inf}
${CMAKE_SOURCE_DIR}/boot/bootdata/livecd.inf ${CMAKE_SOURCE_DIR}/boot/bootdata/livecd.inf
${CMAKE_SOURCE_DIR}/boot/bootdata/hiveinst.inf) ${CMAKE_SOURCE_DIR}/boot/bootdata/hiveinst.inf)
add_custom_command( add_custom_command(
OUTPUT ${CMAKE_BINARY_DIR}/boot/bootdata/sam OUTPUT ${CMAKE_BINARY_DIR}/boot/bootdata/system
${CMAKE_BINARY_DIR}/boot/bootdata/default ${CMAKE_BINARY_DIR}/boot/bootdata/software
${CMAKE_BINARY_DIR}/boot/bootdata/security ${CMAKE_BINARY_DIR}/boot/bootdata/default
${CMAKE_BINARY_DIR}/boot/bootdata/software ${CMAKE_BINARY_DIR}/boot/bootdata/sam
${CMAKE_BINARY_DIR}/boot/bootdata/system ${CMAKE_BINARY_DIR}/boot/bootdata/security
${CMAKE_BINARY_DIR}/boot/bootdata/BCD COMMAND native-mkhive -h:SYSTEM,SOFTWARE,DEFAULT,SAM,SECURITY -d:${CMAKE_BINARY_DIR}/boot/bootdata ${_livecd_inf_files}
COMMAND native-mkhive ${CMAKE_BINARY_DIR}/boot/bootdata ${_livecd_inf_files}
DEPENDS native-mkhive ${_livecd_inf_files}) DEPENDS native-mkhive ${_livecd_inf_files})
add_custom_target(livecd_hives add_custom_target(livecd_hives
DEPENDS ${CMAKE_BINARY_DIR}/boot/bootdata/sam DEPENDS ${CMAKE_BINARY_DIR}/boot/bootdata/system
${CMAKE_BINARY_DIR}/boot/bootdata/default ${CMAKE_BINARY_DIR}/boot/bootdata/software
${CMAKE_BINARY_DIR}/boot/bootdata/security ${CMAKE_BINARY_DIR}/boot/bootdata/default
${CMAKE_BINARY_DIR}/boot/bootdata/software ${CMAKE_BINARY_DIR}/boot/bootdata/sam
${CMAKE_BINARY_DIR}/boot/bootdata/system ${CMAKE_BINARY_DIR}/boot/bootdata/security)
${CMAKE_BINARY_DIR}/boot/bootdata/BCD)
add_cd_file( add_cd_file(
FILE ${CMAKE_BINARY_DIR}/boot/bootdata/sam FILE ${CMAKE_BINARY_DIR}/boot/bootdata/system
${CMAKE_BINARY_DIR}/boot/bootdata/default ${CMAKE_BINARY_DIR}/boot/bootdata/software
${CMAKE_BINARY_DIR}/boot/bootdata/security ${CMAKE_BINARY_DIR}/boot/bootdata/default
${CMAKE_BINARY_DIR}/boot/bootdata/software ${CMAKE_BINARY_DIR}/boot/bootdata/sam
${CMAKE_BINARY_DIR}/boot/bootdata/system ${CMAKE_BINARY_DIR}/boot/bootdata/security
TARGET livecd_hives TARGET livecd_hives
DESTINATION reactos/system32/config DESTINATION reactos/system32/config
FOR livecd) FOR livecd)
# BCD Hive
add_custom_command(
OUTPUT ${CMAKE_BINARY_DIR}/boot/bootdata/BCD
COMMAND native-mkhive -h:BCD -d:${CMAKE_BINARY_DIR}/boot/bootdata ${CMAKE_BINARY_DIR}/boot/bootdata/hivebcd_utf16.inf
DEPENDS native-mkhive ${CMAKE_BINARY_DIR}/boot/bootdata/hivebcd_utf16.inf)
add_custom_target(bcd_hive
DEPENDS ${CMAKE_BINARY_DIR}/boot/bootdata/BCD)
add_cd_file( add_cd_file(
FILE ${CMAKE_BINARY_DIR}/boot/bootdata/BCD FILE ${CMAKE_BINARY_DIR}/boot/bootdata/BCD
TARGET livecd_hives TARGET bcd_hive
DESTINATION efi/boot DESTINATION efi/boot
NO_CAB NO_CAB
FOR bootcd regtest livecd) FOR bootcd regtest livecd)

146
sdk/tools/mkhive/mkhive.c
View file

@ -21,8 +21,9 @@
* PROJECT: ReactOS hive maker * PROJECT: ReactOS hive maker
* FILE: tools/mkhive/mkhive.c * FILE: tools/mkhive/mkhive.c
* PURPOSE: Hive maker * PURPOSE: Hive maker
* PROGRAMMER: Eric Kohl * PROGRAMMERS: Eric Kohl
* Hervé Poussineau * Hervé Poussineau
* Hermès Bélusca-Maïto
*/ */
#include <limits.h> #include <limits.h>
@ -48,11 +49,13 @@
#endif #endif
void usage (void) void usage(void)
{ {
printf ("Usage: mkhive <dstdir> <inffiles>\n\n"); printf("Usage: mkhive -h:hive1[,hiveN...] -d:<dstdir> <inffiles>\n\n"
printf (" dstdir - binary hive files are created in this directory\n"); " -h:hiveN - Comma-separated list of hives to create. Possible values are:\n"
printf (" inffiles - inf files with full path\n"); " SETUPREG, SYSTEM, SOFTWARE, DEFAULT, SAM, SECURITY, BCD.\n"
" -d:dstdir - The binary hive files are created in this directory.\n"
" inffiles - List of INF files with full path.\n");
} }
void convert_path(char *dst, char *src) void convert_path(char *dst, char *src)
@ -83,83 +86,106 @@ void convert_path(char *dst, char *src)
dst[i] = 0; dst[i] = 0;
} }
int main (int argc, char *argv[]) int main(int argc, char *argv[])
{ {
char FileName[PATH_MAX]; INT ret;
int i; UINT i;
PCSTR HiveList = NULL;
CHAR DestPath[PATH_MAX] = "";
CHAR FileName[PATH_MAX];
if (argc < 3) if (argc < 4)
{ {
usage (); usage();
return 1; return -1;
} }
printf ("Binary hive maker\n"); printf("Binary hive maker\n");
RegInitializeRegistry (); /* Read the options */
for (i = 1; i < argc && *argv[i] == '-'; i++)
for (i = 2; i < argc; i++)
{ {
convert_path (FileName, argv[i]); if (argv[i][1] == 'h' && (argv[i][2] == ':' || argv[i][2] == '='))
if (!ImportRegistryFile (FileName))
{ {
return 1; HiveList = argv[i] + 3;
}
else if (argv[i][1] == 'd' && (argv[i][2] == ':' || argv[i][2] == '='))
{
convert_path(DestPath, argv[i] + 3);
}
else
{
fprintf(stderr, "Unrecognized option: %s\n", argv[i]);
return -1;
} }
} }
convert_path (FileName, argv[1]); /* Check whether we have all the parameters needed */
strcat (FileName, DIR_SEPARATOR_STRING); if (!HiveList || !*HiveList)
strcat (FileName, "default");
if (!ExportBinaryHive (FileName, &DefaultHive))
{ {
return 1; fprintf(stderr, "The mandatory list of hives is missing.\n");
return -1;
}
if (!*DestPath)
{
fprintf(stderr, "The mandatory output directory is missing.\n");
return -1;
}
if (i >= argc)
{
fprintf(stderr, "Not enough parameters, or the list of INF files is missing.\n");
return -1;
} }
convert_path (FileName, argv[1]); /* Initialize the registry */
strcat (FileName, DIR_SEPARATOR_STRING); RegInitializeRegistry(HiveList);
strcat (FileName, "sam");
if (!ExportBinaryHive (FileName, &SamHive)) /* Default to failure */
ret = -1;
/* Now we should have the list of INF files: parse it */
for (; i < argc; ++i)
{ {
return 1; convert_path(FileName, argv[i]);
if (!ImportRegistryFile(FileName))
goto Quit;
} }
convert_path (FileName, argv[1]); for (i = 0; i < MAX_NUMBER_OF_REGISTRY_HIVES; ++i)
strcat (FileName, DIR_SEPARATOR_STRING);
strcat (FileName, "security");
if (!ExportBinaryHive (FileName, &SecurityHive))
{ {
return 1; /* Skip this registry hive if it's not in the list */
if (!strstr(HiveList, RegistryHives[i].HiveName))
continue;
strcpy(FileName, DestPath);
strcat(FileName, DIR_SEPARATOR_STRING);
strcat(FileName, RegistryHives[i].HiveName);
/* Exception for the special setup registry hive */
// if (strcmp(RegistryHives[i].HiveName, "SETUPREG") == 0)
if (i == 0)
strcat(FileName, ".HIV");
if (!ExportBinaryHive(FileName, RegistryHives[i].CmHive))
goto Quit;
/* If we happen to deal with the special setup registry hive, stop there */
// if (strcmp(RegistryHives[i].HiveName, "SETUPREG") == 0)
if (i == 0)
break;
} }
convert_path (FileName, argv[1]); /* Success */
strcat (FileName, DIR_SEPARATOR_STRING); ret = 0;
strcat (FileName, "software");
if (!ExportBinaryHive (FileName, &SoftwareHive))
{
return 1;
}
convert_path (FileName, argv[1]); Quit:
strcat (FileName, DIR_SEPARATOR_STRING); /* Shut down the registry */
strcat (FileName, "system"); RegShutdownRegistry();
if (!ExportBinaryHive (FileName, &SystemHive))
{
return 1;
}
convert_path (FileName, argv[1]); if (ret == 0)
strcat (FileName, DIR_SEPARATOR_STRING); printf(" Done.\n");
strcat (FileName, "BCD");
if (!ExportBinaryHive (FileName, &BcdHive))
{
return 1;
}
RegShutdownRegistry (); return ret;
printf (" Done.\n");
return 0;
} }
/* EOF */ /* EOF */

8
sdk/tools/mkhive/mkhive.h
View file

@ -21,7 +21,7 @@
* PROJECT: ReactOS hive maker * PROJECT: ReactOS hive maker
* FILE: tools/mkhive/mkhive.h * FILE: tools/mkhive/mkhive.h
* PURPOSE: Hive maker * PURPOSE: Hive maker
* PROGRAMMER: Eric Kohl * PROGRAMMERS: Eric Kohl
* Hervé Poussineau * Hervé Poussineau
*/ */
@ -32,6 +32,12 @@
#include <typedefs.h> #include <typedefs.h>
#ifndef _MSC_VER
#ifndef _countof
#define _countof(_Array) (sizeof(_Array) / sizeof(_Array[0]))
#endif
#endif
// Definitions copied from <ntstatus.h> // Definitions copied from <ntstatus.h>
// We only want to include host headers, so we define them manually // We only want to include host headers, so we define them manually
#define STATUS_SUCCESS ((NTSTATUS)0x00000000) #define STATUS_SUCCESS ((NTSTATUS)0x00000000)

201
sdk/tools/mkhive/registry.c
View file

@ -21,7 +21,8 @@
* PROJECT: ReactOS hive maker * PROJECT: ReactOS hive maker
* FILE: tools/mkhive/registry.c * FILE: tools/mkhive/registry.c
* PURPOSE: Registry code * PURPOSE: Registry code
* PROGRAMMER: Hervé Poussineau * PROGRAMMERS: Hervé Poussineau
* Hermès Bélusca-Maïto
*/ */
/* /*
@ -38,12 +39,13 @@
static CMHIVE RootHive; static CMHIVE RootHive;
static PMEMKEY RootKey; static PMEMKEY RootKey;
CMHIVE DefaultHive; /* \Registry\User\.DEFAULT */
CMHIVE SamHive; /* \Registry\Machine\SAM */ static CMHIVE SystemHive; /* \Registry\Machine\SYSTEM */
CMHIVE SecurityHive; /* \Registry\Machine\SECURITY */ static CMHIVE SoftwareHive; /* \Registry\Machine\SOFTWARE */
CMHIVE SoftwareHive; /* \Registry\Machine\SOFTWARE */ static CMHIVE DefaultHive; /* \Registry\User\.DEFAULT */
CMHIVE SystemHive; /* \Registry\Machine\SYSTEM */ static CMHIVE SamHive; /* \Registry\Machine\SAM */
CMHIVE BcdHive; /* \Registry\Machine\BCD00000000 */ static CMHIVE SecurityHive; /* \Registry\Machine\SECURITY */
static CMHIVE BcdHive; /* \Registry\Machine\BCD00000000 */
// //
// TODO: Write these values in a more human-readable form. // TODO: Write these values in a more human-readable form.
@ -56,7 +58,7 @@ CMHIVE BcdHive; /* \Registry\Machine\BCD00000000 */
// A cross-check was subsequently done with the system hives to verify that // A cross-check was subsequently done with the system hives to verify that
// the security descriptors were the same. // the security descriptors were the same.
// //
UCHAR BcdSecurity[] = static UCHAR BcdSecurity[] =
{ {
// SECURITY_DESCRIPTOR_RELATIVE // SECURITY_DESCRIPTOR_RELATIVE
0x01, // Revision 0x01, // Revision
@ -118,7 +120,7 @@ UCHAR BcdSecurity[] =
0x01, 0x02, 0x00, 0x00 0x01, 0x02, 0x00, 0x00
}; };
UCHAR SoftwareSecurity[] = static UCHAR SoftwareSecurity[] =
{ {
// SECURITY_DESCRIPTOR_RELATIVE // SECURITY_DESCRIPTOR_RELATIVE
0x01, // Revision 0x01, // Revision
@ -234,7 +236,7 @@ UCHAR SoftwareSecurity[] =
}; };
// Same security for SYSTEM, SAM and .DEFAULT // Same security for SYSTEM, SAM and .DEFAULT
UCHAR SystemSecurity[] = static UCHAR SystemSecurity[] =
{ {
// SECURITY_DESCRIPTOR_RELATIVE // SECURITY_DESCRIPTOR_RELATIVE
0x01, // Revision 0x01, // Revision
@ -330,6 +332,24 @@ UCHAR SystemSecurity[] =
0x01, 0x02, 0x00, 0x00 0x01, 0x02, 0x00, 0x00
}; };
HIVE_LIST_ENTRY RegistryHives[/*MAX_NUMBER_OF_REGISTRY_HIVES*/] =
{
/* Special Setup system registry hive */
// WARNING: Please *keep* it in first position!
{ "SETUPREG", L"Registry\\Machine\\SYSTEM" , &SystemHive , SystemSecurity , sizeof(SystemSecurity) },
/* Regular registry hives */
{ "SYSTEM" , L"Registry\\Machine\\SYSTEM" , &SystemHive , SystemSecurity , sizeof(SystemSecurity) },
{ "SOFTWARE", L"Registry\\Machine\\SOFTWARE" , &SoftwareHive, SoftwareSecurity, sizeof(SoftwareSecurity) },
{ "DEFAULT" , L"Registry\\User\\.DEFAULT" , &DefaultHive , SystemSecurity , sizeof(SystemSecurity) },
{ "SAM" , L"Registry\\Machine\\SAM" , &SamHive , SystemSecurity , sizeof(SystemSecurity) },
{ "SECURITY", L"Registry\\Machine\\SECURITY" , &SecurityHive, NULL , 0 },
{ "BCD" , L"Registry\\Machine\\BCD00000000", &BcdHive , BcdSecurity , sizeof(BcdSecurity) },
};
C_ASSERT(_countof(RegistryHives) == MAX_NUMBER_OF_REGISTRY_HIVES);
static PMEMKEY static PMEMKEY
CreateInMemoryStructure( CreateInMemoryStructure(
IN PCMHIVE RegistryHive, IN PCMHIVE RegistryHive,
@ -346,6 +366,7 @@ CreateInMemoryStructure(
return Key; return Key;
} }
LIST_ENTRY CmiHiveListHead;
LIST_ENTRY CmiReparsePointsHead; LIST_ENTRY CmiReparsePointsHead;
static LONG static LONG
@ -671,9 +692,9 @@ VOID
RepGetValueData( RepGetValueData(
IN PHHIVE Hive, IN PHHIVE Hive,
IN PCM_KEY_VALUE ValueCell, IN PCM_KEY_VALUE ValueCell,
OUT ULONG* Type OPTIONAL, OUT PULONG Type OPTIONAL,
OUT PUCHAR Data OPTIONAL, OUT PUCHAR Data OPTIONAL,
IN OUT ULONG* DataSize OPTIONAL) IN OUT PULONG DataSize OPTIONAL)
{ {
ULONG DataLength; ULONG DataLength;
PVOID DataCell; PVOID DataCell;
@ -759,16 +780,16 @@ static BOOL
ConnectRegistry( ConnectRegistry(
IN HKEY RootKey, IN HKEY RootKey,
IN PCMHIVE HiveToConnect, IN PCMHIVE HiveToConnect,
IN PUCHAR Descriptor, IN PUCHAR SecurityDescriptor,
IN ULONG DescriptorLength, IN ULONG SecurityDescriptorLength,
IN LPCWSTR Path) IN PCWSTR Path)
{ {
NTSTATUS Status; NTSTATUS Status;
PREPARSE_POINT ReparsePoint; PREPARSE_POINT ReparsePoint;
PMEMKEY NewKey; PMEMKEY NewKey;
LONG rc; LONG rc;
ReparsePoint = (PREPARSE_POINT)malloc(sizeof(REPARSE_POINT)); ReparsePoint = (PREPARSE_POINT)malloc(sizeof(*ReparsePoint));
if (!ReparsePoint) if (!ReparsePoint)
return FALSE; return FALSE;
@ -794,7 +815,7 @@ ConnectRegistry(
*/ */
Status = CmiCreateSecurityKey(&HiveToConnect->Hive, Status = CmiCreateSecurityKey(&HiveToConnect->Hive,
HiveToConnect->Hive.BaseBlock->RootCell, HiveToConnect->Hive.BaseBlock->RootCell,
Descriptor, DescriptorLength); SecurityDescriptor, SecurityDescriptorLength);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
DPRINT1("Failed to add security for root key '%S'\n", Path); DPRINT1("Failed to add security for root key '%S'\n", Path);
@ -821,18 +842,64 @@ ConnectRegistry(
ReparsePoint->DestinationHive = NewKey->RegistryHive; ReparsePoint->DestinationHive = NewKey->RegistryHive;
ReparsePoint->DestinationKeyCellOffset = NewKey->KeyCellOffset; ReparsePoint->DestinationKeyCellOffset = NewKey->KeyCellOffset;
InsertTailList(&CmiReparsePointsHead, &ReparsePoint->ListEntry); InsertTailList(&CmiReparsePointsHead, &ReparsePoint->ListEntry);
return TRUE; return TRUE;
} }
LIST_ENTRY CmiHiveListHead; static BOOL
CreateSymLink(
IN PCWSTR LinkKeyPath OPTIONAL,
IN OUT PHKEY LinkKeyHandle OPTIONAL,
// IN PCWSTR TargetKeyPath OPTIONAL,
IN HKEY TargetKeyHandle)
{
PMEMKEY LinkKey, TargetKey;
PREPARSE_POINT ReparsePoint;
ReparsePoint = (PREPARSE_POINT)malloc(sizeof(*ReparsePoint));
if (!ReparsePoint)
return FALSE;
if (LinkKeyPath && !(LinkKeyHandle && *LinkKeyHandle))
{
/* Create the link key */
RegCreateKeyExW(NULL,
LinkKeyPath,
0,
NULL,
REG_OPTION_VOLATILE,
0,
NULL,
(HKEY*)&LinkKey,
NULL);
}
else if (LinkKeyHandle)
{
/* Use the user-provided link key handle */
LinkKey = HKEY_TO_MEMKEY(*LinkKeyHandle);
}
if (LinkKeyHandle)
*LinkKeyHandle = MEMKEY_TO_HKEY(LinkKey);
TargetKey = HKEY_TO_MEMKEY(TargetKeyHandle);
ReparsePoint->SourceHive = LinkKey->RegistryHive;
ReparsePoint->SourceKeyCellOffset = LinkKey->KeyCellOffset;
ReparsePoint->DestinationHive = TargetKey->RegistryHive;
ReparsePoint->DestinationKeyCellOffset = TargetKey->KeyCellOffset;
InsertTailList(&CmiReparsePointsHead, &ReparsePoint->ListEntry);
return TRUE;
}
VOID VOID
RegInitializeRegistry(VOID) RegInitializeRegistry(
IN PCSTR HiveList)
{ {
UNICODE_STRING RootKeyName = RTL_CONSTANT_STRING(L"\\");
NTSTATUS Status; NTSTATUS Status;
PMEMKEY ControlSetKey, CurrentControlSetKey; UINT i;
PREPARSE_POINT ReparsePoint; HKEY ControlSetKey;
InitializeListHead(&CmiHiveListHead); InitializeListHead(&CmiHiveListHead);
InitializeListHead(&CmiReparsePointsHead); InitializeListHead(&CmiReparsePointsHead);
@ -847,70 +914,56 @@ RegInitializeRegistry(VOID)
RootKey = CreateInMemoryStructure(&RootHive, RootKey = CreateInMemoryStructure(&RootHive,
RootHive.Hive.BaseBlock->RootCell); RootHive.Hive.BaseBlock->RootCell);
/* Create DEFAULT key */ for (i = 0; i < _countof(RegistryHives); ++i)
ConnectRegistry(NULL, {
&DefaultHive, /* Skip this registry hive if it's not in the list */
SystemSecurity, sizeof(SystemSecurity), if (!strstr(HiveList, RegistryHives[i].HiveName))
L"Registry\\User\\.DEFAULT"); continue;
/* Create SAM key */ /* Create the registry key */
ConnectRegistry(NULL, ConnectRegistry(NULL,
&SamHive, RegistryHives[i].CmHive,
SystemSecurity, sizeof(SystemSecurity), RegistryHives[i].SecurityDescriptor,
L"Registry\\Machine\\SAM"); RegistryHives[i].SecurityDescriptorLength,
RegistryHives[i].HiveRegistryPath);
/* Create SECURITY key */ /* If we happen to deal with the special setup registry hive, stop there */
ConnectRegistry(NULL, // if (strcmp(RegistryHives[i].HiveName, "SETUPREG") == 0)
&SecurityHive, if (i == 0)
NULL, 0, break;
L"Registry\\Machine\\SECURITY"); }
/* Create SOFTWARE key */ /* Create the 'ControlSet001' key */
ConnectRegistry(NULL,
&SoftwareHive,
SoftwareSecurity, sizeof(SoftwareSecurity),
L"Registry\\Machine\\SOFTWARE");
/* Create BCD key */
ConnectRegistry(NULL,
&BcdHive,
BcdSecurity, sizeof(BcdSecurity),
L"Registry\\Machine\\BCD00000000");
/* Create SYSTEM key */
ConnectRegistry(NULL,
&SystemHive,
SystemSecurity, sizeof(SystemSecurity),
L"Registry\\Machine\\SYSTEM");
/* Create 'ControlSet001' key */
RegCreateKeyW(NULL, RegCreateKeyW(NULL,
L"Registry\\Machine\\SYSTEM\\ControlSet001", L"Registry\\Machine\\SYSTEM\\ControlSet001",
(HKEY*)&ControlSetKey); &ControlSetKey);
/* Create 'CurrentControlSet' key */ /* Create the 'CurrentControlSet' key as a symlink to 'ControlSet001' */
RegCreateKeyExW(NULL, CreateSymLink(L"Registry\\Machine\\SYSTEM\\CurrentControlSet",
L"Registry\\Machine\\SYSTEM\\CurrentControlSet", NULL, ControlSetKey);
0,
NULL,
REG_OPTION_VOLATILE,
0,
NULL,
(HKEY*)&CurrentControlSetKey,
NULL);
/* Connect 'CurrentControlSet' to 'ControlSet001' */ #if 0
ReparsePoint = (PREPARSE_POINT)malloc(sizeof(REPARSE_POINT)); /* Link SECURITY to SAM */
ReparsePoint->SourceHive = CurrentControlSetKey->RegistryHive; CmpLinkKeyToHive(L"\\Registry\\Machine\\Security\\SAM", L"\\Registry\\Machine\\SAM\\SAM");
ReparsePoint->SourceKeyCellOffset = CurrentControlSetKey->KeyCellOffset; /* Link S-1-5-18 to .Default */
ReparsePoint->DestinationHive = ControlSetKey->RegistryHive; CmpLinkKeyToHive(L"\\Registry\\User\\S-1-5-18", L"\\Registry\\User\\.Default");
ReparsePoint->DestinationKeyCellOffset = ControlSetKey->KeyCellOffset; #endif
InsertTailList(&CmiReparsePointsHead, &ReparsePoint->ListEntry);
} }
VOID VOID
RegShutdownRegistry(VOID) RegShutdownRegistry(VOID)
{ {
PLIST_ENTRY Entry;
PREPARSE_POINT ReparsePoint;
/* Clean up the reparse points list */
while (!IsListEmpty(&CmiReparsePointsHead))
{
Entry = RemoveHeadList(&CmiReparsePointsHead);
ReparsePoint = CONTAINING_RECORD(Entry, REPARSE_POINT, ListEntry);
free(ReparsePoint);
}
/* FIXME: clean up the complete hive */ /* FIXME: clean up the complete hive */
free(RootKey); free(RootKey);

20
sdk/tools/mkhive/registry.h
View file

@ -26,12 +26,17 @@ typedef struct _MEMKEY
#define HKEY_TO_MEMKEY(hKey) ((PMEMKEY)(hKey)) #define HKEY_TO_MEMKEY(hKey) ((PMEMKEY)(hKey))
#define MEMKEY_TO_HKEY(memKey) ((HKEY)(memKey)) #define MEMKEY_TO_HKEY(memKey) ((HKEY)(memKey))
extern CMHIVE DefaultHive; /* \Registry\User\.DEFAULT */ typedef struct _HIVE_LIST_ENTRY
extern CMHIVE SamHive; /* \Registry\Machine\SAM */ {
extern CMHIVE SecurityHive; /* \Registry\Machine\SECURITY */ PCSTR HiveName;
extern CMHIVE SoftwareHive; /* \Registry\Machine\SOFTWARE */ PCWSTR HiveRegistryPath;
extern CMHIVE SystemHive; /* \Registry\Machine\SYSTEM */ PCMHIVE CmHive;
extern CMHIVE BcdHive; /* \Registry\Machine\BCD00000000 */ PUCHAR SecurityDescriptor;
ULONG SecurityDescriptorLength;
} HIVE_LIST_ENTRY, *PHIVE_LIST_ENTRY;
#define MAX_NUMBER_OF_REGISTRY_HIVES 7
extern HIVE_LIST_ENTRY RegistryHives[];
#define ERROR_SUCCESS 0L #define ERROR_SUCCESS 0L
#define ERROR_UNSUCCESSFUL 1L #define ERROR_UNSUCCESSFUL 1L
@ -57,7 +62,8 @@ extern CMHIVE BcdHive; /* \Registry\Machine\BCD00000000 */
#define REG_QWORD_LITTLE_ENDIAN 11 #define REG_QWORD_LITTLE_ENDIAN 11
VOID VOID
RegInitializeRegistry(VOID); RegInitializeRegistry(
IN PCSTR HiveList);
VOID VOID
RegShutdownRegistry(VOID); RegShutdownRegistry(VOID);