ReactOS 0.4.15-dev-7196-g0fe0b40
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}
LONG NTSTATUS
Definition: precomp.h:26
struct _CM_KEY_NODE * PCM_KEY_NODE
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
#define VERIFY_KEY_CELL(key)
Definition: cmi.h:29
BOOLEAN NTAPI CmpAddSubKey(IN PHHIVE Hive, IN HCELL_INDEX Parent, IN HCELL_INDEX Child)
Definition: cmindex.c:1465
#define HvReleaseCell(Hive, Cell)
Definition: cmlib.h:455
BOOLEAN CMAPI HvMarkCellDirty(PHHIVE RegistryHive, HCELL_INDEX CellOffset, BOOLEAN HoldingLock)
Definition: hivecell.c:109
#define HvGetCell(Hive, Cell)
Definition: cmlib.h:452
#define FALSE
Definition: types.h:117
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define KeQuerySystemTime(t)
Definition: env_spec_w32.h:570
Status
Definition: gdiplustypes.h:25
ULONG HCELL_INDEX
Definition: hivedata.h:105
#define ASSERT(a)
Definition: mode.c:44
_Must_inspect_result_ _Out_ PNDIS_STATUS _In_ NDIS_HANDLE _In_ PNDIS_STRING SubKeyName
Definition: ndis.h:4725
#define STATUS_SUCCESS
Definition: shellext.h:65
ULONG MaxNameLen
Definition: cmdata.h:109
LARGE_INTEGER LastWriteTime
Definition: cmdata.h:94
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132

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
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}
ACPI_PHYSICAL_ADDRESS ACPI_SIZE BOOLEAN Warn UINT32 *TableIdx 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:732
struct _CM_KEY_VALUE * PCM_KEY_VALUE
#define KEY_IS_VOLATILE
Definition: cmdata.h:30
#define CM_KEY_VALUE_SIGNATURE
Definition: cmdata.h:24
#define VALUE_COMP_NAME
Definition: cmdata.h:44
USHORT NTAPI CmpCopyName(IN PHHIVE Hive, OUT PWCHAR Destination, IN PCUNICODE_STRING Source)
Definition: cmname.c:21
BOOLEAN NTAPI CmpFreeValue(IN PHHIVE Hive, IN HCELL_INDEX Cell)
Definition: cmvalue.c:73
USHORT NTAPI CmpNameSize(IN PHHIVE Hive, IN PCUNICODE_STRING Name)
Definition: cmname.c:74
VOID CMAPI HvFreeCell(PHHIVE RegistryHive, HCELL_INDEX CellOffset)
Definition: hivecell.c:468
HCELL_INDEX CMAPI HvAllocateCell(PHHIVE RegistryHive, ULONG Size, HSTORAGE_TYPE Storage, IN HCELL_INDEX Vicinity)
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
#define NULL
Definition: types.h:112
HSTORAGE_TYPE
Definition: hivedata.h:126
@ Volatile
Definition: hivedata.h:128
@ Stable
Definition: hivedata.h:127
#define HCELL_NIL
Definition: hivedata.h:110
static IStorage Storage
Definition: ole2.c:3548
USHORT Signature
Definition: cmdata.h:124
ULONG Type
Definition: cmdata.h:128
HCELL_INDEX Data
Definition: cmdata.h:127
WCHAR Name[ANYSIZE_ARRAY]
Definition: cmdata.h:131
USHORT NameLength
Definition: cmdata.h:125
USHORT Flags
Definition: cmdata.h:129
ULONG DataLength
Definition: cmdata.h:126
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING ValueName
Definition: wdfregistry.h:243

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,
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 CM_KEY_SECURITY_SIGNATURE
Definition: cmdata.h:23
struct _CM_KEY_SECURITY * PCM_KEY_SECURITY
union node Node
Definition: types.h:1255
ULONG DescriptorLength
Definition: cmdata.h:144
HCELL_INDEX Flink
Definition: cmdata.h:141
ULONG ReferenceCount
Definition: cmdata.h:143
HCELL_INDEX Blink
Definition: cmdata.h:142
USHORT Signature
Definition: cmdata.h:139
SECURITY_DESCRIPTOR_RELATIVE Descriptor
Definition: cmdata.h:145
#define RtlMoveMemory(Destination, Source, Length)
Definition: typedefs.h:264
Definition: dlist.c:348
_Must_inspect_result_ _In_ WDFIORESLIST _In_ PIO_RESOURCE_DESCRIPTOR Descriptor
Definition: wdfresource.h:342

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 {
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 OBJ_NAME_PATH_SEPARATOR
Definition: arcname_tests.c:25
#define KEY_COMP_NAME
Definition: cmdata.h:35
#define CM_KEY_NODE_SIGNATURE
Definition: cmdata.h:21
HCELL_INDEX List
Definition: cmdata.h:75
ULONG Count
Definition: cmdata.h:74
USHORT Signature
Definition: cmdata.h:92
HCELL_INDEX Parent
Definition: cmdata.h:96
WCHAR Name[ANYSIZE_ARRAY]
Definition: cmdata.h:116
HCELL_INDEX SubKeyLists[HTYPE_COUNT]
Definition: cmdata.h:102
ULONG MaxValueNameLen
Definition: cmdata.h:111
ULONG SubKeyCounts[HTYPE_COUNT]
Definition: cmdata.h:97
HCELL_INDEX Security
Definition: cmdata.h:107
USHORT NameLength
Definition: cmdata.h:114
USHORT ClassLength
Definition: cmdata.h:115
ULONG MaxClassLen
Definition: cmdata.h:110
HCELL_INDEX Class
Definition: cmdata.h:108
ULONG MaxValueDataLen
Definition: cmdata.h:112
CHILD_LIST ValueList
Definition: cmdata.h:103
USHORT Flags
Definition: cmdata.h:93
_Must_inspect_result_ _In_ WDFDEVICE _In_ PCUNICODE_STRING KeyName
Definition: wdfdevice.h:2699
__wchar_t WCHAR
Definition: xmlstorage.h:180

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,
128 0,
130 CmpFree,
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}
static BOOLEAN NTAPI CmpFileRead(IN PHHIVE RegistryHive, IN ULONG FileType, IN PULONG FileOffset, OUT PVOID Buffer, IN SIZE_T BufferLength)
Definition: cmi.c:56
static BOOLEAN NTAPI CmpFileWrite(IN PHHIVE RegistryHive, IN ULONG FileType, IN PULONG FileOffset, IN PVOID Buffer, IN SIZE_T BufferLength)
Definition: cmi.c:73
VOID NTAPI CmpFree(IN PVOID Ptr, IN ULONG Quota)
Definition: cmi.c:47
static BOOLEAN NTAPI CmpFileFlush(IN PHHIVE RegistryHive, IN ULONG FileType, PLARGE_INTEGER FileOffset, ULONG Length)
Definition: cmi.c:102
static BOOLEAN NTAPI CmpFileSetSize(IN PHHIVE RegistryHive, IN ULONG FileType, IN ULONG FileSize, IN ULONG OldFileSize)
Definition: cmi.c:90
PVOID NTAPI CmpAllocate(IN SIZE_T Size, IN BOOLEAN Paged, IN ULONG Tag)
Definition: cmi.c:37
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)
VOID CMAPI HvFree(PHHIVE RegistryHive)
#define InsertTailList(ListHead, Entry)
#define HINIT_CREATE
Definition: hivedata.h:13
#define HFILE_TYPE_PRIMARY
Definition: hivedata.h:33
#define HIVE_NOLAZYFLUSH
Definition: hivedata.h:24
LIST_ENTRY CmiHiveListHead
Definition: registry.c:385
BOOLEAN CMAPI CmCreateRootNode(PHHIVE Hive, PCWSTR Name)
Definition: cminit.c:17
#define DPRINT
Definition: sndvol32.h:71
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262

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}
#define malloc
Definition: debug_ros.c:4
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4533

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}
Definition: File.h:16
struct _CMHIVE * PCMHIVE
_Check_return_opt_ _CRTIMP int __cdecl fflush(_Inout_opt_ FILE *_File)
Definition: cmlib.h:316
HANDLE FileHandles[HFILE_TYPE_MAX]
Definition: cmlib.h:318

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}
_In_ PFCB _In_ LONGLONG FileOffset
Definition: cdprocs.h:160
Definition: bufpool.h:45
_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)
_Check_return_opt_ _CRTIMP int __cdecl fseek(_Inout_ FILE *_File, _In_ long _Offset, _In_ int _Origin)
#define SEEK_SET
Definition: jmemansi.c:26
_Must_inspect_result_ _In_ WDFDEVICE _In_ DEVICE_REGISTRY_PROPERTY _In_ ULONG BufferLength
Definition: wdfdevice.h:3771

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}
_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)

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().