[BOOTLIB] Fix 64 bit issues (#433)
[reactos.git] / boot / environ / lib / misc / bcd.c
1 /*
2 * COPYRIGHT: See COPYING.ARM in the top level directory
3 * PROJECT: ReactOS UEFI Boot Library
4 * FILE: boot/environ/lib/misc/bcd.c
5 * PURPOSE: Boot Library BCD Routines
6 * PROGRAMMER: Alex Ionescu (alex.ionescu@reactos.org)
7 */
8
9 /* INCLUDES ******************************************************************/
10
11 #include "bl.h"
12 #include <bcd.h>
13
14 /* FUNCTIONS *****************************************************************/
15
16 VOID
17 BiNotifyEnumerationError (
18 _In_ HANDLE ObjectHandle,
19 _In_ PWCHAR ElementName,
20 _In_ NTSTATUS Status
21 )
22 {
23 /* Stub for now */
24 UNREFERENCED_PARAMETER(ObjectHandle);
25 UNREFERENCED_PARAMETER(ElementName);
26 UNREFERENCED_PARAMETER(Status);
27 EfiPrintf(L"Error in BiNotify: %lx for element %s\r\n", Status, ElementName);
28 }
29
30 ULONG
31 BiConvertElementFormatToValueType (
32 _In_ ULONG Format
33 )
34 {
35 /* Strings and objects are strings */
36 if ((Format == BCD_TYPE_STRING) || (Format == BCD_TYPE_OBJECT))
37 {
38 return REG_SZ;
39 }
40
41 /* Object lists are arrays of strings */
42 if (Format == BCD_TYPE_OBJECT_LIST)
43 {
44 return REG_MULTI_SZ;
45 }
46
47 /* Everything else is binary */
48 return REG_BINARY;
49 }
50
51 NTSTATUS
52 BiConvertRegistryDataToElement (
53 _In_ HANDLE ObjectHandle,
54 _In_ PVOID Data,
55 _In_ ULONG DataLength,
56 _In_ BcdElementType ElementType,
57 _Out_ PVOID Element,
58 _Out_ PULONG ElementSize
59 )
60 {
61 NTSTATUS Status;
62 SIZE_T Length, Size, ReturnedLength;
63 PBL_DEVICE_DESCRIPTOR Device;
64 BOOLEAN NullTerminate;
65 PBCD_DEVICE_OPTION BcdDevice, ElementDevice;
66 PWCHAR BcdString, ElementString;
67 PGUID ElementGuid; UNICODE_STRING GuidString;
68 PULONGLONG ElementInteger;
69 PUSHORT ElementWord; PBOOLEAN BcdBoolean;
70
71 /* Assume failure */
72 ReturnedLength = 0;
73
74 /* Check what type of format we are dealing with */
75 switch (ElementType.Format)
76 {
77 /* Devices -- they are in a binary format */
78 case BCD_TYPE_DEVICE:
79
80 /* First, make sure it's at least big enough for an empty descriptor */
81 if (DataLength < FIELD_OFFSET(BCD_DEVICE_OPTION,
82 DeviceDescriptor.Unknown))
83 {
84 return STATUS_OBJECT_TYPE_MISMATCH;
85 }
86
87 /* Both the registry and BCD format are the same */
88 BcdDevice = (PBCD_DEVICE_OPTION)Data;
89 ElementDevice = (PBCD_DEVICE_OPTION)Element;
90
91 /* Make sure the device fits in the registry data */
92 Device = &BcdDevice->DeviceDescriptor;
93 Size = Device->Size;
94 if ((Size + sizeof(BcdDevice->AssociatedEntry)) != DataLength)
95 {
96 return STATUS_OBJECT_TYPE_MISMATCH;
97 }
98
99 /* Check if this is a locate device */
100 if (Device->DeviceType == LocateDevice)
101 {
102 EfiPrintf(L"Locates not yet supported\r\n");
103 return STATUS_NOT_SUPPORTED;
104 }
105
106 /* Make sure the caller's buffer can fit the device */
107 ReturnedLength = Size + sizeof(BcdDevice->AssociatedEntry);
108 if (ReturnedLength > *ElementSize)
109 {
110 Status = STATUS_BUFFER_TOO_SMALL;
111 break;
112 }
113
114 /* It'll fit -- copy it in */
115 RtlCopyMemory(&ElementDevice->DeviceDescriptor, Device, Size);
116 ElementDevice->AssociatedEntry = BcdDevice->AssociatedEntry;
117 Status = STATUS_SUCCESS;
118 break;
119
120 /* Strings -- they are stored as is */
121 case BCD_TYPE_STRING:
122
123 /* Make sure the string isn't empty or misaligned */
124 if (!(DataLength) || (DataLength & 1))
125 {
126 return STATUS_OBJECT_TYPE_MISMATCH;
127 }
128
129 /* Both the registry and BCD format are the same */
130 BcdString = (PWCHAR)Data;
131 ElementString = (PWCHAR)Element;
132
133 /* We'll need as much data as the string has to offer */
134 ReturnedLength = DataLength;
135
136 /* If the string isn't NULL-terminated, do it now */
137 NullTerminate = FALSE;
138 if (BcdString[(DataLength / sizeof(WCHAR)) - 1] != UNICODE_NULL)
139 {
140 ReturnedLength += sizeof(UNICODE_NULL);
141 NullTerminate = TRUE;
142 }
143
144 /* Will we fit in the caller's buffer? */
145 if (ReturnedLength > *ElementSize)
146 {
147 Status = STATUS_BUFFER_TOO_SMALL;
148 break;
149 }
150
151 /* Yep -- copy it in, and NULL-terminate if needed */
152 RtlCopyMemory(Element, Data, DataLength);
153 if (NullTerminate)
154 {
155 ElementString[DataLength / sizeof(WCHAR)] = UNICODE_NULL;
156 }
157
158 Status = STATUS_SUCCESS;
159 break;
160
161 /* Objects -- they are stored as GUID Strings */
162 case BCD_TYPE_OBJECT:
163
164 /* Registry data is a string, BCD data is a GUID */
165 BcdString = (PWCHAR)Data;
166 ElementGuid = (PGUID)Element;
167
168 /* We need a GUID-sized buffer, does the caller have one? */
169 ReturnedLength = sizeof(*ElementGuid);
170 if (*ElementSize < ReturnedLength)
171 {
172 Status = STATUS_BUFFER_TOO_SMALL;
173 break;
174 }
175
176 /* Yep, copy the GUID */
177 RtlInitUnicodeString(&GuidString, BcdString);
178 Status = RtlGUIDFromString(&GuidString, ElementGuid);
179 break;
180
181 /* Object Lists -- they are stored as arrays of GUID strings */
182 case BCD_TYPE_OBJECT_LIST:
183
184 /* Assume an empty list*/
185 ReturnedLength = 0;
186 Length = 0;
187 Status = STATUS_SUCCESS;
188
189 /* Registry data is an array of strings, BCD data is array of GUIDs */
190 BcdString = (PWCHAR)Data;
191 ElementGuid = (PGUID)Element;
192
193 /* Loop as long as the array still has strings */
194 while (*BcdString)
195 {
196 /* Don't read beyond the registry data */
197 if (Length >= DataLength)
198 {
199 break;
200 }
201
202 /* One more GUID -- does the caller have space? */
203 ReturnedLength += sizeof(GUID);
204 if (ReturnedLength <= *ElementSize)
205 {
206 /* Convert and add it in */
207 RtlInitUnicodeString(&GuidString, BcdString);
208 Status = RtlGUIDFromString(&GuidString, ElementGuid);
209 if (!NT_SUCCESS(Status))
210 {
211 break;
212 }
213
214 /* Move to the next GUID in the caller's buffer */
215 ElementGuid++;
216 }
217
218 /* Move to the next string in the registry array */
219 Size = (wcslen(BcdString) * sizeof(WCHAR)) + sizeof(UNICODE_NULL);
220 Length += Size;
221 BcdString = (PWCHAR)((ULONG_PTR)BcdString + Length);
222 }
223
224 /* Check if we failed anywhere */
225 if (!NT_SUCCESS(Status))
226 {
227 break;
228 }
229
230 /* Check if we consumed more space than we have */
231 if (ReturnedLength > *ElementSize)
232 {
233 Status = STATUS_BUFFER_TOO_SMALL;
234 }
235
236 /* All good here */
237 break;
238
239 /* Integer -- stored as binary */
240 case BCD_TYPE_INTEGER:
241
242 /* BCD data is a ULONGLONG, registry data is 8 bytes binary */
243 ElementInteger = (PULONGLONG)Element;
244 ReturnedLength = sizeof(*ElementInteger);
245
246 /* Make sure the registry data makes sense */
247 if (DataLength > ReturnedLength)
248 {
249 return STATUS_OBJECT_TYPE_MISMATCH;
250 }
251
252 /* Make sure the caller has space */
253 if (*ElementSize < ReturnedLength)
254 {
255 Status = STATUS_BUFFER_TOO_SMALL;
256 break;
257 }
258
259 /* Write the integer result */
260 *ElementInteger = 0;
261 RtlCopyMemory(ElementInteger, Data, DataLength);
262 Status = STATUS_SUCCESS;
263 break;
264
265 /* Boolean -- stored as binary */
266 case BCD_TYPE_BOOLEAN:
267
268 /* BCD data is a BOOLEAN, registry data is 2 bytes binary */
269 ElementWord = (PUSHORT)Element;
270 BcdBoolean = (PBOOLEAN)Data;
271 ReturnedLength = sizeof(ElementWord);
272
273 /* Make sure the registry data makes sense */
274 if (DataLength != sizeof(*BcdBoolean))
275 {
276 return STATUS_OBJECT_TYPE_MISMATCH;
277 }
278
279 /* Make sure the caller has space */
280 if (*ElementSize < ReturnedLength)
281 {
282 Status = STATUS_BUFFER_TOO_SMALL;
283 break;
284 }
285
286 /* Write the boolean result */
287 *ElementWord = 0;
288 *ElementWord = *BcdBoolean != 0;
289 Status = STATUS_SUCCESS;
290 break;
291
292 /* Integer list --stored as binary */
293 case BCD_TYPE_INTEGER_LIST:
294
295 /* BCD Data is n ULONGLONGs, registry data is n*8 bytes binary */
296 ReturnedLength = DataLength;
297 if (!(DataLength) || (DataLength & 7))
298 {
299 return STATUS_OBJECT_TYPE_MISMATCH;
300 }
301
302 /* Make sure the caller has space */
303 if (*ElementSize < ReturnedLength)
304 {
305 Status = STATUS_BUFFER_TOO_SMALL;
306 break;
307 }
308
309 /* Write the integer list result */
310 RtlCopyMemory(Element, Data, DataLength);
311 Status = STATUS_SUCCESS;
312 break;
313
314 /* Arbitrary data */
315 default:
316
317 /* Registry data is copied binary as-is */
318 ReturnedLength = DataLength;
319
320 /* Make sure it's not empty */
321 if (!DataLength)
322 {
323 return STATUS_OBJECT_TYPE_MISMATCH;
324 }
325
326 /* Make sure the caller has space */
327 if (*ElementSize < ReturnedLength)
328 {
329 Status = STATUS_BUFFER_TOO_SMALL;
330 break;
331 }
332
333 /* Write the result */
334 RtlCopyMemory(Element, Data, DataLength);
335 Status = STATUS_SUCCESS;
336 break;
337 }
338
339 /* If we got here due to success or space issues, write the size */
340 if ((NT_SUCCESS(Status)) || (Status == STATUS_BUFFER_TOO_SMALL))
341 {
342 *ElementSize = ReturnedLength;
343 }
344
345 /* All done, return our conversion result */
346 return Status;
347 }
348
349 NTSTATUS
350 BiConvertBcdElements (
351 _In_ PBCD_PACKED_ELEMENT Elements,
352 _Out_opt_ PBCD_ELEMENT Buffer,
353 _Inout_ PULONG BufferSize,
354 _Inout_ PULONG ElementCount
355 )
356 {
357 NTSTATUS Status;
358 ULONG ElementSize, AlignedElementSize, AlignedDataSize;
359 PBCD_ELEMENT_HEADER Header;
360 PVOID Data;
361 BOOLEAN Exists;
362 ULONG i, j, Count;
363
364 /* Local variable to keep track of objects */
365 Count = 0;
366
367 /* Safely compute the element bytes needed */
368 Status = RtlULongMult(*ElementCount, sizeof(BCD_ELEMENT), &ElementSize);
369 if (!NT_SUCCESS(Status))
370 {
371 return Status;
372 }
373
374 /* Safely align the element size */
375 Status = RtlULongAdd(ElementSize,
376 sizeof(ULONG) - 1,
377 &AlignedElementSize);
378 if (!NT_SUCCESS(Status))
379 {
380 return Status;
381 }
382 AlignedElementSize = ALIGN_DOWN(AlignedElementSize, ULONG);
383
384 /* Do a safe version of Add2Ptr to figure out where the headers will start */
385 Status = RtlULongPtrAdd((ULONG_PTR)Buffer,
386 AlignedElementSize,
387 (PULONG_PTR)&Header);
388 if (!NT_SUCCESS(Status))
389 {
390 return Status;
391 }
392
393 /* Safely compute the header bytes needed */
394 Status = RtlULongMult(*ElementCount,
395 sizeof(BCD_ELEMENT_HEADER),
396 &ElementSize);
397 if (!NT_SUCCESS(Status))
398 {
399 return Status;
400 }
401
402 /* Safely align the header size */
403 Status = RtlULongAdd(ElementSize,
404 AlignedElementSize + sizeof(ULONG) - 1,
405 &AlignedElementSize);
406 if (!NT_SUCCESS(Status))
407 {
408 return Status;
409 }
410 AlignedElementSize = ALIGN_DOWN(AlignedElementSize, ULONG);
411
412 /* Do a safe version of Add2Ptr */
413 Status = RtlULongPtrAdd((ULONG_PTR)Buffer,
414 AlignedElementSize,
415 (PULONG_PTR)&Data);
416 if (!NT_SUCCESS(Status))
417 {
418 return Status;
419 }
420
421 /* Iterate over every element */
422 for (i = 0; i < *ElementCount; i++)
423 {
424 /* Safely align the element size */
425 Status = RtlULongAdd(Elements->Size,
426 sizeof(ULONG) - 1,
427 &AlignedDataSize);
428 if (!NT_SUCCESS(Status))
429 {
430 break;
431 }
432 AlignedDataSize = ALIGN_DOWN(AlignedDataSize, ULONG);
433
434 /* Safely add the size of this data element */
435 Status = RtlULongAdd(AlignedElementSize,
436 AlignedDataSize,
437 &AlignedElementSize);
438 if (!NT_SUCCESS(Status))
439 {
440 break;
441 }
442
443 /* Do we have enough space left? */
444 if (*BufferSize >= AlignedElementSize)
445 {
446 /* Check if our root is an inherited object */
447 Exists = FALSE;
448 if (Elements->RootType.PackedValue == BcdLibraryObjectList_InheritedObjects)
449 {
450 /* Yes, scan for us in the current buffer */
451 for (j = 0; j < Count; j++)
452 {
453 /* Do we already exist? */
454 while (Buffer[j].Header->Type == Elements->RootType.PackedValue)
455 {
456 /* Yep */
457 Exists = TRUE;
458 break;
459 }
460 }
461 }
462
463 /* Have we already found ourselves? */
464 if (!Exists)
465 {
466 /* Nope, one more entry */
467 ++Count;
468
469 /* Write out the unpacked object */
470 Buffer->Body = Data;
471 Buffer->Header = Header;
472
473 /* Fill out its header */
474 Header->Size = Elements->Size;
475 Header->Type = Elements->Type;
476 Header->Version = Elements->Version;
477
478 /* And copy the data */
479 RtlCopyMemory(Data, Elements->Data, Header->Size);
480
481 /* Move to the next unpacked object and header */
482 ++Buffer;
483 ++Header;
484
485 /* Move to the next data entry */
486 Data = (PVOID)((ULONG_PTR)Data + AlignedDataSize);
487 }
488 }
489 else
490 {
491 /* Nope, set failure code, but keep going so we can return count */
492 Status = STATUS_BUFFER_TOO_SMALL;
493 }
494
495 /* Move to the next element entry */
496 Elements = Elements->NextEntry;
497 }
498
499 /* Return the new final buffer size and count */
500 *BufferSize = AlignedElementSize;
501 *ElementCount = Count;
502 return Status;
503 }
504
505 NTSTATUS
506 BcdOpenObject (
507 _In_ HANDLE BcdHandle,
508 _In_ PGUID ObjectId,
509 _Out_ PHANDLE ObjectHandle
510 )
511 {
512 NTSTATUS Status;
513 GUID LocalGuid;
514 UNICODE_STRING GuidString;
515 HANDLE RootObjectHandle;
516
517 /* Assume failure */
518 *ObjectHandle = NULL;
519
520 /* Initialize GUID string */
521 GuidString.Buffer = NULL;
522
523 /* Open the root "Objects" handle */
524 RootObjectHandle = NULL;
525 Status = BiOpenKey(BcdHandle, L"Objects", &RootObjectHandle);
526 if (!NT_SUCCESS(Status))
527 {
528 goto Quickie;
529 }
530
531 /* Capture the object ID and convert it into a string */
532 LocalGuid = *ObjectId;
533 Status = RtlStringFromGUID(&LocalGuid, &GuidString);
534 if (!NT_SUCCESS(Status))
535 {
536 goto Quickie;
537 }
538
539 /* Now open the key containing this object ID */
540 Status = BiOpenKey(RootObjectHandle, GuidString.Buffer, ObjectHandle);
541
542 Quickie:
543 /* Free the GUID string if we had one allocated */
544 if (GuidString.Buffer)
545 {
546 RtlFreeUnicodeString(&GuidString);
547 }
548
549 /* Close the root handle if it was open */
550 if (RootObjectHandle)
551 {
552 BiCloseKey(RootObjectHandle);
553 }
554
555 /* Return the final status */
556 return Status;
557 }
558
559 NTSTATUS
560 BcdDeleteElement (
561 _In_ HANDLE ObjectHandle,
562 _In_ ULONG Type
563 )
564 {
565 NTSTATUS Status;
566 HANDLE ElementsHandle, ElementHandle;
567 WCHAR TypeString[22];
568
569 /* Open the elements key */
570 Status = BiOpenKey(ObjectHandle, L"Elements", &ElementsHandle);
571 if (NT_SUCCESS(Status))
572 {
573 /* Convert the element ID into a string */
574 if (!_ultow(Type, TypeString, 16))
575 {
576 /* Failed to do so */
577 Status = STATUS_UNSUCCESSFUL;
578 }
579 else
580 {
581 /* Open the element specifically */
582 Status = BiOpenKey(ElementsHandle, TypeString, &ElementHandle);
583 if (NT_SUCCESS(Status))
584 {
585 /* Delete it */
586 Status = BiDeleteKey(ElementHandle);
587 if (NT_SUCCESS(Status))
588 {
589 /* No point in closing the handle anymore */
590 ElementHandle = NULL;
591 }
592 }
593 else
594 {
595 /* The element doesn't exist */
596 Status = STATUS_NOT_FOUND;
597 }
598
599 /* Check if we should close the key */
600 if (ElementHandle)
601 {
602 /* Do it */
603 BiCloseKey(ElementHandle);
604 }
605 }
606 }
607
608 /* Check if we should close the elements handle */
609 if (ElementsHandle)
610 {
611 /* Do it */
612 BiCloseKey(ElementsHandle);
613 }
614
615 /* Return whatever the result was */
616 return Status;
617 }
618
619 NTSTATUS
620 BiEnumerateSubElements (
621 _In_ HANDLE BcdHandle,
622 _In_ PVOID Object,
623 _In_ ULONG ElementType,
624 _In_ ULONG Flags,
625 _Out_opt_ PBCD_PACKED_ELEMENT* Elements,
626 _Inout_ PULONG ElementSize,
627 _Out_ PULONG ElementCount
628 )
629 {
630 NTSTATUS Status;
631 PBCD_PACKED_ELEMENT Element;
632 HANDLE ObjectHandle;
633 ULONG ParsedElements, RequiredSize;
634
635 /* Assume empty */
636 *ElementCount = 0;
637 RequiredSize = 0;
638 ParsedElements = 0;
639
640 /* Open the object */
641 Status = BcdOpenObject(BcdHandle, Object, &ObjectHandle);
642 if (!NT_SUCCESS(Status))
643 {
644 goto Quickie;
645 }
646
647 /* Read the first entry, and the size available */
648 Element = *Elements;
649 RequiredSize = *ElementSize;
650
651 /* Enumerate the object into the element array */
652 Status = BiEnumerateElements(BcdHandle,
653 ObjectHandle,
654 ElementType,
655 Flags,
656 Element,
657 &RequiredSize,
658 &ParsedElements);
659
660 /* Close the handle and bail out if we couldn't enumerate */
661 BiCloseKey(ObjectHandle);
662 if (!NT_SUCCESS(Status))
663 {
664 goto Quickie;
665 }
666
667 /* Check if the and subelements were present */
668 if (ParsedElements)
669 {
670 /* Keep going until the last one */
671 while (Element->NextEntry)
672 {
673 Element = Element->NextEntry;
674 }
675
676 /* Set the new buffer location to the last element */
677 *Elements = Element;
678 }
679
680 Quickie:
681 /* Return the number of sub-elements and their size */
682 *ElementCount = ParsedElements;
683 *ElementSize = RequiredSize;
684 return Status;
685 }
686
687 NTSTATUS
688 BiEnumerateSubObjectElements (
689 _In_ HANDLE BcdHandle,
690 _Out_ PGUID SubObjectList,
691 _In_ ULONG SubObjectCount,
692 _In_ ULONG Flags,
693 _Out_opt_ PBCD_PACKED_ELEMENT Elements,
694 _Inout_ PULONG ElementSize,
695 _Out_ PULONG ElementCount
696 )
697 {
698 NTSTATUS Status;
699 ULONG SubElementCount, TotalSize, RequiredSize, CurrentSize, i;
700 PBCD_PACKED_ELEMENT PreviousElement;
701
702 /* Assume empty list */
703 *ElementCount = 0;
704 Status = STATUS_SUCCESS;
705
706 /* Initialize variables */
707 TotalSize = 0;
708 PreviousElement = NULL;
709
710 /* Set the currently remaining size based on caller's input */
711 CurrentSize = *ElementSize;
712
713 /* Iterate over every subje object */
714 for (i = 0; i < SubObjectCount; i++)
715 {
716 /* Set the currently remaining buffer space */
717 RequiredSize = CurrentSize;
718
719 /* Enumerate the inherited sub elements */
720 Status = BiEnumerateSubElements(BcdHandle,
721 &SubObjectList[i],
722 BcdLibraryObjectList_InheritedObjects,
723 Flags,
724 &Elements,
725 &RequiredSize,
726 &SubElementCount);
727 if ((NT_SUCCESS(Status)) || (Status == STATUS_BUFFER_TOO_SMALL))
728 {
729 /* Safely add the length of the sub elements */
730 Status = RtlULongAdd(TotalSize, RequiredSize, &TotalSize);
731 if (!NT_SUCCESS(Status))
732 {
733 break;
734 }
735
736 /* Add the sub elements to the total */
737 *ElementCount += SubElementCount;
738
739 /* See if we have enough space*/
740 if (*ElementSize >= TotalSize)
741 {
742 /* Were there any subelements? */
743 if (SubElementCount)
744 {
745 /* Update to keep track of these new subelements */
746 CurrentSize = *ElementSize - TotalSize;
747
748 /* Link the subelements into the chain */
749 PreviousElement = Elements;
750 PreviousElement->NextEntry =
751 (PBCD_PACKED_ELEMENT)((ULONG_PTR)Elements + TotalSize);
752 Elements = PreviousElement->NextEntry;
753 }
754 }
755 else
756 {
757 /* We're out of space */
758 CurrentSize = 0;
759 }
760 }
761 else if ((Status != STATUS_NOT_FOUND) &&
762 (Status != STATUS_OBJECT_NAME_NOT_FOUND))
763 {
764 /* Some other fatal error, break out */
765 break;
766 }
767 else
768 {
769 /* The sub element was not found, print a warning but keep going */
770 BlStatusPrint(L"Ignoring missing BCD inherit object: {%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}\n",
771 (&SubObjectList[i])->Data1,
772 (&SubObjectList[i])->Data2,
773 (&SubObjectList[i])->Data3,
774 (&SubObjectList[i])->Data4[0],
775 (&SubObjectList[i])->Data4[1],
776 (&SubObjectList[i])->Data4[2],
777 (&SubObjectList[i])->Data4[3],
778 (&SubObjectList[i])->Data4[4],
779 (&SubObjectList[i])->Data4[5],
780 (&SubObjectList[i])->Data4[6],
781 (&SubObjectList[i])->Data4[7]);
782 Status = STATUS_SUCCESS;
783 }
784 }
785
786 /* Terminate the last element, if one was left */
787 if (PreviousElement)
788 {
789 PreviousElement->NextEntry = NULL;
790 }
791
792 /* Set failure code if we ran out of space */
793 if (*ElementSize < TotalSize)
794 {
795 Status = STATUS_BUFFER_TOO_SMALL;
796 }
797
798 /* Return final length and status */
799 *ElementSize = TotalSize;
800 return Status;
801 }
802
803 NTSTATUS
804 BiEnumerateElements (
805 _In_ HANDLE BcdHandle,
806 _In_ HANDLE ObjectHandle,
807 _In_ ULONG RootElementType,
808 _In_ ULONG Flags,
809 _Out_opt_ PBCD_PACKED_ELEMENT Elements,
810 _Inout_ PULONG ElementSize,
811 _Out_ PULONG ElementCount
812 )
813 {
814 HANDLE ElementsHandle, ElementHandle;
815 ULONG TotalLength, RegistryElementDataLength, RemainingLength;
816 NTSTATUS Status;
817 ULONG i;
818 PVOID ElementData, SubObjectList, RegistryElementData;
819 BcdElementType ElementType;
820 PBCD_PACKED_ELEMENT PreviousElement, ElementsStart;
821 ULONG SubElementCount, SubKeyCount, SubObjectCount, ElementDataLength;
822 PWCHAR ElementName;
823 PWCHAR* SubKeys;
824
825 /* Assume failure */
826 *ElementCount = 0;
827
828 /* Initialize all locals that are checked at the end*/
829 SubKeys = NULL;
830 ElementsHandle = NULL;
831 ElementHandle = NULL;
832 ElementData = NULL;
833 RegistryElementData = NULL;
834 PreviousElement = NULL;
835 ElementName = NULL;
836 SubObjectList = NULL;
837 TotalLength = 0;
838 ElementDataLength = 0;
839 SubObjectCount = 0;
840 RemainingLength = 0;
841 ElementsStart = Elements;
842
843 /* Open the root object key's elements */
844 Status = BiOpenKey(ObjectHandle, L"Elements", &ElementsHandle);
845 if (!NT_SUCCESS(Status))
846 {
847 goto Quickie;
848 }
849
850 /* Enumerate all elements */
851 Status = BiEnumerateSubKeys(ElementsHandle, &SubKeys, &SubKeyCount);
852 if (!NT_SUCCESS(Status))
853 {
854 goto Quickie;
855 }
856
857 /* Iterate over each one */
858 for (i = 0; i < SubKeyCount; i++)
859 {
860 /* Open the element */
861 ElementName = SubKeys[i];
862 Status = BiOpenKey(ElementsHandle, ElementName, &ElementHandle);
863 if (!NT_SUCCESS(Status))
864 {
865 EfiPrintf(L"ELEMENT ERROR: %lx\r\n", Status);
866 EfiStall(100000);
867 break;
868 }
869
870 /* The name of the element is its data type */
871 ElementType.PackedValue = wcstoul(SubKeys[i], NULL, 16);
872 if (!(ElementType.PackedValue) || (ElementType.PackedValue == -1))
873 {
874 EfiPrintf(L"Value invalid\r\n");
875 BiCloseKey(ElementHandle);
876 ElementHandle = NULL;
877 continue;
878 }
879
880 /* Read the appropriate registry value type for this element */
881 Status = BiGetRegistryValue(ElementHandle,
882 L"Element",
883 BiConvertElementFormatToValueType(
884 ElementType.Format),
885 &RegistryElementData,
886 &RegistryElementDataLength);
887 if (!NT_SUCCESS(Status))
888 {
889 EfiPrintf(L"Element invalid\r\n");
890 break;
891 }
892
893 /* Now figure out how much space the converted element will need */
894 ElementDataLength = 0;
895 Status = BiConvertRegistryDataToElement(ObjectHandle,
896 RegistryElementData,
897 RegistryElementDataLength,
898 ElementType,
899 NULL,
900 &ElementDataLength);
901 if (Status != STATUS_BUFFER_TOO_SMALL)
902 {
903 break;
904 }
905
906 /* Allocate a buffer big enough for the converted element */
907 ElementData = BlMmAllocateHeap(ElementDataLength);
908 if (!ElementData)
909 {
910 Status = STATUS_INSUFFICIENT_RESOURCES;
911 break;
912 }
913
914 /* And actually convert it this time around */
915 Status = BiConvertRegistryDataToElement(ObjectHandle,
916 RegistryElementData,
917 RegistryElementDataLength,
918 ElementType,
919 ElementData,
920 &ElementDataLength);
921 if (!NT_SUCCESS(Status))
922 {
923 break;
924 }
925
926 /* Safely add space for the packed element header */
927 Status = RtlULongAdd(TotalLength,
928 FIELD_OFFSET(BCD_PACKED_ELEMENT, Data),
929 &TotalLength);
930 if (!NT_SUCCESS(Status))
931 {
932 break;
933 }
934
935 /* Safely add space for the data of the element itself */
936 Status = RtlULongAdd(TotalLength, ElementDataLength, &TotalLength);
937 if (!NT_SUCCESS(Status))
938 {
939 break;
940 }
941
942 /* One more element */
943 ++*ElementCount;
944
945 /* See how much space we were given */
946 RemainingLength = *ElementSize;
947 if (RemainingLength >= TotalLength)
948 {
949 /* Set the next pointer */
950 Elements->NextEntry = (PBCD_PACKED_ELEMENT)((ULONG_PTR)ElementsStart + TotalLength);
951
952 /* Fill this one out */
953 Elements->RootType.PackedValue = RootElementType;
954 Elements->Version = 1;
955 Elements->Type = ElementType.PackedValue;
956 Elements->Size = ElementDataLength;
957
958 /* Add the data */
959 RtlCopyMemory(Elements->Data, ElementData, ElementDataLength);
960 RemainingLength -= TotalLength;
961
962 /* Move to the next element on the next pass */
963 PreviousElement = Elements;
964 Elements = Elements->NextEntry;
965 }
966 else
967 {
968 /* We're out of space */
969 RemainingLength = 0;
970 }
971
972 /* Are we enumerating devices, and is this a device? */
973 if ((Flags & BCD_ENUMERATE_FLAG_DEVICES) &&
974 (ElementType.Format == BCD_TYPE_DEVICE))
975 {
976 /* Yep, so go inside to enumerate it */
977 Status = BiEnumerateSubElements(BcdHandle,
978 ElementData,
979 ElementType.PackedValue,
980 Flags,
981 &Elements,
982 &ElementDataLength,
983 &SubElementCount);
984 if ((NT_SUCCESS(Status)) || (Status == STATUS_BUFFER_TOO_SMALL))
985 {
986 /* Safely add the length of the sub elements */
987 Status = RtlULongAdd(TotalLength,
988 ElementDataLength,
989 &TotalLength);
990 if (!NT_SUCCESS(Status))
991 {
992 break;
993 }
994
995 /* Add the sub elements to the total */
996 *ElementCount += SubElementCount;
997
998 /* See if we have enough space*/
999 if (*ElementSize >= TotalLength)
1000 {
1001 /* Were there any subelements? */
1002 if (SubElementCount)
1003 {
1004 /* Update to keep track of these new subelements */
1005 ElementDataLength = *ElementSize - TotalLength;
1006
1007 /* Link the subelements into the chain */
1008 PreviousElement = Elements;
1009 PreviousElement->NextEntry =
1010 (PBCD_PACKED_ELEMENT)((ULONG_PTR)ElementsStart +
1011 TotalLength);
1012 Elements = PreviousElement->NextEntry;
1013 }
1014 }
1015 else
1016 {
1017 /* We're out of space */
1018 ElementDataLength = 0;
1019 }
1020 }
1021 else if ((Status != STATUS_NOT_FOUND) &&
1022 (Status != STATUS_OBJECT_NAME_NOT_FOUND))
1023 {
1024 /* Fatal error trying to read the data, so fail */
1025 break;
1026 }
1027 }
1028 else if ((Flags & BCD_ENUMERATE_FLAG_DEEP) &&
1029 (ElementType.PackedValue == BcdLibraryObjectList_InheritedObjects))
1030 {
1031 /* Inherited objects are requested, so allocate a buffer for them */
1032 SubObjectList = BlMmAllocateHeap(ElementDataLength);
1033 if (!SubObjectList)
1034 {
1035 Status = STATUS_INSUFFICIENT_RESOURCES;
1036 break;
1037 }
1038
1039 /* Copy the elements into the list. They are arrays of GUIDs */
1040 RtlCopyMemory(SubObjectList, ElementData, ElementDataLength);
1041 SubObjectCount = ElementDataLength / sizeof(GUID);
1042 }
1043
1044 /* Free our local buffers */
1045 BlMmFreeHeap(ElementData);
1046 BlMmFreeHeap(RegistryElementData);
1047 ElementData = NULL;
1048 RegistryElementData = NULL;
1049
1050 /* Close the key */
1051 BiCloseKey(ElementHandle);
1052 ElementHandle = NULL;
1053 ElementName = NULL;
1054 }
1055
1056 /* Did we end up here with a sub object list after successful loop parsing? */
1057 if ((i != 0) && (i == SubKeyCount) && (SubObjectList))
1058 {
1059 /* We will actually enumerate it now, at the end */
1060 Status = BiEnumerateSubObjectElements(BcdHandle,
1061 SubObjectList,
1062 SubObjectCount,
1063 Flags,
1064 Elements,
1065 &RemainingLength,
1066 &SubElementCount);
1067 if ((NT_SUCCESS(Status)) || (Status == STATUS_BUFFER_TOO_SMALL))
1068 {
1069 /* Safely add the length of the sub elements */
1070 Status = RtlULongAdd(TotalLength, RemainingLength, &TotalLength);
1071 if ((NT_SUCCESS(Status)) && (SubElementCount))
1072 {
1073 /* Add the sub elements to the total */
1074 *ElementCount += SubElementCount;
1075
1076 /* Don't touch PreviousElement anymore */
1077 PreviousElement = NULL;
1078 }
1079 }
1080 }
1081
1082 Quickie:
1083 /* Free the sub object list, if any */
1084 if (SubObjectList)
1085 {
1086 BlMmFreeHeap(SubObjectList);
1087 }
1088
1089 /* Free any local element data */
1090 if (ElementData)
1091 {
1092 BlMmFreeHeap(ElementData);
1093 }
1094
1095 /* Free any local registry data */
1096 if (RegistryElementData)
1097 {
1098 BlMmFreeHeap(RegistryElementData);
1099 }
1100
1101 /* Close the handle if still opened */
1102 if (ElementHandle)
1103 {
1104 BiCloseKey(ElementHandle);
1105 }
1106
1107 /* Terminate the last element, if any */
1108 if (PreviousElement)
1109 {
1110 PreviousElement->NextEntry = NULL;
1111 }
1112
1113 /* Close the root handle if still opened */
1114 if (ElementsHandle)
1115 {
1116 BiCloseKey(ElementsHandle);
1117 }
1118
1119 /* Set failure code if out of space */
1120 if (*ElementSize < TotalLength)
1121 {
1122 Status = STATUS_BUFFER_TOO_SMALL;
1123 }
1124
1125 /* Other errors will send a notification error */
1126 if (!(NT_SUCCESS(Status)) && (Status != STATUS_BUFFER_TOO_SMALL))
1127 {
1128 BiNotifyEnumerationError(ObjectHandle, ElementName, Status);
1129 }
1130
1131 /* Finally free the subkeys array */
1132 if (SubKeys)
1133 {
1134 BlMmFreeHeap(SubKeys);
1135 }
1136
1137 /* And return the required, final length and status */
1138 *ElementSize = TotalLength;
1139 return Status;
1140 }
1141
1142 NTSTATUS
1143 BiAddStoreFromFile (
1144 _In_ PBL_FILE_PATH_DESCRIPTOR FilePath,
1145 _Out_ PHANDLE StoreHandle
1146 )
1147 {
1148 NTSTATUS Status;
1149 HANDLE HiveHandle, KeyHandle;
1150
1151 /* Load the specified hive */
1152 Status = BiLoadHive(FilePath, &HiveHandle);
1153 if (!NT_SUCCESS(Status))
1154 {
1155 return Status;
1156 }
1157
1158 /* Open the description key to make sure this is really a BCD */
1159 Status = BiOpenKey(HiveHandle, L"Description", &KeyHandle);
1160 if (NT_SUCCESS(Status))
1161 {
1162 /* It is -- close the key as we don't need it */
1163 BiCloseKey(KeyHandle);
1164 *StoreHandle = HiveHandle;
1165 }
1166 else
1167 {
1168 /* Failure, drop a reference on the hive and close the key */
1169 BiDereferenceHive(HiveHandle);
1170 BiCloseKey(HiveHandle);
1171 }
1172
1173 /* Return the status */
1174 return Status;
1175 }
1176
1177 NTSTATUS
1178 BiGetObjectDescription (
1179 _In_ HANDLE ObjectHandle,
1180 _Out_ PBCD_OBJECT_DESCRIPTION Description
1181 )
1182 {
1183 NTSTATUS Status;
1184 HANDLE DescriptionHandle;
1185 PULONG Data;
1186 ULONG Length;
1187
1188 /* Initialize locals */
1189 Data = NULL;
1190 DescriptionHandle = NULL;
1191
1192 /* Open the description key */
1193 Status = BiOpenKey(ObjectHandle, L"Description", &DescriptionHandle);
1194 if (NT_SUCCESS(Status))
1195 {
1196 /* It exists */
1197 Description->Valid = TRUE;
1198
1199 /* Read the type */
1200 Length = 0;
1201 Status = BiGetRegistryValue(DescriptionHandle,
1202 L"Type",
1203 REG_DWORD,
1204 (PVOID*)&Data,
1205 &Length);
1206 if (NT_SUCCESS(Status))
1207 {
1208 /* Make sure it's the length we expected it to be */
1209 if (Length == sizeof(Data))
1210 {
1211 /* Return the type that is stored there */
1212 Description->Type = *Data;
1213 }
1214 else
1215 {
1216 /* Invalid type value */
1217 Status = STATUS_OBJECT_TYPE_MISMATCH;
1218 }
1219 }
1220 }
1221
1222 /* Did we have a handle open? */
1223 if (DescriptionHandle)
1224 {
1225 /* Close it */
1226 BiCloseKey(DescriptionHandle);
1227 }
1228
1229 /* Did we have data allocated? */
1230 if (Data)
1231 {
1232 /* Free it */
1233 BlMmFreeHeap(Data);
1234 }
1235
1236 /* Return back to caller */
1237 return Status;
1238 }
1239
1240 NTSTATUS
1241 BcdEnumerateAndUnpackElements (
1242 _In_ HANDLE BcdHandle,
1243 _In_ HANDLE ObjectHandle,
1244 _Out_opt_ PBCD_ELEMENT Elements,
1245 _Inout_ PULONG ElementSize,
1246 _Out_ PULONG ElementCount
1247 )
1248 {
1249 PVOID LocalElements;
1250 NTSTATUS Status;
1251 ULONG LocalElementCount, LocalElementSize;
1252
1253 /* Make sure required parameters are there */
1254 if (!(ElementSize) || !(ElementCount) || ((Elements) && (!*ElementSize)))
1255 {
1256 return STATUS_INVALID_PARAMETER;
1257 }
1258
1259 /* Set initial count to zero */
1260 *ElementCount = 0;
1261
1262 /* Do the initial enumeration to figure out the size required */
1263 LocalElementSize = 0;
1264 LocalElementCount = 0;
1265 Status = BiEnumerateElements(BcdHandle,
1266 ObjectHandle,
1267 0,
1268 BCD_ENUMERATE_FLAG_IN_ORDER |
1269 BCD_ENUMERATE_FLAG_DEVICES |
1270 BCD_ENUMERATE_FLAG_DEEP,
1271 NULL,
1272 &LocalElementSize,
1273 &LocalElementCount);
1274 if (Status != STATUS_BUFFER_TOO_SMALL)
1275 {
1276 return Status;
1277 }
1278
1279 /* Now allocate a buffer large enough to hold them */
1280 LocalElements = BlMmAllocateHeap(LocalElementSize);
1281 if (!LocalElements)
1282 {
1283 return STATUS_INSUFFICIENT_RESOURCES;
1284 }
1285
1286 /* Zero out the array and do the real enumeration this time around */
1287 RtlZeroMemory(LocalElements, LocalElementSize);
1288 Status = BiEnumerateElements(BcdHandle,
1289 ObjectHandle,
1290 0,
1291 BCD_ENUMERATE_FLAG_IN_ORDER |
1292 BCD_ENUMERATE_FLAG_DEVICES |
1293 BCD_ENUMERATE_FLAG_DEEP,
1294 LocalElements,
1295 &LocalElementSize,
1296 &LocalElementCount);
1297 if (!NT_SUCCESS(Status))
1298 {
1299 return Status;
1300 }
1301
1302 /* Now we know the real count */
1303 *ElementCount = LocalElementCount;
1304
1305 /* Now unpack the data */
1306 Status = BiConvertBcdElements(LocalElements,
1307 Elements,
1308 ElementSize,
1309 &LocalElementCount);
1310 if (NT_SUCCESS(Status))
1311 {
1312 /* Not all elements may have been converted */
1313 *ElementCount = LocalElementCount;
1314 }
1315
1316 /* Free the local (unpacked) buffer and return status */
1317 BlMmFreeHeap(LocalElements);
1318 return Status;
1319 }
1320
1321 NTSTATUS
1322 BcdOpenStoreFromFile (
1323 _In_ PUNICODE_STRING FileName,
1324 _In_ PHANDLE BcdHandle
1325 )
1326 {
1327 ULONG Length;
1328 PBL_FILE_PATH_DESCRIPTOR FilePath;
1329 NTSTATUS Status;
1330 HANDLE LocalHandle;
1331
1332 /* Assume failure */
1333 LocalHandle = NULL;
1334
1335 /* Allocate a path descriptor */
1336 Length = FileName->Length + sizeof(*FilePath);
1337 FilePath = BlMmAllocateHeap(Length);
1338 if (!FilePath)
1339 {
1340 return STATUS_NO_MEMORY;
1341 }
1342
1343 /* Initialize it */
1344 FilePath->Version = 1;
1345 FilePath->PathType = InternalPath;
1346 FilePath->Length = Length;
1347
1348 /* Copy the name and NULL-terminate it */
1349 RtlCopyMemory(FilePath->Path, FileName->Buffer, Length);
1350 FilePath->Path[Length / sizeof(WCHAR)] = UNICODE_NULL;
1351
1352 /* Open the BCD */
1353 Status = BiAddStoreFromFile(FilePath, &LocalHandle);
1354 if (NT_SUCCESS(Status))
1355 {
1356 /* Return the handle on success */
1357 *BcdHandle = LocalHandle;
1358 }
1359
1360 /* Free the descriptor and return the status */
1361 BlMmFreeHeap(FilePath);
1362 return Status;
1363 }
1364