ReactOS  r76032
cmvalue.c
Go to the documentation of this file.
1 /*
2  * PROJECT: ReactOS Kernel
3  * LICENSE: GPL - See COPYING in the top level directory
4  * FILE: lib/cmlib/cmvalue.c
5  * PURPOSE: Configuration Manager Library - Cell Values
6  * PROGRAMMERS: Alex Ionescu (alex.ionescu@reactos.org)
7  */
8 
9 /* INCLUDES ******************************************************************/
10 
11 #include "cmlib.h"
12 #define NDEBUG
13 #include <debug.h>
14 
15 /* FUNCTIONS *****************************************************************/
16 
17 BOOLEAN
18 NTAPI
21 {
22  ULONG KeySize;
23  PAGED_CODE();
24 
25  /* Make sure there's actually any data */
26  if (Value->Data != HCELL_NIL)
27  {
28  /* If this is a small key, there's no need to have it dirty */
29  if (CmpIsKeyValueSmall(&KeySize, Value->DataLength)) return TRUE;
30 
31  /* Check if this is a big key */
32  ASSERT_VALUE_BIG(Hive, KeySize);
33 
34  /* Normal value, just mark it dirty */
35  HvMarkCellDirty(Hive, Value->Data, FALSE);
36  }
37 
38  /* Operation complete */
39  return TRUE;
40 }
41 
42 BOOLEAN
43 NTAPI
45  IN HCELL_INDEX DataCell,
47 {
48  ULONG KeySize;
49  PAGED_CODE();
50 
51  /* If this is a small key, the data is built-in */
52  if (!CmpIsKeyValueSmall(&KeySize, DataLength))
53  {
54  /* If there's no data cell, there's nothing to do */
55  if (DataCell == HCELL_NIL) return TRUE;
56 
57  /* Make sure the data cell is allocated */
58  //ASSERT(HvIsCellAllocated(Hive, DataCell));
59 
60  /* Unsupported value type */
61  ASSERT_VALUE_BIG(Hive, KeySize);
62 
63  /* Normal value, just free the data cell */
64  HvFreeCell(Hive, DataCell);
65  }
66 
67  /* Operation complete */
68  return TRUE;
69 }
70 
71 BOOLEAN
72 NTAPI
75 {
77  PAGED_CODE();
78 
79  /* Get the cell data */
80  Value = (PCM_KEY_VALUE)HvGetCell(Hive, Cell);
81  if (!Value) ASSERT(FALSE);
82 
83  /* Free it */
84  if (!CmpFreeValueData(Hive, Value->Data, Value->DataLength))
85  {
86  /* We failed to free the data, return failure */
87  HvReleaseCell(Hive, Cell);
88  return FALSE;
89  }
90 
91  /* Release the cell and free it */
92  HvReleaseCell(Hive, Cell);
93  HvFreeCell(Hive, Cell);
94  return TRUE;
95 }
96 
98 NTAPI
100  IN PCM_KEY_NODE KeyNode,
102 {
103  HCELL_INDEX CellIndex;
104 
105  /* Call the main function */
106  if (!CmpFindNameInList(Hive,
107  &KeyNode->ValueList,
108  Name,
109  NULL,
110  &CellIndex))
111  {
112  /* Sanity check */
113  ASSERT(CellIndex == HCELL_NIL);
114  }
115 
116  /* Return the index */
117  return CellIndex;
118 }
119 
120 /*
121  * NOTE: This function should support big values, contrary to CmpValueToData.
122  */
123 BOOLEAN
124 NTAPI
127  OUT PULONG Length,
128  OUT PVOID *Buffer,
129  OUT PBOOLEAN BufferAllocated,
130  OUT PHCELL_INDEX CellToRelease)
131 {
132  PAGED_CODE();
133 
134  /* Sanity check */
135  ASSERT(Value->Signature == CM_KEY_VALUE_SIGNATURE);
136 
137  /* Set failure defaults */
138  *BufferAllocated = FALSE;
139  *Buffer = NULL;
140  *CellToRelease = HCELL_NIL;
141 
142  /* Check if this is a small key */
143  if (CmpIsKeyValueSmall(Length, Value->DataLength))
144  {
145  /* Return the data immediately */
146  *Buffer = &Value->Data;
147  return TRUE;
148  }
149 
150  /* Unsupported at the moment */
151  ASSERT_VALUE_BIG(Hive, *Length);
152 
153  /* Get the data from the cell */
154  *Buffer = HvGetCell(Hive, Value->Data);
155  if (!(*Buffer)) return FALSE;
156 
157  /* Return success and the cell to be released */
158  *CellToRelease = Value->Data;
159  return TRUE;
160 }
161 
162 /*
163  * NOTE: This function doesn't support big values, contrary to CmpGetValueData.
164  */
166 NTAPI
169  OUT PULONG Length)
170 {
172  BOOLEAN BufferAllocated;
173  HCELL_INDEX CellToRelease;
174  PAGED_CODE();
175 
176  /* Sanity check */
177  ASSERT(Hive->ReleaseCellRoutine == NULL);
178 
179  /* Get the actual data */
180  if (!CmpGetValueData(Hive,
181  Value,
182  Length,
183  (PVOID*)&Buffer,
184  &BufferAllocated,
185  &CellToRelease))
186  {
187  /* We failed */
188  ASSERT(BufferAllocated == FALSE);
189  ASSERT(Buffer == NULL);
190  return NULL;
191  }
192 
193  /* This should never happen! */
194  if (BufferAllocated)
195  {
196  /* Free the buffer and bugcheck */
197  CmpFree(Buffer, 0);
198  KeBugCheckEx(REGISTRY_ERROR, 8, 0, (ULONG_PTR)Hive, (ULONG_PTR)Value);
199  }
200 
201  /* Otherwise, return the cell data */
202  return Buffer;
203 }
204 
205 NTSTATUS
206 NTAPI
208  IN HCELL_INDEX ValueCell,
209  IN ULONG Index,
210  IN ULONG Type,
211  IN OUT PCHILD_LIST ChildList)
212 {
213  HCELL_INDEX ListCell;
214  ULONG ChildCount, Length, i;
215  PCELL_DATA CellData;
216  PAGED_CODE();
217 
218  /* Sanity check */
219  ASSERT((((LONG)Index) >= 0) && (Index <= ChildList->Count));
220 
221  /* Get the number of entries in the child list */
222  ChildCount = ChildList->Count;
223  ChildCount++;
224  if (ChildCount > 1)
225  {
226  /* The cell should be dirty at this point */
227  ASSERT(HvIsCellDirty(Hive, ChildList->List));
228 
229  /* Check if we have less then 100 children */
230  if (ChildCount < 100)
231  {
232  /* Allocate just enough as requested */
233  Length = ChildCount * sizeof(HCELL_INDEX);
234  }
235  else
236  {
237  /* Otherwise, we have quite a few, so allocate a batch */
238  Length = ROUND_UP(ChildCount, 100) * sizeof(HCELL_INDEX);
239  if (Length > HBLOCK_SIZE)
240  {
241  /* But make sure we don't allocate beyond our block size */
242  Length = ROUND_UP(Length, HBLOCK_SIZE);
243  }
244  }
245 
246  /* Perform the allocation */
247  ListCell = HvReallocateCell(Hive, ChildList->List, Length);
248  }
249  else
250  {
251  /* This is our first child, so allocate a single cell */
252  ListCell = HvAllocateCell(Hive, sizeof(HCELL_INDEX), Type, HCELL_NIL);
253  }
254 
255  /* Fail if we couldn't get a cell */
256  if (ListCell == HCELL_NIL) return STATUS_INSUFFICIENT_RESOURCES;
257 
258  /* Set this cell as the child list's list cell */
259  ChildList->List = ListCell;
260 
261  /* Get the actual key list memory */
262  CellData = HvGetCell(Hive, ListCell);
263  ASSERT(CellData != NULL);
264 
265  /* Loop all the children */
266  for (i = ChildCount - 1; i > Index; i--)
267  {
268  /* Move them all down */
269  CellData->u.KeyList[i] = CellData->u.KeyList[i - 1];
270  }
271 
272  /* Insert us on top now */
273  CellData->u.KeyList[Index] = ValueCell;
274  ChildList->Count = ChildCount;
275 
276  /* Release the list cell and make sure the value cell is dirty */
277  HvReleaseCell(Hive, ListCell);
278  ASSERT(HvIsCellDirty(Hive, ValueCell));
279 
280  /* We're done here */
281  return STATUS_SUCCESS;
282 }
283 
284 NTSTATUS
285 NTAPI
287  IN PVOID Data,
288  IN ULONG DataSize,
289  IN ULONG StorageType,
290  IN HCELL_INDEX ValueCell,
291  OUT PHCELL_INDEX DataCell)
292 {
293  PCELL_DATA CellData;
294  PAGED_CODE();
295  ASSERT(DataSize > CM_KEY_VALUE_SMALL);
296 
297  /* Check if this is a big key */
298  ASSERT_VALUE_BIG(Hive, DataSize);
299 
300  /* Allocate a data cell */
301  *DataCell = HvAllocateCell(Hive, DataSize, StorageType, HCELL_NIL);
302  if (*DataCell == HCELL_NIL) return STATUS_INSUFFICIENT_RESOURCES;
303 
304  /* Get the actual data */
305  CellData = HvGetCell(Hive, *DataCell);
306  if (!CellData) ASSERT(FALSE);
307 
308  /* Copy our buffer into it */
309  RtlCopyMemory(CellData, Data, DataSize);
310 
311  /* All done */
312  return STATUS_SUCCESS;
313 }
314 
315 NTSTATUS
316 NTAPI
318  IN ULONG Index,
319  IN OUT PCHILD_LIST ChildList)
320 {
321  ULONG Count;
322  PCELL_DATA CellData;
323  HCELL_INDEX NewCell;
324  PAGED_CODE();
325 
326  /* Sanity check */
327  ASSERT((((LONG)Index) >= 0) && (Index <= ChildList->Count));
328 
329  /* Get the new count after removal */
330  Count = ChildList->Count - 1;
331  if (Count > 0)
332  {
333  /* Get the actual list array */
334  CellData = HvGetCell(Hive, ChildList->List);
335  if (!CellData) return STATUS_INSUFFICIENT_RESOURCES;
336 
337  /* Make sure cells data have been made dirty */
338  ASSERT(HvIsCellDirty(Hive, ChildList->List));
339  ASSERT(HvIsCellDirty(Hive, CellData->u.KeyList[Index]));
340 
341  /* Loop the list */
342  while (Index < Count)
343  {
344  /* Move everything up */
345  CellData->u.KeyList[Index] = CellData->u.KeyList[Index + 1];
346  Index++;
347  }
348 
349  /* Re-allocate the cell for the list by decreasing the count */
350  NewCell = HvReallocateCell(Hive,
351  ChildList->List,
352  Count * sizeof(HCELL_INDEX));
353  ASSERT(NewCell != HCELL_NIL);
354  HvReleaseCell(Hive,ChildList->List);
355 
356  /* Update the list cell */
357  ChildList->List = NewCell;
358  }
359  else
360  {
361  /* Otherwise, we were the last entry, so free the list entirely */
362  HvFreeCell(Hive, ChildList->List);
363  ChildList->List = HCELL_NIL;
364  }
365 
366  /* Update the child list with the new count */
367  ChildList->Count = Count;
368  return STATUS_SUCCESS;
369 }
370 
372 NTAPI
373 CmpCopyCell(IN PHHIVE SourceHive,
374  IN HCELL_INDEX SourceCell,
375  IN PHHIVE DestinationHive,
376  IN HSTORAGE_TYPE StorageType)
377 {
378  PCELL_DATA SourceData;
379  PCELL_DATA DestinationData = NULL;
380  HCELL_INDEX DestinationCell = HCELL_NIL;
381  LONG DataSize;
382 
383  PAGED_CODE();
384 
385  /* Get the data and the size of the source cell */
386  SourceData = HvGetCell(SourceHive, SourceCell);
387  DataSize = HvGetCellSize(SourceHive, SourceData);
388 
389  /* Allocate a new cell in the destination hive */
390  DestinationCell = HvAllocateCell(DestinationHive,
391  DataSize,
392  StorageType,
393  HCELL_NIL);
394  if (DestinationCell == HCELL_NIL) goto Cleanup;
395 
396  /* Get the data of the destination cell */
397  DestinationData = HvGetCell(DestinationHive, DestinationCell);
398 
399  /* Copy the data from the source cell to the destination cell */
400  RtlMoveMemory(DestinationData, SourceData, DataSize);
401 
402 Cleanup:
403 
404  /* Release the cells */
405  if (DestinationData) HvReleaseCell(DestinationHive, DestinationCell);
406  if (SourceData) HvReleaseCell(SourceHive, SourceCell);
407 
408  /* Return the destination cell index */
409  return DestinationCell;
410 }
411 
413 NTAPI
414 CmpCopyValue(IN PHHIVE SourceHive,
415  IN HCELL_INDEX SourceValueCell,
416  IN PHHIVE DestinationHive,
417  IN HSTORAGE_TYPE StorageType)
418 {
419  PCM_KEY_VALUE Value, NewValue;
420  HCELL_INDEX NewValueCell, NewDataCell;
421  PCELL_DATA CellData;
422  ULONG SmallData;
423  ULONG DataSize;
424  BOOLEAN IsSmall;
425 
426  PAGED_CODE();
427 
428  /* Get the actual source data */
429  Value = (PCM_KEY_VALUE)HvGetCell(SourceHive, SourceValueCell);
430  if (!Value) ASSERT(FALSE);
431 
432  /* Copy the value cell body */
433  NewValueCell = CmpCopyCell(SourceHive,
434  SourceValueCell,
435  DestinationHive,
436  StorageType);
437  if (NewValueCell == HCELL_NIL)
438  {
439  /* Not enough storage space */
440  goto Quit;
441  }
442 
443  /* Copy the value data */
444  IsSmall = CmpIsKeyValueSmall(&DataSize, Value->DataLength);
445  if (DataSize == 0)
446  {
447  /* Nothing to copy */
448 
449  NewValue = (PCM_KEY_VALUE)HvGetCell(DestinationHive, NewValueCell);
450  ASSERT(NewValue);
451  NewValue->DataLength = 0;
452  NewValue->Data = HCELL_NIL;
453  HvReleaseCell(DestinationHive, NewValueCell);
454 
455  goto Quit;
456  }
457 
458  if (DataSize <= CM_KEY_VALUE_SMALL)
459  {
460  if (IsSmall)
461  {
462  /* Small value, copy directly */
463  SmallData = Value->Data;
464  }
465  else
466  {
467  /* The value is small, but was stored in a regular cell. Get the data from it. */
468  CellData = HvGetCell(SourceHive, Value->Data);
469  ASSERT(CellData);
470  SmallData = *(PULONG)CellData;
471  HvReleaseCell(SourceHive, Value->Data);
472  }
473 
474  /* This is a small key, set the data directly inside */
475  NewValue = (PCM_KEY_VALUE)HvGetCell(DestinationHive, NewValueCell);
476  ASSERT(NewValue);
477  NewValue->DataLength = DataSize + CM_KEY_VALUE_SPECIAL_SIZE;
478  NewValue->Data = SmallData;
479  HvReleaseCell(DestinationHive, NewValueCell);
480  }
481  else
482  {
483  /* Big keys are currently unsupported */
484  ASSERT_VALUE_BIG(SourceHive, DataSize);
485  // Should use CmpGetValueData and CmpSetValueDataNew for big values!
486 
487  /* Regular value */
488 
489  /* Copy the data cell */
490  NewDataCell = CmpCopyCell(SourceHive,
491  Value->Data,
492  DestinationHive,
493  StorageType);
494  if (NewDataCell == HCELL_NIL)
495  {
496  /* Not enough storage space */
497  HvFreeCell(DestinationHive, NewValueCell);
498  NewValueCell = HCELL_NIL;
499  goto Quit;
500  }
501 
502  NewValue = (PCM_KEY_VALUE)HvGetCell(DestinationHive, NewValueCell);
503  ASSERT(NewValue);
504  NewValue->DataLength = DataSize;
505  NewValue->Data = NewDataCell;
506  HvReleaseCell(DestinationHive, NewValueCell);
507  }
508 
509 Quit:
510  HvReleaseCell(SourceHive, SourceValueCell);
511 
512  /* Return the copied value body cell index */
513  return NewValueCell;
514 }
515 
516 NTSTATUS
517 NTAPI
519  IN PCHILD_LIST SrcValueList,
520  IN PHHIVE DestinationHive,
521  IN OUT PCHILD_LIST DestValueList,
522  IN HSTORAGE_TYPE StorageType)
523 {
525  PCELL_DATA SrcListData = NULL, DestListData = NULL;
526  HCELL_INDEX NewValue;
527  ULONG Index;
528 
529  PAGED_CODE();
530 
531  /* Reset the destination value list */
532  DestValueList->Count = 0;
533  DestValueList->List = HCELL_NIL;
534 
535  /* Check if the list is empty */
536  if (!SrcValueList->Count)
537  return STATUS_SUCCESS;
538 
539  /* Get the source value list */
540  SrcListData = HvGetCell(SourceHive, SrcValueList->List);
541  ASSERT(SrcListData);
542 
543  /* Copy the actual values */
544  for (Index = 0; Index < SrcValueList->Count; Index++)
545  {
546  NewValue = CmpCopyValue(SourceHive,
547  SrcListData->u.KeyList[Index],
548  DestinationHive,
549  StorageType);
550  if (NewValue == HCELL_NIL)
551  {
552  /* Not enough storage space, stop there and cleanup afterwards */
554  break;
555  }
556 
557  /* Add this value cell to the child list */
558  Status = CmpAddValueToList(DestinationHive,
559  NewValue,
560  Index,
561  StorageType,
562  DestValueList);
563  if (!NT_SUCCESS(Status))
564  {
565  /* Not enough storage space, stop there */
566 
567  /* Cleanup the newly-created value here, the other ones will be cleaned up afterwards */
568  if (!CmpFreeValue(DestinationHive, NewValue))
569  HvFreeCell(DestinationHive, NewValue);
570  break;
571  }
572  }
573 
574  /* Revert-cleanup if failure */
575  if (!NT_SUCCESS(Status) && (DestValueList->List != HCELL_NIL))
576  {
577  /* Do not use CmpRemoveValueFromList but directly delete the data */
578 
579  /* Get the destination value list */
580  DestListData = HvGetCell(DestinationHive, DestValueList->List);
581  ASSERT(DestListData);
582 
583  /* Delete each copied value */
584  while (Index--)
585  {
586  NewValue = DestListData->u.KeyList[Index];
587  if (!CmpFreeValue(DestinationHive, NewValue))
588  HvFreeCell(DestinationHive, NewValue);
589  }
590 
591  /* Release and free the list */
592  HvReleaseCell(DestinationHive, DestValueList->List);
593  HvFreeCell(DestinationHive, DestValueList->List);
594 
595  DestValueList->Count = 0;
596  DestValueList->List = HCELL_NIL;
597  }
598 
599  /* Release the cells */
600  HvReleaseCell(SourceHive, SrcValueList->List);
601 
602  return Status;
603 }
DWORD *typedef PVOID
Definition: winlogon.h:52
#define CM_KEY_VALUE_SIGNATURE
Definition: cmdata.h:24
BOOLEAN CMAPI HvIsCellDirty(IN PHHIVE Hive, IN HCELL_INDEX Cell)
Definition: hivecell.c:126
PCELL_DATA NTAPI CmpValueToData(IN PHHIVE Hive, IN PCM_KEY_VALUE Value, OUT PULONG Length)
Definition: cmvalue.c:167
HCELL_INDEX Data
Definition: cmdata.h:127
#define IN
Definition: typedefs.h:38
#define TRUE
Definition: types.h:120
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
#define HBLOCK_SIZE
Definition: hivedata.h:41
#define ROUND_UP(n, align)
Definition: eventvwr.h:31
Type
Definition: Type.h:6
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel)?(CompletionRoutine!=NULL):TRUE)
HCELL_INDEX CMAPI HvReallocateCell(PHHIVE RegistryHive, HCELL_INDEX CellOffset, ULONG Size)
Definition: hivecell.c:394
return STATUS_SUCCESS
Definition: btrfs.c:2664
#define HvReleaseCell(h, c)
Definition: cmlib.h:390
#define HCELL_NIL
Definition: hivedata.h:80
_Inout_ __drv_aliasesMem PSLIST_ENTRY _Inout_ PSLIST_ENTRY _In_ ULONG Count
Definition: exfuncs.h:1015
HCELL_INDEX CMAPI HvAllocateCell(PHHIVE RegistryHive, ULONG Size, HSTORAGE_TYPE Storage, IN HCELL_INDEX Vicinity)
#define CM_KEY_VALUE_SPECIAL_SIZE
Definition: cm.h:73
_Must_inspect_result_ _In_ ULONG Index
Definition: fltkernel.h:1824
#define RtlMoveMemory(Destination, Source, Length)
Definition: typedefs.h:263
uint32_t ULONG_PTR
Definition: typedefs.h:63
ULONG DataLength
Definition: cmdata.h:126
GLenum GLclampf GLint i
Definition: glfuncs.h:14
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
#define FALSE
Definition: types.h:117
BOOLEAN NTAPI CmpMarkValueDataDirty(IN PHHIVE Hive, IN PCM_KEY_VALUE Value)
Definition: cmvalue.c:19
long LONG
Definition: pedump.c:60
PVOID CMAPI HvGetCell(PHHIVE RegistryHive, HCELL_INDEX CellOffset)
Definition: hivecell.c:67
static BOOLEAN CmpIsKeyValueSmall(OUT PULONG RealLength, IN ULONG Length)
Definition: cmlib.h:323
NTSTATUS NTAPI CmpCopyKeyValueList(IN PHHIVE SourceHive, IN PCHILD_LIST SrcValueList, IN PHHIVE DestinationHive, IN OUT PCHILD_LIST DestValueList, IN HSTORAGE_TYPE StorageType)
Definition: cmvalue.c:518
smooth NULL
Definition: ftsmooth.c:557
ULONG * PHCELL_INDEX
Definition: hivedata.h:75
Definition: bufpool.h:45
NTSTATUS NTAPI CmpAddValueToList(IN PHHIVE Hive, IN HCELL_INDEX ValueCell, IN ULONG Index, IN ULONG Type, IN OUT PCHILD_LIST ChildList)
Definition: cmvalue.c:207
NTSTATUS NTAPI CmpSetValueDataNew(IN PHHIVE Hive, IN PVOID Data, IN ULONG DataSize, IN ULONG StorageType, IN HCELL_INDEX ValueCell, OUT PHCELL_INDEX DataCell)
Definition: cmvalue.c:286
BOOLEAN NTAPI CmpFindNameInList(IN PHHIVE Hive, IN PCHILD_LIST ChildList, IN PUNICODE_STRING Name, OUT PULONG ChildIndex, OUT PHCELL_INDEX CellIndex)
Definition: cmname.c:149
unsigned char BOOLEAN
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:24
VOID NTAPI CmpFree(_In_ PVOID Ptr, _In_ ULONG Quota)
Definition: bootreg.c:105
ULONG HCELL_INDEX
Definition: hivedata.h:75
HCELL_INDEX NTAPI CmpCopyCell(IN PHHIVE SourceHive, IN HCELL_INDEX SourceCell, IN PHHIVE DestinationHive, IN HSTORAGE_TYPE StorageType)
Definition: cmvalue.c:373
Definition: bzip2.c:1694
BOOLEAN CMAPI HvMarkCellDirty(PHHIVE RegistryHive, HCELL_INDEX CellOffset, BOOLEAN HoldingLock)
Definition: hivecell.c:100
HCELL_INDEX KeyList[ANYSIZE_ARRAY]
Definition: cmdata.h:205
BOOLEAN NTAPI CmpGetValueData(IN PHHIVE Hive, IN PCM_KEY_VALUE Value, OUT PULONG Length, OUT PVOID *Buffer, OUT PBOOLEAN BufferAllocated, OUT PHCELL_INDEX CellToRelease)
Definition: cmvalue.c:125
#define PAGED_CODE()
Definition: video.h:57
UINTN VOID * Buffer
Definition: acefiex.h:370
_In_ PUNICODE_STRING Name
Definition: mrx.h:218
VOID CMAPI HvFreeCell(PHHIVE RegistryHive, HCELL_INDEX CellOffset)
Definition: hivecell.c:441
#define CM_KEY_VALUE_SMALL
Definition: cm.h:71
char * PBOOLEAN
Definition: retypes.h:11
LONG CMAPI HvGetCellSize(PHHIVE RegistryHive, PVOID Cell)
VOID UINTN Length
Definition: acefiex.h:744
static const WCHAR Cleanup[]
Definition: register.c:65
UINT64 UINTN DataSize
Definition: acefiex.h:499
UINTN UINT8 Value
Definition: acefiex.h:751
NTSTATUS NTAPI CmpRemoveValueFromList(IN PHHIVE Hive, IN ULONG Index, IN OUT PCHILD_LIST ChildList)
Definition: cmvalue.c:317
Status
Definition: gdiplustypes.h:24
LONG NTSTATUS
Definition: DriverTester.h:11
BOOLEAN NTAPI CmpFreeValueData(IN PHHIVE Hive, IN HCELL_INDEX DataCell, IN ULONG DataLength)
Definition: cmvalue.c:44
HCELL_INDEX NTAPI CmpFindValueByName(IN PHHIVE Hive, IN PCM_KEY_NODE KeyNode, IN PUNICODE_STRING Name)
Definition: cmvalue.c:99
struct _CM_KEY_VALUE * PCM_KEY_VALUE
HSTORAGE_TYPE
Definition: hivedata.h:95
unsigned int * PULONG
Definition: retypes.h:1
#define OUT
Definition: typedefs.h:39
unsigned int ULONG
Definition: retypes.h:1
BOOLEAN NTAPI CmpFreeValue(IN PHHIVE Hive, IN HCELL_INDEX Cell)
Definition: cmvalue.c:73
union _CELL_DATA::@3700 u
_Must_inspect_result_ _Out_writes_to_ DataLength PHIDP_DATA _Inout_ PULONG DataLength
Definition: hidpi.h:333
#define ASSERT_VALUE_BIG(h, s)
Definition: cm.h:42
VOID NTAPI KeBugCheckEx(_In_ ULONG BugCheckCode, _In_ ULONG_PTR BugCheckParameter1, _In_ ULONG_PTR BugCheckParameter2, _In_ ULONG_PTR BugCheckParameter3, _In_ ULONG_PTR BugCheckParameter4)
Definition: rtlcompat.c:90
HCELL_INDEX NTAPI CmpCopyValue(IN PHHIVE SourceHive, IN HCELL_INDEX SourceValueCell, IN PHHIVE DestinationHive, IN HSTORAGE_TYPE StorageType)
Definition: cmvalue.c:414