a038c776f3c0539bd785dc17b262da516d3f8665
[reactos.git] / sdk / lib / cmlib / cmvalue.c
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
19 CmpMarkValueDataDirty(IN PHHIVE Hive,
20 IN PCM_KEY_VALUE Value)
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
44 CmpFreeValueData(IN PHHIVE Hive,
45 IN HCELL_INDEX DataCell,
46 IN ULONG DataLength)
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
73 CmpFreeValue(IN PHHIVE Hive,
74 IN HCELL_INDEX Cell)
75 {
76 PCM_KEY_VALUE Value;
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
97 HCELL_INDEX
98 NTAPI
99 CmpFindValueByName(IN PHHIVE Hive,
100 IN PCM_KEY_NODE KeyNode,
101 IN PUNICODE_STRING Name)
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
125 CmpGetValueData(IN PHHIVE Hive,
126 IN PCM_KEY_VALUE Value,
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 */
165 PCELL_DATA
166 NTAPI
167 CmpValueToData(IN PHHIVE Hive,
168 IN PCM_KEY_VALUE Value,
169 OUT PULONG Length)
170 {
171 PCELL_DATA Buffer;
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
207 CmpAddValueToList(IN PHHIVE Hive,
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
286 CmpSetValueDataNew(IN PHHIVE Hive,
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
317 CmpRemoveValueFromList(IN PHHIVE Hive,
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
371 HCELL_INDEX
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
412 HCELL_INDEX
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
518 CmpCopyKeyValueList(IN PHHIVE SourceHive,
519 IN PCHILD_LIST SrcValueList,
520 IN PHHIVE DestinationHive,
521 IN OUT PCHILD_LIST DestValueList,
522 IN HSTORAGE_TYPE StorageType)
523 {
524 NTSTATUS Status = STATUS_SUCCESS;
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 */
553 Status = STATUS_INSUFFICIENT_RESOURCES;
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 }