Ros-diffs July 2006

ros-diffs@reactos.org

19 participants
662 discussions

[greatlrd] 23340: adding more and find to livecd and bootcd
by greatlrd＠svn.reactos.org 28 Jul '06

28 Jul '06

Author: greatlrd Date: Sat Jul 29 01:05:48 2006 New Revision: 23340 URL: http://svn.reactos.org/svn/reactos?rev=23340&view=rev Log: adding more and find to livecd and bootcd Modified: trunk/reactos/boot/bootdata/packages/reactos.dff Modified: trunk/reactos/boot/bootdata/packages/reactos.dff URL: http://svn.reactos.org/svn/reactos/trunk/reactos/boot/bootdata/packages/rea… ============================================================================== --- trunk/reactos/boot/bootdata/packages/reactos.dff (original) +++ trunk/reactos/boot/bootdata/packages/reactos.dff Sat Jul 29 01:05:48 2006 @@ -31,6 +31,8 @@ ; Base files base\applications\cacls\cacls.exe 1 base\applications\calc\calc.exe 1 +base\rosapps\cmdutils\find\find.exe 1 +base\rosapps\cmdutils\more\more.exe 1 base\applications\control\control.exe 1 base\applications\devmgr\devmgrapp.exe 1 base\applications\games\solitaire\sol.exe 1 @@ -410,9 +412,7 @@ modules\vms\server\vmssrv.dll 1 optional modules\vms\dll\win32\vmsdll\vmsdll.dll 1 optional modules\rosapps\cmdutils\comp\comp.exe 1 optional -modules\rosapps\cmdutils\find\find.exe 1 optional modules\rosapps\cmdutils\mode\mode.exe 1 optional -modules\rosapps\cmdutils\more\more.exe 1 optional modules\rosapps\cmdutils\sort\sort.exe 1 optional modules\rosapps\cmdutils\tee\tee.exe 1 optional modules\rosapps\cmdutils\touch\touch.exe 1 optional

1 0

[greatlrd] 23339: building more and find
by greatlrd＠svn.reactos.org 28 Jul '06

28 Jul '06

Author: greatlrd Date: Sat Jul 29 01:04:25 2006 New Revision: 23339 URL: http://svn.reactos.org/svn/reactos?rev=23339&view=rev Log: building more and find Modified: trunk/reactos/base/applications/applications.rbuild trunk/reactos/base/applications/cmdutils/cmdutils.xml Modified: trunk/reactos/base/applications/applications.rbuild URL: http://svn.reactos.org/svn/reactos/trunk/reactos/base/applications/applicat… ============================================================================== --- trunk/reactos/base/applications/applications.rbuild (original) +++ trunk/reactos/base/applications/applications.rbuild Sat Jul 29 01:04:25 2006 @@ -6,6 +6,9 @@ </directory> <directory name="calc"> <xi:include href="calc/calc.rbuild" /> +</directory> +<directory name="cmdutils"> + <xi:include href="cmdutils/cmdutils.xml" /> </directory> <directory name="devmgr"> <xi:include href="devmgr/devmgr.rbuild" /> Modified: trunk/reactos/base/applications/cmdutils/cmdutils.xml URL: http://svn.reactos.org/svn/reactos/trunk/reactos/base/applications/cmdutils… ============================================================================== --- trunk/reactos/base/applications/cmdutils/cmdutils.xml (original) +++ trunk/reactos/base/applications/cmdutils/cmdutils.xml Sat Jul 29 01:04:25 2006 @@ -1,7 +1,4 @@ <group> -<directory name="comp"> - <xi:include href="comp/comp.xml" /> -</directory> <directory name="find"> <xi:include href="find/find.xml" /> </directory> @@ -11,16 +8,4 @@ <directory name="more"> <xi:include href="more/more.xml" /> </directory> -<directory name="sort"> - <xi:include href="sort/sort.xml" /> -</directory> -<directory name="tee"> - <xi:include href="tee/tee.xml" /> -</directory> -<directory name="touch"> - <xi:include href="touch/touch.xml" /> -</directory> -<directory name="y"> - <xi:include href="y/y.xml" /> -</directory> </group>

1 0

[greatlrd] 23338: making rosapps build again
by greatlrd＠svn.reactos.org 28 Jul '06

28 Jul '06

Author: greatlrd Date: Sat Jul 29 01:00:14 2006 New Revision: 23338 URL: http://svn.reactos.org/svn/reactos?rev=23338&view=rev Log: making rosapps build again Modified: trunk/rosapps/cmdutils/cmdutils.xml Modified: trunk/rosapps/cmdutils/cmdutils.xml URL: http://svn.reactos.org/svn/reactos/trunk/rosapps/cmdutils/cmdutils.xml?rev=… ============================================================================== --- trunk/rosapps/cmdutils/cmdutils.xml (original) +++ trunk/rosapps/cmdutils/cmdutils.xml Sat Jul 29 01:00:14 2006 @@ -2,14 +2,8 @@ <directory name="comp"> <xi:include href="comp/comp.xml" /> </directory> -<directory name="find"> - <xi:include href="find/find.xml" /> -</directory> <directory name="mode"> <xi:include href="mode/mode.xml" /> -</directory> -<directory name="more"> - <xi:include href="more/more.xml" /> </directory> <directory name="sort"> <xi:include href="sort/sort.xml" />

1 0

[greatlrd] 23337: copy cmdutils.rbuild
by greatlrd＠svn.reactos.org 28 Jul '06

28 Jul '06

Author: greatlrd Date: Sat Jul 29 00:57:04 2006 New Revision: 23337 URL: http://svn.reactos.org/svn/reactos?rev=23337&view=rev Log: copy cmdutils.rbuild Added: trunk/reactos/base/applications/cmdutils/cmdutils.xml - copied unchanged from r23336, trunk/rosapps/cmdutils/cmdutils.xml

1 0

[fireball] 23336: Actually add cmlib itself
by fireball＠svn.reactos.org 28 Jul '06

28 Jul '06

