From 3a2fbc9c8f9169ddec643db4e674dcebbb5e0fa0 Mon Sep 17 00:00:00 2001 From: Eric Kohl Date: Fri, 10 Oct 2003 21:55:16 +0000 Subject: [PATCH] - Fixed inconsistent detection of in-offset data. - Fixed class name cell allocation. - Renamed a lot of variables and functions. svn path=/trunk/; revision=6274 --- reactos/ntoskrnl/cm/cm.h | 44 +-- reactos/ntoskrnl/cm/import.c | 7 +- reactos/ntoskrnl/cm/ntfunc.c | 166 +++++------ reactos/ntoskrnl/cm/regfile.c | 498 +++++++++++++++++---------------- reactos/ntoskrnl/cm/registry.c | 12 +- reactos/ntoskrnl/cm/regobj.c | 7 +- reactos/tools/mkhive/binhive.c | 99 +++---- 7 files changed, 425 insertions(+), 408 deletions(-) diff --git a/reactos/ntoskrnl/cm/cm.h b/reactos/ntoskrnl/cm/cm.h index 0ffd2290225..9bad7dee886 100644 --- a/reactos/ntoskrnl/cm/cm.h +++ b/reactos/ntoskrnl/cm/cm.h @@ -37,15 +37,16 @@ #define REG_BLOCK_SIZE 4096 #define REG_HBIN_DATA_OFFSET 32 -#define REG_BIN_ID 0x6e696268 #define REG_INIT_BLOCK_LIST_SIZE 32 #define REG_INIT_HASH_TABLE_SIZE 3 #define REG_EXTEND_HASH_TABLE_SIZE 4 #define REG_VALUE_LIST_CELL_MULTIPLE 4 -#define REG_KEY_CELL_ID 0x6b6e -#define REG_HASH_TABLE_BLOCK_ID 0x666c -#define REG_VALUE_CELL_ID 0x6b76 + #define REG_HIVE_ID 0x66676572 +#define REG_BIN_ID 0x6e696268 +#define REG_KEY_CELL_ID 0x6b6e +#define REG_HASH_TABLE_CELL_ID 0x666c +#define REG_VALUE_CELL_ID 0x6b76 // BLOCK_OFFSET = offset in file after header block @@ -80,7 +81,7 @@ typedef struct _HIVE_HEADER /* Offset into file from the byte after the end of the base block. If the hive is volatile, this is the actual pointer to the KEY_CELL */ - BLOCK_OFFSET RootKeyCell; + BLOCK_OFFSET RootKeyOffset; /* Size of each hive block ? */ ULONG BlockSize; @@ -161,7 +162,7 @@ typedef struct _KEY_CELL ULONG NumberOfValues; /* Block offset of VALUE_LIST_CELL */ - BLOCK_OFFSET ValuesOffset; + BLOCK_OFFSET ValueListOffset; /* Block offset of security cell */ BLOCK_OFFSET SecurityKeyOffset; @@ -187,7 +188,6 @@ typedef struct _KEY_CELL #define REG_KEY_LINK_CELL 0x10 #define REG_KEY_NAME_PACKED 0x20 - /* * Hash record * @@ -213,7 +213,7 @@ typedef struct _HASH_TABLE_CELL typedef struct _VALUE_LIST_CELL { LONG CellSize; - BLOCK_OFFSET Values[0]; + BLOCK_OFFSET ValueOffset[0]; } __attribute__((packed)) VALUE_LIST_CELL, *PVALUE_LIST_CELL; typedef struct _VALUE_CELL @@ -221,7 +221,7 @@ typedef struct _VALUE_CELL LONG CellSize; USHORT Id; // "kv" USHORT NameSize; // length of Name - LONG DataSize; // length of datas in the cell pointed by DataOffset + ULONG DataSize; // length of datas in the cell pointed by DataOffset BLOCK_OFFSET DataOffset;// datas are here if high bit of DataSize is set ULONG DataType; USHORT Flags; @@ -232,6 +232,10 @@ typedef struct _VALUE_CELL /* VALUE_CELL.Flags constants */ #define REG_VALUE_NAME_PACKED 0x0001 +/* VALUE_CELL.DataSize mask constants */ +#define REG_DATA_SIZE_MASK 0x7FFFFFFF +#define REG_DATA_IN_OFFSET 0x80000000 + typedef struct _DATA_CELL { @@ -306,7 +310,7 @@ typedef struct _KEY_OBJECT PREGISTRY_HIVE RegistryHive; /* Block offset of the key cell this key belongs in */ - BLOCK_OFFSET BlockOffset; + BLOCK_OFFSET KeyCellOffset; /* KEY_CELL this key belong in */ PKEY_CELL KeyCell; @@ -506,7 +510,7 @@ CmiDeleteValueFromKey(IN PREGISTRY_HIVE RegistryHive, IN PUNICODE_STRING ValueName); NTSTATUS -CmiAllocateHashTableBlock(IN PREGISTRY_HIVE RegistryHive, +CmiAllocateHashTableCell(IN PREGISTRY_HIVE RegistryHive, OUT PHASH_TABLE_CELL *HashBlock, OUT BLOCK_OFFSET *HBOffset, IN ULONG HashTableSize); @@ -539,19 +543,19 @@ CmiDestroyValueCell(PREGISTRY_HIVE RegistryHive, BLOCK_OFFSET VBOffset); NTSTATUS -CmiAllocateBlock(PREGISTRY_HIVE RegistryHive, - PVOID *Block, - LONG BlockSize, - BLOCK_OFFSET * pBlockOffset); +CmiAllocateCell(PREGISTRY_HIVE RegistryHive, + LONG CellSize, + PVOID *Cell, + BLOCK_OFFSET *CellOffset); NTSTATUS -CmiDestroyBlock(PREGISTRY_HIVE RegistryHive, - PVOID Block, - BLOCK_OFFSET Offset); +CmiDestroyCell(PREGISTRY_HIVE RegistryHive, + PVOID Cell, + BLOCK_OFFSET CellOffset); PVOID -CmiGetBlock(PREGISTRY_HIVE RegistryHive, - BLOCK_OFFSET BlockOffset, +CmiGetCell (PREGISTRY_HIVE RegistryHive, + BLOCK_OFFSET CellOffset, OUT PHBIN * ppBin); VOID diff --git a/reactos/ntoskrnl/cm/import.c b/reactos/ntoskrnl/cm/import.c index 7da07ff08e2..28fe7c0d17e 100644 --- a/reactos/ntoskrnl/cm/import.c +++ b/reactos/ntoskrnl/cm/import.c @@ -1,4 +1,4 @@ -/* $Id: import.c,v 1.21 2003/06/01 15:10:52 ekohl Exp $ +/* $Id: import.c,v 1.22 2003/10/10 21:55:16 ekohl Exp $ * * COPYRIGHT: See COPYING in the top level directory * PROJECT: ReactOS kernel @@ -9,13 +9,12 @@ /* INCLUDES *****************************************************************/ -#include #include +#include +#include #include #include -#include -#include #include #include #include diff --git a/reactos/ntoskrnl/cm/ntfunc.c b/reactos/ntoskrnl/cm/ntfunc.c index 74fcf7b7722..813174811e1 100644 --- a/reactos/ntoskrnl/cm/ntfunc.c +++ b/reactos/ntoskrnl/cm/ntfunc.c @@ -10,10 +10,9 @@ #define NTOS_MODE_KERNEL #include +#include #include #include -#include -#include #include #include @@ -167,7 +166,7 @@ NtCreateKey(OUT PHANDLE KeyHandle, if (KeyObject->RegistryHive == KeyObject->ParentKey->RegistryHive) { - KeyObject->KeyCell->ParentKeyOffset = KeyObject->ParentKey->BlockOffset; + KeyObject->KeyCell->ParentKeyOffset = KeyObject->ParentKey->KeyCellOffset; KeyObject->KeyCell->SecurityKeyOffset = KeyObject->ParentKey->KeyCell->SecurityKeyOffset; } else @@ -276,7 +275,7 @@ NtEnumerateKey(IN HANDLE KeyHandle, PKEY_BASIC_INFORMATION BasicInformation; PKEY_NODE_INFORMATION NodeInformation; PKEY_FULL_INFORMATION FullInformation; - PDATA_CELL ClassData; + PDATA_CELL ClassCell; ULONG NameSize; NTSTATUS Status; @@ -354,7 +353,7 @@ NtEnumerateKey(IN HANDLE KeyHandle, return(STATUS_NO_MORE_ENTRIES); } - HashTableBlock = CmiGetBlock(RegistryHive, KeyCell->HashTableOffset, NULL); + HashTableBlock = CmiGetCell (RegistryHive, KeyCell->HashTableOffset, NULL); if (HashTableBlock == NULL) { DPRINT("CmiGetBlock() failed\n"); @@ -458,12 +457,12 @@ NtEnumerateKey(IN HANDLE KeyHandle, if (SubKeyCell->ClassSize != 0) { - ClassData=CmiGetBlock(KeyObject->RegistryHive, - SubKeyCell->ClassNameOffset, - NULL); - wcsncpy(NodeInformation->Name + SubKeyCell->NameSize, - (PWCHAR)ClassData->Data, - SubKeyCell->ClassSize); + ClassCell = CmiGetCell (KeyObject->RegistryHive, + SubKeyCell->ClassNameOffset, + NULL); + RtlCopyMemory (NodeInformation->Name + SubKeyCell->NameSize, + ClassCell->Data, + SubKeyCell->ClassSize); } } break; @@ -497,12 +496,12 @@ NtEnumerateKey(IN HANDLE KeyHandle, CmiGetMaxValueDataLength(RegistryHive, SubKeyCell); if (SubKeyCell->ClassSize != 0) { - ClassData = CmiGetBlock(KeyObject->RegistryHive, + ClassCell = CmiGetCell (KeyObject->RegistryHive, SubKeyCell->ClassNameOffset, NULL); - wcsncpy(FullInformation->Class, - (PWCHAR)ClassData->Data, - SubKeyCell->ClassSize); + RtlCopyMemory (FullInformation->Class, + ClassCell->Data, + SubKeyCell->ClassSize); } } break; @@ -622,7 +621,7 @@ NtEnumerateValueKey(IN HANDLE KeyHandle, case KeyValuePartialInformation: *ResultLength = sizeof(KEY_VALUE_PARTIAL_INFORMATION) + - (ValueCell->DataSize & LONG_MAX); + (ValueCell->DataSize & REG_DATA_SIZE_MASK); if (Length < *ResultLength) { Status = STATUS_BUFFER_OVERFLOW; @@ -633,21 +632,20 @@ NtEnumerateValueKey(IN HANDLE KeyHandle, KeyValueInformation; ValuePartialInformation->TitleIndex = 0; ValuePartialInformation->Type = ValueCell->DataType; - ValuePartialInformation->DataLength = ValueCell->DataSize & LONG_MAX; - if(ValueCell->DataSize >0) + ValuePartialInformation->DataLength = ValueCell->DataSize & REG_DATA_SIZE_MASK; + if (!(ValueCell->DataSize & REG_DATA_IN_OFFSET)) { - DataCell = CmiGetBlock(RegistryHive, ValueCell->DataOffset, NULL); + DataCell = CmiGetCell (RegistryHive, ValueCell->DataOffset, NULL); RtlCopyMemory(ValuePartialInformation->Data, DataCell->Data, - ValueCell->DataSize & LONG_MAX); + ValueCell->DataSize & REG_DATA_SIZE_MASK); } else { RtlCopyMemory(ValuePartialInformation->Data, &ValueCell->DataOffset, - ValueCell->DataSize & LONG_MAX); + ValueCell->DataSize & REG_DATA_SIZE_MASK); } - DataCell = CmiGetBlock(RegistryHive, ValueCell->DataOffset, NULL); } break; @@ -658,7 +656,7 @@ NtEnumerateValueKey(IN HANDLE KeyHandle, NameSize *= sizeof(WCHAR); } *ResultLength = sizeof(KEY_VALUE_FULL_INFORMATION) + - NameSize + (ValueCell->DataSize & LONG_MAX); + NameSize + (ValueCell->DataSize & REG_DATA_SIZE_MASK); if (Length < *ResultLength) { Status = STATUS_BUFFER_OVERFLOW; @@ -687,21 +685,21 @@ NtEnumerateValueKey(IN HANDLE KeyHandle, ValueFullInformation->NameLength; ValueFullInformation->DataOffset = (ValueFullInformation->DataOffset + 3) & 0xfffffffc; - ValueFullInformation->DataLength = ValueCell->DataSize & LONG_MAX; - if (ValueCell->DataSize > 0) + ValueFullInformation->DataLength = ValueCell->DataSize & REG_DATA_SIZE_MASK; + if (!(ValueCell->DataSize & REG_DATA_IN_OFFSET)) { - DataCell = CmiGetBlock(RegistryHive, ValueCell->DataOffset, NULL); + DataCell = CmiGetCell (RegistryHive, ValueCell->DataOffset, NULL); RtlCopyMemory((PCHAR) ValueFullInformation + ValueFullInformation->DataOffset, DataCell->Data, - ValueCell->DataSize & LONG_MAX); + ValueCell->DataSize & REG_DATA_SIZE_MASK); } else { RtlCopyMemory((PCHAR) ValueFullInformation + ValueFullInformation->DataOffset, &ValueCell->DataOffset, - ValueCell->DataSize & LONG_MAX); + ValueCell->DataSize & REG_DATA_SIZE_MASK); } } break; @@ -839,7 +837,7 @@ NtQueryKey(IN HANDLE KeyHandle, PKEY_NODE_INFORMATION NodeInformation; PKEY_FULL_INFORMATION FullInformation; PREGISTRY_HIVE RegistryHive; - PDATA_CELL ClassData; + PDATA_CELL ClassCell; PKEY_OBJECT KeyObject; PKEY_CELL KeyCell; NTSTATUS Status; @@ -944,12 +942,12 @@ NtQueryKey(IN HANDLE KeyHandle, if (KeyCell->ClassSize != 0) { - ClassData = CmiGetBlock(KeyObject->RegistryHive, + ClassCell = CmiGetCell (KeyObject->RegistryHive, KeyCell->ClassNameOffset, NULL); - wcsncpy(NodeInformation->Name + KeyObject->Name.Length, - (PWCHAR)ClassData->Data, - KeyCell->ClassSize); + RtlCopyMemory (NodeInformation->Name + KeyObject->Name.Length, + ClassCell->Data, + KeyCell->ClassSize); } } break; @@ -982,12 +980,12 @@ NtQueryKey(IN HANDLE KeyHandle, CmiGetMaxValueDataLength(RegistryHive, KeyCell); if (KeyCell->ClassSize != 0) { - ClassData=CmiGetBlock(KeyObject->RegistryHive, - KeyCell->ClassNameOffset, - NULL); - wcsncpy(FullInformation->Class, - (PWCHAR)ClassData->Data, - KeyCell->ClassSize); + ClassCell = CmiGetCell (KeyObject->RegistryHive, + KeyCell->ClassNameOffset, + NULL); + RtlCopyMemory (FullInformation->Class, + ClassCell->Data, + KeyCell->ClassSize); } } break; @@ -1100,7 +1098,7 @@ NtQueryValueKey(IN HANDLE KeyHandle, case KeyValuePartialInformation: *ResultLength = sizeof(KEY_VALUE_PARTIAL_INFORMATION) - + (ValueCell->DataSize & LONG_MAX); + + (ValueCell->DataSize & REG_DATA_SIZE_MASK); if (Length < *ResultLength) { Status = STATUS_BUFFER_TOO_SMALL; @@ -1111,19 +1109,19 @@ NtQueryValueKey(IN HANDLE KeyHandle, KeyValueInformation; ValuePartialInformation->TitleIndex = 0; ValuePartialInformation->Type = ValueCell->DataType; - ValuePartialInformation->DataLength = ValueCell->DataSize & LONG_MAX; - if (ValueCell->DataSize > 0) + ValuePartialInformation->DataLength = ValueCell->DataSize & REG_DATA_SIZE_MASK; + if (!(ValueCell->DataSize & REG_DATA_IN_OFFSET)) { - DataCell = CmiGetBlock(RegistryHive, ValueCell->DataOffset, NULL); + DataCell = CmiGetCell (RegistryHive, ValueCell->DataOffset, NULL); RtlCopyMemory(ValuePartialInformation->Data, DataCell->Data, - ValueCell->DataSize & LONG_MAX); + ValueCell->DataSize & REG_DATA_SIZE_MASK); } else { RtlCopyMemory(ValuePartialInformation->Data, &ValueCell->DataOffset, - ValueCell->DataSize & LONG_MAX); + ValueCell->DataSize & REG_DATA_SIZE_MASK); } } break; @@ -1135,7 +1133,7 @@ NtQueryValueKey(IN HANDLE KeyHandle, NameSize *= sizeof(WCHAR); } *ResultLength = sizeof(KEY_VALUE_FULL_INFORMATION) + - NameSize + (ValueCell->DataSize & LONG_MAX); + NameSize + (ValueCell->DataSize & REG_DATA_SIZE_MASK); if (Length < *ResultLength) { Status = STATUS_BUFFER_TOO_SMALL; @@ -1164,21 +1162,21 @@ NtQueryValueKey(IN HANDLE KeyHandle, ValueFullInformation->NameLength; ValueFullInformation->DataOffset = (ValueFullInformation->DataOffset + 3) & 0xfffffffc; - ValueFullInformation->DataLength = ValueCell->DataSize & LONG_MAX; - if (ValueCell->DataSize > 0) + ValueFullInformation->DataLength = ValueCell->DataSize & REG_DATA_SIZE_MASK; + if (!(ValueCell->DataSize & REG_DATA_IN_OFFSET)) { - DataCell = CmiGetBlock(RegistryHive, ValueCell->DataOffset, NULL); + DataCell = CmiGetCell (RegistryHive, ValueCell->DataOffset, NULL); RtlCopyMemory((PCHAR) ValueFullInformation + ValueFullInformation->DataOffset, DataCell->Data, - ValueCell->DataSize & LONG_MAX); + ValueCell->DataSize & REG_DATA_SIZE_MASK); } else { RtlCopyMemory((PCHAR) ValueFullInformation + ValueFullInformation->DataOffset, &ValueCell->DataOffset, - ValueCell->DataSize & LONG_MAX); + ValueCell->DataSize & REG_DATA_SIZE_MASK); } } break; @@ -1212,7 +1210,7 @@ NtSetValueKey(IN HANDLE KeyHandle, PREGISTRY_HIVE RegistryHive; PKEY_CELL KeyCell; PVALUE_CELL ValueCell; - BLOCK_OFFSET VBOffset; + BLOCK_OFFSET ValueCellOffset; PDATA_CELL DataCell; PDATA_CELL NewDataCell; PHBIN pBin; @@ -1247,7 +1245,7 @@ NtSetValueKey(IN HANDLE KeyHandle, KeyCell, ValueName, &ValueCell, - &VBOffset); + &ValueCellOffset); if (!NT_SUCCESS(Status)) { DPRINT("Value not found. Status 0x%X\n", Status); @@ -1264,10 +1262,10 @@ NtSetValueKey(IN HANDLE KeyHandle, KeyCell, ValueName, &ValueCell, - &VBOffset); + &ValueCellOffset); if (NT_SUCCESS(Status)) { - CmiMarkBlockDirty(RegistryHive, VBOffset); + CmiMarkBlockDirty(RegistryHive, ValueCellOffset); } } @@ -1284,26 +1282,28 @@ NtSetValueKey(IN HANDLE KeyHandle, DPRINT("ValueCell %p\n", ValueCell); DPRINT("ValueCell->DataSize %lu\n", ValueCell->DataSize); - if (DataSize <= 4) + if (DataSize <= sizeof(BLOCK_OFFSET)) { - /* If datasize <= 4 then write in valueblock directly */ + /* If data size <= sizeof(BLOCK_OFFSET) then store data in the data offset */ DPRINT("ValueCell->DataSize %lu\n", ValueCell->DataSize); - if ((ValueCell->DataSize >= 0) && - (DataCell = CmiGetBlock(RegistryHive, ValueCell->DataOffset, NULL))) + if (!(ValueCell->DataSize & REG_DATA_IN_OFFSET) && + (ValueCell->DataSize & REG_DATA_SIZE_MASK) != 0) { - CmiDestroyBlock(RegistryHive, DataCell, ValueCell->DataOffset); + DataCell = CmiGetCell (RegistryHive, ValueCell->DataOffset, NULL); + CmiDestroyCell(RegistryHive, DataCell, ValueCell->DataOffset); } RtlCopyMemory(&ValueCell->DataOffset, Data, DataSize); - ValueCell->DataSize = DataSize | 0x80000000; + ValueCell->DataSize = DataSize | REG_DATA_IN_OFFSET; ValueCell->DataType = Type; RtlMoveMemory(&ValueCell->DataOffset, Data, DataSize); - CmiMarkBlockDirty(RegistryHive, VBOffset); + CmiMarkBlockDirty(RegistryHive, ValueCellOffset); } - else if (DataSize <= (ULONG) (ValueCell->DataSize & 0x7fffffff)) + else if (!(ValueCell->DataSize & REG_DATA_IN_OFFSET) && + (DataSize <= (ValueCell->DataSize & REG_DATA_SIZE_MASK))) { /* If new data size is <= current then overwrite current data */ - DataCell = CmiGetBlock(RegistryHive, ValueCell->DataOffset,&pBin); + DataCell = CmiGetCell (RegistryHive, ValueCell->DataOffset,&pBin); RtlZeroMemory(DataCell->Data, ValueCell->DataSize); RtlCopyMemory(DataCell->Data, Data, DataSize); ValueCell->DataSize = DataSize; @@ -1326,18 +1326,19 @@ NtSetValueKey(IN HANDLE KeyHandle, DPRINT("ValueCell->DataSize %lu\n", ValueCell->DataSize); - if ((ValueCell->DataSize >= 0) && - (DataCell = CmiGetBlock(RegistryHive, ValueCell->DataOffset, NULL))) + if (!(ValueCell->DataSize & REG_DATA_IN_OFFSET) && + (ValueCell->DataSize & REG_DATA_SIZE_MASK) != 0) { - CmiDestroyBlock(RegistryHive, DataCell, ValueCell->DataOffset); + DataCell = CmiGetCell (RegistryHive, ValueCell->DataOffset, NULL); + CmiDestroyCell(RegistryHive, DataCell, ValueCell->DataOffset); ValueCell->DataSize = 0; ValueCell->DataType = 0; - ValueCell->DataOffset = 0xffffffff; + ValueCell->DataOffset = (BLOCK_OFFSET)-1; } - Status = CmiAllocateBlock(RegistryHive, + Status = CmiAllocateCell (RegistryHive, + sizeof(CELL_HEADER) + DataSize, (PVOID *)&NewDataCell, - DataSize, &NewOffset); if (!NT_SUCCESS(Status)) { @@ -1350,10 +1351,11 @@ NtSetValueKey(IN HANDLE KeyHandle, } RtlCopyMemory(&NewDataCell->Data[0], Data, DataSize); - ValueCell->DataSize = DataSize; + ValueCell->DataSize = DataSize & REG_DATA_SIZE_MASK; ValueCell->DataType = Type; ValueCell->DataOffset = NewOffset; CmiMarkBlockDirty(RegistryHive, ValueCell->DataOffset); + CmiMarkBlockDirty(RegistryHive, ValueCellOffset); } /* Mark link key */ @@ -1361,11 +1363,11 @@ NtSetValueKey(IN HANDLE KeyHandle, (Type == REG_LINK)) { KeyCell->Flags |= REG_KEY_LINK_CELL; - CmiMarkBlockDirty(RegistryHive, KeyObject->BlockOffset); + CmiMarkBlockDirty(RegistryHive, KeyObject->KeyCellOffset); } /* Update time of heap */ - if (!IsNoFileHive(RegistryHive) && CmiGetBlock(RegistryHive, VBOffset, &pBin)) + if (!IsNoFileHive(RegistryHive) && CmiGetCell (RegistryHive, ValueCellOffset, &pBin)) { NtQuerySystemTime(&pBin->DateModified); } @@ -1407,7 +1409,7 @@ NtDeleteValueKey (IN HANDLE KeyHandle, Status = CmiDeleteValueFromKey(KeyObject->RegistryHive, KeyObject->KeyCell, - KeyObject->BlockOffset, + KeyObject->KeyCellOffset, ValueName); /* Release hive lock */ @@ -1632,38 +1634,38 @@ NtQueryMultipleValueKey (IN HANDLE KeyHandle, BufferLength = (BufferLength + 3) & 0xfffffffc; - if (BufferLength + (ValueCell->DataSize & LONG_MAX) <= *Length) + if (BufferLength + (ValueCell->DataSize & REG_DATA_SIZE_MASK) <= *Length) { DataPtr = (PUCHAR)(((ULONG)DataPtr + 3) & 0xfffffffc); ValueList[i].Type = ValueCell->DataType; - ValueList[i].DataLength = ValueCell->DataSize & LONG_MAX; + ValueList[i].DataLength = ValueCell->DataSize & REG_DATA_SIZE_MASK; ValueList[i].DataOffset = (ULONG) DataPtr - (ULONG) Buffer; - if (ValueCell->DataSize > 0) + if (!(ValueCell->DataSize & REG_DATA_IN_OFFSET)) { - DataCell = CmiGetBlock(RegistryHive, + DataCell = CmiGetCell (RegistryHive, ValueCell->DataOffset, NULL); RtlCopyMemory(DataPtr, DataCell->Data, - ValueCell->DataSize & LONG_MAX); + ValueCell->DataSize & REG_DATA_SIZE_MASK); } else { RtlCopyMemory(DataPtr, &ValueCell->DataOffset, - ValueCell->DataSize & LONG_MAX); + ValueCell->DataSize & REG_DATA_SIZE_MASK); } - DataPtr += ValueCell->DataSize & LONG_MAX; + DataPtr += ValueCell->DataSize & REG_DATA_SIZE_MASK; } else { Status = STATUS_BUFFER_TOO_SMALL; } - BufferLength += ValueCell->DataSize & LONG_MAX; + BufferLength += ValueCell->DataSize & REG_DATA_SIZE_MASK; } if (NT_SUCCESS(Status)) diff --git a/reactos/ntoskrnl/cm/regfile.c b/reactos/ntoskrnl/cm/regfile.c index 392b4c42463..356a82ebc42 100644 --- a/reactos/ntoskrnl/cm/regfile.c +++ b/reactos/ntoskrnl/cm/regfile.c @@ -7,10 +7,9 @@ */ #include +#include #include #include -#include -#include #include #include #include @@ -53,7 +52,7 @@ CmiCreateDefaultHiveHeader(PHIVE_HEADER Header) Header->Unused5 = 0; Header->Unused6 = 1; Header->Unused7 = 1; - Header->RootKeyCell = 0; + Header->RootKeyOffset = (BLOCK_OFFSET)-1; Header->BlockSize = REG_BLOCK_SIZE; Header->Unused6 = 1; Header->Checksum = 0; @@ -85,7 +84,7 @@ CmiCreateDefaultRootKeyCell(PKEY_CELL RootKeyCell) RootKeyCell->NumberOfSubKeys = 0; RootKeyCell->HashTableOffset = -1; RootKeyCell->NumberOfValues = 0; - RootKeyCell->ValuesOffset = -1; + RootKeyCell->ValueListOffset = -1; RootKeyCell->SecurityKeyOffset = 0; RootKeyCell->ClassNameOffset = -1; RootKeyCell->NameSize = 0; @@ -385,7 +384,7 @@ CmiCreateNewRegFile(HANDLE FileHandle) BinCell->BlockOffset = 0; /* Offset to root key block */ - HiveHeader->RootKeyCell = REG_HBIN_DATA_OFFSET; + HiveHeader->RootKeyOffset = REG_HBIN_DATA_OFFSET; /* The rest of the block is free */ FreeCell->CellSize = REG_BLOCK_SIZE - (REG_HBIN_DATA_OFFSET + sizeof(KEY_CELL)); @@ -1089,7 +1088,7 @@ CmiCreateVolatileHive(PREGISTRY_HIVE *RegistryHive) } CmiCreateDefaultRootKeyCell (RootKeyCell); - Hive->HiveHeader->RootKeyCell = (BLOCK_OFFSET)RootKeyCell; + Hive->HiveHeader->RootKeyOffset = (BLOCK_OFFSET)RootKeyCell; ExInitializeResourceLite (&Hive->HiveResource); @@ -1195,7 +1194,7 @@ CmiCreateTempHive(PREGISTRY_HIVE *RegistryHive) BinCell->BlockOffset = 0; /* Offset to root key block */ - Hive->HiveHeader->RootKeyCell = -1; + Hive->HiveHeader->RootKeyOffset = (BLOCK_OFFSET)-1; /* The rest of the block is free */ FreeCell->CellSize = REG_BLOCK_SIZE - REG_HBIN_DATA_OFFSET; @@ -2014,8 +2013,8 @@ CmiGetMaxNameLength(PKEY_OBJECT KeyObject) VERIFY_KEY_CELL(KeyCell); MaxName = 0; - HashBlock = CmiGetBlock(KeyObject->RegistryHive, - KeyCell->HashTableOffset, + HashBlock = CmiGetCell (KeyObject->RegistryHive, + KeyCell->HashTableOffset, NULL); if (HashBlock == NULL) { @@ -2027,9 +2026,9 @@ CmiGetMaxNameLength(PKEY_OBJECT KeyObject) { if (HashBlock->Table[i].KeyOffset != 0) { - CurSubKeyCell = CmiGetBlock(KeyObject->RegistryHive, - HashBlock->Table[i].KeyOffset, - NULL); + CurSubKeyCell = CmiGetCell (KeyObject->RegistryHive, + HashBlock->Table[i].KeyOffset, + NULL); if (CurSubKeyCell == NULL) { DPRINT("CmiGetBlock() failed\n"); @@ -2094,8 +2093,8 @@ CmiGetMaxClassLength(PKEY_OBJECT KeyObject) VERIFY_KEY_CELL(KeyCell); MaxClass = 0; - HashBlock = CmiGetBlock(KeyObject->RegistryHive, - KeyCell->HashTableOffset, + HashBlock = CmiGetCell (KeyObject->RegistryHive, + KeyCell->HashTableOffset, NULL); if (HashBlock == NULL) { @@ -2107,9 +2106,9 @@ CmiGetMaxClassLength(PKEY_OBJECT KeyObject) { if (HashBlock->Table[i].KeyOffset != 0) { - CurSubKeyCell = CmiGetBlock(KeyObject->RegistryHive, - HashBlock->Table[i].KeyOffset, - NULL); + CurSubKeyCell = CmiGetCell (KeyObject->RegistryHive, + HashBlock->Table[i].KeyOffset, + NULL); if (CurSubKeyCell == NULL) { DPRINT("CmiGetBlock() failed\n"); @@ -2162,8 +2161,8 @@ CmiGetMaxValueNameLength(PREGISTRY_HIVE RegistryHive, VERIFY_KEY_CELL(KeyCell); MaxValueName = 0; - ValueListCell = CmiGetBlock(RegistryHive, - KeyCell->ValuesOffset, + ValueListCell = CmiGetCell (RegistryHive, + KeyCell->ValueListOffset, NULL); if (ValueListCell == NULL) { @@ -2173,9 +2172,9 @@ CmiGetMaxValueNameLength(PREGISTRY_HIVE RegistryHive, for (i = 0; i < KeyCell->NumberOfValues; i++) { - CurValueCell = CmiGetBlock (RegistryHive, - ValueListCell->Values[i], - NULL); + CurValueCell = CmiGetCell (RegistryHive, + ValueListCell->ValueOffset[i], + NULL); if (CurValueCell == NULL) { DPRINT("CmiGetBlock() failed\n"); @@ -2211,7 +2210,7 @@ CmiGetMaxValueDataLength(PREGISTRY_HIVE RegistryHive, VERIFY_KEY_CELL(KeyCell); MaxValueData = 0; - ValueListCell = CmiGetBlock(RegistryHive, KeyCell->ValuesOffset, NULL); + ValueListCell = CmiGetCell (RegistryHive, KeyCell->ValueListOffset, NULL); if (ValueListCell == NULL) { return 0; @@ -2219,12 +2218,12 @@ CmiGetMaxValueDataLength(PREGISTRY_HIVE RegistryHive, for (i = 0; i < KeyCell->NumberOfValues; i++) { - CurValueCell = CmiGetBlock(RegistryHive, - ValueListCell->Values[i],NULL); + CurValueCell = CmiGetCell (RegistryHive, + ValueListCell->ValueOffset[i],NULL); if ((CurValueCell != NULL) && - (MaxValueData < (CurValueCell->DataSize & LONG_MAX))) + (MaxValueData < (CurValueCell->DataSize & REG_DATA_SIZE_MASK))) { - MaxValueData = CurValueCell->DataSize & LONG_MAX; + MaxValueData = CurValueCell->DataSize & REG_DATA_SIZE_MASK; } } @@ -2260,7 +2259,7 @@ CmiScanForSubKey(IN PREGISTRY_HIVE RegistryHive, } /* Get hash table */ - HashBlock = CmiGetBlock(RegistryHive, KeyCell->HashTableOffset, NULL); + HashBlock = CmiGetCell (RegistryHive, KeyCell->HashTableOffset, NULL); if (HashBlock == NULL) { DPRINT("CmiGetBlock() failed\n"); @@ -2276,7 +2275,7 @@ CmiScanForSubKey(IN PREGISTRY_HIVE RegistryHive, (HashBlock->Table[i].HashValue == 0 || CmiCompareHashI(KeyName, (PCHAR)&HashBlock->Table[i].HashValue))) { - CurSubKeyCell = CmiGetBlock(RegistryHive, + CurSubKeyCell = CmiGetCell (RegistryHive, HashBlock->Table[i].KeyOffset, NULL); if (CurSubKeyCell == NULL) @@ -2300,7 +2299,7 @@ CmiScanForSubKey(IN PREGISTRY_HIVE RegistryHive, (HashBlock->Table[i].HashValue == 0 || CmiCompareHash(KeyName, (PCHAR)&HashBlock->Table[i].HashValue))) { - CurSubKeyCell = CmiGetBlock(RegistryHive, + CurSubKeyCell = CmiGetCell (RegistryHive, HashBlock->Table[i].KeyOffset, NULL); if (CurSubKeyCell == NULL) @@ -2338,6 +2337,7 @@ CmiAddSubKey(PREGISTRY_HIVE RegistryHive, PKEY_CELL NewKeyCell; ULONG NewBlockSize; PKEY_CELL KeyCell; + PDATA_CELL ClassCell; NTSTATUS Status; USHORT NameSize; PWSTR NamePtr; @@ -2382,9 +2382,9 @@ CmiAddSubKey(PREGISTRY_HIVE RegistryHive, Status = STATUS_SUCCESS; NewBlockSize = sizeof(KEY_CELL) + NameSize; - Status = CmiAllocateBlock(RegistryHive, - (PVOID) &NewKeyCell, + Status = CmiAllocateCell (RegistryHive, NewBlockSize, + (PVOID) &NewKeyCell, &NKBOffset); if (NewKeyCell == NULL) { @@ -2399,7 +2399,7 @@ CmiAddSubKey(PREGISTRY_HIVE RegistryHive, NewKeyCell->NumberOfSubKeys = 0; NewKeyCell->HashTableOffset = -1; NewKeyCell->NumberOfValues = 0; - NewKeyCell->ValuesOffset = -1; + NewKeyCell->ValueListOffset = -1; NewKeyCell->SecurityKeyOffset = -1; NewKeyCell->ClassNameOffset = -1; @@ -2422,19 +2422,16 @@ CmiAddSubKey(PREGISTRY_HIVE RegistryHive, VERIFY_KEY_CELL(NewKeyCell); - if (Class) + if (Class != NULL) { - PDATA_CELL pClass; - - NewKeyCell->ClassSize = Class->Length + sizeof(WCHAR); - Status = CmiAllocateBlock(RegistryHive, - (PVOID)&pClass, - NewKeyCell->ClassSize, + NewKeyCell->ClassSize = Class->Length; + Status = CmiAllocateCell (RegistryHive, + sizeof(CELL_HEADER) + NewKeyCell->ClassSize, + (PVOID)&ClassCell, &NewKeyCell->ClassNameOffset); - wcsncpy((PWSTR)pClass->Data, - Class->Buffer, - Class->Length); - ((PWSTR) (pClass->Data))[Class->Length] = 0; + RtlCopyMemory (ClassCell->Data, + Class->Buffer, + Class->Length); } } @@ -2444,7 +2441,7 @@ CmiAddSubKey(PREGISTRY_HIVE RegistryHive, } SubKey->KeyCell = NewKeyCell; - SubKey->BlockOffset = NKBOffset; + SubKey->KeyCellOffset = NKBOffset; /* Don't modify hash table if key is located in a pointer-based hive and parent key is not */ if (IsPointerHive(RegistryHive) && (!IsPointerHive(Parent->RegistryHive))) @@ -2454,7 +2451,7 @@ CmiAddSubKey(PREGISTRY_HIVE RegistryHive, if (KeyCell->HashTableOffset == (ULONG_PTR) -1) { - Status = CmiAllocateHashTableBlock(RegistryHive, + Status = CmiAllocateHashTableCell (RegistryHive, &HashBlock, &KeyCell->HashTableOffset, REG_INIT_HASH_TABLE_SIZE); @@ -2465,7 +2462,7 @@ CmiAddSubKey(PREGISTRY_HIVE RegistryHive, } else { - HashBlock = CmiGetBlock(RegistryHive, + HashBlock = CmiGetCell (RegistryHive, KeyCell->HashTableOffset, NULL); if (HashBlock == NULL) @@ -2478,8 +2475,8 @@ CmiAddSubKey(PREGISTRY_HIVE RegistryHive, { BLOCK_OFFSET HTOffset; - /* Reallocate the hash table block */ - Status = CmiAllocateHashTableBlock(RegistryHive, + /* Reallocate the hash table cell */ + Status = CmiAllocateHashTableCell (RegistryHive, &NewHashBlock, &HTOffset, HashBlock->HashTableSize + @@ -2494,7 +2491,7 @@ CmiAddSubKey(PREGISTRY_HIVE RegistryHive, RtlCopyMemory(&NewHashBlock->Table[0], &HashBlock->Table[0], sizeof(NewHashBlock->Table[0]) * HashBlock->HashTableSize); - CmiDestroyBlock(RegistryHive, + CmiDestroyCell (RegistryHive, HashBlock, KeyCell->HashTableOffset); KeyCell->HashTableOffset = HTOffset; @@ -2532,8 +2529,8 @@ CmiRemoveSubKey(PREGISTRY_HIVE RegistryHive, if (SubKey->KeyCell->NumberOfValues != 0) { /* Get pointer to the value list cell */ - ValueList = CmiGetBlock(RegistryHive, - SubKey->KeyCell->ValuesOffset, + ValueList = CmiGetCell (RegistryHive, + SubKey->KeyCell->ValueListOffset, NULL); if (ValueList == NULL) { @@ -2547,14 +2544,14 @@ CmiRemoveSubKey(PREGISTRY_HIVE RegistryHive, for (i = 0; i < SubKey->KeyCell->NumberOfValues; i++) { /* Get pointer to value cell */ - ValueCell = CmiGetBlock(RegistryHive, - ValueList->Values[i], + ValueCell = CmiGetCell (RegistryHive, + ValueList->ValueOffset[i], NULL); if (ValueCell != NULL) { - if (ValueCell->DataSize > 4) + if (ValueCell->DataSize > sizeof(BLOCK_OFFSET)) { - DataCell = CmiGetBlock(RegistryHive, + DataCell = CmiGetCell (RegistryHive, ValueCell->DataOffset, NULL); if (DataCell == NULL) @@ -2566,34 +2563,34 @@ CmiRemoveSubKey(PREGISTRY_HIVE RegistryHive, if (DataCell != NULL) { /* Destroy data cell */ - CmiDestroyBlock(RegistryHive, + CmiDestroyCell (RegistryHive, DataCell, ValueCell->DataOffset); } } /* Destroy value cell */ - CmiDestroyBlock(RegistryHive, + CmiDestroyCell (RegistryHive, ValueCell, - ValueList->Values[i]); + ValueList->ValueOffset[i]); } } } /* Destroy value list cell */ - CmiDestroyBlock(RegistryHive, + CmiDestroyCell (RegistryHive, ValueList, - SubKey->KeyCell->ValuesOffset); + SubKey->KeyCell->ValueListOffset); SubKey->KeyCell->NumberOfValues = 0; - SubKey->KeyCell->ValuesOffset = -1; + SubKey->KeyCell->ValueListOffset = (BLOCK_OFFSET)-1; } /* Remove the key from the parent key's hash block */ if (ParentKey->KeyCell->HashTableOffset != (BLOCK_OFFSET) -1) { DPRINT("ParentKey HashTableOffset %lx\n", ParentKey->KeyCell->HashTableOffset) - HashBlock = CmiGetBlock(ParentKey->RegistryHive, + HashBlock = CmiGetCell (ParentKey->RegistryHive, ParentKey->KeyCell->HashTableOffset, NULL); if (HashBlock == NULL) @@ -2606,7 +2603,7 @@ CmiRemoveSubKey(PREGISTRY_HIVE RegistryHive, { CmiRemoveKeyFromHashTable(ParentKey->RegistryHive, HashBlock, - SubKey->BlockOffset); + SubKey->KeyCellOffset); CmiMarkBlockDirty(ParentKey->RegistryHive, ParentKey->KeyCell->HashTableOffset); } @@ -2616,7 +2613,7 @@ CmiRemoveSubKey(PREGISTRY_HIVE RegistryHive, if (SubKey->KeyCell->HashTableOffset != (BLOCK_OFFSET) -1) { DPRINT("SubKey HashTableOffset %lx\n", SubKey->KeyCell->HashTableOffset) - HashBlock = CmiGetBlock(RegistryHive, + HashBlock = CmiGetCell (RegistryHive, SubKey->KeyCell->HashTableOffset, NULL); if (HashBlock == NULL) @@ -2627,7 +2624,7 @@ CmiRemoveSubKey(PREGISTRY_HIVE RegistryHive, DPRINT("SubKey HashBlock %p\n", HashBlock) if (HashBlock != NULL) { - CmiDestroyBlock(RegistryHive, + CmiDestroyCell (RegistryHive, HashBlock, SubKey->KeyCell->HashTableOffset); SubKey->KeyCell->HashTableOffset = -1; @@ -2644,7 +2641,7 @@ CmiRemoveSubKey(PREGISTRY_HIVE RegistryHive, if (ParentKey->KeyCell->NumberOfSubKeys == 0) { DPRINT("ParentKey HashTableOffset %lx\n", ParentKey->KeyCell->HashTableOffset) - HashBlock = CmiGetBlock(ParentKey->RegistryHive, + HashBlock = CmiGetCell (ParentKey->RegistryHive, ParentKey->KeyCell->HashTableOffset, NULL); if (HashBlock == NULL) @@ -2655,24 +2652,24 @@ CmiRemoveSubKey(PREGISTRY_HIVE RegistryHive, DPRINT("ParentKey HashBlock %p\n", HashBlock) if (HashBlock != NULL) { - CmiDestroyBlock(ParentKey->RegistryHive, + CmiDestroyCell (ParentKey->RegistryHive, HashBlock, ParentKey->KeyCell->HashTableOffset); - ParentKey->KeyCell->HashTableOffset = -1; + ParentKey->KeyCell->HashTableOffset = (BLOCK_OFFSET)-1; } } NtQuerySystemTime(&ParentKey->KeyCell->LastWriteTime); CmiMarkBlockDirty(ParentKey->RegistryHive, - ParentKey->BlockOffset); + ParentKey->KeyCellOffset); } /* Destroy key cell */ - CmiDestroyBlock(RegistryHive, + CmiDestroyCell (RegistryHive, SubKey->KeyCell, - SubKey->BlockOffset); - SubKey->BlockOffset = -1; + SubKey->KeyCellOffset); SubKey->KeyCell = NULL; + SubKey->KeyCellOffset = (BLOCK_OFFSET)-1; return(STATUS_SUCCESS); } @@ -2692,12 +2689,12 @@ CmiScanKeyForValue(IN PREGISTRY_HIVE RegistryHive, *ValueCell = NULL; /* The key does not have any values */ - if (KeyCell->ValuesOffset == (BLOCK_OFFSET)-1) + if (KeyCell->ValueListOffset == (BLOCK_OFFSET)-1) { return STATUS_SUCCESS; } - ValueListCell = CmiGetBlock(RegistryHive, KeyCell->ValuesOffset, NULL); + ValueListCell = CmiGetCell (RegistryHive, KeyCell->ValueListOffset, NULL); if (ValueListCell == NULL) { DPRINT("ValueListCell is NULL\n"); @@ -2708,8 +2705,8 @@ CmiScanKeyForValue(IN PREGISTRY_HIVE RegistryHive, for (i = 0; i < KeyCell->NumberOfValues; i++) { - CurValueCell = CmiGetBlock(RegistryHive, - ValueListCell->Values[i], + CurValueCell = CmiGetCell (RegistryHive, + ValueListCell->ValueOffset[i], NULL); if (CurValueCell == NULL) { @@ -2725,7 +2722,7 @@ CmiScanKeyForValue(IN PREGISTRY_HIVE RegistryHive, { *ValueCell = CurValueCell; if (VBOffset) - *VBOffset = ValueListCell->Values[i]; + *VBOffset = ValueListCell->ValueOffset[i]; //DPRINT("Found value %s\n", ValueName); break; } @@ -2746,7 +2743,7 @@ CmiGetValueFromKeyByIndex(IN PREGISTRY_HIVE RegistryHive, *ValueCell = NULL; - if (KeyCell->ValuesOffset == (BLOCK_OFFSET)-1) + if (KeyCell->ValueListOffset == (BLOCK_OFFSET)-1) { return STATUS_NO_MORE_ENTRIES; } @@ -2757,7 +2754,7 @@ CmiGetValueFromKeyByIndex(IN PREGISTRY_HIVE RegistryHive, } - ValueListCell = CmiGetBlock(RegistryHive, KeyCell->ValuesOffset, NULL); + ValueListCell = CmiGetCell (RegistryHive, KeyCell->ValueListOffset, NULL); if (ValueListCell == NULL) { DPRINT("CmiGetBlock() failed\n"); @@ -2767,8 +2764,8 @@ CmiGetValueFromKeyByIndex(IN PREGISTRY_HIVE RegistryHive, VERIFY_VALUE_LIST_CELL(ValueListCell); - CurValueCell = CmiGetBlock(RegistryHive, - ValueListCell->Values[Index], + CurValueCell = CmiGetCell (RegistryHive, + ValueListCell->ValueOffset[Index], NULL); if (CurValueCell == NULL) { @@ -2794,6 +2791,7 @@ CmiAddValueToKey(IN PREGISTRY_HIVE RegistryHive, PVALUE_CELL NewValueCell; BLOCK_OFFSET VLBOffset; BLOCK_OFFSET VBOffset; + ULONG CellSize; NTSTATUS Status; Status = CmiAllocateValueCell(RegistryHive, @@ -2805,31 +2803,34 @@ CmiAddValueToKey(IN PREGISTRY_HIVE RegistryHive, return Status; } - DPRINT("KeyCell->ValuesOffset %lu\n", (ULONG)KeyCell->ValuesOffset); + DPRINT("KeyCell->ValuesOffset %lu\n", (ULONG)KeyCell->ValueListOffset); - ValueListCell = CmiGetBlock(RegistryHive, KeyCell->ValuesOffset, NULL); + ValueListCell = CmiGetCell (RegistryHive, KeyCell->ValueListOffset, NULL); if (ValueListCell == NULL) { - Status = CmiAllocateBlock(RegistryHive, - (PVOID) &ValueListCell, - sizeof(BLOCK_OFFSET) * 3, - &VLBOffset); + CellSize = sizeof(VALUE_LIST_CELL) + + (3 * sizeof(BLOCK_OFFSET)); + Status = CmiAllocateCell (RegistryHive, + CellSize, + (PVOID) &ValueListCell, + &VLBOffset); if (!NT_SUCCESS(Status)) { CmiDestroyValueCell(RegistryHive, NewValueCell, VBOffset); return Status; } - KeyCell->ValuesOffset = VLBOffset; + KeyCell->ValueListOffset = VLBOffset; } else if (KeyCell->NumberOfValues >= - (((ULONG)ABS_VALUE(ValueListCell->CellSize) - 4) / sizeof(BLOCK_OFFSET))) + (((ULONG)ABS_VALUE(ValueListCell->CellSize) - sizeof(VALUE_LIST_CELL)) / sizeof(BLOCK_OFFSET))) { - Status = CmiAllocateBlock(RegistryHive, + CellSize = sizeof(VALUE_LIST_CELL) + + ((KeyCell->NumberOfValues + REG_VALUE_LIST_CELL_MULTIPLE) * sizeof(BLOCK_OFFSET)); + Status = CmiAllocateCell (RegistryHive, + CellSize, (PVOID) &NewValueListCell, - (KeyCell->NumberOfValues + REG_VALUE_LIST_CELL_MULTIPLE) * - sizeof(BLOCK_OFFSET), &VLBOffset); if (!NT_SUCCESS(Status)) { @@ -2837,21 +2838,21 @@ CmiAddValueToKey(IN PREGISTRY_HIVE RegistryHive, return Status; } - RtlCopyMemory(&NewValueListCell->Values[0], - &ValueListCell->Values[0], + RtlCopyMemory(&NewValueListCell->ValueOffset[0], + &ValueListCell->ValueOffset[0], sizeof(BLOCK_OFFSET) * KeyCell->NumberOfValues); - CmiDestroyBlock(RegistryHive, ValueListCell, KeyCell->ValuesOffset); - KeyCell->ValuesOffset = VLBOffset; + CmiDestroyCell (RegistryHive, ValueListCell, KeyCell->ValueListOffset); + KeyCell->ValueListOffset = VLBOffset; ValueListCell = NewValueListCell; } DPRINT("KeyCell->NumberOfValues %lu, ValueListCell->CellSize %lu (%lu %lx)\n", KeyCell->NumberOfValues, (ULONG)ABS_VALUE(ValueListCell->CellSize), - ((ULONG)ABS_VALUE(ValueListCell->CellSize) - 4) / sizeof(BLOCK_OFFSET), - ((ULONG)ABS_VALUE(ValueListCell->CellSize) - 4) / sizeof(BLOCK_OFFSET)); + ((ULONG)ABS_VALUE(ValueListCell->CellSize) - sizeof(VALUE_LIST_CELL)) / sizeof(BLOCK_OFFSET), + ((ULONG)ABS_VALUE(ValueListCell->CellSize) - sizeof(VALUE_LIST_CELL)) / sizeof(BLOCK_OFFSET)); - ValueListCell->Values[KeyCell->NumberOfValues] = VBOffset; + ValueListCell->ValueOffset[KeyCell->NumberOfValues] = VBOffset; KeyCell->NumberOfValues++; *pValueCell = NewValueCell; @@ -2871,7 +2872,7 @@ CmiDeleteValueFromKey(IN PREGISTRY_HIVE RegistryHive, PVALUE_CELL CurValueCell; ULONG i; - ValueListCell = CmiGetBlock(RegistryHive, KeyCell->ValuesOffset, NULL); + ValueListCell = CmiGetCell (RegistryHive, KeyCell->ValueListOffset, NULL); if (ValueListCell == NULL) { @@ -2883,7 +2884,7 @@ CmiDeleteValueFromKey(IN PREGISTRY_HIVE RegistryHive, for (i = 0; i < KeyCell->NumberOfValues; i++) { - CurValueCell = CmiGetBlock(RegistryHive, ValueListCell->Values[i], NULL); + CurValueCell = CmiGetCell (RegistryHive, ValueListCell->ValueOffset[i], NULL); if (CurValueCell == NULL) { DPRINT("CmiGetBlock() failed\n"); @@ -2896,17 +2897,17 @@ CmiDeleteValueFromKey(IN PREGISTRY_HIVE RegistryHive, CurValueCell->NameSize, CurValueCell->Flags & REG_VALUE_NAME_PACKED)) { - CmiDestroyValueCell(RegistryHive, CurValueCell, ValueListCell->Values[i]); + CmiDestroyValueCell(RegistryHive, CurValueCell, ValueListCell->ValueOffset[i]); if ((KeyCell->NumberOfValues - 1) < i) { - RtlCopyMemory(&ValueListCell->Values[i], - &ValueListCell->Values[i + 1], + RtlCopyMemory(&ValueListCell->ValueOffset[i], + &ValueListCell->ValueOffset[i + 1], sizeof(BLOCK_OFFSET) * (KeyCell->NumberOfValues - 1 - i)); } else { - RtlZeroMemory(&ValueListCell->Values[i], sizeof(BLOCK_OFFSET)); + RtlZeroMemory(&ValueListCell->ValueOffset[i], sizeof(BLOCK_OFFSET)); } KeyCell->NumberOfValues -= 1; @@ -2916,14 +2917,14 @@ CmiDeleteValueFromKey(IN PREGISTRY_HIVE RegistryHive, if (KeyCell->NumberOfValues == 0) { - CmiDestroyBlock(RegistryHive, + CmiDestroyCell (RegistryHive, ValueListCell, - KeyCell->ValuesOffset); + KeyCell->ValueListOffset); } else { CmiMarkBlockDirty(RegistryHive, - KeyCell->ValuesOffset); + KeyCell->ValueListOffset); } CmiMarkBlockDirty(RegistryHive, @@ -2934,7 +2935,7 @@ CmiDeleteValueFromKey(IN PREGISTRY_HIVE RegistryHive, NTSTATUS -CmiAllocateHashTableBlock(IN PREGISTRY_HIVE RegistryHive, +CmiAllocateHashTableCell (IN PREGISTRY_HIVE RegistryHive, OUT PHASH_TABLE_CELL *HashBlock, OUT BLOCK_OFFSET *HBOffset, IN ULONG HashTableSize) @@ -2947,9 +2948,9 @@ CmiAllocateHashTableBlock(IN PREGISTRY_HIVE RegistryHive, *HashBlock = NULL; NewHashSize = sizeof(HASH_TABLE_CELL) + (HashTableSize - 1) * sizeof(HASH_RECORD); - Status = CmiAllocateBlock(RegistryHive, - (PVOID*) &NewHashBlock, + Status = CmiAllocateCell (RegistryHive, NewHashSize, + (PVOID*) &NewHashBlock, HBOffset); if ((NewHashBlock == NULL) || (!NT_SUCCESS(Status))) @@ -2958,7 +2959,7 @@ CmiAllocateHashTableBlock(IN PREGISTRY_HIVE RegistryHive, } else { - NewHashBlock->Id = REG_HASH_TABLE_BLOCK_ID; + NewHashBlock->Id = REG_HASH_TABLE_CELL_ID; NewHashBlock->HashTableSize = HashTableSize; *HashBlock = NewHashBlock; } @@ -2985,7 +2986,7 @@ CmiGetKeyFromHashByIndex(PREGISTRY_HIVE RegistryHive, else { KeyOffset = HashBlock->Table[Index].KeyOffset; - KeyCell = CmiGetBlock(RegistryHive, KeyOffset, NULL); + KeyCell = CmiGetCell (RegistryHive, KeyOffset, NULL); } return KeyCell; @@ -3010,7 +3011,7 @@ CmiAddKeyToHashTable(PREGISTRY_HIVE RegistryHive, { RtlCopyMemory(&HashBlock->Table[i].HashValue, NewKeyCell->Name, - min(NewKeyCell->NameSize, 4)); + min(NewKeyCell->NameSize, sizeof(ULONG))); } return STATUS_SUCCESS; } @@ -3060,9 +3061,9 @@ CmiAllocateValueCell(PREGISTRY_HIVE RegistryHive, DPRINT("ValueName->Length %lu NameSize %lu\n", ValueName->Length, NameSize); - Status = CmiAllocateBlock(RegistryHive, - (PVOID*) &NewValueCell, + Status = CmiAllocateCell (RegistryHive, sizeof(VALUE_CELL) + NameSize, + (PVOID*) &NewValueCell, VBOffset); if ((NewValueCell == NULL) || (!NT_SUCCESS(Status))) { @@ -3111,16 +3112,16 @@ CmiDestroyValueCell(PREGISTRY_HIVE RegistryHive, VERIFY_VALUE_CELL(ValueCell); /* Destroy the data cell */ - if (ValueCell->DataSize > 4) + if (ValueCell->DataSize > sizeof(BLOCK_OFFSET)) { - pBlock = CmiGetBlock(RegistryHive, ValueCell->DataOffset, &pBin); + pBlock = CmiGetCell (RegistryHive, ValueCell->DataOffset, &pBin); if (pBlock == NULL) { DPRINT("CmiGetBlock() failed\n"); return STATUS_UNSUCCESSFUL; } - Status = CmiDestroyBlock(RegistryHive, pBlock, ValueCell->DataOffset); + Status = CmiDestroyCell (RegistryHive, pBlock, ValueCell->DataOffset); if (!NT_SUCCESS(Status)) { return Status; @@ -3132,10 +3133,10 @@ CmiDestroyValueCell(PREGISTRY_HIVE RegistryHive, } /* Destroy the value cell */ - Status = CmiDestroyBlock(RegistryHive, ValueCell, VBOffset); + Status = CmiDestroyCell (RegistryHive, ValueCell, VBOffset); /* Update time of heap */ - if (!IsNoFileHive(RegistryHive) && CmiGetBlock(RegistryHive, VBOffset, &pBin)) + if (!IsNoFileHive(RegistryHive) && CmiGetCell (RegistryHive, VBOffset, &pBin)) { NtQuerySystemTime(&pBin->DateModified); } @@ -3232,12 +3233,12 @@ CmiAddBin(PREGISTRY_HIVE RegistryHive, NTSTATUS -CmiAllocateBlock(PREGISTRY_HIVE RegistryHive, - PVOID *Block, - LONG BlockSize, - BLOCK_OFFSET * pBlockOffset) +CmiAllocateCell (PREGISTRY_HIVE RegistryHive, + LONG CellSize, + PVOID *Cell, + BLOCK_OFFSET *CellOffset) { - PCELL_HEADER NewBlock; + PCELL_HEADER NewCell; NTSTATUS Status; PHBIN pBin; ULONG i; @@ -3246,40 +3247,40 @@ CmiAllocateBlock(PREGISTRY_HIVE RegistryHive, Status = STATUS_SUCCESS; /* Round to 16 bytes multiple */ - BlockSize = (BlockSize + sizeof(DWORD) + 15) & 0xfffffff0; + CellSize = (CellSize + sizeof(DWORD) + 15) & 0xfffffff0; /* Handle volatile hives first */ if (IsPointerHive(RegistryHive)) { - NewBlock = ExAllocatePool(NonPagedPool, BlockSize); + NewCell = ExAllocatePool(NonPagedPool, CellSize); - if (NewBlock == NULL) + if (NewCell == NULL) { Status = STATUS_INSUFFICIENT_RESOURCES; } else { - RtlZeroMemory(NewBlock, BlockSize); - NewBlock->CellSize = BlockSize; - *Block = NewBlock; - if (pBlockOffset) - *pBlockOffset = (BLOCK_OFFSET) NewBlock; + RtlZeroMemory(NewCell, CellSize); + NewCell->CellSize = CellSize; + *Cell = NewCell; + if (CellOffset != NULL) + *CellOffset = (BLOCK_OFFSET) NewCell; } } else { /* first search in free blocks */ - NewBlock = NULL; + NewCell = NULL; for (i = 0; i < RegistryHive->FreeListSize; i++) { - if (RegistryHive->FreeList[i]->CellSize >= BlockSize) + if (RegistryHive->FreeList[i]->CellSize >= CellSize) { - NewBlock = RegistryHive->FreeList[i]; - if (pBlockOffset) - *pBlockOffset = RegistryHive->FreeListOffset[i]; + NewCell = RegistryHive->FreeList[i]; + if (CellOffset != NULL) + *CellOffset = RegistryHive->FreeListOffset[i]; /* Update time of heap */ - Temp = CmiGetBlock(RegistryHive, RegistryHive->FreeListOffset[i], &pBin); + Temp = CmiGetCell (RegistryHive, RegistryHive->FreeListOffset[i], &pBin); if (Temp == NULL) { DPRINT("CmiGetBlock() failed\n"); @@ -3309,35 +3310,35 @@ CmiAllocateBlock(PREGISTRY_HIVE RegistryHive, } /* Need to extend hive file : */ - if (NewBlock == NULL) + if (NewCell == NULL) { - /* Add a new block */ - Status = CmiAddBin(RegistryHive, (PVOID *) &NewBlock , pBlockOffset); + /* Add a new bin */ + Status = CmiAddBin(RegistryHive, (PVOID *) &NewCell , CellOffset); } if (NT_SUCCESS(Status)) { - *Block = NewBlock; + *Cell = NewCell; /* Split the block in two parts */ - if (NewBlock->CellSize > BlockSize) + if (NewCell->CellSize > CellSize) { - NewBlock = (PCELL_HEADER) ((ULONG_PTR) NewBlock+BlockSize); - NewBlock->CellSize = ((PCELL_HEADER) (*Block))->CellSize - BlockSize; + NewCell = (PCELL_HEADER) ((ULONG_PTR) NewCell + CellSize); + NewCell->CellSize = ((PCELL_HEADER) (*Cell))->CellSize - CellSize; CmiAddFree(RegistryHive, - NewBlock, - *pBlockOffset + BlockSize, + NewCell, + *CellOffset + CellSize, TRUE); CmiMarkBlockDirty(RegistryHive, - *pBlockOffset + BlockSize); + *CellOffset + CellSize); } - else if (NewBlock->CellSize < BlockSize) + else if (NewCell->CellSize < CellSize) { return(STATUS_UNSUCCESSFUL); } - RtlZeroMemory(*Block, BlockSize); - ((PCELL_HEADER) (*Block))->CellSize = -BlockSize; + RtlZeroMemory(*Cell, CellSize); + ((PCELL_HEADER) (*Cell))->CellSize = -CellSize; } } @@ -3346,9 +3347,9 @@ CmiAllocateBlock(PREGISTRY_HIVE RegistryHive, NTSTATUS -CmiDestroyBlock(PREGISTRY_HIVE RegistryHive, - PVOID Block, - BLOCK_OFFSET Offset) +CmiDestroyCell (PREGISTRY_HIVE RegistryHive, + PVOID Cell, + BLOCK_OFFSET CellOffset) { NTSTATUS Status; PHBIN pBin; @@ -3357,11 +3358,11 @@ CmiDestroyBlock(PREGISTRY_HIVE RegistryHive, if (IsPointerHive(RegistryHive)) { - ExFreePool(Block); + ExFreePool(Cell); } else { - PCELL_HEADER pFree = Block; + PCELL_HEADER pFree = Cell; if (pFree->CellSize < 0) pFree->CellSize = -pFree->CellSize; @@ -3371,19 +3372,63 @@ CmiDestroyBlock(PREGISTRY_HIVE RegistryHive, pFree->CellSize - sizeof(ULONG)); /* Add block to the list of free blocks */ - CmiAddFree(RegistryHive, Block, Offset, TRUE); + CmiAddFree(RegistryHive, Cell, CellOffset, TRUE); /* Update time of heap */ - if (!IsNoFileHive(RegistryHive) && CmiGetBlock(RegistryHive, Offset,&pBin)) + if (!IsNoFileHive(RegistryHive) && CmiGetCell (RegistryHive, CellOffset,&pBin)) NtQuerySystemTime(&pBin->DateModified); - CmiMarkBlockDirty(RegistryHive, Offset); + CmiMarkBlockDirty(RegistryHive, CellOffset); } return Status; } +PVOID +CmiGetCell (PREGISTRY_HIVE RegistryHive, + BLOCK_OFFSET CellOffset, + PHBIN * ppBin) +{ + PHBIN pBin; + + if (ppBin) + { + *ppBin = NULL; + } + + if (CellOffset == (BLOCK_OFFSET)-1) + { + return NULL; + } + + if (IsPointerHive (RegistryHive)) + { + return (PVOID)CellOffset; + } + + if (CellOffset > RegistryHive->BlockListSize * 4096) + { + DPRINT1("CellOffset exceeds valid range (%lu > %lu)\n", + CellOffset, RegistryHive->BlockListSize * 4096); + return NULL; + } + + pBin = RegistryHive->BlockList[CellOffset / 4096]; + if (pBin == NULL) + { + return NULL; + } + + if (ppBin) + { + *ppBin = pBin; + } + + return((PVOID)((ULONG_PTR)pBin + (CellOffset - pBin->BlockOffset))); +} + + static BOOLEAN CmiMergeFree(PREGISTRY_HIVE RegistryHive, PCELL_HEADER FreeBlock, @@ -3399,7 +3444,7 @@ CmiMergeFree(PREGISTRY_HIVE RegistryHive, DPRINT("CmiMergeFree(Block %lx Offset %lx Size %lx) called\n", FreeBlock, FreeOffset, FreeBlock->CellSize); - CmiGetBlock(RegistryHive, + CmiGetCell (RegistryHive, FreeOffset, &Bin); DPRINT("Bin %p\n", Bin); @@ -3589,41 +3634,6 @@ CmiAddFree(PREGISTRY_HIVE RegistryHive, } -PVOID -CmiGetBlock(PREGISTRY_HIVE RegistryHive, - BLOCK_OFFSET BlockOffset, - PHBIN * ppBin) -{ - PHBIN pBin; - - if (ppBin) - *ppBin = NULL; - - if (BlockOffset == (BLOCK_OFFSET)-1) - { - return NULL; - } - - if (IsPointerHive (RegistryHive)) - { - return (PVOID)BlockOffset; - } - else - { - if (BlockOffset > RegistryHive->BlockListSize * 4096) - { - DPRINT1("BlockOffset exceeds valid range (%lu > %lu)\n", - BlockOffset, RegistryHive->BlockListSize * 4096); - return NULL; - } - pBin = RegistryHive->BlockList[BlockOffset / 4096]; - if (ppBin) - *ppBin = pBin; - return((PVOID)((ULONG_PTR)pBin + (BlockOffset - pBin->BlockOffset))); - } -} - - VOID CmiMarkBlockDirty(PREGISTRY_HIVE RegistryHive, BLOCK_OFFSET BlockOffset) @@ -3640,7 +3650,7 @@ CmiMarkBlockDirty(PREGISTRY_HIVE RegistryHive, BlockNumber = (ULONG)BlockOffset / 4096; - Cell = CmiGetBlock(RegistryHive, + Cell = CmiGetCell (RegistryHive, BlockOffset, NULL); @@ -3894,10 +3904,10 @@ CmiCopyKey (PREGISTRY_HIVE DstHive, { /* Allocate and copy key cell */ NewKeyCellSize = sizeof(KEY_CELL) + SrcKeyCell->NameSize; - Status = CmiAllocateBlock (DstHive, - (PVOID) &NewKeyCell, - NewKeyCellSize, - &NewKeyCellOffset); + Status = CmiAllocateCell (DstHive, + NewKeyCellSize, + (PVOID) &NewKeyCell, + &NewKeyCellOffset); if (!NT_SUCCESS(Status)) { DPRINT1 ("CmiAllocateBlock() failed (Status %lx)\n", Status); @@ -3913,7 +3923,7 @@ CmiCopyKey (PREGISTRY_HIVE DstHive, SrcKeyCell, NewKeyCellSize); - DstHive->HiveHeader->RootKeyCell = NewKeyCellOffset; + DstHive->HiveHeader->RootKeyOffset = NewKeyCellOffset; /* Copy class name */ if (SrcKeyCell->ClassNameOffset != (BLOCK_OFFSET) -1) @@ -3922,13 +3932,13 @@ CmiCopyKey (PREGISTRY_HIVE DstHive, PDATA_CELL NewClassNameCell; BLOCK_OFFSET NewClassNameOffset; - SrcClassNameCell = CmiGetBlock (SrcHive, SrcKeyCell->ClassNameOffset, NULL), + SrcClassNameCell = CmiGetCell (SrcHive, SrcKeyCell->ClassNameOffset, NULL), NewKeyCell->ClassSize = SrcKeyCell->ClassSize; - Status = CmiAllocateBlock (DstHive, - (PVOID)&NewClassNameCell, - NewKeyCell->ClassSize, - &NewClassNameOffset); + Status = CmiAllocateCell (DstHive, + NewKeyCell->ClassSize, + (PVOID)&NewClassNameCell, + &NewClassNameOffset); if (!NT_SUCCESS(Status)) { DPRINT1 ("CmiAllocateBlock() failed (Status %lx)\n", Status); @@ -3950,10 +3960,10 @@ CmiCopyKey (PREGISTRY_HIVE DstHive, if (SrcKeyCell->NumberOfSubKeys > 0) { NewHashTableSize = ROUND_UP(SrcKeyCell->NumberOfSubKeys + 1, 4) - 1; - Status = CmiAllocateHashTableBlock (DstHive, - &NewHashTableCell, - &NewHashTableOffset, - NewHashTableSize); + Status = CmiAllocateHashTableCell (DstHive, + &NewHashTableCell, + &NewHashTableOffset, + NewHashTableSize); if (!NT_SUCCESS(Status)) { DPRINT1 ("CmiAllocateHashTableBlock() failed (Status %lx)\n", Status); @@ -3979,10 +3989,10 @@ CmiCopyKey (PREGISTRY_HIVE DstHive, NewValueListCellSize = ROUND_UP(SrcKeyCell->NumberOfValues, 4) * sizeof(BLOCK_OFFSET); - Status = CmiAllocateBlock (DstHive, - (PVOID)&NewValueListCell, - NewValueListCellSize, - &NewKeyCell->ValuesOffset); + Status = CmiAllocateCell (DstHive, + NewValueListCellSize, + (PVOID)&NewValueListCell, + &NewKeyCell->ValueListOffset); if (!NT_SUCCESS(Status)) { DPRINT1 ("CmiAllocateBlock() failed (Status %lx)\n", Status); @@ -3993,24 +4003,24 @@ CmiCopyKey (PREGISTRY_HIVE DstHive, NewValueListCellSize); /* Copy values */ - SrcValueListCell = CmiGetBlock (SrcHive, SrcKeyCell->ValuesOffset, NULL); + SrcValueListCell = CmiGetCell (SrcHive, SrcKeyCell->ValueListOffset, NULL); for (i = 0; i < SrcKeyCell->NumberOfValues; i++) { /* Copy value cell */ - SrcValueCell = CmiGetBlock (SrcHive, SrcValueListCell->Values[i], NULL); + SrcValueCell = CmiGetCell (SrcHive, SrcValueListCell->ValueOffset[i], NULL); NewValueCellSize = sizeof(VALUE_CELL) + SrcValueCell->NameSize; - Status = CmiAllocateBlock (DstHive, - (PVOID*) &NewValueCell, - NewValueCellSize, - &ValueCellOffset); + Status = CmiAllocateCell (DstHive, + NewValueCellSize, + (PVOID*) &NewValueCell, + &ValueCellOffset); if (!NT_SUCCESS(Status)) { DPRINT1 ("CmiAllocateBlock() failed (Status %lx)\n", Status); return Status; } - NewValueListCell->Values[i] = ValueCellOffset; + NewValueListCell->ValueOffset[i] = ValueCellOffset; RtlCopyMemory (NewValueCell, SrcValueCell, NewValueCellSize); @@ -4018,12 +4028,12 @@ CmiCopyKey (PREGISTRY_HIVE DstHive, /* Copy value data cell */ if (SrcValueCell->DataSize > (LONG) sizeof(PVOID)) { - SrcValueDataCell = CmiGetBlock (SrcHive, SrcValueCell->DataOffset, NULL); + SrcValueDataCell = CmiGetCell (SrcHive, SrcValueCell->DataOffset, NULL); - Status = CmiAllocateBlock (DstHive, - (PVOID*) &NewValueDataCell, - SrcValueCell->DataSize, - &ValueDataCellOffset); + Status = CmiAllocateCell (DstHive, + SrcValueCell->DataSize, + (PVOID*) &NewValueDataCell, + &ValueDataCellOffset); if (!NT_SUCCESS(Status)) { DPRINT1 ("CmiAllocateBlock() failed (Status %lx)\n", Status); @@ -4047,21 +4057,21 @@ CmiCopyKey (PREGISTRY_HIVE DstHive, BLOCK_OFFSET NewSubKeyCellOffset; PHASH_RECORD SrcHashRecord; - SrcHashTableCell = CmiGetBlock (SrcHive, - SrcKeyCell->HashTableOffset, - NULL); + SrcHashTableCell = CmiGetCell (SrcHive, + SrcKeyCell->HashTableOffset, + NULL); for (i = 0; i < SrcKeyCell->NumberOfSubKeys; i++) { SrcHashRecord = &SrcHashTableCell->Table[i]; - SrcSubKeyCell = CmiGetBlock (SrcHive, SrcHashRecord->KeyOffset, NULL); + SrcSubKeyCell = CmiGetCell (SrcHive, SrcHashRecord->KeyOffset, NULL); /* Allocate and copy key cell */ NewSubKeyCellSize = sizeof(KEY_CELL) + SrcSubKeyCell->NameSize; - Status = CmiAllocateBlock (DstHive, - (PVOID)&NewSubKeyCell, - NewSubKeyCellSize, - &NewSubKeyCellOffset); + Status = CmiAllocateCell (DstHive, + NewSubKeyCellSize, + (PVOID)&NewSubKeyCell, + &NewSubKeyCellOffset); if (!NT_SUCCESS(Status)) { DPRINT1 ("CmiAllocateBlock() failed (Status %lx)\n", Status); @@ -4087,15 +4097,15 @@ CmiCopyKey (PREGISTRY_HIVE DstHive, PDATA_CELL NewClassNameCell; BLOCK_OFFSET NewClassNameOffset; - SrcClassNameCell = CmiGetBlock (SrcHive, - SrcSubKeyCell->ClassNameOffset, - NULL), + SrcClassNameCell = CmiGetCell (SrcHive, + SrcSubKeyCell->ClassNameOffset, + NULL), NewSubKeyCell->ClassSize = SrcSubKeyCell->ClassSize; - Status = CmiAllocateBlock (DstHive, - (PVOID)&NewClassNameCell, - NewSubKeyCell->ClassSize, - &NewClassNameOffset); + Status = CmiAllocateCell (DstHive, + NewSubKeyCell->ClassSize, + (PVOID)&NewClassNameCell, + &NewClassNameOffset); if (!NT_SUCCESS(Status)) { DPRINT1 ("CmiAllocateBlock() failed (Status %lx)\n", Status); diff --git a/reactos/ntoskrnl/cm/registry.c b/reactos/ntoskrnl/cm/registry.c index 3a4b3a4089d..ae5cc9ec6d5 100644 --- a/reactos/ntoskrnl/cm/registry.c +++ b/reactos/ntoskrnl/cm/registry.c @@ -1,4 +1,4 @@ -/* $Id: registry.c,v 1.109 2003/10/07 14:08:43 ekohl Exp $ +/* $Id: registry.c,v 1.110 2003/10/10 21:55:16 ekohl Exp $ * * COPYRIGHT: See COPYING in the top level directory * PROJECT: ReactOS kernel @@ -13,9 +13,9 @@ #define NTOS_MODE_KERNEL #include -#include #include #include +#include #include #include #include @@ -310,8 +310,8 @@ CmInitializeRegistry(VOID) &RootKeyHandle); assert(NT_SUCCESS(Status)); RootKey->RegistryHive = CmiVolatileHive; - RootKey->BlockOffset = CmiVolatileHive->HiveHeader->RootKeyCell; - RootKey->KeyCell = CmiGetBlock(CmiVolatileHive, RootKey->BlockOffset, NULL); + RootKey->KeyCellOffset = CmiVolatileHive->HiveHeader->RootKeyOffset; + RootKey->KeyCell = CmiGetCell (CmiVolatileHive, RootKey->KeyCellOffset, NULL); RootKey->ParentKey = RootKey; RootKey->Flags = 0; RootKey->NumberOfSubKeys = 0; @@ -567,8 +567,8 @@ CmiConnectHive(IN POBJECT_ATTRIBUTES KeyObjectAttributes, } NewKey->RegistryHive = RegistryHive; - NewKey->BlockOffset = RegistryHive->HiveHeader->RootKeyCell; - NewKey->KeyCell = CmiGetBlock(RegistryHive, NewKey->BlockOffset, NULL); + NewKey->KeyCellOffset = RegistryHive->HiveHeader->RootKeyOffset; + NewKey->KeyCell = CmiGetCell (RegistryHive, NewKey->KeyCellOffset, NULL); NewKey->Flags = 0; NewKey->NumberOfSubKeys = 0; NewKey->SubKeys = ExAllocatePool(PagedPool, diff --git a/reactos/ntoskrnl/cm/regobj.c b/reactos/ntoskrnl/cm/regobj.c index 70838701ca4..be75552f972 100644 --- a/reactos/ntoskrnl/cm/regobj.c +++ b/reactos/ntoskrnl/cm/regobj.c @@ -8,10 +8,9 @@ #define NTOS_MODE_KERNEL #include +#include #include #include -#include -#include #include #include @@ -164,7 +163,7 @@ CmiObjectParse(PVOID ParsedObject, FoundObject->Flags = 0; FoundObject->KeyCell = SubKeyCell; - FoundObject->BlockOffset = BlockOffset; + FoundObject->KeyCellOffset = BlockOffset; FoundObject->RegistryHive = ParsedKey->RegistryHive; RtlCreateUnicodeString(&FoundObject->Name, KeyName.Buffer); @@ -552,7 +551,7 @@ CmiGetLinkTarget(PREGISTRY_HIVE RegistryHive, if (ValueCell->DataSize > 0) { - DataCell = CmiGetBlock(RegistryHive, ValueCell->DataOffset, NULL); + DataCell = CmiGetCell (RegistryHive, ValueCell->DataOffset, NULL); RtlCopyMemory(TargetPath->Buffer, DataCell->Data, TargetPath->Length); diff --git a/reactos/tools/mkhive/binhive.c b/reactos/tools/mkhive/binhive.c index 39f0c524e9e..fa91cf86df0 100644 --- a/reactos/tools/mkhive/binhive.c +++ b/reactos/tools/mkhive/binhive.c @@ -16,7 +16,7 @@ * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ -/* $Id: binhive.c,v 1.5 2003/07/30 21:22:51 royce Exp $ +/* $Id: binhive.c,v 1.6 2003/10/10 21:53:47 ekohl Exp $ * COPYRIGHT: See COPYING in the top level directory * PROJECT: ReactOS hive maker * FILE: tools/mkhive/binhive.c @@ -38,7 +38,7 @@ #define REG_HIVE_ID 0x66676572 #define REG_BIN_ID 0x6e696268 #define REG_KEY_CELL_ID 0x6b6e -#define REG_HASH_TABLE_BLOCK_ID 0x666c +#define REG_HASH_TABLE_CELL_ID 0x666c #define REG_VALUE_CELL_ID 0x6b76 #define REG_BLOCK_SIZE 4096 @@ -88,7 +88,7 @@ typedef struct _HIVE_HEADER /* Offset into file from the byte after the end of the base block. If the hive is volatile, this is the actual pointer to the KEY_CELL */ - BLOCK_OFFSET RootKeyCell; + BLOCK_OFFSET RootKeyOffset; /* Size of each hive block ? */ ULONG BlockSize; @@ -169,7 +169,7 @@ typedef struct _KEY_CELL ULONG NumberOfValues; /* Block offset of VALUE_LIST_CELL */ - BLOCK_OFFSET ValuesOffset; + BLOCK_OFFSET ValueListOffset; /* Block offset of security cell */ BLOCK_OFFSET SecurityKeyOffset; @@ -215,7 +215,7 @@ typedef struct _HASH_TABLE_CELL typedef struct _VALUE_LIST_CELL { LONG CellSize; - BLOCK_OFFSET Values[0]; + BLOCK_OFFSET ValueOffset[0]; } __attribute__((packed)) VALUE_LIST_CELL, *PVALUE_LIST_CELL; typedef struct _VALUE_CELL @@ -223,7 +223,7 @@ typedef struct _VALUE_CELL LONG CellSize; USHORT Id; // "kv" USHORT NameSize; // length of Name - LONG DataSize; // length of datas in the cell pointed by DataOffset + ULONG DataSize; // length of datas in the cell pointed by DataOffset BLOCK_OFFSET DataOffset;// datas are here if high bit of DataSize is set ULONG DataType; USHORT Flags; @@ -234,6 +234,9 @@ typedef struct _VALUE_CELL /* VALUE_CELL.Flags constants */ #define REG_VALUE_NAME_PACKED 0x0001 +/* VALUE_CELL.DataSize mask constants */ +#define REG_DATA_SIZE_MASK 0x7FFFFFFF +#define REG_DATA_IN_OFFSET 0x80000000 typedef struct _DATA_CELL { @@ -269,7 +272,7 @@ CmiCreateDefaultHiveHeader(PHIVE_HEADER Header) Header->Unused5 = 0; Header->Unused6 = 1; Header->Unused7 = 1; - Header->RootKeyCell = 0; + Header->RootKeyOffset = -1; Header->BlockSize = REG_BLOCK_SIZE; Header->Unused6 = 1; Header->Checksum = 0; @@ -300,7 +303,7 @@ CmiCreateDefaultRootKeyCell(PKEY_CELL RootKeyCell) RootKeyCell->NumberOfSubKeys = 0; RootKeyCell->HashTableOffset = -1; RootKeyCell->NumberOfValues = 0; - RootKeyCell->ValuesOffset = -1; + RootKeyCell->ValueListOffset = -1; RootKeyCell->SecurityKeyOffset = 0; RootKeyCell->ClassNameOffset = -1; RootKeyCell->NameSize = 0; @@ -386,7 +389,7 @@ CmiCreateRegistryHive (VOID) /* Init root key cell */ RootKeyCell = (PKEY_CELL)((ULONG_PTR)BinCell + REG_HBIN_DATA_OFFSET); CmiCreateDefaultRootKeyCell(RootKeyCell); - Hive->HiveHeader->RootKeyCell = REG_HBIN_DATA_OFFSET; + Hive->HiveHeader->RootKeyOffset = REG_HBIN_DATA_OFFSET; /* Init free cell */ FreeCell = (PCELL_HEADER)((ULONG_PTR)RootKeyCell + sizeof(KEY_CELL)); @@ -449,7 +452,7 @@ CmiDestroyRegistryHive (PREGISTRY_HIVE Hive) static PVOID -CmiGetBlock(PREGISTRY_HIVE Hive, +CmiGetCell (PREGISTRY_HIVE Hive, BLOCK_OFFSET BlockOffset, PHBIN * ppBin) { @@ -489,7 +492,7 @@ CmiMergeFree(PREGISTRY_HIVE RegistryHive, DPRINT("CmiMergeFree(Block %lx Offset %lx Size %lx) called\n", FreeBlock, FreeOffset, FreeBlock->CellSize); - CmiGetBlock(RegistryHive, + CmiGetCell (RegistryHive, FreeOffset, &Bin); DPRINT("Bin %p\n", Bin); @@ -729,7 +732,7 @@ CmiAddBin(PREGISTRY_HIVE RegistryHive, static BOOL -CmiAllocateBlock(PREGISTRY_HIVE RegistryHive, +CmiAllocateCell (PREGISTRY_HIVE RegistryHive, PVOID *Block, LONG BlockSize, PBLOCK_OFFSET pBlockOffset) @@ -813,16 +816,16 @@ CmiAllocateHashTableCell (PREGISTRY_HIVE Hive, NewHashSize = ROUND_UP(sizeof(HASH_TABLE_CELL) + (SubKeyCount - 1) * sizeof(HASH_RECORD), 0x10); - Status = CmiAllocateBlock (Hive, - (PVOID*) &HashCell, - NewHashSize, - HBOffset); + Status = CmiAllocateCell (Hive, + (PVOID*) &HashCell, + NewHashSize, + HBOffset); if ((HashCell == NULL) || (Status == FALSE)) { return FALSE; } - HashCell->Id = REG_HASH_TABLE_BLOCK_ID; + HashCell->Id = REG_HASH_TABLE_CELL_ID; HashCell->HashTableSize = SubKeyCount; return TRUE; @@ -839,18 +842,18 @@ CmiAddKeyToParentHashTable (PREGISTRY_HIVE Hive, PKEY_CELL ParentKeyCell; ULONG i; - ParentKeyCell = CmiGetBlock (Hive, - ParentKeyOffset, - NULL); + ParentKeyCell = CmiGetCell (Hive, + ParentKeyOffset, + NULL); if (ParentKeyCell == NULL) { DPRINT1 ("CmiGetBlock() failed\n"); return FALSE; } - HashBlock =CmiGetBlock (Hive, - ParentKeyCell->HashTableOffset, - NULL); + HashBlock =CmiGetCell (Hive, + ParentKeyCell->HashTableOffset, + NULL); if (HashBlock == NULL) { DPRINT1 ("CmiGetBlock() failed\n"); @@ -885,10 +888,10 @@ CmiAllocateValueListCell (PREGISTRY_HIVE Hive, ValueListSize = ROUND_UP (ValueCount * sizeof(BLOCK_OFFSET), 0x10); - Status = CmiAllocateBlock (Hive, - (PVOID)&ValueListCell, - ValueListSize, - ValueListOffset); + Status = CmiAllocateCell (Hive, + (PVOID)&ValueListCell, + ValueListSize, + ValueListOffset); if ((ValueListCell == NULL) || (Status == FALSE)) { DPRINT1 ("CmiAllocateBlock() failed\n"); @@ -910,7 +913,7 @@ CmiAllocateValueCell(PREGISTRY_HIVE Hive, BOOL Status; NameSize = (ValueName == NULL) ? 0 : strlen (ValueName); - Status = CmiAllocateBlock(Hive, + Status = CmiAllocateCell (Hive, (PVOID*)&NewValueCell, sizeof(VALUE_CELL) + NameSize, ValueCellOffset); @@ -947,21 +950,21 @@ CmiAddValueToKeyValueList(PREGISTRY_HIVE Hive, PVALUE_LIST_CELL ValueListCell; PKEY_CELL KeyCell; - KeyCell = CmiGetBlock (Hive, KeyCellOffset, NULL); + KeyCell = CmiGetCell (Hive, KeyCellOffset, NULL); if (KeyCell == NULL) { DPRINT1 ("CmiGetBlock() failed\n"); return FALSE; } - ValueListCell = CmiGetBlock (Hive, KeyCell->ValuesOffset, NULL); + ValueListCell = CmiGetCell (Hive, KeyCell->ValueListOffset, NULL); if (ValueListCell == NULL) { DPRINT1 ("CmiGetBlock() failed\n"); return FALSE; } - ValueListCell->Values[KeyCell->NumberOfValues] = ValueCellOffset; + ValueListCell->ValueOffset[KeyCell->NumberOfValues] = ValueCellOffset; KeyCell->NumberOfValues++; return TRUE; @@ -1032,9 +1035,9 @@ CmiExportValue (PREGISTRY_HIVE Hive, Expand = TRUE; } - if (DstDataSize <= sizeof(BLOCK_OFFSET)) + if ((DstDataSize & REG_DATA_SIZE_MASK) <= sizeof(BLOCK_OFFSET)) { - ValueCell->DataSize = DstDataSize | 0x80000000; + ValueCell->DataSize = DstDataSize | REG_DATA_IN_OFFSET; ValueCell->DataType = DataType; if (Expand) { @@ -1051,16 +1054,16 @@ CmiExportValue (PREGISTRY_HIVE Hive, } else { - if (!CmiAllocateBlock (Hive, - (PVOID *)&DataCell, - DstDataSize, - &DataCellOffset)) + if (!CmiAllocateCell (Hive, + (PVOID *)&DataCell, + DstDataSize, + &DataCellOffset)) { return FALSE; } ValueCell->DataOffset = DataCellOffset; - ValueCell->DataSize = DstDataSize; + ValueCell->DataSize = DstDataSize & REG_DATA_SIZE_MASK; ValueCell->DataType = DataType; if (Expand) @@ -1113,7 +1116,7 @@ CmiExportSubKey (PREGISTRY_HIVE Hive, /* Allocate key cell */ KeyCellSize = sizeof(KEY_CELL) + Key->NameSize - 1; - if (!CmiAllocateBlock (Hive, (PVOID)&NewKeyCell, KeyCellSize, &NKBOffset)) + if (!CmiAllocateCell (Hive, (PVOID)&NewKeyCell, KeyCellSize, &NKBOffset)) { DPRINT1 ("CmiAllocateBlock() failed\n"); return FALSE; @@ -1127,7 +1130,7 @@ CmiExportSubKey (PREGISTRY_HIVE Hive, NewKeyCell->NumberOfSubKeys = 0; NewKeyCell->HashTableOffset = -1; NewKeyCell->NumberOfValues = 0; - NewKeyCell->ValuesOffset = -1; + NewKeyCell->ValueListOffset = -1; NewKeyCell->SecurityKeyOffset = -1; NewKeyCell->NameSize = Key->NameSize - 1; NewKeyCell->ClassNameOffset = -1; @@ -1151,7 +1154,7 @@ CmiExportSubKey (PREGISTRY_HIVE Hive, { /* Allocate value list cell */ CmiAllocateValueListCell (Hive, - &NewKeyCell->ValuesOffset, + &NewKeyCell->ValueListOffset, ValueCount); if (Key->DataSize != 0) @@ -1242,9 +1245,9 @@ CmiExportHive (PREGISTRY_HIVE Hive, DPRINT ("Name: %s\n", KeyName); - KeyCell = CmiGetBlock (Hive, - Hive->HiveHeader->RootKeyCell, - NULL); + KeyCell = CmiGetCell (Hive, + Hive->HiveHeader->RootKeyOffset, + NULL); if (KeyCell == NULL) { DPRINT1 ("CmiGetBlock() failed\n"); @@ -1257,12 +1260,12 @@ CmiExportHive (PREGISTRY_HIVE Hive, { /* Allocate value list cell */ CmiAllocateValueListCell (Hive, - &KeyCell->ValuesOffset, + &KeyCell->ValueListOffset, ValueCount); if (Key->DataSize != 0) { - if (!CmiExportValue (Hive, Hive->HiveHeader->RootKeyCell, Key, NULL)) + if (!CmiExportValue (Hive, Hive->HiveHeader->RootKeyOffset, Key, NULL)) return FALSE; } @@ -1274,7 +1277,7 @@ CmiExportHive (PREGISTRY_HIVE Hive, VALUE, ValueList); - if (!CmiExportValue (Hive, Hive->HiveHeader->RootKeyCell, Key, Value)) + if (!CmiExportValue (Hive, Hive->HiveHeader->RootKeyOffset, Key, Value)) return FALSE; Entry = Entry->Flink; @@ -1298,7 +1301,7 @@ CmiExportHive (PREGISTRY_HIVE Hive, KEY, KeyList); - if (!CmiExportSubKey (Hive, Hive->HiveHeader->RootKeyCell, Key, SubKey)) + if (!CmiExportSubKey (Hive, Hive->HiveHeader->RootKeyOffset, Key, SubKey)) return FALSE; Entry = Entry->Flink;