ReactOS  0.4.14-dev-552-g2fad488
cmi.c File Reference
#include "mkhive.h"
Include dependency graph for cmi.c:

Go to the source code of this file.

Macros

#define NDEBUG
 

Functions

PVOID NTAPI CmpAllocate (IN SIZE_T Size, IN BOOLEAN Paged, IN ULONG Tag)
 
VOID NTAPI CmpFree (IN PVOID Ptr, IN ULONG Quota)
 
static BOOLEAN NTAPI CmpFileRead (IN PHHIVE RegistryHive, IN ULONG FileType, IN PULONG FileOffset, OUT PVOID Buffer, IN SIZE_T BufferLength)
 
static BOOLEAN NTAPI CmpFileWrite (IN PHHIVE RegistryHive, IN ULONG FileType, IN PULONG FileOffset, IN PVOID Buffer, IN SIZE_T BufferLength)
 
static BOOLEAN NTAPI CmpFileSetSize (IN PHHIVE RegistryHive, IN ULONG FileType, IN ULONG FileSize, IN ULONG OldFileSize)
 
static BOOLEAN NTAPI CmpFileFlush (IN PHHIVE RegistryHive, IN ULONG FileType, PLARGE_INTEGER FileOffset, ULONG Length)
 
NTSTATUS CmiInitializeHive (IN OUT PCMHIVE Hive, IN PCWSTR Name)
 
NTSTATUS CmiCreateSecurityKey (IN PHHIVE Hive, IN HCELL_INDEX Cell, IN PUCHAR Descriptor, IN ULONG DescriptorLength)
 
static NTSTATUS CmiCreateSubKey (IN PCMHIVE RegistryHive, IN HCELL_INDEX ParentKeyCellOffset, IN PCUNICODE_STRING SubKeyName, IN BOOLEAN VolatileKey, OUT HCELL_INDEX *pNKBOffset)
 
NTSTATUS CmiAddSubKey (IN PCMHIVE RegistryHive, IN HCELL_INDEX ParentKeyCellOffset, IN PCUNICODE_STRING SubKeyName, IN BOOLEAN VolatileKey, OUT HCELL_INDEX *pBlockOffset)
 
NTSTATUS CmiAddValueKey (IN PCMHIVE RegistryHive, IN PCM_KEY_NODE Parent, IN ULONG ChildIndex, IN PCUNICODE_STRING ValueName, OUT PCM_KEY_VALUE *pValueCell, OUT HCELL_INDEX *pValueCellOffset)
 

Macro Definition Documentation

◆ NDEBUG

#define NDEBUG

Definition at line 30 of file cmi.c.

Function Documentation

◆ CmiAddSubKey()

NTSTATUS CmiAddSubKey ( IN PCMHIVE  RegistryHive,
IN HCELL_INDEX  ParentKeyCellOffset,
IN PCUNICODE_STRING  SubKeyName,
IN BOOLEAN  VolatileKey,
OUT HCELL_INDEX pBlockOffset 
)

Definition at line 297 of file cmi.c.