Author: fireball Date: Sat Jul 29 00:50:05 2006 New Revision: 23336 URL: http://svn.reactos.org/svn/reactos?rev=23336&view=rev Log: Actually add cmlib itself Added: trunk/reactos/lib/cmlib/ trunk/reactos/lib/cmlib/cmdata.h trunk/reactos/lib/cmlib/cminit.c trunk/reactos/lib/cmlib/cmlib.h trunk/reactos/lib/cmlib/cmlib.mak trunk/reactos/lib/cmlib/cmlib.rbuild trunk/reactos/lib/cmlib/hivebin.c trunk/reactos/lib/cmlib/hivecell.c trunk/reactos/lib/cmlib/hivedata.h trunk/reactos/lib/cmlib/hiveinit.c trunk/reactos/lib/cmlib/hivesum.c trunk/reactos/lib/cmlib/hivewrt.c Added: trunk/reactos/lib/cmlib/cmdata.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/lib/cmlib/cmdata.h?rev=233… ============================================================================== --- trunk/reactos/lib/cmlib/cmdata.h (added) +++ trunk/reactos/lib/cmlib/cmdata.h Sat Jul 29 00:50:05 2006 @@ -1,0 +1,134 @@ +/* + * PROJECT: registry manipulation library + * LICENSE: GPL - See COPYING in the top level directory + * COPYRIGHT: Copyright 2005 Filip Navara <navaraf(a)reactos.org> + * Copyright 2001 - 2005 Eric Kohl + */ + +#ifndef CMLIB_CMDATA_H +#define CMLIB_CMDATA_H + +#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_CELL_ID 0x666c +#define REG_VALUE_CELL_ID 0x6b76 +#define REG_SECURITY_CELL_ID 0x6b73 + +#include <pshpack1.h> + +typedef struct _KEY_CELL +{ + /* Key cell identifier "kn" (0x6b6e) */ + USHORT Id; + + /* Flags */ + USHORT Flags; + + /* Time of last flush */ + LARGE_INTEGER LastWriteTime; + + /* ? */ + ULONG UnUsed1; + + /* Block offset of parent key cell */ + HCELL_INDEX ParentKeyOffset; + + /* Count of sub keys for the key in this key cell (stable & volatile) */ + ULONG NumberOfSubKeys[HvMaxStorageType]; + + /* Block offset of has table for FIXME: subkeys/values? (stable & volatile) */ + HCELL_INDEX HashTableOffset[HvMaxStorageType]; + + /* Count of values contained in this key cell */ + ULONG NumberOfValues; + + /* Block offset of VALUE_LIST_CELL */ + HCELL_INDEX ValueListOffset; + + /* Block offset of security cell */ + HCELL_INDEX SecurityKeyOffset; + + /* Block offset of registry key class */ + HCELL_INDEX ClassNameOffset; + + /* ? */ + ULONG Unused4[5]; + + /* Size in bytes of key name */ + USHORT NameSize; + + /* Size of class name in bytes */ + USHORT ClassSize; + + /* Name of key (not zero terminated) */ + UCHAR Name[0]; +} KEY_CELL, *PKEY_CELL; + +/* KEY_CELL.Flags constants */ +#define REG_KEY_VOLATILE_CELL 0x01 +#define REG_KEY_ROOT_CELL 0x0C +#define REG_KEY_LINK_CELL 0x10 +#define REG_KEY_NAME_PACKED 0x20 + +/* + * Hash record + * + * HashValue: + * packed name: four letters of value's name + * otherwise: Zero! + */ +typedef struct _HASH_RECORD +{ + HCELL_INDEX KeyOffset; + ULONG HashValue; +} HASH_RECORD, *PHASH_RECORD; + +typedef struct _HASH_TABLE_CELL +{ + USHORT Id; + USHORT HashTableSize; + HASH_RECORD Table[0]; +} HASH_TABLE_CELL, *PHASH_TABLE_CELL; + +typedef struct _VALUE_LIST_CELL +{ + HCELL_INDEX ValueOffset[0]; +} VALUE_LIST_CELL, *PVALUE_LIST_CELL; + +typedef struct _VALUE_CELL +{ + USHORT Id; // "kv" + USHORT NameSize; // length of Name + ULONG DataSize; // length of datas in the cell pointed by DataOffset + HCELL_INDEX DataOffset;// datas are here if high bit of DataSize is set + ULONG DataType; + USHORT Flags; + USHORT Unused1; + UCHAR Name[0]; /* warning : not zero terminated */ +} VALUE_CELL, *PVALUE_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 _SECURITY_CELL +{ + USHORT Id; // "sk" + USHORT Reserved; + HCELL_INDEX PrevSecurityCell; + HCELL_INDEX NextSecurityCell; + ULONG RefCount; + ULONG SdSize; + UCHAR Data[0]; +} SECURITY_CELL, *PSECURITY_CELL; + +#include <poppack.h> + +#endif /* CMLIB_CMDATA_H */ Added: trunk/reactos/lib/cmlib/cminit.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/lib/cmlib/cminit.c?rev=233… ============================================================================== --- trunk/reactos/lib/cmlib/cminit.c (added) +++ trunk/reactos/lib/cmlib/cminit.c Sat Jul 29 00:50:05 2006 @@ -1,0 +1,82 @@ +/* + * PROJECT: registry manipulation library + * LICENSE: GPL - See COPYING in the top level directory + * COPYRIGHT: Copyright 2005 Filip Navara <navaraf(a)reactos.org> + * Copyright 2001 - 2005 Eric Kohl + */ + +#include "cmlib.h" + +BOOLEAN CMAPI +CmCreateRootNode( + PREGISTRY_HIVE Hive, + PCWSTR Name) +{ + PKEY_CELL KeyCell; + HCELL_INDEX RootCellIndex; + ULONG NameSize; + + NameSize = wcslen(Name) * sizeof(WCHAR); + RootCellIndex = HvAllocateCell(Hive, sizeof(KEY_CELL) + NameSize, HvStable); + if (RootCellIndex == HCELL_NULL) + return FALSE; + + Hive->HiveHeader->RootCell = RootCellIndex; + Hive->HiveHeader->Checksum = HvpHiveHeaderChecksum(Hive->HiveHeader); + + KeyCell = (PKEY_CELL)HvGetCell(Hive, RootCellIndex); + KeyCell->Id = REG_KEY_CELL_ID; + KeyCell->Flags = REG_KEY_ROOT_CELL; + KeyCell->LastWriteTime.QuadPart = 0; + KeyCell->ParentKeyOffset = HCELL_NULL; + KeyCell->NumberOfSubKeys[0] = 0; + KeyCell->NumberOfSubKeys[1] = 0; + KeyCell->HashTableOffset[0] = HCELL_NULL; + KeyCell->HashTableOffset[1] = HCELL_NULL; + KeyCell->NumberOfValues = 0; + KeyCell->ValueListOffset = HCELL_NULL; + KeyCell->SecurityKeyOffset = HCELL_NULL; + KeyCell->ClassNameOffset = HCELL_NULL; + KeyCell->NameSize = NameSize; + KeyCell->ClassSize = 0; + memcpy(KeyCell->Name, Name, NameSize); + + return TRUE; +} + +static VOID CMAPI +CmpPrepareKey( + PREGISTRY_HIVE RegistryHive, + PKEY_CELL KeyCell) +{ + PKEY_CELL SubKeyCell; + PHASH_TABLE_CELL HashCell; + ULONG i; + + ASSERT(KeyCell->Id == REG_KEY_CELL_ID); + + KeyCell->HashTableOffset[HvVolatile] = HCELL_NULL; + KeyCell->NumberOfSubKeys[HvVolatile] = 0; + + /* Enumerate and add subkeys */ + if (KeyCell->NumberOfSubKeys[HvStable] > 0) + { + HashCell = HvGetCell(RegistryHive, KeyCell->HashTableOffset[HvStable]); + + for (i = 0; i < KeyCell->NumberOfSubKeys[HvStable]; i++) + { + SubKeyCell = HvGetCell(RegistryHive, HashCell->Table[i].KeyOffset); + CmpPrepareKey(RegistryHive, SubKeyCell); + } + } +} + +VOID CMAPI +CmPrepareHive( + PREGISTRY_HIVE RegistryHive) +{ + PKEY_CELL RootCell; + + RootCell = HvGetCell(RegistryHive, RegistryHive->HiveHeader->RootCell); + CmpPrepareKey(RegistryHive, RootCell); +} Added: trunk/reactos/lib/cmlib/cmlib.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/lib/cmlib/cmlib.h?rev=2333… ============================================================================== --- trunk/reactos/lib/cmlib/cmlib.h (added) +++ trunk/reactos/lib/cmlib/cmlib.h Sat Jul 29 00:50:05 2006 @@ -1,0 +1,175 @@ +/* + * PROJECT: registry manipulation library + * LICENSE: GPL - See COPYING in the top level directory + * COPYRIGHT: Copyright 2005 Filip Navara <navaraf(a)reactos.org> + * Copyright 2001 - 2005 Eric Kohl + */ + +#ifndef CMLIB_H +#define CMLIB_H + +#include <ddk/ntddk.h> +#include "hivedata.h" +#include "cmdata.h" + +#ifndef ROUND_UP +#define ROUND_UP(a,b) ((((a)+(b)-1)/(b))*(b)) +#define ROUND_DOWN(a,b) (((a)/(b))*(b)) +#endif + +#define CMAPI + +typedef struct _BLOCK_LIST_ENTRY +{ + PHBIN Bin; + PVOID Block; +} BLOCK_LIST_ENTRY, *PBLOCK_LIST_ENTRY; + +struct _REGISTRY_HIVE; + +typedef PVOID (CMAPI *PHV_ALLOCATE)( + ULONG Size, + BOOLEAN Paged); + +typedef VOID (CMAPI *PHV_FREE)( + PVOID Ptr); + +typedef BOOLEAN (CMAPI *PHV_FILE_READ)( + struct _REGISTRY_HIVE *RegistryHive, + ULONG FileType, + ULONG FileOffset, + PVOID Buffer, + ULONG BufferLength); + +typedef BOOLEAN (CMAPI *PHV_FILE_WRITE)( + struct _REGISTRY_HIVE *RegistryHive, + ULONG FileType, + ULONG FileOffset, + PVOID Buffer, + ULONG BufferLength); + +typedef BOOLEAN (CMAPI *PHV_FILE_SET_SIZE)( + struct _REGISTRY_HIVE *RegistryHive, + ULONG FileType, + ULONG FileSize); + +typedef BOOLEAN (CMAPI *PHV_FILE_FLUSH)( + struct _REGISTRY_HIVE *RegistryHive, + ULONG FileType); + +typedef struct _REGISTRY_HIVE +{ + PHIVE_HEADER HiveHeader; + BOOLEAN ReadOnly; + BOOLEAN Flat; + RTL_BITMAP DirtyBitmap; + struct + { + ULONG BlockListSize; + PBLOCK_LIST_ENTRY BlockList; + HCELL_INDEX FreeListOffset[24]; + } Storage[HvMaxStorageType]; + + PHV_ALLOCATE Allocate; + PHV_FREE Free; + PHV_FILE_READ FileRead; + PHV_FILE_WRITE FileWrite; + PHV_FILE_SET_SIZE FileSetSize; + PHV_FILE_FLUSH FileFlush; + PVOID Opaque; +} REGISTRY_HIVE, *PREGISTRY_HIVE; + +/* + * Public functions. + */ + +#define HV_OPERATION_CREATE_HIVE 1 +#define HV_OPERATION_MEMORY 2 +#define HV_OPERATION_MEMORY_INPLACE 3 + +NTSTATUS CMAPI +HvInitialize( + PREGISTRY_HIVE *RegistryHive, + ULONG Operation, + ULONG_PTR ChunkBase, + SIZE_T ChunkSize, + PHV_ALLOCATE Allocate, + PHV_FREE Free, + PHV_FILE_READ FileRead, + PHV_FILE_WRITE FileWrite, + PHV_FILE_SET_SIZE FileSetSize, + PHV_FILE_FLUSH FileFlush, + PVOID Opaque); + +VOID CMAPI +HvFree( + PREGISTRY_HIVE RegistryHive); + +PVOID CMAPI +HvGetCell( + PREGISTRY_HIVE RegistryHive, + HCELL_INDEX CellOffset); + +LONG CMAPI +HvGetCellSize( + PREGISTRY_HIVE RegistryHive, + PVOID Cell); + +HCELL_INDEX CMAPI +HvAllocateCell( + PREGISTRY_HIVE RegistryHive, + ULONG Size, + HV_STORAGE_TYPE Storage); + +HCELL_INDEX CMAPI +HvReallocateCell( + PREGISTRY_HIVE RegistryHive, + HCELL_INDEX CellOffset, + ULONG Size); + +VOID CMAPI +HvFreeCell( + PREGISTRY_HIVE RegistryHive, + HCELL_INDEX CellOffset); + +VOID CMAPI +HvMarkCellDirty( + PREGISTRY_HIVE RegistryHive, + HCELL_INDEX CellOffset); + +BOOLEAN CMAPI +HvSyncHive( + PREGISTRY_HIVE RegistryHive); + +BOOLEAN CMAPI +HvWriteHive( + PREGISTRY_HIVE RegistryHive); + +BOOLEAN CMAPI +CmCreateRootNode( + PREGISTRY_HIVE Hive, + PCWSTR Name); + +VOID CMAPI +CmPrepareHive( + PREGISTRY_HIVE RegistryHive); + +/* + * Private functions. + */ + +PHBIN CMAPI +HvpAddBin( + PREGISTRY_HIVE RegistryHive, + ULONG Size, + HV_STORAGE_TYPE Storage); + +NTSTATUS CMAPI +HvpCreateHiveFreeCellList( + PREGISTRY_HIVE Hive); + +ULONG CMAPI +HvpHiveHeaderChecksum( + PHIVE_HEADER HiveHeader); + +#endif /* CMLIB_H */ Added: trunk/reactos/lib/cmlib/cmlib.mak URL: http://svn.reactos.org/svn/reactos/trunk/reactos/lib/cmlib/cmlib.mak?rev=23… ============================================================================== --- trunk/reactos/lib/cmlib/cmlib.mak (added) +++ trunk/reactos/lib/cmlib/cmlib.mak Sat Jul 29 00:50:05 2006 @@ -1,0 +1,55 @@ +CMLIB_BASE = $(LIB_BASE_)cmlib +CMLIB_BASE_ = $(CMLIB_BASE)$(SEP) +CMLIB_INT = $(INTERMEDIATE_)$(CMLIB_BASE)_host +CMLIB_INT_ = $(INTERMEDIATE_)$(CMLIB_BASE)_host$(SEP) +CMLIB_OUT = $(OUTPUT_)$(CMLIB_BASE)_host +CMLIB_OUT_ = $(OUTPUT_)$(CMLIB_BASE)_host$(SEP) + +$(CMLIB_INT): | $(LIB_INT) + $(ECHO_MKDIR) + ${mkdir} $@ + +ifneq ($(INTERMEDIATE),$(OUTPUT)) +$(CMLIB_OUT): | $(OUTPUT_)$(LIB_BASE) + $(ECHO_MKDIR) + ${mkdir} $@ +endif + +CMLIB_HOST_TARGET = \ + $(CMLIB_OUT)$(SEP)cmlib.a + +CMLIB_HOST_SOURCES = $(addprefix $(CMLIB_BASE_), \ + hivebin.c \ + hivecell.c \ + hiveinit.c \ + ) + +CMLIB_HOST_OBJECTS = \ + $(subst $(CMLIB_BASE), $(CMLIB_INT), $(CMLIB_HOST_SOURCES:.c=.o)) + +CMLIB_HOST_CFLAGS = -O3 -Wall -Wwrite-strings -Wpointer-arith -Wconversion \ + -DCMLIB_HOST -D_M_IX86 -I$(CMLIB_BASE) -Iinclude/reactos -DDBG + +$(CMLIB_HOST_TARGET): $(CMLIB_HOST_OBJECTS) | $(CMLIB_OUT) + $(ECHO_AR) + $(host_ar) -r $@ $(CMLIB_HOST_OBJECTS) + +$(CMLIB_INT_)hivebin.o: $(CMLIB_BASE_)hivebin.c | $(CMLIB_INT) + $(ECHO_CC) + ${host_gcc} $(CMLIB_HOST_CFLAGS) -c $< -o $@ + +$(CMLIB_INT_)hivecell.o: $(CMLIB_BASE_)hivecell.c | $(CMLIB_INT) + $(ECHO_CC) + ${host_gcc} $(CMLIB_HOST_CFLAGS) -c $< -o $@ + +$(CMLIB_INT_)hiveinit.o: $(CMLIB_BASE_)hiveinit.c | $(CMLIB_INT) + $(ECHO_CC) + ${host_gcc} $(CMLIB_HOST_CFLAGS) -c $< -o $@ + +.PHONY: cmlib_host +cmlib_host: $(CMLIB_HOST_TARGET) + +.PHONY: cmlib_host_clean +cmlib_host_clean: + -@$(rm) $(CMLIB_HOST_TARGET) $(CMLIB_HOST_OBJECTS) 2>$(NUL) +clean: cmlib_host_clean Added: trunk/reactos/lib/cmlib/cmlib.rbuild URL: http://svn.reactos.org/svn/reactos/trunk/reactos/lib/cmlib/cmlib.rbuild?rev… ============================================================================== --- trunk/reactos/lib/cmlib/cmlib.rbuild (added) +++ trunk/reactos/lib/cmlib/cmlib.rbuild Sat Jul 29 00:50:05 2006 @@ -1,0 +1,14 @@ +<module name="cmlib" type="staticlibrary"> + <include base="cmlib">.</include> + <define name="__NO_CTYPE_INLINES" /> + <define name="_NTOSKRNL_" /> + <define name="_NTSYSTEM_" /> + <define name="NASSERT" /> + <pch>cmlib.h</pch> + <file>cminit.c</file> + <file>hivebin.c</file> + <file>hivecell.c</file> + <file>hiveinit.c</file> + <file>hivesum.c</file> + <file>hivewrt.c</file> +</module> Added: trunk/reactos/lib/cmlib/hivebin.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/lib/cmlib/hivebin.c?rev=23… ============================================================================== --- trunk/reactos/lib/cmlib/hivebin.c (added) +++ trunk/reactos/lib/cmlib/hivebin.c Sat Jul 29 00:50:05 2006 @@ -1,0 +1,98 @@ +/* + * PROJECT: registry manipulation library + * LICENSE: GPL - See COPYING in the top level directory + * COPYRIGHT: Copyright 2005 Filip Navara <navaraf(a)reactos.org> + * Copyright 2005 Hartmut Birr + * Copyright 2001 - 2005 Eric Kohl + */ + +#include "cmlib.h" + +PHBIN CMAPI +HvpAddBin( + PREGISTRY_HIVE RegistryHive, + ULONG Size, + HV_STORAGE_TYPE Storage) +{ + PBLOCK_LIST_ENTRY BlockList; + PHBIN Bin; + ULONG BinSize; + ULONG i; + ULONG BitmapSize; + ULONG BlockCount; + ULONG OldBlockListSize; + PCELL_HEADER Block; + + BinSize = ROUND_UP(Size + sizeof(HBIN), HV_BLOCK_SIZE); + BlockCount = BinSize / HV_BLOCK_SIZE; + + Bin = RegistryHive->Allocate(BinSize, TRUE); + if (Bin == NULL) + return NULL; + RtlZeroMemory(Bin, sizeof(HBIN)); + + Bin->Signature = HV_BIN_SIGNATURE; + Bin->BinOffset = RegistryHive->Storage[Storage].BlockListSize * + HV_BLOCK_SIZE; + Bin->BinSize = BinSize; + + /* Allocate new block list */ + OldBlockListSize = RegistryHive->Storage[Storage].BlockListSize; + BlockList = RegistryHive->Allocate(sizeof(BLOCK_LIST_ENTRY) * + (OldBlockListSize + BlockCount), TRUE); + if (BlockList == NULL) + { + RegistryHive->Free(Bin); + return NULL; + } + + if (OldBlockListSize > 0) + { + RtlCopyMemory(BlockList, RegistryHive->Storage[Storage].BlockList, + OldBlockListSize * sizeof(BLOCK_LIST_ENTRY)); + RegistryHive->Free(RegistryHive->Storage[Storage].BlockList); + } + + RegistryHive->Storage[Storage].BlockList = BlockList; + RegistryHive->Storage[Storage].BlockListSize += BlockCount; + + for (i = 0; i < BlockCount; i++) + { + RegistryHive->Storage[Storage].BlockList[OldBlockListSize + i].Block = + (PVOID)((ULONG_PTR)Bin + (i * HV_BLOCK_SIZE)); + RegistryHive->Storage[Storage].BlockList[OldBlockListSize + i].Bin = Bin; + } + + /* Initialize a free block in this heap. */ + Block = (PCELL_HEADER)(Bin + 1); + Block->CellSize = BinSize - sizeof(HBIN); + + if (Storage == HvStable) + { + /* Calculate bitmap size in bytes (always a multiple of 32 bits). */ + BitmapSize = ROUND_UP(RegistryHive->Storage[HvStable].BlockListSize, + sizeof(ULONG) * 8) / 8; + + /* Grow bitmap if necessary. */ + if (BitmapSize > RegistryHive->DirtyBitmap.SizeOfBitMap / 8) + { + PULONG BitmapBuffer; + + BitmapBuffer = RegistryHive->Allocate(BitmapSize, TRUE); + RtlZeroMemory(BitmapBuffer, BitmapSize); + RtlCopyMemory(BitmapBuffer, + RegistryHive->DirtyBitmap.Buffer, + RegistryHive->DirtyBitmap.SizeOfBitMap / 8); + RegistryHive->Free(RegistryHive->DirtyBitmap.Buffer); + RtlInitializeBitMap(&RegistryHive->DirtyBitmap, BitmapBuffer, + BitmapSize * 8); + } + + /* Mark new bin dirty. */ + RtlSetBits(&RegistryHive->DirtyBitmap, + Bin->BinOffset / HV_BLOCK_SIZE, + BlockCount); + } + + return Bin; +} Added: trunk/reactos/lib/cmlib/hivecell.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/lib/cmlib/hivecell.c?rev=2… ============================================================================== --- trunk/reactos/lib/cmlib/hivecell.c (added) +++ trunk/reactos/lib/cmlib/hivecell.c Sat Jul 29 00:50:05 2006 @@ -1,0 +1,429 @@ +/* + * PROJECT: registry manipulation library + * LICENSE: GPL - See COPYING in the top level directory + * COPYRIGHT: Copyright 2005 Filip Navara <navaraf(a)reactos.org> + * Copyright 2001 - 2005 Eric Kohl + */ + +#include "cmlib.h" +#define NDEBUG +#include <debug.h> + +static PCELL_HEADER __inline CMAPI +HvpGetCellHeader( + PREGISTRY_HIVE RegistryHive, + HCELL_INDEX CellIndex) +{ + PVOID Block; + + ASSERT(CellIndex != HCELL_NULL); + if (!RegistryHive->Flat) + { + ULONG CellType; + ULONG CellBlock; + ULONG CellOffset; + + CellType = (CellIndex & HCELL_TYPE_MASK) >> HCELL_TYPE_SHIFT; + CellBlock = (CellIndex & HCELL_BLOCK_MASK) >> HCELL_BLOCK_SHIFT; + CellOffset = (CellIndex & HCELL_OFFSET_MASK) >> HCELL_OFFSET_SHIFT; + ASSERT(CellBlock < RegistryHive->Storage[CellType].BlockListSize); + Block = RegistryHive->Storage[CellType].BlockList[CellBlock].Block; + ASSERT(Block != NULL); + return (PVOID)((ULONG_PTR)Block + CellOffset); + } + else + { + ASSERT((CellIndex & HCELL_TYPE_MASK) == HvStable); + return (PVOID)((ULONG_PTR)RegistryHive->HiveHeader + HV_BLOCK_SIZE + + CellIndex); + } +} + +PVOID CMAPI +HvGetCell( + PREGISTRY_HIVE RegistryHive, + HCELL_INDEX CellIndex) +{ + return (PVOID)(HvpGetCellHeader(RegistryHive, CellIndex) + 1); +} + +static LONG __inline CMAPI +HvpGetCellFullSize( + PREGISTRY_HIVE RegistryHive, + PVOID Cell) +{ + return ((PCELL_HEADER)Cell - 1)->CellSize; +} + +LONG CMAPI +HvGetCellSize( + PREGISTRY_HIVE RegistryHive, + PVOID Cell) +{ + PCELL_HEADER CellHeader; + + CellHeader = (PCELL_HEADER)Cell - 1; + if (CellHeader->CellSize < 0) + return CellHeader->CellSize + sizeof(CELL_HEADER); + else + return CellHeader->CellSize - sizeof(CELL_HEADER); +} + +VOID CMAPI +HvMarkCellDirty( + PREGISTRY_HIVE RegistryHive, + HCELL_INDEX CellIndex) +{ + LONG CellSize; + ULONG CellBlock; + ULONG CellLastBlock; + + ASSERT(RegistryHive->ReadOnly == FALSE); + + if ((CellIndex & HCELL_TYPE_MASK) >> HCELL_TYPE_SHIFT != HvStable) + return; + + CellBlock = (CellIndex & HCELL_BLOCK_MASK) >> HCELL_BLOCK_SHIFT; + CellLastBlock = ((CellIndex + HV_BLOCK_SIZE - 1) & HCELL_BLOCK_MASK) >> HCELL_BLOCK_SHIFT; + + CellSize = HvpGetCellFullSize(RegistryHive, HvGetCell(RegistryHive, CellIndex)); + if (CellSize < 0) + CellSize = -CellSize; + + RtlSetBits(&RegistryHive->DirtyBitmap, + CellBlock, CellLastBlock - CellBlock); +} + +static ULONG __inline CMAPI +HvpComputeFreeListIndex( + ULONG Size) +{ + ULONG Index; + static CCHAR FindFirstSet[256] = { + 0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7}; + + Index = (Size >> 3) - 1; + if (Index >= 16) + { + if (Index > 255) + Index = 23; + else + Index = FindFirstSet[Index] + 7; + } + + return Index; +} + +static NTSTATUS CMAPI +HvpAddFree( + PREGISTRY_HIVE RegistryHive, + PCELL_HEADER FreeBlock, + HCELL_INDEX FreeIndex) +{ + PHCELL_INDEX FreeBlockData; + HV_STORAGE_TYPE Storage; + ULONG Index; + + ASSERT(RegistryHive != NULL); + ASSERT(FreeBlock != NULL); + + Storage = (FreeIndex & HCELL_TYPE_MASK) >> HCELL_TYPE_SHIFT; + Index = HvpComputeFreeListIndex(FreeBlock->CellSize); + + FreeBlockData = (PHCELL_INDEX)(FreeBlock + 1); + *FreeBlockData = RegistryHive->Storage[Storage].FreeListOffset[Index]; + RegistryHive->Storage[Storage].FreeListOffset[Index] = FreeIndex; + + /* FIXME: Eventually get rid of free bins. */ + + return STATUS_SUCCESS; +} + +static VOID CMAPI +HvpRemoveFree( + PREGISTRY_HIVE RegistryHive, + PCELL_HEADER CellBlock, + HCELL_INDEX CellIndex) +{ + PHCELL_INDEX FreeCellData; + PHCELL_INDEX pFreeCellOffset; + HV_STORAGE_TYPE Storage; + ULONG Index; + + ASSERT(RegistryHive->ReadOnly == FALSE); + + Storage = (CellIndex & HCELL_TYPE_MASK) >> HCELL_TYPE_SHIFT; + Index = HvpComputeFreeListIndex(CellBlock->CellSize); + + pFreeCellOffset = &RegistryHive->Storage[Storage].FreeListOffset[Index]; + while (*pFreeCellOffset != HCELL_NULL) + { + FreeCellData = (PHCELL_INDEX)HvGetCell(RegistryHive, *pFreeCellOffset); + if (*pFreeCellOffset == CellIndex) + { + *pFreeCellOffset = *FreeCellData; + return; + } + pFreeCellOffset = FreeCellData; + } + + ASSERT(FALSE); +} + +static HCELL_INDEX CMAPI +HvpFindFree( + PREGISTRY_HIVE RegistryHive, + ULONG Size, + HV_STORAGE_TYPE Storage) +{ + PHCELL_INDEX FreeCellData; + HCELL_INDEX FreeCellOffset; + PHCELL_INDEX pFreeCellOffset; + ULONG Index; + + for (Index = HvpComputeFreeListIndex(Size); Index < 24; Index++) + { + pFreeCellOffset = &RegistryHive->Storage[Storage].FreeListOffset[Index]; + while (*pFreeCellOffset != HCELL_NULL) + { + FreeCellData = (PHCELL_INDEX)HvGetCell(RegistryHive, *pFreeCellOffset); + if (HvpGetCellFullSize(RegistryHive, FreeCellData) >= Size) + { + FreeCellOffset = *pFreeCellOffset; + *pFreeCellOffset = *FreeCellData; + return FreeCellOffset; + } + pFreeCellOffset = FreeCellData; + } + } + + return HCELL_NULL; +} + +NTSTATUS CMAPI +HvpCreateHiveFreeCellList( + PREGISTRY_HIVE Hive) +{ + HCELL_INDEX BlockOffset; + PCELL_HEADER FreeBlock; + ULONG BlockIndex; + ULONG FreeOffset; + PHBIN Bin; + NTSTATUS Status; + ULONG Index; + + /* Initialize the free cell list */ + for (Index = 0; Index < 24; Index++) + { + Hive->Storage[HvStable].FreeListOffset[Index] = HCELL_NULL; + Hive->Storage[HvVolatile].FreeListOffset[Index] = HCELL_NULL; + } + + BlockOffset = 0; + BlockIndex = 0; + while (BlockIndex < Hive->Storage[HvStable].BlockListSize) + { + Bin = Hive->Storage[HvStable].BlockList[BlockIndex].Bin; + + /* Search free blocks and add to list */ + FreeOffset = sizeof(HBIN); + while (FreeOffset < Bin->BinSize) + { + FreeBlock = (PCELL_HEADER)((ULONG_PTR)Bin + FreeOffset); + if (FreeBlock->CellSize > 0) + { + Status = HvpAddFree(Hive, FreeBlock, Bin->BinOffset + FreeOffset); + if (!NT_SUCCESS(Status)) + return Status; + + FreeOffset += FreeBlock->CellSize; + } + else + { + FreeOffset -= FreeBlock->CellSize; + } + } + + BlockIndex += Bin->BinSize / HV_BLOCK_SIZE; + BlockOffset += Bin->BinSize; + } + + return STATUS_SUCCESS; +} + +HCELL_INDEX CMAPI +HvAllocateCell( + PREGISTRY_HIVE RegistryHive, + ULONG Size, + HV_STORAGE_TYPE Storage) +{ + PCELL_HEADER FreeCell; + HCELL_INDEX FreeCellOffset; + PCELL_HEADER NewCell; + PHBIN Bin; + + ASSERT(RegistryHive->ReadOnly == FALSE); + + /* Round to 16 bytes multiple. */ + Size = ROUND_UP(Size + sizeof(CELL_HEADER), 16); + + /* First search in free blocks. */ + FreeCellOffset = HvpFindFree(RegistryHive, Size, Storage); + + /* If no free cell was found we need to extend the hive file. */ + if (FreeCellOffset == HCELL_NULL) + { + Bin = HvpAddBin(RegistryHive, Size, Storage); + if (Bin == NULL) + return HCELL_NULL; + FreeCellOffset = Bin->BinOffset + sizeof(HBIN); + FreeCellOffset |= Storage << HCELL_TYPE_SHIFT; + } + + FreeCell = HvpGetCellHeader(RegistryHive, FreeCellOffset); + + /* Split the block in two parts */ + /* FIXME: There is some minimal cell size that we must respect. */ + if (FreeCell->CellSize > Size + sizeof(HCELL_INDEX)) + { + NewCell = (PCELL_HEADER)((ULONG_PTR)FreeCell + Size); + NewCell->CellSize = FreeCell->CellSize - Size; + FreeCell->CellSize = Size; + HvpAddFree(RegistryHive, NewCell, FreeCellOffset + Size); + if (Storage == HvStable) + HvMarkCellDirty(RegistryHive, FreeCellOffset + Size); + } + + if (Storage == HvStable) + HvMarkCellDirty(RegistryHive, FreeCellOffset); + FreeCell->CellSize = -FreeCell->CellSize; + RtlZeroMemory(FreeCell + 1, Size - sizeof(CELL_HEADER)); + + return FreeCellOffset; +} + +HCELL_INDEX CMAPI +HvReallocateCell( + PREGISTRY_HIVE RegistryHive, + HCELL_INDEX CellIndex, + ULONG Size) +{ + PVOID OldCell; + PVOID NewCell; + LONG OldCellSize; + HCELL_INDEX NewCellIndex; + HV_STORAGE_TYPE Storage; + + ASSERT(CellIndex != HCELL_NULL); + + Storage = (CellIndex & HCELL_TYPE_MASK) >> HCELL_TYPE_SHIFT; + + OldCell = HvGetCell(RegistryHive, CellIndex); + OldCellSize = HvGetCellSize(RegistryHive, OldCell); + ASSERT(OldCellSize < 0); + + /* + * If new data size is larger than the current, destroy current + * data block and allocate a new one. + * + * FIXME: Merge with adjacent free cell if possible. + * FIXME: Implement shrinking. + */ + if (Size > -OldCellSize) + { + NewCellIndex = HvAllocateCell(RegistryHive, Size, Storage); + if (NewCellIndex == HCELL_NULL) + return HCELL_NULL; + + NewCell = HvGetCell(RegistryHive, NewCellIndex); + RtlCopyMemory(NewCell, OldCell, -OldCellSize); + + HvFreeCell(RegistryHive, CellIndex); + + return NewCellIndex; + } + + return CellIndex; +} + +VOID CMAPI +HvFreeCell( + PREGISTRY_HIVE RegistryHive, + HCELL_INDEX CellIndex) +{ + PCELL_HEADER Free; + PCELL_HEADER Neighbor; + PHBIN Bin; + ULONG CellType; + ULONG CellBlock; + + ASSERT(RegistryHive->ReadOnly == FALSE); + + Free = HvpGetCellHeader(RegistryHive, CellIndex); + + ASSERT(Free->CellSize < 0); + + Free->CellSize = -Free->CellSize; + + CellType = (CellIndex & HCELL_TYPE_MASK) >> HCELL_TYPE_SHIFT; + CellBlock = (CellIndex & HCELL_BLOCK_MASK) >> HCELL_BLOCK_SHIFT; + + /* FIXME: Merge free blocks */ + Bin = RegistryHive->Storage[CellType].BlockList[CellBlock].Bin; + + if ((CellIndex & ~HCELL_TYPE_MASK) + Free->CellSize < + Bin->BinOffset + Bin->BinSize) + { + Neighbor = (PCELL_HEADER)((ULONG_PTR)Free + Free->CellSize); + if (Neighbor->CellSize > 0) + { + HvpRemoveFree(RegistryHive, Neighbor, + ((HCELL_INDEX)Neighbor - (HCELL_INDEX)Bin + + Bin->BinOffset) | (CellIndex & HCELL_TYPE_MASK)); + Free->CellSize += Neighbor->CellSize; + } + } + + Neighbor = (PCELL_HEADER)(Bin + 1); + while (Neighbor < Free) + { + if (Neighbor->CellSize > 0) + { + if ((ULONG_PTR)Neighbor + Neighbor->CellSize == (ULONG_PTR)Free) + { + Neighbor->CellSize += Free->CellSize; + if (CellType == HvStable) + HvMarkCellDirty(RegistryHive, + (HCELL_INDEX)Neighbor - (HCELL_INDEX)Bin + + Bin->BinOffset); + return; + } + Neighbor = (PCELL_HEADER)((ULONG_PTR)Neighbor + Neighbor->CellSize); + } + else + { + Neighbor = (PCELL_HEADER)((ULONG_PTR)Neighbor - Neighbor->CellSize); + } + } + + /* Add block to the list of free blocks */ + HvpAddFree(RegistryHive, Free, CellIndex); + + if (CellType == HvStable) + HvMarkCellDirty(RegistryHive, CellIndex); +} Added: trunk/reactos/lib/cmlib/hivedata.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/lib/cmlib/hivedata.h?rev=2… ============================================================================== --- trunk/reactos/lib/cmlib/hivedata.h (added) +++ trunk/reactos/lib/cmlib/hivedata.h Sat Jul 29 00:50:05 2006 @@ -1,0 +1,138 @@ +/* + * PROJECT: registry manipulation library + * LICENSE: GPL - See COPYING in the top level directory + * COPYRIGHT: Copyright 2005 Filip Navara <navaraf(a)reactos.org> + * Copyright 2001 - 2005 Eric Kohl + */ + +#ifndef CMLIB_HIVEDATA_H +#define CMLIB_HIVEDATA_H + +#define HV_BLOCK_SIZE 4096 +#define HV_LOG_HEADER_SIZE FIELD_OFFSET(HIVE_HEADER, Reserved2) +#define HV_SIGNATURE 0x66676572 +#define HV_BIN_SIGNATURE 0x6e696268 + +#define HV_MAJOR_VER 1 +#define HV_MINOR_VER 3 +#define HV_FORMAT_MEMORY 1 + +#define HV_TYPE_PRIMARY 0 +#define HV_TYPE_ALTERNATE 1 +#define HV_TYPE_LOG 2 +#define HV_TYPE_EXTERNAL 3 +#define HV_TYPE_MAX 4 + +/** + * @name HCELL_INDEX + * + * A handle to cell index. The highest bit specifies the cell storage and + * the other bits specify index into the hive file. The value HCELL_NULL + * (-1) is reserved for marking invalid cells. + */ + +typedef ULONG HCELL_INDEX, *PHCELL_INDEX; + +#define HCELL_NULL ((HCELL_INDEX)-1) +#define HCELL_TYPE_MASK 0x80000000 +#define HCELL_BLOCK_MASK 0x7ffff000 +#define HCELL_OFFSET_MASK 0x00000fff +#define HCELL_TYPE_SHIFT 31 +#define HCELL_BLOCK_SHIFT 12 +#define HCELL_OFFSET_SHIFT 0 + +#include <pshpack1.h> + +/** + * @name HIVE_HEADER + * + * On-disk header for registry hive file. + */ + +typedef struct _HIVE_HEADER +{ + /* Hive identifier "regf" (0x66676572) */ + ULONG Signature; + + /* Update counter */ + ULONG Sequence1; + + /* Update counter */ + ULONG Sequence2; + + /* When this hive file was last modified */ + LARGE_INTEGER TimeStamp; + + /* Registry format major version (1) */ + ULONG Major; + + /* Registry format minor version (3) + Version 3 added fast indexes, version 5 has large value optimizations */ + ULONG Minor; + + /* Registry file type (0 - Primary, 1 - Log) */ + ULONG Type; + + /* Registry format (1 is the only defined value so far) */ + ULONG Format; + + /* 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 */ + HCELL_INDEX RootCell; + + /* Size of each hive block ? */ + ULONG Length; + + /* (1?) */ + ULONG Cluster; + + /* Name of hive file */ + WCHAR FileName[32]; + + ULONG Reserved1[99]; + + /* Checksum of first 0x200 bytes */ + ULONG Checksum; + + ULONG Reserved2[0x380]; +} HIVE_HEADER, *PHIVE_HEADER; + +typedef struct _BIN_HEADER +{ + /* Bin identifier "hbin" (0x6E696268) */ + ULONG Signature; + + /* Block offset of this bin */ + HCELL_INDEX BinOffset; + + /* Size in bytes, multiple of the block size (4KB) */ + ULONG BinSize; + + ULONG Reserved[2]; + + /* When this bin was last modified */ + LARGE_INTEGER DateModified; + + /* ? (In-memory only) */ + ULONG MemAlloc; +} HBIN, *PHBIN; + +typedef struct _CELL_HEADER +{ + /* <0 if used, >0 if free */ + LONG CellSize; +} CELL_HEADER, *PCELL_HEADER; + +#include <poppack.h> + +#define IsFreeCell(Cell)(Cell->CellSize >= 0) +#define IsUsedCell(Cell)(Cell->CellSize < 0) + +typedef enum _HV_STORAGE_TYPE +{ + HvStable = 0, + HvVolatile, + HvMaxStorageType +} HV_STORAGE_TYPE; + +#endif /* CMLIB_HIVEDATA_H */ Added: trunk/reactos/lib/cmlib/hiveinit.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/lib/cmlib/hiveinit.c?rev=2… ============================================================================== --- trunk/reactos/lib/cmlib/hiveinit.c (added) +++ trunk/reactos/lib/cmlib/hiveinit.c Sat Jul 29 00:50:05 2006 @@ -1,0 +1,377 @@ +/* + * PROJECT: registry manipulation library + * LICENSE: GPL - See COPYING in the top level directory + * COPYRIGHT: Copyright 2005 Filip Navara <navaraf(a)reactos.org> + * Copyright 2001 - 2005 Eric Kohl + */ + +#include "cmlib.h" +#define NDEBUG +#include <debug.h> + +/** + * @name HvpVerifyHiveHeader + * + * Internal function to verify that a hive header has valid format. + */ + +BOOLEAN CMAPI +HvpVerifyHiveHeader( + PHIVE_HEADER HiveHeader) +{ + if (HiveHeader->Signature != HV_SIGNATURE || + HiveHeader->Major != HV_MAJOR_VER || + HiveHeader->Minor > HV_MINOR_VER || + HiveHeader->Type != HV_TYPE_PRIMARY || + HiveHeader->Format != HV_FORMAT_MEMORY || + HiveHeader->Cluster != 1 || + HiveHeader->Sequence1 != HiveHeader->Sequence2 || + HvpHiveHeaderChecksum(HiveHeader) != HiveHeader->Checksum) + { + return FALSE; + } + + return TRUE; +} + +/** + * @name HvpFreeHiveBins + * + * Internal function to free all bin storage associated with hive + * descriptor. + */ + +VOID CMAPI +HvpFreeHiveBins( + PREGISTRY_HIVE Hive) +{ + ULONG i; + PHBIN Bin; + ULONG Storage; + + for (Storage = HvStable; Storage < HvMaxStorageType; Storage++) + { + Bin = NULL; + for (i = 0; i < Hive->Storage[Storage].BlockListSize; i++) + { + if (Hive->Storage[Storage].BlockList[i].Bin == NULL) + continue; + if (Hive->Storage[Storage].BlockList[i].Bin != Bin) + { + Bin = Hive->Storage[Storage].BlockList[i].Bin; + Hive->Free(Hive->Storage[Storage].BlockList[i].Bin); + } + Hive->Storage[Storage].BlockList[i].Bin = NULL; + Hive->Storage[Storage].BlockList[i].Block = NULL; + } + + if (Hive->Storage[Storage].BlockListSize) + Hive->Free(Hive->Storage[Storage].BlockList); + } +} + +/** + * @name HvpCreateHive + * + * Internal helper function to initalize hive descriptor structure for + * newly created hive. + * + * @see HvInitialize + */ + +NTSTATUS CMAPI +HvpCreateHive( + PREGISTRY_HIVE RegistryHive) +{ + PHIVE_HEADER HiveHeader; + ULONG Index; + + HiveHeader = RegistryHive->Allocate(sizeof(HIVE_HEADER), FALSE); + if (HiveHeader == NULL) + return STATUS_NO_MEMORY; + RtlZeroMemory(HiveHeader, sizeof(HIVE_HEADER)); + HiveHeader->Signature = HV_SIGNATURE; + HiveHeader->Major = HV_MAJOR_VER; + HiveHeader->Minor = HV_MINOR_VER; + HiveHeader->Type = HV_TYPE_PRIMARY; + HiveHeader->Format = HV_FORMAT_MEMORY; + HiveHeader->Cluster = 1; + HiveHeader->RootCell = HCELL_NULL; + HiveHeader->Length = HV_BLOCK_SIZE; + HiveHeader->Sequence1 = 1; + HiveHeader->Sequence2 = 1; + /* FIXME: Fill in the file name */ + HiveHeader->Checksum = HvpHiveHeaderChecksum(HiveHeader); + + RegistryHive->HiveHeader = HiveHeader; + for (Index = 0; Index < 24; Index++) + { + RegistryHive->Storage[HvStable].FreeListOffset[Index] = HCELL_NULL; + RegistryHive->Storage[HvVolatile].FreeListOffset[Index] = HCELL_NULL; + } + RtlInitializeBitMap(&RegistryHive->DirtyBitmap, NULL, 0); + + return STATUS_SUCCESS; +} + +/** + * @name HvpInitializeMemoryHive + * + * Internal helper function to initalize hive descriptor structure for + * a hive stored in memory. The data of the hive are copied and it is + * prepared for read/write access. + * + * @see HvInitialize + */ + +NTSTATUS CMAPI +HvpInitializeMemoryHive( + PREGISTRY_HIVE Hive, + ULONG_PTR ChunkBase, + SIZE_T ChunkSize) +{ + SIZE_T BlockIndex; + PHBIN Bin, NewBin; + ULONG i; + ULONG BitmapSize; + PULONG BitmapBuffer; + + if (ChunkSize < sizeof(HIVE_HEADER) || + !HvpVerifyHiveHeader((PHIVE_HEADER)ChunkBase)) + { + return STATUS_REGISTRY_CORRUPT; + } + + Hive->HiveHeader = Hive->Allocate(sizeof(HIVE_HEADER), FALSE); + if (Hive->HiveHeader == NULL) + { + return STATUS_NO_MEMORY; + } + RtlCopyMemory(Hive->HiveHeader, (PVOID)ChunkBase, sizeof(HIVE_HEADER)); + + /* + * Build a block list from the in-memory chunk and copy the data as + * we go. + */ + + Hive->Storage[HvStable].BlockListSize = (ChunkSize / HV_BLOCK_SIZE) - 1; + Hive->Storage[HvStable].BlockList = + Hive->Allocate(Hive->Storage[HvStable].BlockListSize * + sizeof(BLOCK_LIST_ENTRY), FALSE); + if (Hive->Storage[HvStable].BlockList == NULL) + { + DPRINT1("Allocating block list failed\n"); + Hive->Free(Hive->HiveHeader); + return STATUS_NO_MEMORY; + } + + for (BlockIndex = 0; BlockIndex < Hive->Storage[HvStable].BlockListSize; ) + { + Bin = (PHBIN)((ULONG_PTR)ChunkBase + (BlockIndex + 1) * HV_BLOCK_SIZE); + if (Bin->Signature != HV_BIN_SIGNATURE || + (Bin->BinSize % HV_BLOCK_SIZE) != 0) + { + Hive->Free(Hive->HiveHeader); + Hive->Free(Hive->Storage[HvStable].BlockList); + return STATUS_REGISTRY_CORRUPT; + } + + NewBin = Hive->Allocate(Bin->BinSize, TRUE); + if (NewBin == NULL) + { + Hive->Free(Hive->HiveHeader); + Hive->Free(Hive->Storage[HvStable].BlockList); + return STATUS_NO_MEMORY; + } + + Hive->Storage[HvStable].BlockList[BlockIndex].Bin = NewBin; + Hive->Storage[HvStable].BlockList[BlockIndex].Block = NewBin; + + RtlCopyMemory(NewBin, Bin, Bin->BinSize); + + if (Bin->BinSize > HV_BLOCK_SIZE) + { + for (i = 1; i < Bin->BinSize / HV_BLOCK_SIZE; i++) + { + Hive->Storage[HvStable].BlockList[BlockIndex + i].Bin = NewBin; + Hive->Storage[HvStable].BlockList[BlockIndex + i].Block = + (PVOID)((ULONG_PTR)NewBin + (i * HV_BLOCK_SIZE)); + } + } + + BlockIndex += Bin->BinSize / HV_BLOCK_SIZE; + } + + if (HvpCreateHiveFreeCellList(Hive)) + { + HvpFreeHiveBins(Hive); + Hive->Free(Hive->HiveHeader); + return STATUS_NO_MEMORY; + } + + BitmapSize = ROUND_UP(Hive->Storage[HvStable].BlockListSize, + sizeof(ULONG) * 8) / 8; + BitmapBuffer = (PULONG)Hive->Allocate(BitmapSize, TRUE); + if (BitmapBuffer == NULL) + { + HvpFreeHiveBins(Hive); + Hive->Free(Hive->HiveHeader); + return STATUS_NO_MEMORY; + } + + RtlInitializeBitMap(&Hive->DirtyBitmap, BitmapBuffer, BitmapSize * 8); + RtlClearAllBits(&Hive->DirtyBitmap); + + return STATUS_SUCCESS; +} + +/** + * @name HvpInitializeMemoryInplaceHive + * + * Internal helper function to initalize hive descriptor structure for + * a hive stored in memory. The in-memory data of the hive are directly + * used and it is read-only accessible. + * + * @see HvInitialize + */ + +NTSTATUS CMAPI +HvpInitializeMemoryInplaceHive( + PREGISTRY_HIVE Hive, + ULONG_PTR ChunkBase, + SIZE_T ChunkSize) +{ + if (ChunkSize < sizeof(HIVE_HEADER) || + !HvpVerifyHiveHeader((PHIVE_HEADER)ChunkBase)) + { + return STATUS_REGISTRY_CORRUPT; + } + + Hive->HiveHeader = (PHIVE_HEADER)ChunkBase; + Hive->ReadOnly = TRUE; + Hive->Flat = TRUE; + + return STATUS_SUCCESS; +} + +/** + * @name HvInitialize + * + * Allocate a new hive descriptor structure and intialize it. + * + * @param RegistryHive + * Output variable to store pointer to the hive descriptor. + * @param Operation + * - HV_OPERATION_CREATE_HIVE + * Create a new hive for read/write access. + * - HV_OPERATION_MEMORY + * Load and copy in-memory hive for read/write access. The + * pointer to data passed to this routine can be freed after + * the function is executed. + * - HV_OPERATION_MEMORY_INPLACE + * Load an in-memory hive for read-only access. The pointer + * to data passed to this routine MUSTN'T be freed until + * HvFree is called. + * @param ChunkBase + * Pointer to hive data. + * @param ChunkSize + * Size of passed hive data. + * + * @return + * STATUS_NO_MEMORY - A memory allocation failed. + * STATUS_REGISTRY_CORRUPT - Registry corruption was detected. + * STATUS_SUCCESS + * + * @see HvFree + */ + +NTSTATUS CMAPI +HvInitialize( + PREGISTRY_HIVE *RegistryHive, + ULONG Operation, + ULONG_PTR ChunkBase, + SIZE_T ChunkSize, + PHV_ALLOCATE Allocate, + PHV_FREE Free, + PHV_FILE_READ FileRead, + PHV_FILE_WRITE FileWrite, + PHV_FILE_SET_SIZE FileSetSize, + PHV_FILE_FLUSH FileFlush, + PVOID Opaque) +{ + NTSTATUS Status; + PREGISTRY_HIVE Hive; + + /* + * Create a new hive structure that will hold all the maintenance data. + */ + + Hive = Allocate(sizeof(REGISTRY_HIVE), TRUE); + if (Hive == NULL) + return STATUS_NO_MEMORY; + RtlZeroMemory(Hive, sizeof(REGISTRY_HIVE)); + + Hive->Allocate = Allocate; + Hive->Free = Free; + Hive->FileRead = FileRead; + Hive->FileWrite = FileWrite; + Hive->FileSetSize = FileSetSize; + Hive->FileFlush = FileFlush; + Hive->Opaque = Opaque; + + switch (Operation) + { + case HV_OPERATION_CREATE_HIVE: + Status = HvpCreateHive(Hive); + break; + + case HV_OPERATION_MEMORY: + Status = HvpInitializeMemoryHive(Hive, ChunkBase, ChunkSize); + break; + + case HV_OPERATION_MEMORY_INPLACE: + Status = HvpInitializeMemoryInplaceHive(Hive, ChunkBase, ChunkSize); + break; + + default: + /* FIXME: A better return status value is needed */ + Status = STATUS_NOT_IMPLEMENTED; + ASSERT(FALSE); + } + + if (!NT_SUCCESS(Status)) + { + Hive->Free(Hive); + return Status; + } + + *RegistryHive = Hive; + + return Status; +} + +/** + * @name HvFree + * + * Free all stroage and handles associated with hive descriptor. + */ + +VOID CMAPI +HvFree( + PREGISTRY_HIVE RegistryHive) +{ + if (!RegistryHive->ReadOnly) + { + /* Release hive bitmap */ + if (RegistryHive->DirtyBitmap.Buffer) + { + RegistryHive->Free(RegistryHive->DirtyBitmap.Buffer); + } + + HvpFreeHiveBins(RegistryHive); + } + + RegistryHive->Free(RegistryHive); +} + +/* EOF */ Added: trunk/reactos/lib/cmlib/hivesum.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/lib/cmlib/hivesum.c?rev=23… ============================================================================== --- trunk/reactos/lib/cmlib/hivesum.c (added) +++ trunk/reactos/lib/cmlib/hivesum.c Sat Jul 29 00:50:05 2006 @@ -1,0 +1,32 @@ +/* + * PROJECT: registry manipulation library + * LICENSE: GPL - See COPYING in the top level directory + * COPYRIGHT: Copyright 2005 Filip Navara <navaraf(a)reactos.org> + * Copyright 2001 - 2005 Eric Kohl + */ + +#include "cmlib.h" + +/** + * @name HvpHiveHeaderChecksum + * + * Compute checksum of hive header and return it. + */ + +ULONG CMAPI +HvpHiveHeaderChecksum( + PHIVE_HEADER HiveHeader) +{ + PULONG Buffer = (PULONG)HiveHeader; + ULONG Sum = 0; + ULONG i; + + for (i = 0; i < 127; i++) + Sum ^= Buffer[i]; + if (Sum == (ULONG)-1) + Sum = (ULONG)-2; + if (Sum == 0) + Sum = 1; + + return Sum; +} Added: trunk/reactos/lib/cmlib/hivewrt.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/lib/cmlib/hivewrt.c?rev=23… ============================================================================== --- trunk/reactos/lib/cmlib/hivewrt.c (added) +++ trunk/reactos/lib/cmlib/hivewrt.c Sat Jul 29 00:50:05 2006 @@ -1,0 +1,277 @@ +/* + * PROJECT: registry manipulation library + * LICENSE: GPL - See COPYING in the top level directory + * COPYRIGHT: Copyright 2005 Filip Navara <navaraf(a)reactos.org> + * Copyright 2001 - 2005 Eric Kohl + */ + +#include "cmlib.h" +#define NDEBUG +#include <debug.h> + +static BOOLEAN CMAPI +HvpWriteLog( + PREGISTRY_HIVE RegistryHive) +{ + ULONG FileOffset; + ULONG BufferSize; + ULONG BitmapSize; + PUCHAR Buffer; + PUCHAR Ptr; + ULONG BlockIndex; + ULONG LastIndex; + PVOID BlockPtr; + BOOLEAN Success; + + ASSERT(RegistryHive->ReadOnly == FALSE); + + DPRINT("HvpWriteLog called\n"); + + if (RegistryHive->HiveHeader->Sequence1 != + RegistryHive->HiveHeader->Sequence2) + { + return FALSE; + } + + BitmapSize = RegistryHive->DirtyBitmap.SizeOfBitMap; + BufferSize = HV_LOG_HEADER_SIZE + sizeof(ULONG) + BitmapSize; + BufferSize = ROUND_UP(BufferSize, HV_BLOCK_SIZE); + + DPRINT("Bitmap size %lu buffer size: %lu\n", BitmapSize, BufferSize); + + Buffer = RegistryHive->Allocate(BufferSize, TRUE); + if (Buffer == NULL) + { + return FALSE; + } + + /* Update first update counter and checksum */ + RegistryHive->HiveHeader->Type = HV_TYPE_LOG; + RegistryHive->HiveHeader->Sequence1++; + RegistryHive->HiveHeader->Checksum = + HvpHiveHeaderChecksum(RegistryHive->HiveHeader); + + /* Copy hive header */ + RtlCopyMemory(Buffer, RegistryHive->HiveHeader, HV_LOG_HEADER_SIZE); + Ptr = Buffer + HV_LOG_HEADER_SIZE; + RtlCopyMemory(Ptr, "DIRT", 4); + Ptr += 4; + RtlCopyMemory(Ptr, RegistryHive->DirtyBitmap.Buffer, BitmapSize); + + /* Write hive block and block bitmap */ + Success = RegistryHive->FileWrite(RegistryHive, HV_TYPE_LOG, + 0, Buffer, BufferSize); + if (!Success) + { + return FALSE; + } + + RegistryHive->Free(Buffer); + + /* Write dirty blocks */ + FileOffset = BufferSize; + BlockIndex = 0; + while (BlockIndex < RegistryHive->Storage[HvStable].BlockListSize) + { + LastIndex = BlockIndex; + BlockIndex = RtlFindSetBits(&RegistryHive->DirtyBitmap, 1, BlockIndex); + if (BlockIndex == ~0 || BlockIndex < LastIndex) + { + break; + } + + BlockPtr = RegistryHive->Storage[HvStable].BlockList[BlockIndex].Block; + + /* Write hive block */ + Success = RegistryHive->FileWrite(RegistryHive, HV_TYPE_LOG, + FileOffset, BlockPtr, + HV_BLOCK_SIZE); + if (!Success) + { + return FALSE; + } + + BlockIndex++; + FileOffset += HV_BLOCK_SIZE; + } + + Success = RegistryHive->FileSetSize(RegistryHive, HV_TYPE_LOG, FileOffset); + if (!Success) + { + DPRINT("FileSetSize failed\n"); + return FALSE; + } + + /* Flush the log file */ + Success = RegistryHive->FileFlush(RegistryHive, HV_TYPE_LOG); + if (!Success) + { + DPRINT("FileFlush failed\n"); + } + + /* Update first and second update counter and checksum. */ + RegistryHive->HiveHeader->Sequence2++; + RegistryHive->HiveHeader->Checksum = + HvpHiveHeaderChecksum(RegistryHive->HiveHeader); + + /* Write hive header again with updated sequence counter. */ + Success = RegistryHive->FileWrite(RegistryHive, HV_TYPE_LOG, + 0, RegistryHive->HiveHeader, + HV_LOG_HEADER_SIZE); + if (!Success) + { + return FALSE; + } + + /* Flush the log file */ + Success = RegistryHive->FileFlush(RegistryHive, HV_TYPE_LOG); + if (!Success) + { + DPRINT("FileFlush failed\n"); + } + + return TRUE; +} + +static BOOLEAN CMAPI +HvpWriteHive( + PREGISTRY_HIVE RegistryHive, + BOOLEAN OnlyDirty) +{ + ULONG FileOffset; + ULONG BlockIndex; + ULONG LastIndex; + PVOID BlockPtr; + BOOLEAN Success; + + ASSERT(RegistryHive->ReadOnly == FALSE); + + DPRINT("HvpWriteHive called\n"); + + if (RegistryHive->HiveHeader->Sequence1 != + RegistryHive->HiveHeader->Sequence2) + { + return FALSE; + } + + /* Update first update counter and checksum */ + RegistryHive->HiveHeader->Type = HV_TYPE_PRIMARY; + RegistryHive->HiveHeader->Sequence1++; + RegistryHive->HiveHeader->Checksum = + HvpHiveHeaderChecksum(RegistryHive->HiveHeader); + + /* Write hive block */ + Success = RegistryHive->FileWrite(RegistryHive, HV_TYPE_PRIMARY, + 0, RegistryHive->HiveHeader, + sizeof(HIVE_HEADER)); + if (!Success) + { + return FALSE; + } + + BlockIndex = 0; + while (BlockIndex < RegistryHive->Storage[HvStable].BlockListSize) + { + if (OnlyDirty) + { + LastIndex = BlockIndex; + BlockIndex = RtlFindSetBits(&RegistryHive->DirtyBitmap, 1, BlockIndex); + if (BlockIndex == ~0 || BlockIndex < LastIndex) + { + break; + } + } + + BlockPtr = RegistryHive->Storage[HvStable].BlockList[BlockIndex].Block; + FileOffset = (ULONGLONG)(BlockIndex + 1) * (ULONGLONG)HV_BLOCK_SIZE; + + /* Write hive block */ + Success = RegistryHive->FileWrite(RegistryHive, HV_TYPE_PRIMARY, + FileOffset, BlockPtr, + HV_BLOCK_SIZE); + if (!Success) + { + return FALSE; + } + + BlockIndex++; + } + + Success = RegistryHive->FileFlush(RegistryHive, HV_TYPE_PRIMARY); + if (!Success) + { + DPRINT("FileFlush failed\n"); + } + + /* Update second update counter and checksum */ + RegistryHive->HiveHeader->Sequence2++; + RegistryHive->HiveHeader->Checksum = + HvpHiveHeaderChecksum(RegistryHive->HiveHeader); + + /* Write hive block */ + Success = RegistryHive->FileWrite(RegistryHive, HV_TYPE_PRIMARY, + 0, RegistryHive->HiveHeader, + sizeof(HIVE_HEADER)); + if (!Success) + { + return FALSE; + } + + Success = RegistryHive->FileFlush(RegistryHive, HV_TYPE_PRIMARY); + if (!Success) + { + DPRINT("FileFlush failed\n"); + } + + return TRUE; +} + +BOOLEAN CMAPI +HvSyncHive( + PREGISTRY_HIVE RegistryHive) +{ + ASSERT(RegistryHive->ReadOnly == FALSE); + + if (RtlFindSetBits(&RegistryHive->DirtyBitmap, 1, 0) == ~0) + { + return TRUE; + } + + /* Update hive header modification time */ + KeQuerySystemTime(&RegistryHive->HiveHeader->TimeStamp); + + /* Update log file */ + if (!HvpWriteLog(RegistryHive)) + { + return FALSE; + } + + /* Update hive file */ + if (!HvpWriteHive(RegistryHive, TRUE)) + { + return FALSE; + } + + /* Clear dirty bitmap. */ + RtlClearAllBits(&RegistryHive->DirtyBitmap); + + return TRUE; +} + +BOOLEAN CMAPI +HvWriteHive( + PREGISTRY_HIVE RegistryHive) +{ + ASSERT(RegistryHive->ReadOnly == FALSE); + + /* Update hive header modification time */ + KeQuerySystemTime(&RegistryHive->HiveHeader->TimeStamp); + + /* Update hive file */ + if (!HvpWriteHive(RegistryHive, FALSE)) + { + return FALSE; + } + + return TRUE; +}