303 {
304  PCM_KEY_NODE ParentKeyCell;
305  HCELL_INDEX NKBOffset;
307 
308  /* Create the new key */
309  Status = CmiCreateSubKey(RegistryHive, ParentKeyCellOffset, SubKeyName, VolatileKey, &NKBOffset);
310  if (!NT_SUCCESS(Status))
311  return Status;
312 
313  /* Mark the parent cell as dirty */
314  HvMarkCellDirty(&RegistryHive->Hive, ParentKeyCellOffset, FALSE);
315 
316  if (!CmpAddSubKey(&RegistryHive->Hive, ParentKeyCellOffset, NKBOffset))
317  {
318  /* FIXME: delete newly created cell */
319  // CmpFreeKeyByCell(&RegistryHive->Hive, NewCell /*NKBOffset*/, FALSE);
320  ASSERT(FALSE);
321  return STATUS_UNSUCCESSFUL;
322  }
323 
324  /* Get the parent node */
325  ParentKeyCell = (PCM_KEY_NODE)HvGetCell(&RegistryHive->Hive, ParentKeyCellOffset);
326  if (!ParentKeyCell)
327  {
328  /* FIXME: delete newly created cell */
329  return STATUS_UNSUCCESSFUL;
330  }
331  VERIFY_KEY_CELL(ParentKeyCell);
332 
333  /* Update the timestamp */
334  KeQuerySystemTime(&ParentKeyCell->LastWriteTime);
335 
336  /* Check if we need to update name maximum, update it if so */
337  if (ParentKeyCell->MaxNameLen < SubKeyName->Length)
338  ParentKeyCell->MaxNameLen = SubKeyName->Length;
339 
340  /* Release the cell */
341  HvReleaseCell(&RegistryHive->Hive, ParentKeyCellOffset);
342 
343  *pBlockOffset = NKBOffset;
344  return STATUS_SUCCESS;
345 }
#define KeQuerySystemTime(t)
Definition: env_spec_w32.h:570
BOOLEAN NTAPI CmpAddSubKey(IN PHHIVE Hive, IN HCELL_INDEX Parent, IN HCELL_INDEX Child)
Definition: cmindex.c:1467
_Must_inspect_result_ _Out_ PNDIS_STATUS _In_ NDIS_HANDLE _In_ PNDIS_STRING SubKeyName
Definition: ndis.h:4723
#define HvReleaseCell(h, c)
Definition: cmlib.h:390
LONG NTSTATUS
Definition: precomp.h:26
#define VERIFY_KEY_CELL(key)
Definition: cmi.h:29
static NTSTATUS CmiCreateSubKey(IN PCMHIVE RegistryHive, IN HCELL_INDEX ParentKeyCellOffset, IN PCUNICODE_STRING SubKeyName, IN BOOLEAN VolatileKey, OUT HCELL_INDEX *pNKBOffset)
Definition: cmi.c:198
ULONG MaxNameLen
Definition: cmdata.h:109
PVOID CMAPI HvGetCell(PHHIVE RegistryHive, HCELL_INDEX CellOffset)
Definition: hivecell.c:67
struct _CM_KEY_NODE * PCM_KEY_NODE
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
ULONG HCELL_INDEX
Definition: hivedata.h:80
BOOLEAN CMAPI HvMarkCellDirty(PHHIVE RegistryHive, HCELL_INDEX CellOffset, BOOLEAN HoldingLock)
Definition: hivecell.c:100
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
LARGE_INTEGER LastWriteTime
Definition: cmdata.h:94
Status
Definition: gdiplustypes.h:24
return STATUS_SUCCESS
Definition: btrfs.c:2938

Referenced by RegpCreateOrOpenKey().

◆ CmiAddValueKey()

NTSTATUS CmiAddValueKey ( IN PCMHIVE  RegistryHive,
IN PCM_KEY_NODE  Parent,
IN ULONG  ChildIndex,
IN PCUNICODE_STRING  ValueName,
OUT PCM_KEY_VALUE pValueCell,
OUT HCELL_INDEX pValueCellOffset 
)

Definition at line 348 of file cmi.c.

355 {
358  PCM_KEY_VALUE NewValueCell;
359  HCELL_INDEX NewValueCellOffset;
360 
361  Storage = (Parent->Flags & KEY_IS_VOLATILE) ? Volatile : Stable;
362 
363  NewValueCellOffset = HvAllocateCell(&RegistryHive->Hive,
365  CmpNameSize(&RegistryHive->Hive, (PUNICODE_STRING)ValueName),
366  Storage,
367  HCELL_NIL);
368  if (NewValueCellOffset == HCELL_NIL)
369  {
371  }
372 
373  NewValueCell = (PCM_KEY_VALUE)HvGetCell(&RegistryHive->Hive, NewValueCellOffset);
374  if (NewValueCell == NULL)
375  {
376  HvFreeCell(&RegistryHive->Hive, NewValueCellOffset);
378  }
379 
380  NewValueCell->Signature = CM_KEY_VALUE_SIGNATURE;
381  NewValueCell->NameLength = CmpCopyName(&RegistryHive->Hive,
382  NewValueCell->Name,
384 
385  /* Check for compressed name */
386  if (NewValueCell->NameLength < ValueName->Length)
387  {
388  /* This is a compressed name */
389  NewValueCell->Flags = VALUE_COMP_NAME;
390  }
391  else
392  {
393  /* No flags to set */
394  NewValueCell->Flags = 0;
395  }
396 
397  NewValueCell->Type = 0;
398  NewValueCell->DataLength = 0;
399  NewValueCell->Data = HCELL_NIL;
400 
401  HvMarkCellDirty(&RegistryHive->Hive, NewValueCellOffset, FALSE);
402 
403  /* Check if we already have a value list */
404  if (Parent->ValueList.Count)
405  {
406  /* Then make sure it's valid and dirty it */
407  ASSERT(Parent->ValueList.List != HCELL_NIL);
408  HvMarkCellDirty(&RegistryHive->Hive, Parent->ValueList.List, FALSE);
409  }
410 
411  /* Add this value cell to the child list */
412  Status = CmpAddValueToList(&RegistryHive->Hive,
413  NewValueCellOffset,
414  ChildIndex,
415  Storage,
416  &Parent->ValueList);
417 
418  /* If we failed, free the entire cell, including the data */
419  if (!NT_SUCCESS(Status))
420  {
421  /* Overwrite the status with a known one */
422  CmpFreeValue(&RegistryHive->Hive, NewValueCellOffset);
424  }
425  else
426  {
427  *pValueCell = NewValueCell;
428  *pValueCellOffset = NewValueCellOffset;
430  }
431 
432  return Status;
433 }
#define CM_KEY_VALUE_SIGNATURE
Definition: cmdata.h:24
HCELL_INDEX Data
Definition: cmdata.h:127
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
USHORT Flags
Definition: cmdata.h:129
LONG NTSTATUS
Definition: precomp.h:26
#define KEY_IS_VOLATILE
Definition: cmdata.h:30
#define HCELL_NIL
Definition: hivedata.h:85
HCELL_INDEX CMAPI HvAllocateCell(PHHIVE RegistryHive, ULONG Size, HSTORAGE_TYPE Storage, IN HCELL_INDEX Vicinity)
ACPI_PHYSICAL_ADDRESS ACPI_SIZE BOOLEAN Warn BOOLEAN Physical UINT32 ACPI_TABLE_HEADER *OutTableHeader ACPI_TABLE_HEADER **OutTable ACPI_HANDLE UINT32 ACPI_WALK_CALLBACK ACPI_WALK_CALLBACK void void **ReturnValue UINT32 ACPI_BUFFER *RetPathPtr ACPI_OBJECT_HANDLER void *Data ACPI_OBJECT_HANDLER void **Data ACPI_STRING ACPI_OBJECT_LIST ACPI_BUFFER *ReturnObjectBuffer ACPI_DEVICE_INFO **ReturnBuffer ACPI_HANDLE Parent
Definition: acpixf.h:728
NTSTATUS NTAPI CmpAddValueToList(IN PHHIVE Hive, IN HCELL_INDEX ValueCell, IN ULONG Index, IN HSTORAGE_TYPE StorageType, IN OUT PCHILD_LIST ChildList)
Definition: cmvalue.c:207
ULONG DataLength
Definition: cmdata.h:126
_In_ PUNICODE_STRING ValueName
Definition: cmfuncs.h:264
BOOLEAN NTAPI CmpFreeValue(IN PHHIVE Hive, IN HCELL_INDEX Cell)
Definition: cmvalue.c:73
USHORT NameLength
Definition: cmdata.h:125
PVOID CMAPI HvGetCell(PHHIVE RegistryHive, HCELL_INDEX CellOffset)
Definition: hivecell.c:67
WCHAR Name[ANYSIZE_ARRAY]
Definition: cmdata.h:131
smooth NULL
Definition: ftsmooth.c:416
USHORT NTAPI CmpCopyName(IN PHHIVE Hive, OUT PWCHAR Destination, IN PUNICODE_STRING Source)
Definition: cmname.c:21
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
ULONG HCELL_INDEX
Definition: hivedata.h:80
#define VALUE_COMP_NAME
Definition: cmdata.h:44
BOOLEAN CMAPI HvMarkCellDirty(PHHIVE RegistryHive, HCELL_INDEX CellOffset, BOOLEAN HoldingLock)
Definition: hivecell.c:100
USHORT Signature
Definition: cmdata.h:124
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
VOID CMAPI HvFreeCell(PHHIVE RegistryHive, HCELL_INDEX CellOffset)
Definition: hivecell.c:441
USHORT NTAPI CmpNameSize(IN PHHIVE Hive, IN PUNICODE_STRING Name)
Definition: cmname.c:74
Status
Definition: gdiplustypes.h:24
struct _CM_KEY_VALUE * PCM_KEY_VALUE
ULONG Type
Definition: cmdata.h:128
HSTORAGE_TYPE
Definition: hivedata.h:100
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:254
return STATUS_SUCCESS
Definition: btrfs.c:2938
static IStorage Storage
Definition: ole2.c:3548

Referenced by RegSetValueExW().

◆ CmiCreateSecurityKey()

NTSTATUS CmiCreateSecurityKey ( IN PHHIVE  Hive,
IN HCELL_INDEX  Cell,
IN PUCHAR  Descriptor,
IN ULONG  DescriptorLength 
)

Definition at line 157 of file cmi.c.

162 {
163  HCELL_INDEX SecurityCell;
165  PCM_KEY_SECURITY Security;
166 
167  Node = (PCM_KEY_NODE)HvGetCell(Hive, Cell);
168  SecurityCell = HvAllocateCell(Hive,
170  DescriptorLength,
171  Stable,
172  HCELL_NIL);
173  if (SecurityCell == HCELL_NIL)
174  {
175  HvReleaseCell(Hive, Cell);
177  }
178 
179  Node->Security = SecurityCell;
180  Security = (PCM_KEY_SECURITY)HvGetCell(Hive, SecurityCell);
182  Security->ReferenceCount = 1;
183  Security->DescriptorLength = DescriptorLength;
184 
185  RtlMoveMemory(&Security->Descriptor,
186  Descriptor,
187  DescriptorLength);
188 
189  Security->Flink = Security->Blink = SecurityCell;
190 
191  HvReleaseCell(Hive, SecurityCell);
192  HvReleaseCell(Hive, Cell);
193 
194  return STATUS_SUCCESS;
195 }
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
#define CM_KEY_SECURITY_SIGNATURE
Definition: cmdata.h:23
#define HvReleaseCell(h, c)
Definition: cmlib.h:390
#define HCELL_NIL
Definition: hivedata.h:85
HCELL_INDEX Flink
Definition: cmdata.h:141
SECURITY_DESCRIPTOR_RELATIVE Descriptor
Definition: cmdata.h:145
HCELL_INDEX CMAPI HvAllocateCell(PHHIVE RegistryHive, ULONG Size, HSTORAGE_TYPE Storage, IN HCELL_INDEX Vicinity)
#define RtlMoveMemory(Destination, Source, Length)
Definition: typedefs.h:263
struct _CM_KEY_SECURITY * PCM_KEY_SECURITY
union node Node
Definition: types.h:1255
PVOID CMAPI HvGetCell(PHHIVE RegistryHive, HCELL_INDEX CellOffset)
Definition: hivecell.c:67
struct _CM_KEY_NODE * PCM_KEY_NODE
ULONG ReferenceCount
Definition: cmdata.h:143
ULONG HCELL_INDEX
Definition: hivedata.h:80
ULONG DescriptorLength
Definition: cmdata.h:144
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:254
USHORT Signature
Definition: cmdata.h:139
return STATUS_SUCCESS
Definition: btrfs.c:2938
HCELL_INDEX Blink
Definition: cmdata.h:142
Definition: dlist.c:348
_In_ PSTORAGE_PROPERTY_ID _Outptr_ PSTORAGE_DESCRIPTOR_HEADER * Descriptor
Definition: classpnp.h:966

Referenced by ConnectRegistry().

◆ CmiCreateSubKey()

static NTSTATUS CmiCreateSubKey ( IN PCMHIVE  RegistryHive,
IN HCELL_INDEX  ParentKeyCellOffset,
IN PCUNICODE_STRING  SubKeyName,
IN BOOLEAN  VolatileKey,
OUT HCELL_INDEX pNKBOffset 
)
static

Definition at line 198 of file cmi.c.

204 {
205  HCELL_INDEX NKBOffset;
206  PCM_KEY_NODE NewKeyCell;
209 
210  /* Skip leading path separator if present */
211  if (SubKeyName->Buffer[0] == OBJ_NAME_PATH_SEPARATOR)
212  {
213  KeyName.Buffer = &SubKeyName->Buffer[1];
214  KeyName.Length = KeyName.MaximumLength = SubKeyName->Length - sizeof(WCHAR);
215  }
216  else
217  {
218  KeyName = *SubKeyName;
219  }
220 
221  Storage = (VolatileKey ? Volatile : Stable);
222 
223  NKBOffset = HvAllocateCell(&RegistryHive->Hive,
225  CmpNameSize(&RegistryHive->Hive, &KeyName),
226  Storage,
227  HCELL_NIL);
228  if (NKBOffset == HCELL_NIL)
229  {
231  }
232 
233  NewKeyCell = (PCM_KEY_NODE)HvGetCell(&RegistryHive->Hive, NKBOffset);
234  if (NewKeyCell == NULL)
235  {
236  HvFreeCell(&RegistryHive->Hive, NKBOffset);
238  }
239 
240  NewKeyCell->Signature = CM_KEY_NODE_SIGNATURE;
241  NewKeyCell->Flags = (VolatileKey ? KEY_IS_VOLATILE : 0);
242  KeQuerySystemTime(&NewKeyCell->LastWriteTime);
243  NewKeyCell->Parent = ParentKeyCellOffset;
244  NewKeyCell->SubKeyCounts[Stable] = 0;
245  NewKeyCell->SubKeyCounts[Volatile] = 0;
246  NewKeyCell->SubKeyLists[Stable] = HCELL_NIL;
247  NewKeyCell->SubKeyLists[Volatile] = HCELL_NIL;
248  NewKeyCell->ValueList.Count = 0;
249  NewKeyCell->ValueList.List = HCELL_NIL;
250  NewKeyCell->Security = HCELL_NIL;
251  NewKeyCell->Class = HCELL_NIL;
252  NewKeyCell->ClassLength = 0;
253  NewKeyCell->MaxNameLen = 0;
254  NewKeyCell->MaxClassLen = 0;
255  NewKeyCell->MaxValueNameLen = 0;
256  NewKeyCell->MaxValueDataLen = 0;
257  NewKeyCell->NameLength = CmpCopyName(&RegistryHive->Hive, NewKeyCell->Name, &KeyName);
258  if (NewKeyCell->NameLength < KeyName.Length) NewKeyCell->Flags |= KEY_COMP_NAME;
259 
260  /* Inherit the security from the parent */
261  if (ParentKeyCellOffset == HCELL_NIL)
262  {
263  // We are in fact creating a root key.
264  // This is not handled there, but when we
265  // call CmCreateRootNode instead.
266  ASSERT(FALSE);
267  }
268  else
269  {
270  /* Get the parent node */
271  PCM_KEY_NODE ParentKeyCell;
272  ParentKeyCell = (PCM_KEY_NODE)HvGetCell(&RegistryHive->Hive, ParentKeyCellOffset);
273 
274  if (ParentKeyCell)
275  {
276  /* Inherit the security block of the parent */
277  NewKeyCell->Security = ParentKeyCell->Security;
278  if (NewKeyCell->Security != HCELL_NIL)
279  {
280  PCM_KEY_SECURITY Security;
281  Security = (PCM_KEY_SECURITY)HvGetCell(&RegistryHive->Hive, NewKeyCell->Security);
282  ++Security->ReferenceCount;
283  HvReleaseCell(&RegistryHive->Hive, NewKeyCell->Security);
284  }
285 
286  HvReleaseCell(&RegistryHive->Hive, ParentKeyCellOffset);
287  }
288  }
289 
290  HvReleaseCell(&RegistryHive->Hive, NKBOffset);
291 
292  *pNKBOffset = NKBOffset;
293  return STATUS_SUCCESS;
294 }
#define KeQuerySystemTime(t)
Definition: env_spec_w32.h:570
#define KEY_COMP_NAME
Definition: cmdata.h:35
_Must_inspect_result_ _Out_ PNDIS_STATUS _In_ NDIS_HANDLE _In_ ULONG _Out_ PNDIS_STRING KeyName
Definition: ndis.h:4711
WCHAR Name[ANYSIZE_ARRAY]
Definition: cmdata.h:116
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
HCELL_INDEX List
Definition: cmdata.h:75
_Must_inspect_result_ _Out_ PNDIS_STATUS _In_ NDIS_HANDLE _In_ PNDIS_STRING SubKeyName
Definition: ndis.h:4723
ULONG MaxValueNameLen
Definition: cmdata.h:111
#define CM_KEY_NODE_SIGNATURE
Definition: cmdata.h:21
USHORT ClassLength
Definition: cmdata.h:115
#define HvReleaseCell(h, c)
Definition: cmlib.h:390
#define KEY_IS_VOLATILE
Definition: cmdata.h:30
#define HCELL_NIL
Definition: hivedata.h:85
HCELL_INDEX CMAPI HvAllocateCell(PHHIVE RegistryHive, ULONG Size, HSTORAGE_TYPE Storage, IN HCELL_INDEX Vicinity)
USHORT NameLength
Definition: cmdata.h:114
struct _CM_KEY_SECURITY * PCM_KEY_SECURITY
ULONG MaxNameLen
Definition: cmdata.h:109
HCELL_INDEX Class
Definition: cmdata.h:108
#define OBJ_NAME_PATH_SEPARATOR
Definition: arcname_tests.c:25
PVOID CMAPI HvGetCell(PHHIVE RegistryHive, HCELL_INDEX CellOffset)
Definition: hivecell.c:67
HCELL_INDEX SubKeyLists[HTYPE_COUNT]
Definition: cmdata.h:102
smooth NULL
Definition: ftsmooth.c:416
struct _CM_KEY_NODE * PCM_KEY_NODE
ULONG ReferenceCount
Definition: cmdata.h:143
CHILD_LIST ValueList
Definition: cmdata.h:103
USHORT NTAPI CmpCopyName(IN PHHIVE Hive, OUT PWCHAR Destination, IN PUNICODE_STRING Source)
Definition: cmname.c:21
__wchar_t WCHAR
Definition: xmlstorage.h:180
HCELL_INDEX Parent
Definition: cmdata.h:96
ULONG HCELL_INDEX
Definition: hivedata.h:80
ULONG SubKeyCounts[HTYPE_COUNT]
Definition: cmdata.h:97
USHORT Signature
Definition: cmdata.h:92
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
VOID CMAPI HvFreeCell(PHHIVE RegistryHive, HCELL_INDEX CellOffset)
Definition: hivecell.c:441
USHORT NTAPI CmpNameSize(IN PHHIVE Hive, IN PUNICODE_STRING Name)
Definition: cmname.c:74
LARGE_INTEGER LastWriteTime
Definition: cmdata.h:94
ULONG Count
Definition: cmdata.h:74
HCELL_INDEX Security
Definition: cmdata.h:107
ULONG MaxClassLen
Definition: cmdata.h:110
HSTORAGE_TYPE
Definition: hivedata.h:100
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:254
ULONG MaxValueDataLen
Definition: cmdata.h:112
return STATUS_SUCCESS
Definition: btrfs.c:2938
static IStorage Storage
Definition: ole2.c:3548
USHORT Flags
Definition: cmdata.h:93

Referenced by CmiAddSubKey().

◆ CmiInitializeHive()

NTSTATUS CmiInitializeHive ( IN OUT PCMHIVE  Hive,
IN PCWSTR  Name 
)

Definition at line 114 of file cmi.c.

117 {
119 
120  RtlZeroMemory(Hive, sizeof(*Hive));
121 
122  DPRINT("Hive 0x%p\n", Hive);
123 
124  Status = HvInitialize(&Hive->Hive,
125  HINIT_CREATE,
128  0,
129  CmpAllocate,
130  CmpFree,
132  CmpFileWrite,
133  CmpFileRead,
134  CmpFileFlush,
135  1,
136  NULL);
137  if (!NT_SUCCESS(Status))
138  {
139  return Status;
140  }
141 
142  // HACK: See the HACK from r31253
143  if (!CmCreateRootNode(&Hive->Hive, Name))
144  {
145  HvFree(&Hive->Hive);
147  }
148 
149  /* Add the new hive to the hive list */
151  &Hive->HiveList);
152 
153  return STATUS_SUCCESS;
154 }
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
static BOOLEAN NTAPI CmpFileRead(IN PHHIVE RegistryHive, IN ULONG FileType, IN PULONG FileOffset, OUT PVOID Buffer, IN SIZE_T BufferLength)
Definition: cmi.c:56
NTSTATUS CMAPI HvInitialize(PHHIVE RegistryHive, ULONG OperationType, ULONG HiveFlags, ULONG FileType, PVOID HiveData OPTIONAL, PALLOCATE_ROUTINE Allocate, PFREE_ROUTINE Free, PFILE_SET_SIZE_ROUTINE FileSetSize, PFILE_WRITE_ROUTINE FileWrite, PFILE_READ_ROUTINE FileRead, PFILE_FLUSH_ROUTINE FileFlush, ULONG Cluster OPTIONAL, PCUNICODE_STRING FileName OPTIONAL)
Definition: hiveinit.c:522
LIST_ENTRY CmiHiveListHead
Definition: registry.c:385
LONG NTSTATUS
Definition: precomp.h:26
#define InsertTailList(ListHead, Entry)
static BOOLEAN NTAPI CmpFileFlush(IN PHHIVE RegistryHive, IN ULONG FileType, PLARGE_INTEGER FileOffset, ULONG Length)
Definition: cmi.c:102
smooth NULL
Definition: ftsmooth.c:416
void DPRINT(...)
Definition: polytest.cpp:61
VOID CMAPI HvFree(PHHIVE RegistryHive)
Definition: hiveinit.c:623
BOOLEAN CMAPI CmCreateRootNode(PHHIVE Hive, PCWSTR Name)
Definition: cminit.c:17
#define HINIT_CREATE
Definition: hivedata.h:13
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
VOID NTAPI CmpFree(IN PVOID Ptr, IN ULONG Quota)
Definition: cmi.c:47
Status
Definition: gdiplustypes.h:24
static BOOLEAN NTAPI CmpFileSetSize(IN PHHIVE RegistryHive, IN ULONG FileType, IN ULONG FileSize, IN ULONG OldFileSize)
Definition: cmi.c:90
static BOOLEAN NTAPI CmpFileWrite(IN PHHIVE RegistryHive, IN ULONG FileType, IN PULONG FileOffset, IN PVOID Buffer, IN SIZE_T BufferLength)
Definition: cmi.c:73
#define HFILE_TYPE_PRIMARY
Definition: hivedata.h:33
#define HIVE_NOLAZYFLUSH
Definition: hivedata.h:24
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
return STATUS_SUCCESS
Definition: btrfs.c:2938
PVOID NTAPI CmpAllocate(IN SIZE_T Size, IN BOOLEAN Paged, IN ULONG Tag)
Definition: cmi.c:37