1 0

[greatlrd] 23335: Moved cmdutils command more remotely
by greatlrd＠svn.reactos.org 28 Jul '06

28 Jul '06

Author: greatlrd Date: Sat Jul 29 00:48:20 2006 New Revision: 23335 URL: http://svn.reactos.org/svn/reactos?rev=23335&view=rev Log: Moved cmdutils command more remotely Added: trunk/reactos/base/applications/cmdutils/more/ - copied from r23334, trunk/rosapps/cmdutils/more/ Removed: trunk/rosapps/cmdutils/more/

1 0

[greatlrd] 23334: Moved cmdutils command find remotely
by greatlrd＠svn.reactos.org 28 Jul '06

28 Jul '06

Author: greatlrd Date: Sat Jul 29 00:47:22 2006 New Revision: 23334 URL: http://svn.reactos.org/svn/reactos?rev=23334&view=rev Log: Moved cmdutils command find remotely Added: trunk/reactos/base/applications/cmdutils/find/ - copied from r23333, trunk/rosapps/cmdutils/find/ Removed: trunk/rosapps/cmdutils/find/

1 0

[greatlrd] 23333: prepare move for cmdutils more and find for they are necessary cmd command for allot bat files. Fireball agrees to it.
by greatlrd＠svn.reactos.org 28 Jul '06