Referenced by ConnectRegistry(), and RegInitializeRegistry().

◆ CmpAllocate()

PVOID NTAPI CmpAllocate ( IN SIZE_T  Size,
IN BOOLEAN  Paged,
IN ULONG  Tag 
)

Definition at line 37 of file cmi.c.

41 {
42  return (PVOID)malloc((size_t)Size);
43 }
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:359
#define malloc
Definition: debug_ros.c:4

Referenced by CmiInitializeHive().

◆ CmpFileFlush()

static BOOLEAN NTAPI CmpFileFlush ( IN PHHIVE  RegistryHive,
IN ULONG  FileType,
PLARGE_INTEGER  FileOffset,
ULONG  Length 
)
static

Definition at line 102 of file cmi.c.

107 {
108  PCMHIVE CmHive = (PCMHIVE)RegistryHive;
110  return (fflush(File) == 0);
111 }
struct _CMHIVE * PCMHIVE
HANDLE FileHandles[HFILE_TYPE_MAX]
Definition: cm.h:394
#define HFILE_TYPE_PRIMARY
Definition: hivedata.h:33
_Check_return_opt_ _CRTIMP int __cdecl fflush(_Inout_opt_ FILE *_File)
static PCMHIVE CmHive
Definition: registry.c:28
Definition: File.h:15
Definition: cm.h:391

Referenced by CmiInitializeHive().

◆ CmpFileRead()

static BOOLEAN NTAPI CmpFileRead ( IN PHHIVE  RegistryHive,
IN ULONG  FileType,
IN PULONG  FileOffset,
OUT PVOID  Buffer,
IN SIZE_T  BufferLength 
)
static

Definition at line 56 of file cmi.c.

62 {
63  PCMHIVE CmHive = (PCMHIVE)RegistryHive;
65  if (fseek(File, *FileOffset, SEEK_SET) != 0)
66  return FALSE;
67 
68  return (fread(Buffer, 1, BufferLength, File) == BufferLength);
69 }
struct _CMHIVE * PCMHIVE
_Check_return_opt_ _CRTIMP size_t __cdecl fread(_Out_writes_bytes_(_ElementSize *_Count) void *_DstBuf, _In_ size_t _ElementSize, _In_ size_t _Count, _Inout_ FILE *_File)
_In_ ULONG BufferLength
Definition: usbdlib.h:225
HANDLE FileHandles[HFILE_TYPE_MAX]
Definition: cm.h:394
_Check_return_opt_ _CRTIMP int __cdecl fseek(_Inout_ FILE *_File, _In_ long _Offset, _In_ int _Origin)
Definition: bufpool.h:45
#define SEEK_SET
Definition: jmemansi.c:26
#define HFILE_TYPE_PRIMARY
Definition: hivedata.h:33
_In_ PFCB _In_ LONGLONG FileOffset
Definition: cdprocs.h:151
static PCMHIVE CmHive
Definition: registry.c:28
Definition: File.h:15
Definition: cm.h:391