28 Jul '06

Author: greatlrd Date: Sat Jul 29 00:43:58 2006 New Revision: 23333 URL: http://svn.reactos.org/svn/reactos?rev=23333&view=rev Log: prepare move for cmdutils more and find for they are necessary cmd command for allot bat files. Fireball agrees to it. Added: trunk/reactos/base/applications/cmdutils/

1 0

[fireball] 23332: - Add Filip Navara's cmlib - Use cmlib in Freeldr and Setupldr (patch by Filip Navara) - Fix some HIVE definition and checksum calculation in mkhive and ntoskrnl (so they btoh create a compatible registry) TODO: Apply 2nd half of the patch, which makes ntoskrnl using cmlib. This commit is dedicated to Filip Navara's constant promises to commit cmlib and to recent small Arty vs. Alex debate on irc :)
by fireball＠svn.reactos.org 28 Jul '06

28 Jul '06

Author: fireball Date: Sat Jul 29 00:25:47 2006 New Revision: 23332 URL: http://svn.reactos.org/svn/reactos?rev=23332&view=rev Log: - Add Filip Navara's cmlib - Use cmlib in Freeldr and Setupldr (patch by Filip Navara) - Fix some HIVE definition and checksum calculation in mkhive and ntoskrnl (so they btoh create a compatible registry) TODO: Apply 2nd half of the patch, which makes ntoskrnl using cmlib. This commit is dedicated to Filip Navara's constant promises to commit cmlib and to recent small Arty vs. Alex debate on irc :) Modified: trunk/reactos/boot/freeldr/freeldr/freeldr.rbuild trunk/reactos/boot/freeldr/freeldr/freeldr_base.rbuild trunk/reactos/boot/freeldr/freeldr/include/arch/i386/hardware.h trunk/reactos/boot/freeldr/freeldr/reactos/binhive.c trunk/reactos/boot/freeldr/freeldr/setupldr.rbuild trunk/reactos/lib/lib.mak (contents, props changed) trunk/reactos/lib/lib.rbuild trunk/reactos/ntoskrnl/cm/cm.h trunk/reactos/ntoskrnl/cm/regfile.c trunk/reactos/tools/mkhive/binhive.c Modified: trunk/reactos/boot/freeldr/freeldr/freeldr.rbuild URL: http://svn.reactos.org/svn/reactos/trunk/reactos/boot/freeldr/freeldr/freel… ============================================================================== --- trunk/reactos/boot/freeldr/freeldr/freeldr.rbuild (original) +++ trunk/reactos/boot/freeldr/freeldr/freeldr.rbuild Sat Jul 29 00:25:47 2006 @@ -7,5 +7,6 @@ <library>freeldr_main</library> <library>rossym</library> <library>string</library> + <library>cmlib</library> <library>rtl</library> </module> Modified: trunk/reactos/boot/freeldr/freeldr/freeldr_base.rbuild URL: http://svn.reactos.org/svn/reactos/trunk/reactos/boot/freeldr/freeldr/freel… ============================================================================== --- trunk/reactos/boot/freeldr/freeldr/freeldr_base.rbuild (original) +++ trunk/reactos/boot/freeldr/freeldr/freeldr_base.rbuild Sat Jul 29 00:25:47 2006 @@ -1,6 +1,7 @@ <module name="freeldr_base" type="objectlibrary"> <include base="freeldr_base">include</include> <include base="freeldr_base">cache</include> + <include base="cmlib">.</include> <include base="ntoskrnl">include</include> <define name="__USE_W32API" /> <!-- Modified: trunk/reactos/boot/freeldr/freeldr/include/arch/i386/hardware.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/boot/freeldr/freeldr/inclu… ============================================================================== --- trunk/reactos/boot/freeldr/freeldr/include/arch/i386/hardware.h (original) +++ trunk/reactos/boot/freeldr/freeldr/include/arch/i386/hardware.h Sat Jul 29 00:25:47 2006 @@ -43,7 +43,7 @@ /* CM_COMPONENT_INFORMATION.Flags */ #define Failed 0x00000001 -#define ReadOnly 0x00000002 +//#define ReadOnly 0x00000002 #define Removable 0x00000004 #define ConsoleIn 0x00000008 #define ConsoleOut 0x00000010 Modified: trunk/reactos/boot/freeldr/freeldr/reactos/binhive.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/boot/freeldr/freeldr/react… ============================================================================== --- trunk/reactos/boot/freeldr/freeldr/reactos/binhive.c (original) +++ trunk/reactos/boot/freeldr/freeldr/reactos/binhive.c Sat Jul 29 00:25:47 2006 @@ -20,855 +20,45 @@ */ #include <freeldr.h> +#include <cmlib.h> #define NDEBUG #include <debug.h> -#define REG_HIVE_ID 0x66676572 /* "regf" */ -#define REG_BIN_ID 0x6e696268 /* "hbin" */ -#define REG_KEY_CELL_ID 0x6b6e -#define REG_HASH_TABLE_BLOCK_ID 0x666c -#define REG_VALUE_CELL_ID 0x6b76 - -#define REG_BLOCK_SIZE 4096 -#define REG_HBIN_DATA_OFFSET 32 -#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 ABS_VALUE(V) (((V) < 0) ? -(V) : (V)) - - -/* BLOCK_OFFSET = offset in file after header block */ -typedef ULONG BLOCK_OFFSET, *PBLOCK_OFFSET; - -/* header for registry hive file : */ -typedef struct _HIVE_HEADER -{ - /* Hive identifier "regf" (0x66676572) */ - ULONG BlockId; - - /* Update counter */ - ULONG UpdateCounter1; - - /* Update counter */ - ULONG UpdateCounter2; - - /* When this hive file was last modified */ - ULONGLONG DateModified; - - /* Registry format major version (1) */ - ULONG MajorVersion; - - /* Registry format minor version (3) - Version 3 added fast indexes, version 5 has large value optimizations */ - ULONG MinorVersion; - - /* Registry file type (0 - Primary, 1 - Log) */ - ULONG Type; - - /* Registry format (1 is the only defined value so far) */ - ULONG Format; - - /* 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 RootKeyOffset; - - /* Size of each hive block ? */ - ULONG BlockSize; - - /* (1?) */ - ULONG Unused7; - - /* Name of hive file */ - WCHAR FileName[48]; - - ULONG Reserved[99]; - - /* Checksum of first 0x200 bytes */ - ULONG Checksum; -} __attribute__((packed)) HIVE_HEADER, *PHIVE_HEADER; - - -typedef struct _BIN_HEADER -{ - /* Bin identifier "hbin" (0x6E696268) */ - ULONG HeaderId; - - /* Block offset of this bin */ - BLOCK_OFFSET BinOffset; - - /* Size in bytes, multiple of the block size (4KB) */ - ULONG BinSize; - - ULONG Reserved[2]; - - /* When this bin was last modified */ - ULONGLONG DateModified; - - /* ? (In-memory only) */ - ULONG MemAlloc; -} __attribute__((packed)) HBIN, *PHBIN; - - -typedef struct _CELL_HEADER -{ - /* <0 if used, >0 if free */ - LONG CellSize; -} __attribute__((packed)) CELL_HEADER, *PCELL_HEADER; - - -typedef struct _KEY_CELL -{ - /* Size of this cell */ - LONG CellSize; - - /* Key cell identifier "kn" (0x6b6e) */ - USHORT Id; - - /* Flags */ - USHORT Flags; - - /* Time of last flush */ - ULONGLONG LastWriteTime; /* FILETIME */ - - /* ? */ - ULONG UnUsed1; - - /* Block offset of parent key cell */ - BLOCK_OFFSET ParentKeyOffset; - - /* Count of sub keys for the key in this key cell */ - ULONG NumberOfSubKeys; - - /* ? */ - ULONG UnUsed2; - - /* Block offset of has table for FIXME: subkeys/values? */ - BLOCK_OFFSET HashTableOffset; - - /* ? */ - ULONG UnUsed3; - - /* Count of values contained in this key cell */ - ULONG NumberOfValues; - - /* Block offset of VALUE_LIST_CELL */ - BLOCK_OFFSET ValueListOffset; - - /* Block offset of security cell */ - BLOCK_OFFSET SecurityKeyOffset; - - /* Block offset of registry key class */ - BLOCK_OFFSET ClassNameOffset; - - /* ? */ - ULONG Unused4[5]; - - /* Size in bytes of key name */ - USHORT NameSize; - - /* Size of class name in bytes */ - USHORT ClassSize; - - /* Name of key (not zero terminated) */ - CHAR Name[0]; -} __attribute__((packed)) KEY_CELL, *PKEY_CELL; - - -/* KEY_CELL.Type constants */ -#define REG_LINK_KEY_CELL_TYPE 0x10 -#define REG_KEY_NAME_PACKED 0x20 -#define REG_ROOT_KEY_CELL_TYPE 0x0c - - -// hash record : -// HashValue=four letters of value's name -typedef struct _HASH_RECORD -{ - BLOCK_OFFSET KeyOffset; - ULONG HashValue; -} __attribute__((packed)) HASH_RECORD, *PHASH_RECORD; - - -typedef struct _HASH_TABLE_CELL -{ - LONG CellSize; - USHORT Id; - USHORT HashTableSize; - HASH_RECORD Table[0]; -} __attribute__((packed)) HASH_TABLE_CELL, *PHASH_TABLE_CELL; - - -typedef struct _VALUE_LIST_CELL -{ - LONG CellSize; - BLOCK_OFFSET ValueOffset[0]; -} __attribute__((packed)) VALUE_LIST_CELL, *PVALUE_LIST_CELL; - - -typedef struct _VALUE_CELL -{ - LONG CellSize; - USHORT Id; // "kv" - USHORT NameSize; // length of Name - 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; - USHORT Unused1; - CHAR Name[0]; /* warning : not zero terminated */ -} __attribute__((packed)) VALUE_CELL, *PVALUE_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 -{ - LONG CellSize; - CHAR Data[0]; -} __attribute__((packed)) DATA_CELL, *PDATA_CELL; - - -typedef struct _REGISTRY_HIVE -{ - ULONG FileSize; - PHIVE_HEADER HiveHeader; - ULONG BlockListSize; - PHBIN *BlockList; - ULONG FreeListSize; - ULONG FreeListMax; - PCELL_HEADER *FreeList; - BLOCK_OFFSET *FreeListOffset; -} REGISTRY_HIVE, *PREGISTRY_HIVE; - - -static PVOID MbBase = NULL; -static ULONG MbSize = 0; - /* FUNCTIONS ****************************************************************/ +static PVOID +CmpAllocate (ULONG Size, BOOLEAN Paged) +{ + return MmAllocateMemory(Size); +} + + static VOID -InitMbMemory (PVOID ChunkBase) -{ - MbBase = ChunkBase; - MbSize = 0; -} - - -static PVOID -AllocateMbMemory (ULONG MemSize) -{ - PVOID CurBase; - - CurBase = MbBase; - - MbBase = (PVOID)((ULONG)MbBase + MemSize); - MbSize += MemSize; - - return CurBase; -} - -static VOID -FreeMbMemory (VOID) -{ - MbSize = 0; -} - -static ULONG -GetMbAllocatedSize (VOID) -{ - return MbSize; -} - - -static VOID -CmiCreateDefaultHiveHeader (PHIVE_HEADER Header) -{ - assert(Header); - memset (Header, 0, REG_BLOCK_SIZE); - Header->BlockId = REG_HIVE_ID; - Header->UpdateCounter1 = 0; - Header->UpdateCounter2 = 0; - Header->DateModified = 0; - Header->MajorVersion = 1; - Header->MinorVersion = 3; - Header->Type = 0; - Header->Format = 1; - Header->Unused7 = 1; - Header->RootKeyOffset = -1; - Header->BlockSize = REG_BLOCK_SIZE; - Header->Checksum = 0; -} - - -static VOID -CmiCreateDefaultBinCell (PHBIN BinCell) -{ - assert(BinCell); - memset (BinCell, 0, REG_BLOCK_SIZE); - BinCell->HeaderId = REG_BIN_ID; - BinCell->DateModified = 0ULL; - BinCell->BinSize = REG_BLOCK_SIZE; -} - - -static VOID -CmiCreateDefaultRootKeyCell (PKEY_CELL RootKeyCell, PCWSTR KeyName) -{ - PWCHAR BaseKeyName; - ULONG NameSize; - ULONG CellSize; - ULONG i; - BOOLEAN Packable = TRUE; - - assert (RootKeyCell); - - BaseKeyName = wcsrchr(KeyName, L'\\') + 1; - NameSize = wcslen(BaseKeyName); - for (i = 0; i < NameSize; i++) - { - if (KeyName[i] & 0xFF00) - { - Packable = FALSE; - NameSize *= sizeof(WCHAR); - break; - } - } - - CellSize = ROUND_UP(sizeof(KEY_CELL) + NameSize, 16); - - memset (RootKeyCell, 0, CellSize); - RootKeyCell->CellSize = -CellSize; - RootKeyCell->Id = REG_KEY_CELL_ID; - RootKeyCell->Flags = REG_ROOT_KEY_CELL_TYPE; - RootKeyCell->LastWriteTime = 0ULL; - RootKeyCell->ParentKeyOffset = 0; - RootKeyCell->NumberOfSubKeys = 0; - RootKeyCell->HashTableOffset = -1; - RootKeyCell->NumberOfValues = 0; - RootKeyCell->ValueListOffset = -1; - RootKeyCell->SecurityKeyOffset = 0; - RootKeyCell->ClassNameOffset = -1; - RootKeyCell->NameSize = NameSize; - RootKeyCell->ClassSize = 0; - if (Packable) - { - for(i = 0; i < NameSize; i++) - { - ((PCHAR)RootKeyCell->Name)[i] = BaseKeyName[i]; - } - RootKeyCell->Flags |= REG_KEY_NAME_PACKED; - } - else - { - memcpy (RootKeyCell->Name, BaseKeyName, NameSize); - } -} - - -static PREGISTRY_HIVE -CmiCreateHive (PCWSTR KeyName) -{ - PREGISTRY_HIVE Hive; - PCELL_HEADER FreeCell; - PKEY_CELL RootKeyCell; - PHBIN BinCell; - - Hive = (PREGISTRY_HIVE) MmAllocateMemory (sizeof(REGISTRY_HIVE)); - if (Hive == NULL) - { - return NULL; - } - memset (Hive, 0, sizeof(REGISTRY_HIVE)); - - DbgPrint((DPRINT_REGISTRY, "Hive %x\n", Hive)); - - /* Create hive beader (aka 'base block') */ - Hive->HiveHeader = (PHIVE_HEADER) AllocateMbMemory (REG_BLOCK_SIZE); - if (Hive->HiveHeader == NULL) - { - MmFreeMemory (Hive); - return NULL; - } - CmiCreateDefaultHiveHeader(Hive->HiveHeader); - Hive->FileSize = REG_BLOCK_SIZE; - - /* Allocate block list */ - Hive->BlockListSize = 1; - Hive->BlockList = MmAllocateMemory (sizeof(PHBIN) * Hive->BlockListSize); - if (Hive->BlockList == NULL) - { - MmFreeMemory (Hive); - return NULL; - } - - /* Allocate free cell list */ - Hive->FreeListMax = 32; - Hive->FreeList = MmAllocateMemory(sizeof(PCELL_HEADER) * Hive->FreeListMax); - if (Hive->FreeList == NULL) - { - MmFreeMemory (Hive->BlockList); - MmFreeMemory (Hive); - return NULL; - } - Hive->FreeListOffset = MmAllocateMemory(sizeof(BLOCK_OFFSET) * Hive->FreeListMax); - if (Hive->FreeListOffset == NULL) - { - MmFreeMemory (Hive->FreeList); - MmFreeMemory (Hive->BlockList); - MmFreeMemory (Hive); - return NULL; - } - - /* Allocate first bin */ - Hive->BlockList[0] = (PHBIN) AllocateMbMemory (REG_BLOCK_SIZE); - if (Hive->BlockList[0] == NULL) - { - MmFreeMemory (Hive->FreeListOffset); - MmFreeMemory (Hive->FreeList); - MmFreeMemory (Hive->BlockList); - MmFreeMemory (Hive); - return NULL; - } - Hive->FileSize += REG_BLOCK_SIZE; - - /* Init first bin */ - BinCell = (PHBIN)Hive->BlockList[0]; - CmiCreateDefaultBinCell(BinCell); - BinCell->BinOffset = 0; - - /* Init root key cell */ - RootKeyCell = (PKEY_CELL)((ULONG)BinCell + REG_HBIN_DATA_OFFSET); - CmiCreateDefaultRootKeyCell(RootKeyCell, KeyName); - Hive->HiveHeader->RootKeyOffset = REG_HBIN_DATA_OFFSET; - - /* Init free cell */ - FreeCell = (PCELL_HEADER)((ULONG)RootKeyCell - RootKeyCell->CellSize); - FreeCell->CellSize = REG_BLOCK_SIZE - (REG_HBIN_DATA_OFFSET - RootKeyCell->CellSize); - - Hive->FreeList[0] = FreeCell; - Hive->FreeListOffset[0] = REG_HBIN_DATA_OFFSET - RootKeyCell->CellSize; - Hive->FreeListSize++; - - return Hive; -} - - -static VOID -CmiCleanupHive(PREGISTRY_HIVE Hive, BOOLEAN Release) -{ - MmFreeMemory (Hive->FreeListOffset); - MmFreeMemory (Hive->FreeList); - MmFreeMemory (Hive->BlockList); - MmFreeMemory (Hive); - - if (Release) - { - FreeMbMemory (); - } -} - - -static PHBIN -CmiGetBin (PREGISTRY_HIVE Hive, - BLOCK_OFFSET BlockOffset) -{ - ULONG BlockIndex; - - if (BlockOffset == (ULONG) -1) - return NULL; - - BlockIndex = BlockOffset / REG_BLOCK_SIZE; - if (BlockIndex >= Hive->BlockListSize) - return NULL; - - return Hive->BlockList[BlockIndex]; -} - - -static BOOLEAN -CmiMergeFree(PREGISTRY_HIVE RegistryHive, - PCELL_HEADER FreeBlock, - BLOCK_OFFSET FreeOffset) -{ - BLOCK_OFFSET BlockOffset; - BLOCK_OFFSET BinOffset; - ULONG BlockSize; - ULONG BinSize; - PHBIN Bin; - ULONG i; - - DbgPrint((DPRINT_REGISTRY, "CmiMergeFree(Block %lx Offset %lx Size %lx) called\n", - FreeBlock, FreeOffset, FreeBlock->CellSize)); - - Bin = CmiGetBin (RegistryHive, FreeOffset); - if (Bin == NULL) - return FALSE; - - DbgPrint((DPRINT_REGISTRY, "Bin %p\n", Bin)); - - BinOffset = Bin->BinOffset; - BinSize = Bin->BinSize; - DbgPrint((DPRINT_REGISTRY, "Bin %p Offset %lx Size %lx\n", Bin, BinOffset, BinSize)); - - for (i = 0; i < RegistryHive->FreeListSize; i++) - { - BlockOffset = RegistryHive->FreeListOffset[i]; - BlockSize = RegistryHive->FreeList[i]->CellSize; - if (BlockOffset > BinOffset && - BlockOffset < BinOffset + BinSize) - { - DbgPrint((DPRINT_REGISTRY, "Free block: Offset %lx Size %lx\n", - BlockOffset, BlockSize)); - - if ((i < (RegistryHive->FreeListSize - 1)) && - (BlockOffset + BlockSize == FreeOffset) && - (FreeOffset + FreeBlock->CellSize == RegistryHive->FreeListOffset[i + 1])) - { - DbgPrint((DPRINT_REGISTRY, "Merge current block with previous and next block\n")); - - RegistryHive->FreeList[i]->CellSize += - (FreeBlock->CellSize + RegistryHive->FreeList[i + 1]->CellSize); - - FreeBlock->CellSize = 0; - RegistryHive->FreeList[i + 1]->CellSize = 0; - - - if ((i + 2) < RegistryHive->FreeListSize) - { - memmove (&RegistryHive->FreeList[i + 1], - &RegistryHive->FreeList[i + 2], - sizeof(RegistryHive->FreeList[0]) - * (RegistryHive->FreeListSize - i - 2)); - memmove (&RegistryHive->FreeListOffset[i + 1], - &RegistryHive->FreeListOffset[i + 2], - sizeof(RegistryHive->FreeListOffset[0]) - * (RegistryHive->FreeListSize - i - 2)); - } - RegistryHive->FreeListSize--; - - return TRUE; - } - else if (BlockOffset + BlockSize == FreeOffset) - { - DbgPrint((DPRINT_REGISTRY, "Merge current block with previous block\n")); - - RegistryHive->FreeList[i]->CellSize += FreeBlock->CellSize; - FreeBlock->CellSize = 0; - - return TRUE; - } - else if (FreeOffset + FreeBlock->CellSize == BlockOffset) - { - DbgPrint((DPRINT_REGISTRY, "Merge current block with next block\n")); - - FreeBlock->CellSize += RegistryHive->FreeList[i]->CellSize; - RegistryHive->FreeList[i]->CellSize = 0; - RegistryHive->FreeList[i] = FreeBlock; - RegistryHive->FreeListOffset[i] = FreeOffset; - - return TRUE; - } - } - } - - return FALSE; -} - - -static BOOLEAN -CmiAddFree(PREGISTRY_HIVE RegistryHive, - PCELL_HEADER FreeBlock, - BLOCK_OFFSET FreeOffset, - BOOLEAN MergeFreeBlocks) -{ - PCELL_HEADER *tmpList; - BLOCK_OFFSET *tmpListOffset; - LONG minInd; - LONG maxInd; - LONG medInd; - - assert(RegistryHive); - assert(FreeBlock); - - DbgPrint((DPRINT_REGISTRY, "FreeBlock %.08lx FreeOffset %.08lx\n", - FreeBlock, FreeOffset)); - - /* Merge free blocks */ - if (MergeFreeBlocks == TRUE) - { - if (CmiMergeFree(RegistryHive, FreeBlock, FreeOffset)) - return TRUE; - } - - if ((RegistryHive->FreeListSize + 1) > RegistryHive->FreeListMax) - { - tmpList = MmAllocateMemory (sizeof(PCELL_HEADER) * (RegistryHive->FreeListMax + 32)); - if (tmpList == NULL) - { - return FALSE; - } - - tmpListOffset = MmAllocateMemory (sizeof(BLOCK_OFFSET) * (RegistryHive->FreeListMax + 32)); - if (tmpListOffset == NULL) - { - MmFreeMemory (tmpList); - return FALSE; - } - - if (RegistryHive->FreeListMax) - { - memmove (tmpList, - RegistryHive->FreeList, - sizeof(PCELL_HEADER) * (RegistryHive->FreeListMax)); - memmove (tmpListOffset, - RegistryHive->FreeListOffset, - sizeof(BLOCK_OFFSET) * (RegistryHive->FreeListMax)); - MmFreeMemory (RegistryHive->FreeList); - MmFreeMemory (RegistryHive->FreeListOffset); - } - RegistryHive->FreeList = tmpList; - RegistryHive->FreeListOffset = tmpListOffset; - RegistryHive->FreeListMax += 32; - } - - /* Add new offset to free list, maintaining list in ascending order */ - if ((RegistryHive->FreeListSize == 0) - || (RegistryHive->FreeListOffset[RegistryHive->FreeListSize-1] < FreeOffset)) - { - /* Add to end of list */ - RegistryHive->FreeList[RegistryHive->FreeListSize] = FreeBlock; - RegistryHive->FreeListOffset[RegistryHive->FreeListSize++] = FreeOffset; - } - else if (RegistryHive->FreeListOffset[0] > FreeOffset) - { - /* Add to begin of list */ - memmove (&RegistryHive->FreeList[1], - &RegistryHive->FreeList[0], - sizeof(RegistryHive->FreeList[0]) * RegistryHive->FreeListSize); - memmove (&RegistryHive->FreeListOffset[1], - &RegistryHive->FreeListOffset[0], - sizeof(RegistryHive->FreeListOffset[0]) * RegistryHive->FreeListSize); - RegistryHive->FreeList[0] = FreeBlock; - RegistryHive->FreeListOffset[0] = FreeOffset; - RegistryHive->FreeListSize++; - } - else - { - /* Search where to insert */ - minInd = 0; - maxInd = RegistryHive->FreeListSize - 1; - while ((maxInd - minInd) > 1) - { - medInd = (minInd + maxInd) / 2; - if (RegistryHive->FreeListOffset[medInd] > FreeOffset) - maxInd = medInd; - else - minInd = medInd; - } - - /* Insert before maxInd */ - memmove (&RegistryHive->FreeList[maxInd+1], - &RegistryHive->FreeList[maxInd], - sizeof(RegistryHive->FreeList[0]) * (RegistryHive->FreeListSize - minInd)); - memmove (&RegistryHive->FreeListOffset[maxInd + 1], - &RegistryHive->FreeListOffset[maxInd], - sizeof(RegistryHive->FreeListOffset[0]) * (RegistryHive->FreeListSize-minInd)); - RegistryHive->FreeList[maxInd] = FreeBlock; - RegistryHive->FreeListOffset[maxInd] = FreeOffset; - RegistryHive->FreeListSize++; - } - - return TRUE; -} - - -static BOOLEAN -CmiAddBin(PREGISTRY_HIVE RegistryHive, - ULONG BlockCount, - PVOID *NewBlock, - PBLOCK_OFFSET NewBlockOffset) -{ - PCELL_HEADER tmpBlock; - PHBIN *BlockList; - PHBIN tmpBin; - ULONG BinSize; - ULONG i; - - BinSize = BlockCount * REG_BLOCK_SIZE; - tmpBin = AllocateMbMemory (BinSize); - if (tmpBin == NULL) - { - return FALSE; - } - memset (tmpBin, 0, BinSize); - - tmpBin->HeaderId = REG_BIN_ID; - tmpBin->BinOffset = RegistryHive->FileSize - REG_BLOCK_SIZE; - RegistryHive->FileSize += BinSize; - tmpBin->BinSize = BinSize; - tmpBin->DateModified = 0ULL; - tmpBin->MemAlloc = 0; - - /* Increase size of list of blocks */ - BlockList = MmAllocateMemory (sizeof(PHBIN) * (RegistryHive->BlockListSize + BlockCount)); - if (BlockList == NULL) - { - return FALSE; - } - - if (RegistryHive->BlockListSize > 0) - { - memcpy (BlockList, - RegistryHive->BlockList, - sizeof(PHBIN) * RegistryHive->BlockListSize); - MmFreeMemory (RegistryHive->BlockList); - } - - RegistryHive->BlockList = BlockList; - for (i = 0; i < BlockCount; i++) - RegistryHive->BlockList[RegistryHive->BlockListSize + i] = tmpBin; - RegistryHive->BlockListSize += BlockCount; - - /* Initialize a free block in this heap : */ - tmpBlock = (PCELL_HEADER)((ULONG) tmpBin + REG_HBIN_DATA_OFFSET); - tmpBlock->CellSize = (REG_BLOCK_SIZE - REG_HBIN_DATA_OFFSET); - - *NewBlock = (PVOID) tmpBlock; - - if (NewBlockOffset) - *NewBlockOffset = tmpBin->BinOffset + REG_HBIN_DATA_OFFSET; - - return TRUE; -} - - -static BOOLEAN -CmiAllocateCell (PREGISTRY_HIVE RegistryHive, - LONG CellSize, - PVOID *Block, - PBLOCK_OFFSET pBlockOffset) -{ - PCELL_HEADER NewBlock; - ULONG i; - - *Block = NULL; - - /* Round to 16 bytes multiple */ - CellSize = ROUND_UP(CellSize, 16); - - /* first search in free blocks */ - NewBlock = NULL; - for (i = 0; i < RegistryHive->FreeListSize; i++) - { - if (RegistryHive->FreeList[i]->CellSize >= CellSize) - { - NewBlock = RegistryHive->FreeList[i]; - if (pBlockOffset) - *pBlockOffset = RegistryHive->FreeListOffset[i]; - - if ((i + 1) < RegistryHive->FreeListSize) - { - memmove (&RegistryHive->FreeList[i], - &RegistryHive->FreeList[i + 1], - sizeof(RegistryHive->FreeList[0]) - * (RegistryHive->FreeListSize - i - 1)); - memmove (&RegistryHive->FreeListOffset[i], - &RegistryHive->FreeListOffset[i + 1], - sizeof(RegistryHive->FreeListOffset[0]) - * (RegistryHive->FreeListSize - i - 1)); - } - RegistryHive->FreeListSize--; - break; - } - } - - /* Need to extend hive file */ - if (NewBlock == NULL) - { - /* Add a new block */ - if (!CmiAddBin(RegistryHive, - ((sizeof(HBIN) + CellSize - 1) / REG_BLOCK_SIZE) + 1, - (PVOID *)(PVOID)&NewBlock, - pBlockOffset)) - return FALSE; - } - - *Block = NewBlock; - - /* Split the block in two parts */ - if (NewBlock->CellSize > CellSize) - { - NewBlock = (PCELL_HEADER) ((ULONG)NewBlock + CellSize); - NewBlock->CellSize = ((PCELL_HEADER) (*Block))->CellSize - CellSize; - CmiAddFree (RegistryHive, - NewBlock, - *pBlockOffset + CellSize, - TRUE); - } - else if (NewBlock->CellSize < CellSize) - { - return FALSE; - } - - memset(*Block, 0, CellSize); - ((PCELL_HEADER)(*Block))->CellSize = -CellSize; - - return TRUE; -} - - -static PVOID -CmiGetCell (PREGISTRY_HIVE Hive, - BLOCK_OFFSET BlockOffset) -{ - PHBIN Bin; - ULONG BlockIndex; - - if (BlockOffset == (ULONG) -1) - return NULL; - - BlockIndex = BlockOffset / REG_BLOCK_SIZE; - if (BlockIndex >= Hive->BlockListSize) - return NULL; - - Bin = Hive->BlockList[BlockIndex]; - if (Bin == NULL) - return NULL; - - return (PVOID)((ULONG)Bin + (BlockOffset - Bin->BinOffset)); +CmpFree (PVOID Ptr) +{ + return MmFreeMemory(Ptr); } static BOOLEAN CmiAllocateHashTableCell (PREGISTRY_HIVE Hive, - PBLOCK_OFFSET HBOffset, + PHCELL_INDEX HBOffset, ULONG SubKeyCount) { PHASH_TABLE_CELL HashCell; ULONG NewHashSize; - BOOLEAN Status; NewHashSize = sizeof(HASH_TABLE_CELL) + (SubKeyCount * sizeof(HASH_RECORD)); - Status = CmiAllocateCell (Hive, - NewHashSize, - (PVOID*)(PVOID)&HashCell, - HBOffset); - if ((HashCell == NULL) || (Status == FALSE)) - { - return FALSE; - } - - HashCell->Id = REG_HASH_TABLE_BLOCK_ID; + *HBOffset = HvAllocateCell (Hive, NewHashSize, HvStable); + if (*HBOffset == HCELL_NULL) + { + return FALSE; + } + + HashCell = HvGetCell (Hive, *HBOffset); + HashCell->Id = REG_HASH_TABLE_CELL_ID; HashCell->HashTableSize = SubKeyCount; return TRUE; @@ -877,27 +67,16 @@ static BOOLEAN CmiAddKeyToParentHashTable (PREGISTRY_HIVE Hive, - BLOCK_OFFSET ParentKeyOffset, + HCELL_INDEX ParentKeyOffset, PKEY_CELL NewKeyCell, - BLOCK_OFFSET NKBOffset) + HCELL_INDEX NKBOffset) { PHASH_TABLE_CELL HashBlock; PKEY_CELL ParentKeyCell; ULONG i; - ParentKeyCell = CmiGetCell (Hive, ParentKeyOffset); - if (ParentKeyCell == NULL) - { - DbgPrint((DPRINT_REGISTRY, "CmiGetCell() failed\n")); - return FALSE; - } - - HashBlock =CmiGetCell (Hive, ParentKeyCell->HashTableOffset); - if (HashBlock == NULL) - { - DbgPrint((DPRINT_REGISTRY, "CmiGetCell() failed\n")); - return FALSE; - } + ParentKeyCell = HvGetCell (Hive, ParentKeyOffset); + HashBlock = HvGetCell (Hive, ParentKeyCell->HashTableOffset[HvStable]); for (i = 0; i < HashBlock->HashTableSize; i++) { @@ -907,7 +86,7 @@ memcpy (&HashBlock->Table[i].HashValue, NewKeyCell->Name, min(NewKeyCell->NameSize, sizeof(ULONG))); - ParentKeyCell->NumberOfSubKeys++; + ParentKeyCell->NumberOfSubKeys[HvStable]++; return TRUE; } } @@ -918,22 +97,17 @@ static BOOLEAN CmiAllocateValueListCell (PREGISTRY_HIVE Hive, - PBLOCK_OFFSET ValueListOffset, + PHCELL_INDEX ValueListOffset, ULONG ValueCount) { - PVALUE_LIST_CELL ValueListCell; ULONG ValueListSize; - BOOLEAN Status; ValueListSize = sizeof(VALUE_LIST_CELL) + - (ValueCount * sizeof(BLOCK_OFFSET)); - Status = CmiAllocateCell (Hive, - ValueListSize, - (PVOID)&ValueListCell, - ValueListOffset); - if ((ValueListCell == NULL) || (Status == FALSE)) - { - DbgPrint((DPRINT_REGISTRY, "CmiAllocateCell() failed\n")); + (ValueCount * sizeof(HCELL_INDEX)); + *ValueListOffset = HvAllocateCell (Hive, ValueListSize, HvStable); + if (*ValueListOffset == HCELL_NULL) + { + DbgPrint((DPRINT_REGISTRY, "HvAllocateCell() failed\n")); return FALSE; } @@ -944,12 +118,11 @@ static BOOLEAN CmiAllocateValueCell(PREGISTRY_HIVE Hive, PVALUE_CELL *ValueCell, - BLOCK_OFFSET *ValueCellOffset, + HCELL_INDEX *ValueCellOffset, PWCHAR ValueName) { PVALUE_CELL NewValueCell; ULONG NameSize; - BOOLEAN Status; BOOLEAN Packable = TRUE; ULONG i; @@ -963,16 +136,14 @@ break; } } - Status = CmiAllocateCell (Hive, - sizeof(VALUE_CELL) + NameSize, - (PVOID*)(PVOID)&NewValueCell, - ValueCellOffset); - if ((NewValueCell == NULL) || (Status == FALSE)) + *ValueCellOffset = HvAllocateCell (Hive, sizeof(VALUE_CELL) + NameSize, HvStable); + if (*ValueCellOffset == HCELL_NULL) { DbgPrint((DPRINT_REGISTRY, "CmiAllocateCell() failed\n")); return FALSE; } + NewValueCell = (PVALUE_CELL) HvGetCell (Hive, *ValueCellOffset); NewValueCell->Id = REG_VALUE_CELL_ID; NewValueCell->NameSize = NameSize; NewValueCell->Flags = 0; @@ -1005,23 +176,23 @@ static BOOLEAN CmiAddValueToKeyValueList(PREGISTRY_HIVE Hive, - BLOCK_OFFSET KeyCellOffset, - BLOCK_OFFSET ValueCellOffset) + HCELL_INDEX KeyCellOffset, + HCELL_INDEX ValueCellOffset) { PVALUE_LIST_CELL ValueListCell; PKEY_CELL KeyCell; - KeyCell = CmiGetCell (Hive, KeyCellOffset); + KeyCell = HvGetCell (Hive, KeyCellOffset); if (KeyCell == NULL) { - DbgPrint((DPRINT_REGISTRY, "CmiGetCell() failed\n")); - return FALSE; - } - - ValueListCell = CmiGetCell (Hive, KeyCell->ValueListOffset); + DbgPrint((DPRINT_REGISTRY, "HvGetCell() failed\n")); + return FALSE; + } + + ValueListCell = HvGetCell (Hive, KeyCell->ValueListOffset); if (ValueListCell == NULL) { - DbgPrint((DPRINT_REGISTRY, "CmiGetCell() failed\n")); + DbgPrint((DPRINT_REGISTRY, "HvGetCell() failed\n")); return FALSE; } @@ -1033,14 +204,14 @@ static BOOLEAN CmiExportValue (PREGISTRY_HIVE Hive, - BLOCK_OFFSET KeyCellOffset, + HCELL_INDEX KeyCellOffset, FRLDRHKEY Key, PVALUE Value) { - BLOCK_OFFSET ValueCellOffset; - BLOCK_OFFSET DataCellOffset; + HCELL_INDEX ValueCellOffset; + HCELL_INDEX DataCellOffset; PVALUE_CELL ValueCell; - PDATA_CELL DataCell; + PVOID DataCell; ULONG DataSize; ULONG DataType; PCHAR Data; @@ -1074,7 +245,7 @@ Data = Value->Data; } - if (DataSize <= sizeof(BLOCK_OFFSET)) + if (DataSize <= sizeof(HCELL_INDEX)) { ValueCell->DataSize = DataSize | REG_DATA_IN_OFFSET; ValueCell->DataType = DataType; @@ -1085,10 +256,8 @@ else { /* Allocate data cell */ - if (!CmiAllocateCell (Hive, - sizeof(CELL_HEADER) + DataSize, - (PVOID *)(PVOID)&DataCell, - &DataCellOffset)) + DataCellOffset = HvAllocateCell (Hive, DataSize, HvStable); + if (DataCellOffset == HCELL_NULL) { return FALSE; } @@ -1097,7 +266,8 @@ ValueCell->DataSize = DataSize; ValueCell->DataType = DataType; - memcpy (DataCell->Data, + DataCell = HvGetCell (Hive, DataCellOffset); + memcpy (DataCell, Data, DataSize); } @@ -1108,11 +278,11 @@ static BOOLEAN CmiExportSubKey (PREGISTRY_HIVE Hive, - BLOCK_OFFSET ParentKeyOffset, + HCELL_INDEX ParentKeyOffset, FRLDRHKEY ParentKey, FRLDRHKEY Key) { - BLOCK_OFFSET NKBOffset; + HCELL_INDEX NKBOffset; PKEY_CELL NewKeyCell; ULONG KeyCellSize; ULONG SubKeyCount; @@ -1143,19 +313,21 @@ /* Allocate key cell */ KeyCellSize = sizeof(KEY_CELL) + NameSize; - if (!CmiAllocateCell (Hive, KeyCellSize, (PVOID)&NewKeyCell, &NKBOffset)) - { - DbgPrint((DPRINT_REGISTRY, "CmiAllocateCell() failed\n")); + NKBOffset = HvAllocateCell (Hive, KeyCellSize, HvStable); + if (NKBOffset == HCELL_NULL) + { + DbgPrint((DPRINT_REGISTRY, "HvAllocateCell() failed\n")); return FALSE; } /* Initialize key cell */ + NewKeyCell = (PKEY_CELL) HvGetCell (Hive, NKBOffset); NewKeyCell->Id = REG_KEY_CELL_ID; NewKeyCell->Flags = 0; - NewKeyCell->LastWriteTime = 0ULL; + NewKeyCell->LastWriteTime.QuadPart = 0ULL; NewKeyCell->ParentKeyOffset = ParentKeyOffset; - NewKeyCell->NumberOfSubKeys = 0; - NewKeyCell->HashTableOffset = -1; + NewKeyCell->NumberOfSubKeys[HvStable] = 0; + NewKeyCell->HashTableOffset[HvStable] = -1; NewKeyCell->NumberOfValues = 0; NewKeyCell->ValueListOffset = -1; NewKeyCell->SecurityKeyOffset = -1; @@ -1228,7 +400,7 @@ { /* Allocate hash table cell */ if (!CmiAllocateHashTableCell (Hive, - &NewKeyCell->HashTableOffset, + &NewKeyCell->HashTableOffset[HvStable], SubKeyCount)) { DbgPrint((DPRINT_REGISTRY, "CmiAllocateHashTableCell() failed\n")); @@ -1251,22 +423,6 @@ } return TRUE; -} - - -static VOID -CmiCalcHiveChecksum (PREGISTRY_HIVE Hive) -{ - ULONG *Buffer; - ULONG Sum; - ULONG i; - - Buffer = (ULONG*)Hive->HiveHeader; - Sum = 0; - for (i = 0; i < 127; i++) - Sum += Buffer[i]; - - Hive->HiveHeader->Checksum = Sum; } @@ -1290,10 +446,10 @@ return FALSE; } - KeyCell = CmiGetCell (Hive, Hive->HiveHeader->RootKeyOffset); + KeyCell = HvGetCell (Hive, Hive->HiveHeader->RootCell); if (KeyCell == NULL) { - DbgPrint((DPRINT_REGISTRY, "CmiGetBlock() failed\n")); + DbgPrint((DPRINT_REGISTRY, "HvGetCell() failed\n")); return FALSE; } @@ -1312,7 +468,7 @@ if (Key->DataSize != 0) { - if (!CmiExportValue (Hive, Hive->HiveHeader->RootKeyOffset, Key, NULL)) + if (!CmiExportValue (Hive, Hive->HiveHeader->RootCell, Key, NULL)) return FALSE; } @@ -1324,7 +480,7 @@ VALUE, ValueList); - if (!CmiExportValue (Hive, Hive->HiveHeader->RootKeyOffset, Key, Value)) + if (!CmiExportValue (Hive, Hive->HiveHeader->RootCell, Key, Value)) return FALSE; Entry = Entry->Flink; @@ -1337,7 +493,7 @@ { /* Allocate hash table cell */ if (!CmiAllocateHashTableCell (Hive, - &KeyCell->HashTableOffset, + &KeyCell->HashTableOffset[HvStable], SubKeyCount)) { DbgPrint((DPRINT_REGISTRY, "CmiAllocateHashTableCell() failed\n")); @@ -1352,31 +508,29 @@ KEY, KeyList); - if (!CmiExportSubKey (Hive, Hive->HiveHeader->RootKeyOffset, Key, SubKey)) + if (!CmiExportSubKey (Hive, Hive->HiveHeader->RootCell, Key, SubKey)) return FALSE; Entry = Entry->Flink; } } - CmiCalcHiveChecksum (Hive); - - return TRUE; -} - - -static BOOLEAN -RegImportValue (PHBIN RootBin, + return TRUE; +} + + +static BOOLEAN +RegImportValue (PREGISTRY_HIVE Hive, PVALUE_CELL ValueCell, FRLDRHKEY Key) { - PDATA_CELL DataCell; + PVOID DataCell; PWCHAR wName; LONG Error; ULONG DataSize; ULONG i; - if (ValueCell->CellSize >= 0 || ValueCell->Id != REG_VALUE_CELL_ID) + if (ValueCell->Id != REG_VALUE_CELL_ID) { DbgPrint((DPRINT_REGISTRY, "Invalid key cell!\n")); return FALSE; @@ -1405,7 +559,7 @@ DbgPrint((DPRINT_REGISTRY, "ValueName: '%S'\n", wName)); DbgPrint((DPRINT_REGISTRY, "DataSize: %u\n", DataSize)); - if (DataSize <= sizeof(BLOCK_OFFSET) && (ValueCell->DataSize & REG_DATA_IN_OFFSET)) + if (DataSize <= sizeof(HCELL_INDEX) && (ValueCell->DataSize & REG_DATA_IN_OFFSET)) { Error = RegSetValue(Key, wName, @@ -1421,20 +575,13 @@ } else { - DataCell = (PDATA_CELL)((PUCHAR)RootBin + ValueCell->DataOffset); + DataCell = HvGetCell (Hive, ValueCell->DataOffset); DbgPrint((DPRINT_REGISTRY, "DataCell: %x\n", DataCell)); - - if (DataCell->CellSize >= 0) - { - DbgPrint((DPRINT_REGISTRY, "Invalid data cell size!\n")); - MmFreeMemory (wName); - return FALSE; - } Error = RegSetValue (Key, wName, ValueCell->DataType, - DataCell->Data, + DataCell, DataSize); if (Error != ERROR_SUCCESS) @@ -1452,7 +599,7 @@ static BOOLEAN -RegImportSubKey(PHBIN RootBin, +RegImportSubKey(PREGISTRY_HIVE Hive, PKEY_CELL KeyCell, FRLDRHKEY ParentKey) { @@ -1467,9 +614,8 @@ DbgPrint((DPRINT_REGISTRY, "KeyCell: %x\n", KeyCell)); - DbgPrint((DPRINT_REGISTRY, "KeyCell->CellSize: %x\n", KeyCell->CellSize)); DbgPrint((DPRINT_REGISTRY, "KeyCell->Id: %x\n", KeyCell->Id)); - if (KeyCell->Id != REG_KEY_CELL_ID || KeyCell->CellSize >= 0) + if (KeyCell->Id != REG_KEY_CELL_ID) { DbgPrint((DPRINT_REGISTRY, "Invalid key cell id!\n")); return FALSE; @@ -1511,37 +657,38 @@ /* Enumerate and add values */ if (KeyCell->NumberOfValues > 0) { - ValueListCell = (PVALUE_LIST_CELL)((PUCHAR)RootBin + KeyCell->ValueListOffset); + ValueListCell = (PVALUE_LIST_CELL) HvGetCell (Hive, KeyCell->ValueListOffset); DbgPrint((DPRINT_REGISTRY, "ValueListCell: %x\n", ValueListCell)); for (i = 0; i < KeyCell->NumberOfValues; i++) { DbgPrint((DPRINT_REGISTRY, "ValueOffset[%d]: %x\n", i, ValueListCell->ValueOffset[i])); - ValueCell = (PVALUE_CELL)((PUCHAR)RootBin + ValueListCell->ValueOffset[i]); + ValueCell = (PVALUE_CELL) HvGetCell (Hive, ValueListCell->ValueOffset[i]); DbgPrint((DPRINT_REGISTRY, "ValueCell[%d]: %x\n", i, ValueCell)); - if (!RegImportValue(RootBin, ValueCell, SubKey)) + if (!RegImportValue(Hive, ValueCell, SubKey)) return FALSE; } } /* Enumerate and add subkeys */ - if (KeyCell->NumberOfSubKeys > 0) - { - HashCell = (PHASH_TABLE_CELL)((PUCHAR)RootBin + KeyCell->HashTableOffset); + if (KeyCell->NumberOfSubKeys[HvStable] > 0) + { + HashCell = (PHASH_TABLE_CELL) HvGetCell (Hive, KeyCell->HashTableOffset[HvStable]); DbgPrint((DPRINT_REGISTRY, "HashCell: %x\n", HashCell)); - - for (i = 0; i < KeyCell->NumberOfSubKeys; i++) + DbgPrint((DPRINT_REGISTRY, "NumberOfSubKeys: %x\n", KeyCell->NumberOfSubKeys)); + + for (i = 0; i < KeyCell->NumberOfSubKeys[HvStable]; i++) { DbgPrint((DPRINT_REGISTRY, "KeyOffset[%d]: %x\n", i, HashCell->Table[i].KeyOffset)); - SubKeyCell = (PKEY_CELL)((PUCHAR)RootBin + HashCell->Table[i].KeyOffset); + SubKeyCell = (PKEY_CELL) HvGetCell (Hive, HashCell->Table[i].KeyOffset); DbgPrint((DPRINT_REGISTRY, "SubKeyCell[%d]: %x\n", i, SubKeyCell)); - if (!RegImportSubKey(RootBin, SubKeyCell, SubKey)) + if (!RegImportSubKey(Hive, SubKeyCell, SubKey)) return FALSE; } } @@ -1554,38 +701,31 @@ RegImportBinaryHive(PCHAR ChunkBase, ULONG ChunkSize) { - PHIVE_HEADER HiveHeader; - PHBIN RootBin; PKEY_CELL KeyCell; PHASH_TABLE_CELL HashCell; PKEY_CELL SubKeyCell; FRLDRHKEY SystemKey; ULONG i; LONG Error; + PREGISTRY_HIVE Hive; + NTSTATUS Status; DbgPrint((DPRINT_REGISTRY, "RegImportBinaryHive(%x, %u) called\n",ChunkBase,ChunkSize)); - HiveHeader = (PHIVE_HEADER)ChunkBase; - DbgPrint((DPRINT_REGISTRY, "HiveHeader: %x\n", HiveHeader)); - if (HiveHeader->BlockId != REG_HIVE_ID) + Status = HvInitialize (&Hive, HV_OPERATION_MEMORY_INPLACE, + (ULONG_PTR)ChunkBase, ChunkSize, + CmpAllocate, CmpFree, + NULL, NULL, NULL, NULL, NULL); + if (!NT_SUCCESS(Status)) { DbgPrint((DPRINT_REGISTRY, "Invalid hive id!\n")); return FALSE; } - RootBin = (PHBIN)((ULONG)HiveHeader + REG_BLOCK_SIZE); - DbgPrint((DPRINT_REGISTRY, "RootBin: %x\n", RootBin)); - if (RootBin->HeaderId != REG_BIN_ID || RootBin->BinSize == 0) - { - DbgPrint((DPRINT_REGISTRY, "Invalid bin id!\n")); - return FALSE; - } - - KeyCell = (PKEY_CELL)((ULONG)RootBin + REG_HBIN_DATA_OFFSET); + KeyCell = HvGetCell (Hive, Hive->HiveHeader->RootCell); DbgPrint((DPRINT_REGISTRY, "KeyCell: %x\n", KeyCell)); - DbgPrint((DPRINT_REGISTRY, "KeyCell->CellSize: %x\n", KeyCell->CellSize)); DbgPrint((DPRINT_REGISTRY, "KeyCell->Id: %x\n", KeyCell->Id)); - if (KeyCell->Id != REG_KEY_CELL_ID || KeyCell->CellSize >= 0) + if (KeyCell->Id != REG_KEY_CELL_ID) { DbgPrint((DPRINT_REGISTRY, "Invalid key cell id!\n")); return FALSE; @@ -1605,25 +745,56 @@ } /* Enumerate and add subkeys */ - if (KeyCell->NumberOfSubKeys > 0) - { - HashCell = (PHASH_TABLE_CELL)((ULONG)RootBin + KeyCell->HashTableOffset); + if (KeyCell->NumberOfSubKeys[HvStable] > 0) + { + HashCell = HvGetCell (Hive, KeyCell->HashTableOffset[HvStable]); DbgPrint((DPRINT_REGISTRY, "HashCell: %x\n", HashCell)); - - for (i = 0; i < KeyCell->NumberOfSubKeys; i++) + DbgPrint((DPRINT_REGISTRY, "NumberOfSubKeys: %x\n", KeyCell->NumberOfSubKeys[HvStable])); + + for (i = 0; i < KeyCell->NumberOfSubKeys[HvStable]; i++) { DbgPrint((DPRINT_REGISTRY, "KeyOffset[%d]: %x\n", i, HashCell->Table[i].KeyOffset)); - SubKeyCell = (PKEY_CELL)((ULONG)RootBin + HashCell->Table[i].KeyOffset); + SubKeyCell = HvGetCell (Hive, HashCell->Table[i].KeyOffset); DbgPrint((DPRINT_REGISTRY, "SubKeyCell[%d]: %x\n", i, SubKeyCell)); - if (!RegImportSubKey(RootBin, SubKeyCell, SystemKey)) + if (!RegImportSubKey(Hive, SubKeyCell, SystemKey)) return FALSE; } } return TRUE; +} + + +static VOID +CmiWriteHive(PREGISTRY_HIVE Hive, + PCHAR ChunkBase, + ULONG* ChunkSize) +{ + PHBIN Bin; + ULONG i, Size; + + /* Write hive header */ + memcpy (ChunkBase, Hive->HiveHeader, HV_BLOCK_SIZE); + Size = HV_BLOCK_SIZE; + + Bin = NULL; + for (i = 0; i < Hive->Storage[HvStable].BlockListSize; i++) + { + if (Hive->Storage[HvStable].BlockList[i].Bin != Bin) + { + Bin = Hive->Storage[HvStable].BlockList[i].Bin; + memcpy (ChunkBase + (i + 1) * HV_BLOCK_SIZE, + Bin, Bin->BinSize); + Size += Bin->BinSize; + } + } + + DbgPrint((DPRINT_REGISTRY, "ChunkSize: %x\n", Size)); + + *ChunkSize = Size; } @@ -1633,25 +804,34 @@ ULONG* ChunkSize) { PREGISTRY_HIVE Hive; + NTSTATUS Status; DbgPrint((DPRINT_REGISTRY, "Creating binary hardware hive\n")); - *ChunkSize = 0; - InitMbMemory (ChunkBase); - - Hive = CmiCreateHive (KeyName); - if (Hive == NULL) - return FALSE; + Status = HvInitialize (&Hive, HV_OPERATION_CREATE_HIVE, 0, 0, + CmpAllocate, CmpFree, + NULL, NULL, NULL, NULL, NULL); + if (!NT_SUCCESS(Status)) + { + return FALSE; + } + + /* Init root key cell */ + if (!CmCreateRootNode (Hive, KeyName)) + { + HvFree (Hive); + return FALSE; + } if (!CmiExportHive (Hive, KeyName)) { - CmiCleanupHive (Hive, TRUE); - return FALSE; - } - - CmiCleanupHive (Hive, FALSE); - - *ChunkSize = GetMbAllocatedSize (); + HvFree (Hive); + return FALSE; + } + + CmiWriteHive (Hive, ChunkBase, ChunkSize); + + HvFree (Hive); return TRUE; } Modified: trunk/reactos/boot/freeldr/freeldr/setupldr.rbuild URL: http://svn.reactos.org/svn/reactos/trunk/reactos/boot/freeldr/freeldr/setup… ============================================================================== --- trunk/reactos/boot/freeldr/freeldr/setupldr.rbuild (original) +++ trunk/reactos/boot/freeldr/freeldr/setupldr.rbuild Sat Jul 29 00:25:47 2006 @@ -7,5 +7,6 @@ <library>setupldr_main</library> <library>rossym</library> <library>string</library> + <library>cmlib</library> <library>rtl</library> </module> Modified: trunk/reactos/lib/lib.mak URL: http://svn.reactos.org/svn/reactos/trunk/reactos/lib/lib.mak?rev=23332&r1=2… ============================================================================== --- trunk/reactos/lib/lib.mak (original) +++ trunk/reactos/lib/lib.mak Sat Jul 29 00:25:47 2006 @@ -3,3 +3,4 @@ include lib/inflib/inflib.mak include lib/3rdparty/zlib/zlib.mak +include lib/cmlib/cmlib.mak Propchange: trunk/reactos/lib/lib.mak ------------------------------------------------------------------------------ --- svn:needs-lock (original) +++ svn:needs-lock (removed) @@ -1,1 +1,0 @@ -* Modified: trunk/reactos/lib/lib.rbuild URL: http://svn.reactos.org/svn/reactos/trunk/reactos/lib/lib.rbuild?rev=23332&r… ============================================================================== --- trunk/reactos/lib/lib.rbuild (original) +++ trunk/reactos/lib/lib.rbuild Sat Jul 29 00:25:47 2006 @@ -3,6 +3,9 @@ <group> <directory name="3rdparty"> <xi:include href="3rdparty/3rdparty.rbuild" /> +</directory> +<directory name="cmlib"> + <xi:include href="cmlib/cmlib.rbuild" /> </directory> <directory name="crt"> <xi:include href="crt/crt.rbuild" /> Modified: trunk/reactos/ntoskrnl/cm/cm.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/cm/cm.h?rev=23332… ============================================================================== --- trunk/reactos/ntoskrnl/cm/cm.h (original) +++ trunk/reactos/ntoskrnl/cm/cm.h Sat Jul 29 00:25:47 2006 @@ -94,7 +94,7 @@ ULONG Unused7; /* Name of hive file */ - WCHAR FileName[48]; + WCHAR FileName[32]; ULONG Reserved[99]; Modified: trunk/reactos/ntoskrnl/cm/regfile.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/cm/regfile.c?rev=… ============================================================================== --- trunk/reactos/ntoskrnl/cm/regfile.c (original) +++ trunk/reactos/ntoskrnl/cm/regfile.c Sat Jul 29 00:25:47 2006 @@ -1360,7 +1360,11 @@ ULONG i; for (i = 0; i < 127; i++) - Sum += Buffer[i]; + Sum ^= Buffer[i]; + if (Sum == (ULONG)-1) + Sum = (ULONG)-2; + if (Sum == 0) + Sum = 1; return(Sum); } Modified: trunk/reactos/tools/mkhive/binhive.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/tools/mkhive/binhive.c?rev… ============================================================================== --- trunk/reactos/tools/mkhive/binhive.c (original) +++ trunk/reactos/tools/mkhive/binhive.c Sat Jul 29 00:25:47 2006 @@ -107,7 +107,7 @@ ULONG Unused7; /* Name of hive file */ - WCHAR FileName[48]; + WCHAR FileName[32]; ULONG Reserved[99]; @@ -1248,7 +1248,11 @@ Buffer = (PULONG)Hive->HiveHeader; Sum = 0; for (i = 0; i < 127; i++) - Sum += Buffer[i]; + Sum ^= Buffer[i]; + if (Sum == (ULONG)-1) + Sum = (ULONG)-2; + if (Sum == 0) + Sum = 1; Hive->HiveHeader->Checksum = Sum; }

1 0

[greatlrd] 23331: patch from LMH1 : Bug#: 1684 : Norwegian translation
by greatlrd＠svn.reactos.org 28 Jul '06

28 Jul '06

Author: greatlrd Date: Sat Jul 29 00:03:29 2006 New Revision: 23331 URL: http://svn.reactos.org/svn/reactos?rev=23331&view=rev Log: patch from LMH1 : Bug#: 1684 : Norwegian translation Added: trunk/reactos/base/system/format/No.rc (with props) Modified: trunk/reactos/base/system/format/format.rc Added: trunk/reactos/base/system/format/No.rc URL: http://svn.reactos.org/svn/reactos/trunk/reactos/base/system/format/No.rc?r… ============================================================================== --- trunk/reactos/base/system/format/No.rc (added) +++ trunk/reactos/base/system/format/No.rc Sat Jul 29 00:03:29 2006 @@ -1,0 +1,72 @@ +#include "resource.h" +/* + * Moved all hardcoded strings to En.rc. + * By Magnus Olsen 2005 + */ + +LANGUAGE LANG_NORWEGIAN, SUBLANG_NEUTRAL +STRINGTABLE DISCARDABLE +{ +STRING_HELP, "bruk: %S stasjon: [-FS:fil-system] [-V:merke] [-Q] [-A:størrelse] [-C]\n\n\ + [stasjon:] Spesifisere stasjon til formater.\n\ + -FS:file-system Spesifisere typen av fil system (f.eks. FAT).\n\ + -V:merke Spesifisere volum merke.\n\ + -Q Fullføre en rask formatering.\n\ + -A:størrelse Dominerende standard fordeling enhet størrelse. Standard innstilling\n\ + er sterkt anbefalt for generielt bruk\n\ + NTFS støtter 512, 1024, 2048, 4096, 8192, 16K, 32K, 64K.\n\ + FAT støtter 8192, 16K, 32K, 64K, 128K, 256K.\n\ + NTFS komprimering er ikke støttet for fordeling enhet størrelse\n\ + ovenfor 4096.\n\ + -C Filer opprettet på nytt volum vil bli komprimert etter\n\ + standard.\n\n" + +STRING_COMPLETE "%lu prosent ferdig.\r" + +STRING_FORMAT_FAIL "FormatEx var ikke i stand til fullstendig vellykket.\n\n" + +STRING_NO_SUPPORT "Operasjon ikke støttet" + +STRING_FMIFS_FAIL "Kunne ikke befinne seg FMIFS artikkel momenter.\n\n" + +STRING_UNKNOW_ARG "Ukjent argument: %S\n" + +STRING_DRIVE_PARM "Obligatorisk drive parameter er mistet.\n\n" + +STRING_ERROR_DRIVE_TYPE "Kunne ikke få drive typen" + +STRING_INSERT_DISK "Sett inn en ny diskett i stasjon %C:\nog trykk på Enter når du er klar..." + +STRING_NO_VOLUME "Kunne ikke spørre om volumet" + +STRING_NO_VOLUME_SIZE "Kunne ikke spørre om volumet størrelse" + +STRING_FILESYSTEM "Typen av filsystem er %S.\n" + +STRING_LABEL_NAME_EDIT "Velg aktuell volum merke for stasjon %C: " + +STRING_ERROR_LABEL "Et uriktig volum merke ble innskrivet for denne stasjonen.\n" + +STRING_YN_FORMAT "\nADVARSEL, ALLE DATA PÅ EN DISK SOM IKKE KAN FJERNES \n\ +STASJON %C: VIL BLI BORTE!\nFortsette med Formateringen (J/N)? " + +STRING_YES_NO_FAQ "JN" + +STRING_VERIFYING "kontrollerer" + +STRING_FAST_FMT "Rask Formatering" + +STRING_CREATE_FSYS "Opprett filsystem struktur.\n" + +STRING_FMT_COMPLETE "Formateringen fullført.\n" + +STRING_VOL_COMPRESS "Volumet støtter ikke komprimering.\n" + +STRING_ENTER_LABEL "Volum merke (11 tegn, legge inn for ingen)? " + +STRING_NO_LABEL "Kunne ikke merke volumet" + +STRING_FREE_SPACE "\n%I64d byte total ledig plass.\n%I64d byte tilgjengelig på disken.\n" + +STRING_SERIAL_NUMBER "\nVolumet Serie nummer er %04X-%04X\n" +} Propchange: trunk/reactos/base/system/format/No.rc ------------------------------------------------------------------------------ svn:eol-style = native Modified: trunk/reactos/base/system/format/format.rc URL: http://svn.reactos.org/svn/reactos/trunk/reactos/base/system/format/format.… ============================================================================== --- trunk/reactos/base/system/format/format.rc (original) +++ trunk/reactos/base/system/format/format.rc Sat Jul 29 00:03:29 2006 @@ -8,3 +8,4 @@ #include "De.rc" #include "Fr.rc" #include "Hu.rc" +#include "No.rc"

1 0

← Newer
1
...
4
5
6
7
8
9
10
...
67
Older →

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Ros-diffs July 2006