Referenced by CmiInitializeHive().

◆ CmpFileSetSize()

static BOOLEAN NTAPI CmpFileSetSize ( IN PHHIVE  RegistryHive,
IN ULONG  FileType,
IN ULONG  FileSize,
IN ULONG  OldFileSize 
)
static

Definition at line 90 of file cmi.c.

95 {
96  DPRINT1("CmpFileSetSize() unimplemented\n");
97  return FALSE;
98 }
#define DPRINT1
Definition: precomp.h:8

Referenced by CmiInitializeHive().

◆ CmpFileWrite()

static BOOLEAN NTAPI CmpFileWrite ( IN PHHIVE  RegistryHive,
IN ULONG  FileType,
IN PULONG  FileOffset,
IN PVOID  Buffer,
IN SIZE_T  BufferLength 
)
static

Definition at line 73 of file cmi.c.

79 {
80  PCMHIVE CmHive = (PCMHIVE)RegistryHive;
82  if (fseek(File, *FileOffset, SEEK_SET) != 0)
83  return FALSE;
84 
85  return (fwrite(Buffer, 1, BufferLength, File) == BufferLength);
86 }
struct _CMHIVE * PCMHIVE
_Check_return_opt_ _CRTIMP size_t __cdecl fwrite(_In_reads_bytes_(_Size *_Count) const void *_Str, _In_ size_t _Size, _In_ size_t _Count, _Inout_ FILE *_File)
_In_ ULONG BufferLength
Definition: usbdlib.h:225
HANDLE FileHandles[HFILE_TYPE_MAX]
Definition: cm.h:394
_Check_return_opt_ _CRTIMP int __cdecl fseek(_Inout_ FILE *_File, _In_ long _Offset, _In_ int _Origin)
Definition: bufpool.h:45
#define SEEK_SET
Definition: jmemansi.c:26
#define HFILE_TYPE_PRIMARY
Definition: hivedata.h:33
_In_ PFCB _In_ LONGLONG FileOffset
Definition: cdprocs.h:151
static PCMHIVE CmHive
Definition: registry.c:28
Definition: File.h:15
Definition: cm.h:391

Referenced by CmiInitializeHive().

◆ CmpFree()

VOID NTAPI CmpFree ( IN PVOID  Ptr,
IN ULONG  Quota 
)

Definition at line 47 of file cmi.c.

50 {
51  free(Ptr);
52 }
#define free
Definition: debug_ros.c:5
_Must_inspect_result_ _In_ PFSRTL_PER_STREAM_CONTEXT Ptr
Definition: fsrtlfuncs.h:898

Referenced by CmiInitializeHive().