]> git.proxmox.com Git - mirror_edk2.git/blob - BaseTools/Source/C/VolInfo/VolInfo.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
BaseTools: Replace BSD License with BSD+Patent License
[mirror_edk2.git] / BaseTools / Source / C / VolInfo / VolInfo.c
1 /** @file
2 The tool dumps the contents of a firmware volume
3
4 Copyright (c) 1999 - 2018, Intel Corporation. All rights reserved.<BR>
5 SPDX-License-Identifier: BSD-2-Clause-Patent
6
7 **/
8
9 #include <stdio.h>
10 #include <stdlib.h>
11 #include <string.h>
12 #include <ctype.h>
13 #include <assert.h>
14 #ifdef __GNUC__
15 #include <unistd.h>
16 #else
17 #include <direct.h>
18 #endif
19
20 #include <FvLib.h>
21 #include <Common/UefiBaseTypes.h>
22 #include <Common/UefiCapsule.h>
23 #include <Common/PiFirmwareFile.h>
24 #include <Common/PiFirmwareVolume.h>
25 #include <Guid/PiFirmwareFileSystem.h>
26 #include <IndustryStandard/PeImage.h>
27 #include <Protocol/GuidedSectionExtraction.h>
28
29 #include "Compress.h"
30 #include "Decompress.h"
31 #include "VolInfo.h"
32 #include "CommonLib.h"
33 #include "EfiUtilityMsgs.h"
34 #include "FirmwareVolumeBufferLib.h"
35 #include "OsPath.h"
36 #include "ParseGuidedSectionTools.h"
37 #include "StringFuncs.h"
38 #include "ParseInf.h"
39 #include "PeCoffLib.h"
40
41 //
42 // Utility global variables
43 //
44
45 EFI_GUID gEfiCrc32GuidedSectionExtractionProtocolGuid = EFI_CRC32_GUIDED_SECTION_EXTRACTION_PROTOCOL_GUID;
46
47 #define UTILITY_MAJOR_VERSION 1
48 #define UTILITY_MINOR_VERSION 0
49
50 #define UTILITY_NAME "VolInfo"
51
52 #define EFI_SECTION_ERROR EFIERR (100)
53
54 #define MAX_BASENAME_LEN 60 // not good to hardcode, but let's be reasonable
55
56 //
57 // Structure to keep a list of guid-to-basenames
58 //
59 typedef struct _GUID_TO_BASENAME {
60 struct _GUID_TO_BASENAME *Next;
61 INT8 Guid[PRINTED_GUID_BUFFER_SIZE];
62 INT8 BaseName[MAX_BASENAME_LEN];
63 } GUID_TO_BASENAME;
64
65 static GUID_TO_BASENAME *mGuidBaseNameList = NULL;
66
67 //
68 // Store GUIDed Section guid->tool mapping
69 //
70 EFI_HANDLE mParsedGuidedSectionTools = NULL;
71
72 CHAR8* mUtilityFilename = NULL;
73
74 BOOLEAN EnableHash = FALSE;
75 CHAR8 *OpenSslPath = NULL;
76
77 EFI_STATUS
78 ParseGuidBaseNameFile (
79 CHAR8 *FileName
80 );
81
82 EFI_STATUS
83 FreeGuidBaseNameList (
84 VOID
85 );
86
87 EFI_STATUS
88 PrintGuidName (
89 IN UINT8 *GuidStr
90 );
91
92 EFI_STATUS
93 ParseSection (
94 IN UINT8 *SectionBuffer,
95 IN UINT32 BufferLength
96 );
97
98 EFI_STATUS
99 DumpDepexSection (
100 IN UINT8 *Ptr,
101 IN UINT32 SectionLength
102 );
103
104 STATIC
105 EFI_STATUS
106 ReadHeader (
107 IN FILE *InputFile,
108 OUT UINT32 *FvSize,
109 OUT BOOLEAN *ErasePolarity
110 );
111
112 STATIC
113 EFI_STATUS
114 PrintFileInfo (
115 EFI_FIRMWARE_VOLUME_HEADER *FvImage,
116 EFI_FFS_FILE_HEADER *FileHeader,
117 BOOLEAN ErasePolarity
118 );
119
120 static
121 EFI_STATUS
122 PrintFvInfo (
123 IN VOID *Fv,
124 IN BOOLEAN IsChildFv
125 );
126
127 static
128 VOID
129 LoadGuidedSectionToolsTxt (
130 IN CHAR8* FirmwareVolumeFilename
131 );
132
133 EFI_STATUS
134 CombinePath (
135 IN CHAR8* DefaultPath,
136 IN CHAR8* AppendPath,
137 OUT CHAR8* NewPath
138 );
139
140 void
141 Usage (
142 VOID
143 );
144
145 UINT32
146 UnicodeStrLen (
147 IN CHAR16 *String
148 )
149 /*++
150
151 Routine Description:
152
153 Returns the length of a null-terminated unicode string.
154
155 Arguments:
156
157 String - The pointer to a null-terminated unicode string.
158
159 Returns:
160
161 N/A
162
163 --*/
164 {
165 UINT32 Length;
166
167 for (Length = 0; *String != L'\0'; String++, Length++) {
168 ;
169 }
170 return Length;
171 }
172
173 VOID
174 Unicode2AsciiString (
175 IN CHAR16 *Source,
176 OUT CHAR8 *Destination
177 )
178 /*++
179
180 Routine Description:
181
182 Convert a null-terminated unicode string to a null-terminated ascii string.
183
184 Arguments:
185
186 Source - The pointer to the null-terminated input unicode string.
187 Destination - The pointer to the null-terminated output ascii string.
188
189 Returns:
190
191 N/A
192
193 --*/
194 {
195 while (*Source != '\0') {
196 *(Destination++) = (CHAR8) *(Source++);
197 }
198 //
199 // End the ascii with a NULL.
200 //
201 *Destination = '\0';
202 }
203
204 int
205 main (
206 int argc,
207 char *argv[]
208 )
209 /*++
210
211 Routine Description:
212
213 GC_TODO: Add function description
214
215 Arguments:
216
217 argc - GC_TODO: add argument description
218 ] - GC_TODO: add argument description
219
220 Returns:
221
222 GC_TODO: add return values
223
224 --*/
225 {
226 FILE *InputFile;
227 int BytesRead;
228 EFI_FIRMWARE_VOLUME_HEADER *FvImage;
229 UINT32 FvSize;
230 EFI_STATUS Status;
231 int Offset;
232 BOOLEAN ErasePolarity;
233 UINT64 LogLevel;
234 CHAR8 *OpenSslEnv;
235 CHAR8 *OpenSslCommand;
236
237 SetUtilityName (UTILITY_NAME);
238 //
239 // Print utility header
240 //
241 printf ("%s Version %d.%d Build %s\n",
242 UTILITY_NAME,
243 UTILITY_MAJOR_VERSION,
244 UTILITY_MINOR_VERSION,
245 __BUILD_VERSION
246 );
247
248 if (argc == 1) {
249 Usage ();
250 return -1;
251 }
252
253 argc--;
254 argv++;
255 LogLevel = 0;
256 Offset = 0;
257
258 //
259 // Look for help options
260 //
261 if ((strcmp(argv[0], "-h") == 0) || (strcmp(argv[0], "--help") == 0) ||
262 (strcmp(argv[0], "-?") == 0) || (strcmp(argv[0], "/?") == 0)) {
263 Usage();
264 return STATUS_SUCCESS;
265 }
266 //
267 // Version has already be printed, so just return success
268 //
269 if (strcmp(argv[0], "--version") == 0) {
270 return STATUS_SUCCESS;
271 }
272
273 //
274 // If they specified -x xref guid/basename cross-reference files, process it.
275 // This will print the basename beside each file guid. To use it, specify
276 // -x xref_filename to processdsc, then use xref_filename as a parameter
277 // here.
278 //
279 while (argc > 0) {
280 if ((strcmp(argv[0], "-x") == 0) || (strcmp(argv[0], "--xref") == 0)) {
281 ParseGuidBaseNameFile (argv[1]);
282 printf("ParseGuidBaseNameFile: %s\n", argv[1]);
283 argc -= 2;
284 argv += 2;
285 continue;
286 }
287 if (strcmp(argv[0], "--offset") == 0) {
288 //
289 // Hex or decimal?
290 //
291 if ((argv[1][0] == '0') && (tolower ((int)argv[1][1]) == 'x')) {
292 if (sscanf (argv[1], "%x", &Offset) != 1) {
293 Error (NULL, 0, 1003, "Invalid option value", "Offset = %s", argv[1]);
294 return GetUtilityStatus ();
295 }
296 } else {
297 if (sscanf (argv[1], "%d", &Offset) != 1) {
298 Error (NULL, 0, 1003, "Invalid option value", "Offset = %s", argv[1]);
299 return GetUtilityStatus ();
300 }
301 //
302 // See if they said something like "64K"
303 //
304 if (tolower ((int)argv[1][strlen (argv[1]) - 1]) == 'k') {
305 Offset *= 1024;
306 }
307 }
308
309 argc -= 2;
310 argv += 2;
311 continue;
312 }
313 if ((stricmp (argv[0], "--hash") == 0)) {
314 if (EnableHash == TRUE) {
315 //
316 // --hash already given in the option, ignore this one
317 //
318 argc --;
319 argv ++;
320 continue;
321 }
322 EnableHash = TRUE;
323 OpenSslCommand = "openssl";
324 OpenSslEnv = getenv("OPENSSL_PATH");
325 if (OpenSslEnv == NULL) {
326 OpenSslPath = OpenSslCommand;
327 } else {
328 //
329 // We add quotes to the Openssl Path in case it has space characters
330 //
331 OpenSslPath = malloc(2+strlen(OpenSslEnv)+strlen(OpenSslCommand)+1);
332 if (OpenSslPath == NULL) {
333 Error (NULL, 0, 4001, "Resource", "memory cannot be allocated!");
334 return GetUtilityStatus ();
335 }
336 CombinePath(OpenSslEnv, OpenSslCommand, OpenSslPath);
337 }
338 if (OpenSslPath == NULL){
339 Error (NULL, 0, 3000, "Open SSL command not available. Please verify PATH or set OPENSSL_PATH.", NULL);
340 return GetUtilityStatus ();
341 }
342 argc --;
343 argv ++;
344 continue;
345 }
346
347 if ((stricmp (argv[0], "-v") == 0) || (stricmp (argv[0], "--verbose") == 0)) {
348 SetPrintLevel (VERBOSE_LOG_LEVEL);
349 argc --;
350 argv ++;
351 continue;
352 }
353
354 if ((stricmp (argv[0], "-q") == 0) || (stricmp (argv[0], "--quiet") == 0)) {
355 SetPrintLevel (KEY_LOG_LEVEL);
356 argc --;
357 argv ++;
358 continue;
359 }
360
361 if ((stricmp (argv[0], "-d") == 0) || (stricmp (argv[0], "--debug") == 0)) {
362 Status = AsciiStringToUint64 (argv[1], FALSE, &LogLevel);
363 if (EFI_ERROR (Status)) {
364 Error (NULL, 0, 1003, "Invalid option value", "%s = %s", argv[0], argv[1]);
365 return -1;
366 }
367 if (LogLevel > 9) {
368 Error (NULL, 0, 1003, "Invalid option value", "Debug Level range is 0-9, current input level is %d", (int) LogLevel);
369 return -1;
370 }
371 SetPrintLevel (LogLevel);
372 DebugMsg (NULL, 0, 9, "Debug Mode Set", "Debug Output Mode Level %s is set!", argv[1]);
373 argc -= 2;
374 argv += 2;
375 continue;
376 }
377
378 mUtilityFilename = argv[0];
379 argc --;
380 argv ++;
381 }
382
383 //
384 // Open the file containing the FV
385 //
386 if (mUtilityFilename == NULL) {
387 Error (NULL, 0, 1001, "Missing option", "Input files are not specified");
388 return GetUtilityStatus ();
389 }
390 InputFile = fopen (LongFilePath (mUtilityFilename), "rb");
391 if (InputFile == NULL) {
392 Error (NULL, 0, 0001, "Error opening the input file", mUtilityFilename);
393 return GetUtilityStatus ();
394 }
395 //
396 // Skip over pad bytes if specified. This is used if they prepend 0xff
397 // data to the FV image binary.
398 //
399 if (Offset != 0) {
400 fseek (InputFile, Offset, SEEK_SET);
401 }
402 //
403 // Determine size of FV
404 //
405 Status = ReadHeader (InputFile, &FvSize, &ErasePolarity);
406 if (EFI_ERROR (Status)) {
407 Error (NULL, 0, 0003, "error parsing FV image", "%s Header is invalid", mUtilityFilename);
408 fclose (InputFile);
409 return GetUtilityStatus ();
410 }
411 //
412 // Allocate a buffer for the FV image
413 //
414 FvImage = malloc (FvSize);
415 if (FvImage == NULL) {
416 Error (NULL, 0, 4001, "Resource: Memory can't be allocated", NULL);
417 fclose (InputFile);
418 return GetUtilityStatus ();
419 }
420 //
421 // Seek to the start of the image, then read the entire FV to the buffer
422 //
423 fseek (InputFile, Offset, SEEK_SET);
424 BytesRead = fread (FvImage, 1, FvSize, InputFile);
425 fclose (InputFile);
426 if ((unsigned int) BytesRead != FvSize) {
427 Error (NULL, 0, 0004, "error reading FvImage from", mUtilityFilename);
428 free (FvImage);
429 return GetUtilityStatus ();
430 }
431
432 LoadGuidedSectionToolsTxt (mUtilityFilename);
433
434 PrintFvInfo (FvImage, FALSE);
435
436 //
437 // Clean up
438 //
439 free (FvImage);
440 FreeGuidBaseNameList ();
441 return GetUtilityStatus ();
442 }
443
444
445 static
446 EFI_STATUS
447 PrintFvInfo (
448 IN VOID *Fv,
449 IN BOOLEAN IsChildFv
450 )
451 /*++
452
453 Routine Description:
454
455 GC_TODO: Add function description
456
457 Arguments:
458
459 Fv - Firmware Volume to print information about
460 IsChildFv - Flag specifies whether the input FV is a child FV.
461
462 Returns:
463
464 EFI_STATUS
465
466 --*/
467 {
468 EFI_STATUS Status;
469 UINTN NumberOfFiles;
470 BOOLEAN ErasePolarity;
471 UINTN FvSize;
472 EFI_FFS_FILE_HEADER *CurrentFile;
473 UINTN Key;
474
475 Status = FvBufGetSize (Fv, &FvSize);
476
477 NumberOfFiles = 0;
478 ErasePolarity =
479 (((EFI_FIRMWARE_VOLUME_HEADER*)Fv)->Attributes & EFI_FVB2_ERASE_POLARITY) ?
480 TRUE : FALSE;
481
482 //
483 // Get the first file
484 //
485 Key = 0;
486 Status = FvBufFindNextFile (Fv, &Key, (VOID **) &CurrentFile);
487 if (EFI_ERROR (Status)) {
488 Error (NULL, 0, 0003, "error parsing FV image", "cannot find the first file in the FV image");
489 return GetUtilityStatus ();
490 }
491 //
492 // Display information about files found
493 //
494 while (CurrentFile != NULL) {
495 //
496 // Increment the number of files counter
497 //
498 NumberOfFiles++;
499
500 //
501 // Display info about this file
502 //
503 Status = PrintFileInfo (Fv, CurrentFile, ErasePolarity);
504 if (EFI_ERROR (Status)) {
505 Error (NULL, 0, 0003, "error parsing FV image", "failed to parse a file in the FV");
506 return GetUtilityStatus ();
507 }
508 //
509 // Get the next file
510 //
511 Status = FvBufFindNextFile (Fv, &Key, (VOID **) &CurrentFile);
512 if (Status == EFI_NOT_FOUND) {
513 CurrentFile = NULL;
514 } else if (EFI_ERROR (Status)) {
515 Error (NULL, 0, 0003, "error parsing FV image", "cannot find the next file in the FV image");
516 return GetUtilityStatus ();
517 }
518 }
519
520 if (IsChildFv) {
521 printf ("There are a total of %d files in the child FV\n", (int) NumberOfFiles);
522 } else {
523 printf ("There are a total of %d files in this FV\n", (int) NumberOfFiles);
524 }
525
526 return EFI_SUCCESS;
527 }
528
529 UINT32
530 GetOccupiedSize (
531 IN UINT32 ActualSize,
532 IN UINT32 Alignment
533 )
534 /*++
535
536 Routine Description:
537
538 This function returns the next larger size that meets the alignment
539 requirement specified.
540
541 Arguments:
542
543 ActualSize The size.
544 Alignment The desired alignment.
545
546 Returns:
547
548 EFI_SUCCESS Function completed successfully.
549 EFI_ABORTED The function encountered an error.
550
551 --*/
552 {
553 UINT32 OccupiedSize;
554
555 OccupiedSize = ActualSize;
556 while ((OccupiedSize & (Alignment - 1)) != 0) {
557 OccupiedSize++;
558 }
559
560 return OccupiedSize;
561 }
562
563 static
564 CHAR8 *
565 SectionNameToStr (
566 IN EFI_SECTION_TYPE Type
567 )
568 /*++
569
570 Routine Description:
571
572 Converts EFI Section names to Strings
573
574 Arguments:
575
576 Type - The EFI Section type
577
578 Returns:
579
580 CHAR8* - Pointer to the String containing the section name.
581
582 --*/
583 {
584 CHAR8 *SectionStr;
585 CHAR8 *SectionTypeStringTable[] = {
586 //
587 // 0X00
588 //
589 "EFI_SECTION_ALL",
590 //
591 // 0x01
592 //
593 "EFI_SECTION_COMPRESSION",
594 //
595 // 0x02
596 //
597 "EFI_SECTION_GUID_DEFINED",
598 //
599 // 0x03
600 //
601 "Unknown section type - Reserved 0x03",
602 //
603 // 0x04
604 //
605 "Unknown section type - Reserved 0x04",
606 //
607 // 0x05
608 //
609 "Unknown section type - Reserved 0x05",
610 //
611 // 0x06
612 //
613 "Unknown section type - Reserved 0x06",
614 //
615 // 0x07
616 //
617 "Unknown section type - Reserved 0x07",
618 //
619 // 0x08
620 //
621 "Unknown section type - Reserved 0x08",
622 //
623 // 0x09
624 //
625 "Unknown section type - Reserved 0x09",
626 //
627 // 0x0A
628 //
629 "Unknown section type - Reserved 0x0A",
630 //
631 // 0x0B
632 //
633 "Unknown section type - Reserved 0x0B",
634 //
635 // 0x0C
636 //
637 "Unknown section type - Reserved 0x0C",
638 //
639 // 0x0D
640 //
641 "Unknown section type - Reserved 0x0D",
642 //
643 // 0x0E
644 //
645 "Unknown section type - Reserved 0x0E",
646 //
647 // 0x0F
648 //
649 "Unknown section type - Reserved 0x0E",
650 //
651 // 0x10
652 //
653 "EFI_SECTION_PE32",
654 //
655 // 0x11
656 //
657 "EFI_SECTION_PIC",
658 //
659 // 0x12
660 //
661 "EFI_SECTION_TE",
662 //
663 // 0x13
664 //
665 "EFI_SECTION_DXE_DEPEX",
666 //
667 // 0x14
668 //
669 "EFI_SECTION_VERSION",
670 //
671 // 0x15
672 //
673 "EFI_SECTION_USER_INTERFACE",
674 //
675 // 0x16
676 //
677 "EFI_SECTION_COMPATIBILITY16",
678 //
679 // 0x17
680 //
681 "EFI_SECTION_FIRMWARE_VOLUME_IMAGE ",
682 //
683 // 0x18
684 //
685 "EFI_SECTION_FREEFORM_SUBTYPE_GUID ",
686 //
687 // 0x19
688 //
689 "EFI_SECTION_RAW",
690 //
691 // 0x1A
692 //
693 "Unknown section type - 0x1A",
694 //
695 // 0x1B
696 //
697 "EFI_SECTION_PEI_DEPEX",
698 //
699 // 0x1C
700 //
701 "EFI_SECTION_SMM_DEPEX",
702 //
703 // 0x1C+
704 //
705 "Unknown section type - Reserved - beyond last defined section"
706 };
707
708 if (Type > EFI_SECTION_LAST_SECTION_TYPE) {
709 Type = EFI_SECTION_LAST_SECTION_TYPE + 1;
710 }
711
712 SectionStr = malloc (100);
713 if (SectionStr == NULL) {
714 printf ("Error: Out of memory resources.\n");
715 return SectionStr;
716 }
717 strcpy (SectionStr, SectionTypeStringTable[Type]);
718 return SectionStr;
719 }
720
721 STATIC
722 EFI_STATUS
723 ReadHeader (
724 IN FILE *InputFile,
725 OUT UINT32 *FvSize,
726 OUT BOOLEAN *ErasePolarity
727 )
728 /*++
729
730 Routine Description:
731
732 This function determines the size of the FV and the erase polarity. The
733 erase polarity is the FALSE value for file state.
734
735 Arguments:
736
737 InputFile The file that contains the FV image.
738 FvSize The size of the FV.
739 ErasePolarity The FV erase polarity.
740
741 Returns:
742
743 EFI_SUCCESS Function completed successfully.
744 EFI_INVALID_PARAMETER A required parameter was NULL or is out of range.
745 EFI_ABORTED The function encountered an error.
746
747 --*/
748 {
749 EFI_FIRMWARE_VOLUME_HEADER VolumeHeader;
750 EFI_FV_BLOCK_MAP_ENTRY BlockMap;
751 UINTN Signature[2];
752 UINTN BytesRead;
753 UINT32 Size;
754
755 BytesRead = 0;
756 Size = 0;
757 //
758 // Check input parameters
759 //
760 if (InputFile == NULL || FvSize == NULL || ErasePolarity == NULL) {
761 Error (__FILE__, __LINE__, 0, "application error", "invalid parameter to function");
762 return EFI_INVALID_PARAMETER;
763 }
764 //
765 // Read the header
766 //
767 fread (&VolumeHeader, sizeof (EFI_FIRMWARE_VOLUME_HEADER) - sizeof (EFI_FV_BLOCK_MAP_ENTRY), 1, InputFile);
768 BytesRead = sizeof (EFI_FIRMWARE_VOLUME_HEADER) - sizeof (EFI_FV_BLOCK_MAP_ENTRY);
769 Signature[0] = VolumeHeader.Signature;
770 Signature[1] = 0;
771
772 //
773 // Print FV header information
774 //
775 printf ("Signature: %s (%X)\n", (char *) Signature, (unsigned) VolumeHeader.Signature);
776 printf ("Attributes: %X\n", (unsigned) VolumeHeader.Attributes);
777
778 if (VolumeHeader.Attributes & EFI_FVB2_READ_DISABLED_CAP) {
779 printf (" EFI_FVB2_READ_DISABLED_CAP\n");
780 }
781
782 if (VolumeHeader.Attributes & EFI_FVB2_READ_ENABLED_CAP) {
783 printf (" EFI_FVB2_READ_ENABLED_CAP\n");
784 }
785
786 if (VolumeHeader.Attributes & EFI_FVB2_READ_STATUS) {
787 printf (" EFI_FVB2_READ_STATUS\n");
788 }
789
790 if (VolumeHeader.Attributes & EFI_FVB2_WRITE_DISABLED_CAP) {
791 printf (" EFI_FVB2_WRITE_DISABLED_CAP\n");
792 }
793
794 if (VolumeHeader.Attributes & EFI_FVB2_WRITE_ENABLED_CAP) {
795 printf (" EFI_FVB2_WRITE_ENABLED_CAP\n");
796 }
797
798 if (VolumeHeader.Attributes & EFI_FVB2_WRITE_STATUS) {
799 printf (" EFI_FVB2_WRITE_STATUS\n");
800 }
801
802 if (VolumeHeader.Attributes & EFI_FVB2_LOCK_CAP) {
803 printf (" EFI_FVB2_LOCK_CAP\n");
804 }
805
806 if (VolumeHeader.Attributes & EFI_FVB2_LOCK_STATUS) {
807 printf (" EFI_FVB2_LOCK_STATUS\n");
808 }
809
810 if (VolumeHeader.Attributes & EFI_FVB2_STICKY_WRITE) {
811 printf (" EFI_FVB2_STICKY_WRITE\n");
812 }
813
814 if (VolumeHeader.Attributes & EFI_FVB2_MEMORY_MAPPED) {
815 printf (" EFI_FVB2_MEMORY_MAPPED\n");
816 }
817
818 if (VolumeHeader.Attributes & EFI_FVB2_ERASE_POLARITY) {
819 printf (" EFI_FVB2_ERASE_POLARITY\n");
820 *ErasePolarity = TRUE;
821 }
822
823 #if (PI_SPECIFICATION_VERSION < 0x00010000)
824 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT) {
825 printf (" EFI_FVB2_ALIGNMENT\n");
826 }
827
828 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_2) {
829 printf (" EFI_FVB2_ALIGNMENT_2\n");
830 }
831
832 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_4) {
833 printf (" EFI_FVB2_ALIGNMENT_4\n");
834 }
835
836 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_8) {
837 printf (" EFI_FVB2_ALIGNMENT_8\n");
838 }
839
840 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_16) {
841 printf (" EFI_FVB2_ALIGNMENT_16\n");
842 }
843
844 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_32) {
845 printf (" EFI_FVB2_ALIGNMENT_32\n");
846 }
847
848 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_64) {
849 printf (" EFI_FVB2_ALIGNMENT_64\n");
850 }
851
852 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_128) {
853 printf (" EFI_FVB2_ALIGNMENT_128\n");
854 }
855
856 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_256) {
857 printf (" EFI_FVB2_ALIGNMENT_256\n");
858 }
859
860 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_512) {
861 printf (" EFI_FVB2_ALIGNMENT_512\n");
862 }
863
864 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_1K) {
865 printf (" EFI_FVB2_ALIGNMENT_1K\n");
866 }
867
868 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_2K) {
869 printf (" EFI_FVB2_ALIGNMENT_2K\n");
870 }
871
872 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_4K) {
873 printf (" EFI_FVB2_ALIGNMENT_4K\n");
874 }
875
876 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_8K) {
877 printf (" EFI_FVB2_ALIGNMENT_8K\n");
878 }
879
880 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_16K) {
881 printf (" EFI_FVB2_ALIGNMENT_16K\n");
882 }
883
884 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_32K) {
885 printf (" EFI_FVB2_ALIGNMENT_32K\n");
886 }
887
888 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_64K) {
889 printf (" EFI_FVB2_ALIGNMENT_64K\n");
890 }
891
892 #else
893
894 if (VolumeHeader.Attributes & EFI_FVB2_READ_LOCK_CAP) {
895 printf (" EFI_FVB2_READ_LOCK_CAP\n");
896 }
897
898 if (VolumeHeader.Attributes & EFI_FVB2_READ_LOCK_STATUS) {
899 printf (" EFI_FVB2_READ_LOCK_STATUS\n");
900 }
901
902 if (VolumeHeader.Attributes & EFI_FVB2_WRITE_LOCK_CAP) {
903 printf (" EFI_FVB2_WRITE_LOCK_CAP\n");
904 }
905
906 if (VolumeHeader.Attributes & EFI_FVB2_WRITE_LOCK_STATUS) {
907 printf (" EFI_FVB2_WRITE_LOCK_STATUS\n");
908 }
909
910 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_1) {
911 printf (" EFI_FVB2_ALIGNMENT_1\n");
912 }
913
914 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_2) {
915 printf (" EFI_FVB2_ALIGNMENT_2\n");
916 }
917
918 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_4) {
919 printf (" EFI_FVB2_ALIGNMENT_4\n");
920 }
921
922 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_8) {
923 printf (" EFI_FVB2_ALIGNMENT_8\n");
924 }
925
926 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_16) {
927 printf (" EFI_FVB2_ALIGNMENT_16\n");
928 }
929
930 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_32) {
931 printf (" EFI_FVB2_ALIGNMENT_32\n");
932 }
933
934 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_64) {
935 printf (" EFI_FVB2_ALIGNMENT_64\n");
936 }
937
938 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_128) {
939 printf (" EFI_FVB2_ALIGNMENT_128\n");
940 }
941
942 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_256) {
943 printf (" EFI_FVB2_ALIGNMENT_256\n");
944 }
945
946 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_512) {
947 printf (" EFI_FVB2_ALIGNMENT_512\n");
948 }
949
950 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_1K) {
951 printf (" EFI_FVB2_ALIGNMENT_1K\n");
952 }
953
954 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_2K) {
955 printf (" EFI_FVB2_ALIGNMENT_2K\n");
956 }
957
958 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_4K) {
959 printf (" EFI_FVB2_ALIGNMENT_4K\n");
960 }
961
962 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_8K) {
963 printf (" EFI_FVB2_ALIGNMENT_8K\n");
964 }
965
966 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_16K) {
967 printf (" EFI_FVB2_ALIGNMENT_16K\n");
968 }
969
970 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_32K) {
971 printf (" EFI_FVB2_ALIGNMENT_32K\n");
972 }
973
974 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_64K) {
975 printf (" EFI_FVB2_ALIGNMENT_64K\n");
976 }
977
978 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_128K) {
979 printf (" EFI_FVB2_ALIGNMENT_128K\n");
980 }
981
982 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_256K) {
983 printf (" EFI_FVB2_ALIGNMENT_256K\n");
984 }
985
986 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_512K) {
987 printf (" EFI_FVB2_ALIGNMENT_512K\n");
988 }
989
990 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_1M) {
991 printf (" EFI_FVB2_ALIGNMENT_1M\n");
992 }
993
994 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_2M) {
995 printf (" EFI_FVB2_ALIGNMENT_2M\n");
996 }
997
998 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_4M) {
999 printf (" EFI_FVB2_ALIGNMENT_4M\n");
1000 }
1001
1002 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_8M) {
1003 printf (" EFI_FVB2_ALIGNMENT_8M\n");
1004 }
1005
1006 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_16M) {
1007 printf (" EFI_FVB2_ALIGNMENT_16M\n");
1008 }
1009
1010 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_32M) {
1011 printf (" EFI_FVB2_ALIGNMENT_32M\n");
1012 }
1013
1014 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_64M) {
1015 printf (" EFI_FVB2_ALIGNMENT_64M\n");
1016 }
1017
1018 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_128M) {
1019 printf (" EFI_FVB2_ALIGNMENT_128M\n");
1020 }
1021
1022 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_64M) {
1023 printf (" EFI_FVB2_ALIGNMENT_64M\n");
1024 }
1025
1026 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_128M) {
1027 printf (" EFI_FVB2_ALIGNMENT_128M\n");
1028 }
1029
1030 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_256M) {
1031 printf (" EFI_FVB2_ALIGNMENT_256M\n");
1032 }
1033
1034 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_512M) {
1035 printf (" EFI_FVB2_ALIGNMENT_512M\n");
1036 }
1037
1038 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_1G) {
1039 printf (" EFI_FVB2_ALIGNMENT_1G\n");
1040 }
1041
1042 if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_2G) {
1043 printf (" EFI_FVB2_ALIGNMENT_2G\n");
1044 }
1045
1046 #endif
1047 printf ("Header Length: 0x%08X\n", VolumeHeader.HeaderLength);
1048 printf ("File System ID: ");
1049 PrintGuid (&VolumeHeader.FileSystemGuid);
1050 //
1051 // printf ("\n");
1052 //
1053 printf ("Revision: 0x%04X\n", VolumeHeader.Revision);
1054
1055 do {
1056 fread (&BlockMap, sizeof (EFI_FV_BLOCK_MAP_ENTRY), 1, InputFile);
1057 BytesRead += sizeof (EFI_FV_BLOCK_MAP_ENTRY);
1058
1059 if (BlockMap.NumBlocks != 0) {
1060 printf ("Number of Blocks: 0x%08X\n", (unsigned) BlockMap.NumBlocks);
1061 printf ("Block Length: 0x%08X\n", (unsigned) BlockMap.Length);
1062 Size += BlockMap.NumBlocks * BlockMap.Length;
1063 }
1064
1065 } while (!(BlockMap.NumBlocks == 0 && BlockMap.Length == 0));
1066
1067 if (BytesRead != VolumeHeader.HeaderLength) {
1068 printf ("ERROR: Header length not consistent with Block Maps!\n");
1069 return EFI_ABORTED;
1070 }
1071
1072 if (VolumeHeader.FvLength != Size) {
1073 printf ("ERROR: Volume Size not consistant with Block Maps!\n");
1074 return EFI_ABORTED;
1075 }
1076
1077 printf ("Total Volume Size: 0x%08X\n", (unsigned) Size);
1078
1079 *FvSize = Size;
1080
1081 //
1082 // rewind (InputFile);
1083 //
1084 return EFI_SUCCESS;
1085 }
1086
1087 STATIC
1088 EFI_STATUS
1089 PrintFileInfo (
1090 EFI_FIRMWARE_VOLUME_HEADER *FvImage,
1091 EFI_FFS_FILE_HEADER *FileHeader,
1092 BOOLEAN ErasePolarity
1093 )
1094 /*++
1095
1096 Routine Description:
1097
1098 GC_TODO: Add function description
1099
1100 Arguments:
1101
1102 FvImage - GC_TODO: add argument description
1103 FileHeader - GC_TODO: add argument description
1104 ErasePolarity - GC_TODO: add argument description
1105
1106 Returns:
1107
1108 EFI_SUCCESS - GC_TODO: Add description for return value
1109 EFI_ABORTED - GC_TODO: Add description for return value
1110
1111 --*/
1112 {
1113 UINT32 FileLength;
1114 UINT8 FileState;
1115 UINT8 Checksum;
1116 EFI_FFS_FILE_HEADER2 BlankHeader;
1117 EFI_STATUS Status;
1118 UINT8 GuidBuffer[PRINTED_GUID_BUFFER_SIZE];
1119 UINT32 HeaderSize;
1120 #if (PI_SPECIFICATION_VERSION < 0x00010000)
1121 UINT16 *Tail;
1122 #endif
1123 //
1124 // Check if we have free space
1125 //
1126 HeaderSize = FvBufGetFfsHeaderSize(FileHeader);
1127 if (ErasePolarity) {
1128 memset (&BlankHeader, -1, HeaderSize);
1129 } else {
1130 memset (&BlankHeader, 0, HeaderSize);
1131 }
1132
1133 if (memcmp (&BlankHeader, FileHeader, HeaderSize) == 0) {
1134 return EFI_SUCCESS;
1135 }
1136 //
1137 // Print file information.
1138 //
1139 printf ("============================================================\n");
1140
1141 printf ("File Name: ");
1142 PrintGuidToBuffer (&FileHeader->Name, GuidBuffer, sizeof (GuidBuffer), TRUE);
1143 printf ("%s ", GuidBuffer);
1144 PrintGuidName (GuidBuffer);
1145 printf ("\n");
1146
1147 //
1148 // PrintGuid (&FileHeader->Name);
1149 // printf ("\n");
1150 //
1151 FileLength = FvBufGetFfsFileSize (FileHeader);
1152 printf ("File Offset: 0x%08X\n", (unsigned) ((UINTN) FileHeader - (UINTN) FvImage));
1153 printf ("File Length: 0x%08X\n", (unsigned) FileLength);
1154 printf ("File Attributes: 0x%02X\n", FileHeader->Attributes);
1155 printf ("File State: 0x%02X\n", FileHeader->State);
1156
1157 //
1158 // Print file state
1159 //
1160 FileState = GetFileState (ErasePolarity, FileHeader);
1161
1162 switch (FileState) {
1163
1164 case EFI_FILE_HEADER_CONSTRUCTION:
1165 printf (" EFI_FILE_HEADER_CONSTRUCTION\n");
1166 return EFI_SUCCESS;
1167
1168 case EFI_FILE_HEADER_INVALID:
1169 printf (" EFI_FILE_HEADER_INVALID\n");
1170 return EFI_SUCCESS;
1171
1172 case EFI_FILE_HEADER_VALID:
1173 printf (" EFI_FILE_HEADER_VALID\n");
1174 Checksum = CalculateSum8 ((UINT8 *) FileHeader, HeaderSize);
1175 Checksum = (UINT8) (Checksum - FileHeader->IntegrityCheck.Checksum.File);
1176 Checksum = (UINT8) (Checksum - FileHeader->State);
1177 if (Checksum != 0) {
1178 printf ("ERROR: Header checksum invalid.\n");
1179 return EFI_ABORTED;
1180 }
1181
1182 return EFI_SUCCESS;
1183
1184 case EFI_FILE_DELETED:
1185 printf (" EFI_FILE_DELETED\n");
1186
1187 case EFI_FILE_MARKED_FOR_UPDATE:
1188 printf (" EFI_FILE_MARKED_FOR_UPDATE\n");
1189
1190 case EFI_FILE_DATA_VALID:
1191 printf (" EFI_FILE_DATA_VALID\n");
1192
1193 //
1194 // Calculate header checksum
1195 //
1196 Checksum = CalculateSum8 ((UINT8 *) FileHeader, HeaderSize);
1197 Checksum = (UINT8) (Checksum - FileHeader->IntegrityCheck.Checksum.File);
1198 Checksum = (UINT8) (Checksum - FileHeader->State);
1199 if (Checksum != 0) {
1200 Error (NULL, 0, 0003, "error parsing FFS file", "FFS file with Guid %s has invalid header checksum", GuidBuffer);
1201 return EFI_ABORTED;
1202 }
1203
1204 FileLength = FvBufGetFfsFileSize (FileHeader);
1205
1206 if (FileHeader->Attributes & FFS_ATTRIB_CHECKSUM) {
1207 //
1208 // Calculate file checksum
1209 //
1210 Checksum = CalculateSum8 ((UINT8 *)FileHeader + HeaderSize, FileLength - HeaderSize);
1211 Checksum = Checksum + FileHeader->IntegrityCheck.Checksum.File;
1212 if (Checksum != 0) {
1213 Error (NULL, 0, 0003, "error parsing FFS file", "FFS file with Guid %s has invalid file checksum", GuidBuffer);
1214 return EFI_ABORTED;
1215 }
1216 } else {
1217 if (FileHeader->IntegrityCheck.Checksum.File != FFS_FIXED_CHECKSUM) {
1218 Error (NULL, 0, 0003, "error parsing FFS file", "FFS file with Guid %s has invalid header checksum -- not set to fixed value of 0xAA", GuidBuffer);
1219 return EFI_ABORTED;
1220 }
1221 }
1222 #if (PI_SPECIFICATION_VERSION < 0x00010000)
1223 //
1224 // Verify tail if present
1225 //
1226 if (FileHeader->Attributes & FFS_ATTRIB_TAIL_PRESENT) {
1227 //
1228 // Verify tail is complement of integrity check field in the header.
1229 //
1230 Tail = (UINT16 *) ((UINTN) FileHeader + GetLength (FileHeader->Size) - sizeof (EFI_FFS_INTEGRITY_CHECK));
1231 if (FileHeader->IntegrityCheck.TailReference != (UINT16)~(*Tail)) {
1232 Error (NULL, 0, 0003, "error parsing FFS file", \
1233 "FFS file with Guid %s failed in the integrity check, tail is not the complement of the header field", GuidBuffer);
1234 return EFI_ABORTED;
1235 }
1236 }
1237 #endif
1238 break;
1239
1240 default:
1241 Error (NULL, 0, 0003, "error parsing FFS file", "FFS file with Guid %s has the invalid/unrecognized file state bits", GuidBuffer);
1242 return EFI_ABORTED;
1243 }
1244
1245 printf ("File Type: 0x%02X ", FileHeader->Type);
1246
1247 switch (FileHeader->Type) {
1248
1249 case EFI_FV_FILETYPE_RAW:
1250 printf ("EFI_FV_FILETYPE_RAW\n");
1251 break;
1252
1253 case EFI_FV_FILETYPE_FREEFORM:
1254 printf ("EFI_FV_FILETYPE_FREEFORM\n");
1255 break;
1256
1257 case EFI_FV_FILETYPE_SECURITY_CORE:
1258 printf ("EFI_FV_FILETYPE_SECURITY_CORE\n");
1259 break;
1260
1261 case EFI_FV_FILETYPE_PEI_CORE:
1262 printf ("EFI_FV_FILETYPE_PEI_CORE\n");
1263 break;
1264
1265 case EFI_FV_FILETYPE_DXE_CORE:
1266 printf ("EFI_FV_FILETYPE_DXE_CORE\n");
1267 break;
1268
1269 case EFI_FV_FILETYPE_PEIM:
1270 printf ("EFI_FV_FILETYPE_PEIM\n");
1271 break;
1272
1273 case EFI_FV_FILETYPE_DRIVER:
1274 printf ("EFI_FV_FILETYPE_DRIVER\n");
1275 break;
1276
1277 case EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER:
1278 printf ("EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER\n");
1279 break;
1280
1281 case EFI_FV_FILETYPE_APPLICATION:
1282 printf ("EFI_FV_FILETYPE_APPLICATION\n");
1283 break;
1284
1285 case EFI_FV_FILETYPE_SMM:
1286 printf ("EFI_FV_FILETYPE_SMM\n");
1287 break;
1288
1289 case EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE:
1290 printf ("EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE\n");
1291 break;
1292
1293 case EFI_FV_FILETYPE_COMBINED_SMM_DXE:
1294 printf ("EFI_FV_FILETYPE_COMBINED_SMM_DXE\n");
1295 break;
1296
1297 case EFI_FV_FILETYPE_SMM_CORE:
1298 printf ("EFI_FV_FILETYPE_SMM_CORE\n");
1299 break;
1300
1301 case EFI_FV_FILETYPE_MM_STANDALONE:
1302 printf ("EFI_FV_FILETYPE_MM_STANDALONE\n");
1303 break;
1304
1305 case EFI_FV_FILETYPE_MM_CORE_STANDALONE:
1306 printf ("EFI_FV_FILETYPE_MM_CORE_STANDALONE\n");
1307 break;
1308
1309 case EFI_FV_FILETYPE_FFS_PAD:
1310 printf ("EFI_FV_FILETYPE_FFS_PAD\n");
1311 break;
1312
1313 default:
1314 printf ("\nERROR: Unrecognized file type %X.\n", FileHeader->Type);
1315 return EFI_ABORTED;
1316 break;
1317 }
1318
1319 switch (FileHeader->Type) {
1320
1321 case EFI_FV_FILETYPE_ALL:
1322 case EFI_FV_FILETYPE_RAW:
1323 case EFI_FV_FILETYPE_FFS_PAD:
1324 break;
1325
1326 default:
1327 //
1328 // All other files have sections
1329 //
1330 Status = ParseSection (
1331 (UINT8 *) ((UINTN) FileHeader + HeaderSize),
1332 FvBufGetFfsFileSize (FileHeader) - HeaderSize
1333 );
1334 if (EFI_ERROR (Status)) {
1335 //
1336 // printf ("ERROR: Parsing the FFS file.\n");
1337 //
1338 return EFI_ABORTED;
1339 }
1340 break;
1341 }
1342
1343 return EFI_SUCCESS;
1344 }
1345
1346 EFI_STATUS
1347 RebaseImageRead (
1348 IN VOID *FileHandle,
1349 IN UINTN FileOffset,
1350 IN OUT UINT32 *ReadSize,
1351 OUT VOID *Buffer
1352 )
1353 /*++
1354
1355 Routine Description:
1356
1357 Support routine for the PE/COFF Loader that reads a buffer from a PE/COFF file
1358
1359 Arguments:
1360
1361 FileHandle - The handle to the PE/COFF file
1362
1363 FileOffset - The offset, in bytes, into the file to read
1364
1365 ReadSize - The number of bytes to read from the file starting at FileOffset
1366
1367 Buffer - A pointer to the buffer to read the data into.
1368
1369 Returns:
1370
1371 EFI_SUCCESS - ReadSize bytes of data were read into Buffer from the PE/COFF file starting at FileOffset
1372
1373 --*/
1374 {
1375 CHAR8 *Destination8;
1376 CHAR8 *Source8;
1377 UINT32 Length;
1378
1379 Destination8 = Buffer;
1380 Source8 = (CHAR8 *) ((UINTN) FileHandle + FileOffset);
1381 Length = *ReadSize;
1382 while (Length--) {
1383 *(Destination8++) = *(Source8++);
1384 }
1385
1386 return EFI_SUCCESS;
1387 }
1388
1389 EFI_STATUS
1390 SetAddressToSectionHeader (
1391 IN CHAR8 *FileName,
1392 IN OUT UINT8 *FileBuffer,
1393 IN UINT64 NewPe32BaseAddress
1394 )
1395 /*++
1396
1397 Routine Description:
1398
1399 Set new base address into the section header of PeImage
1400
1401 Arguments:
1402
1403 FileName - Name of file
1404 FileBuffer - Pointer to PeImage.
1405 NewPe32BaseAddress - New Base Address for PE image.
1406
1407 Returns:
1408
1409 EFI_SUCCESS Set new base address into this image successfully.
1410
1411 --*/
1412 {
1413 EFI_STATUS Status;
1414 PE_COFF_LOADER_IMAGE_CONTEXT ImageContext;
1415 UINTN Index;
1416 EFI_IMAGE_OPTIONAL_HEADER_UNION *ImgHdr;
1417 EFI_IMAGE_SECTION_HEADER *SectionHeader;
1418
1419 //
1420 // Initialize context
1421 //
1422 memset (&ImageContext, 0, sizeof (ImageContext));
1423 ImageContext.Handle = (VOID *) FileBuffer;
1424 ImageContext.ImageRead = (PE_COFF_LOADER_READ_FILE) RebaseImageRead;
1425 Status = PeCoffLoaderGetImageInfo (&ImageContext);
1426 if (EFI_ERROR (Status)) {
1427 Error (NULL, 0, 3000, "Invalid", "The input PeImage %s is not valid", FileName);
1428 return Status;
1429 }
1430
1431 if (ImageContext.RelocationsStripped) {
1432 Error (NULL, 0, 3000, "Invalid", "The input PeImage %s has no relocation to be fixed up", FileName);
1433 return Status;
1434 }
1435
1436 //
1437 // Get PeHeader pointer
1438 //
1439 ImgHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)(FileBuffer + ImageContext.PeCoffHeaderOffset);
1440
1441 //
1442 // Get section header list
1443 //
1444 SectionHeader = (EFI_IMAGE_SECTION_HEADER *) (
1445 (UINTN) ImgHdr +
1446 sizeof (UINT32) +
1447 sizeof (EFI_IMAGE_FILE_HEADER) +
1448 ImgHdr->Pe32.FileHeader.SizeOfOptionalHeader
1449 );
1450
1451 //
1452 // Set base address into the first section header that doesn't point to code section.
1453 //
1454 for (Index = 0; Index < ImgHdr->Pe32.FileHeader.NumberOfSections; Index ++, SectionHeader ++) {
1455 if ((SectionHeader->Characteristics & EFI_IMAGE_SCN_CNT_CODE) == 0) {
1456 *(UINT64 *) &SectionHeader->PointerToRelocations = NewPe32BaseAddress;
1457 break;
1458 }
1459 }
1460
1461 //
1462 // BaseAddress is set to section header.
1463 //
1464 return EFI_SUCCESS;
1465 }
1466
1467 EFI_STATUS
1468 RebaseImage (
1469 IN CHAR8 *FileName,
1470 IN OUT UINT8 *FileBuffer,
1471 IN UINT64 NewPe32BaseAddress
1472 )
1473 /*++
1474
1475 Routine Description:
1476
1477 Set new base address into PeImage, and fix up PeImage based on new address.
1478
1479 Arguments:
1480
1481 FileName - Name of file
1482 FileBuffer - Pointer to PeImage.
1483 NewPe32BaseAddress - New Base Address for PE image.
1484
1485 Returns:
1486
1487 EFI_INVALID_PARAMETER - BaseAddress is not valid.
1488 EFI_SUCCESS - Update PeImage is correctly.
1489
1490 --*/
1491 {
1492 EFI_STATUS Status;
1493 PE_COFF_LOADER_IMAGE_CONTEXT ImageContext;
1494 UINTN Index;
1495 EFI_IMAGE_OPTIONAL_HEADER_UNION *ImgHdr;
1496 UINT8 *MemoryImagePointer;
1497 EFI_IMAGE_SECTION_HEADER *SectionHeader;
1498
1499 //
1500 // Initialize context
1501 //
1502 memset (&ImageContext, 0, sizeof (ImageContext));
1503 ImageContext.Handle = (VOID *) FileBuffer;
1504 ImageContext.ImageRead = (PE_COFF_LOADER_READ_FILE) RebaseImageRead;
1505 Status = PeCoffLoaderGetImageInfo (&ImageContext);
1506 if (EFI_ERROR (Status)) {
1507 Error (NULL, 0, 3000, "Invalid", "The input PeImage %s is not valid", FileName);
1508 return Status;
1509 }
1510
1511 if (ImageContext.RelocationsStripped) {
1512 Error (NULL, 0, 3000, "Invalid", "The input PeImage %s has no relocation to be fixed up", FileName);
1513 return Status;
1514 }
1515
1516 //
1517 // Get PeHeader pointer
1518 //
1519 ImgHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)(FileBuffer + ImageContext.PeCoffHeaderOffset);
1520
1521 //
1522 // Load and Relocate Image Data
1523 //
1524 MemoryImagePointer = (UINT8 *) malloc ((UINTN) ImageContext.ImageSize + ImageContext.SectionAlignment);
1525 if (MemoryImagePointer == NULL) {
1526 Error (NULL, 0, 4001, "Resource", "memory cannot be allocated on rebase of %s", FileName);
1527 return EFI_OUT_OF_RESOURCES;
1528 }
1529 memset ((VOID *) MemoryImagePointer, 0, (UINTN) ImageContext.ImageSize + ImageContext.SectionAlignment);
1530 ImageContext.ImageAddress = ((UINTN) MemoryImagePointer + ImageContext.SectionAlignment - 1) & (~((INT64)ImageContext.SectionAlignment - 1));
1531
1532 Status = PeCoffLoaderLoadImage (&ImageContext);
1533 if (EFI_ERROR (Status)) {
1534 Error (NULL, 0, 3000, "Invalid", "LocateImage() call failed on rebase of %s", FileName);
1535 free ((VOID *) MemoryImagePointer);
1536 return Status;
1537 }
1538
1539 ImageContext.DestinationAddress = NewPe32BaseAddress;
1540 Status = PeCoffLoaderRelocateImage (&ImageContext);
1541 if (EFI_ERROR (Status)) {
1542 Error (NULL, 0, 3000, "Invalid", "RelocateImage() call failed on rebase of %s", FileName);
1543 free ((VOID *) MemoryImagePointer);
1544 return Status;
1545 }
1546
1547 //
1548 // Copy Relocated data to raw image file.
1549 //
1550 SectionHeader = (EFI_IMAGE_SECTION_HEADER *) (
1551 (UINTN) ImgHdr +
1552 sizeof (UINT32) +
1553 sizeof (EFI_IMAGE_FILE_HEADER) +
1554 ImgHdr->Pe32.FileHeader.SizeOfOptionalHeader
1555 );
1556
1557 for (Index = 0; Index < ImgHdr->Pe32.FileHeader.NumberOfSections; Index ++, SectionHeader ++) {
1558 CopyMem (
1559 FileBuffer + SectionHeader->PointerToRawData,
1560 (VOID*) (UINTN) (ImageContext.ImageAddress + SectionHeader->VirtualAddress),
1561 SectionHeader->SizeOfRawData
1562 );
1563 }
1564
1565 free ((VOID *) MemoryImagePointer);
1566
1567 //
1568 // Update Image Base Address
1569 //
1570 if (ImgHdr->Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
1571 ImgHdr->Pe32.OptionalHeader.ImageBase = (UINT32) NewPe32BaseAddress;
1572 } else if (ImgHdr->Pe32Plus.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC) {
1573 ImgHdr->Pe32Plus.OptionalHeader.ImageBase = NewPe32BaseAddress;
1574 } else {
1575 Error (NULL, 0, 3000, "Invalid", "unknown PE magic signature %X in PE32 image %s",
1576 ImgHdr->Pe32.OptionalHeader.Magic,
1577 FileName
1578 );
1579 return EFI_ABORTED;
1580 }
1581
1582 //
1583 // Set new base address into section header
1584 //
1585 Status = SetAddressToSectionHeader (FileName, FileBuffer, NewPe32BaseAddress);
1586
1587 return Status;
1588 }
1589
1590 EFI_STATUS
1591 CombinePath (
1592 IN CHAR8* DefaultPath,
1593 IN CHAR8* AppendPath,
1594 OUT CHAR8* NewPath
1595 )
1596 {
1597 UINT32 DefaultPathLen;
1598 UINT64 Index;
1599 CHAR8 QuotesStr[] = "\"";
1600 strcpy(NewPath, QuotesStr);
1601 DefaultPathLen = strlen(DefaultPath);
1602 strcat(NewPath, DefaultPath);
1603 Index = 0;
1604 for (; Index < DefaultPathLen + 1; Index ++) {
1605 if (NewPath[Index] == '\\' || NewPath[Index] == '/') {
1606 if (NewPath[Index + 1] != '\0') {
1607 NewPath[Index] = '/';
1608 }
1609 }
1610 }
1611 if (NewPath[Index -1] != '/') {
1612 NewPath[Index] = '/';
1613 NewPath[Index + 1] = '\0';
1614 }
1615 strcat(NewPath, AppendPath);
1616 strcat(NewPath, QuotesStr);
1617 return EFI_SUCCESS;
1618 }
1619
1620 EFI_STATUS
1621 ParseSection (
1622 IN UINT8 *SectionBuffer,
1623 IN UINT32 BufferLength
1624 )
1625 /*++
1626
1627 Routine Description:
1628
1629 Parses EFI Sections
1630
1631 Arguments:
1632
1633 SectionBuffer - Buffer containing the section to parse.
1634 BufferLength - Length of SectionBuffer
1635
1636 Returns:
1637
1638 EFI_SECTION_ERROR - Problem with section parsing.
1639 (a) compression errors
1640 (b) unrecognized section
1641 EFI_UNSUPPORTED - Do not know how to parse the section.
1642 EFI_SUCCESS - Section successfully parsed.
1643 EFI_OUT_OF_RESOURCES - Memory allocation failed.
1644
1645 --*/
1646 {
1647 EFI_SECTION_TYPE Type;
1648 UINT8 *Ptr;
1649 UINT32 SectionLength;
1650 UINT32 SectionHeaderLen;
1651 CHAR8 *SectionName;
1652 EFI_STATUS Status;
1653 UINT32 ParsedLength;
1654 UINT8 *CompressedBuffer;
1655 UINT32 CompressedLength;
1656 UINT8 *UncompressedBuffer;
1657 UINT32 UncompressedLength;
1658 UINT8 *ToolOutputBuffer;
1659 UINT32 ToolOutputLength;
1660 UINT8 CompressionType;
1661 UINT32 DstSize;
1662 UINT32 ScratchSize;
1663 UINT8 *ScratchBuffer;
1664 DECOMPRESS_FUNCTION DecompressFunction;
1665 GETINFO_FUNCTION GetInfoFunction;
1666 // CHAR16 *name;
1667 CHAR8 *ExtractionTool;
1668 CHAR8 *ToolInputFile;
1669 CHAR8 *ToolOutputFile;
1670 CHAR8 *SystemCommand;
1671 EFI_GUID *EfiGuid;
1672 UINT16 DataOffset;
1673 UINT16 Attributes;
1674 UINT32 RealHdrLen;
1675 CHAR8 *ToolInputFileName;
1676 CHAR8 *ToolOutputFileName;
1677 CHAR8 *UIFileName;
1678
1679 ParsedLength = 0;
1680 ToolInputFileName = NULL;
1681 ToolOutputFileName = NULL;
1682
1683 while (ParsedLength < BufferLength) {
1684 Ptr = SectionBuffer + ParsedLength;
1685
1686 SectionLength = GetLength (((EFI_COMMON_SECTION_HEADER *) Ptr)->Size);
1687 Type = ((EFI_COMMON_SECTION_HEADER *) Ptr)->Type;
1688
1689 //
1690 // This is sort of an odd check, but is necessary because FFS files are
1691 // padded to a QWORD boundary, meaning there is potentially a whole section
1692 // header worth of 0xFF bytes.
1693 //
1694 if (SectionLength == 0xffffff && Type == 0xff) {
1695 ParsedLength += 4;
1696 continue;
1697 }
1698
1699 //
1700 // Get real section file size
1701 //
1702 SectionLength = GetSectionFileLength ((EFI_COMMON_SECTION_HEADER *) Ptr);
1703 SectionHeaderLen = GetSectionHeaderLength((EFI_COMMON_SECTION_HEADER *)Ptr);
1704
1705 SectionName = SectionNameToStr (Type);
1706 if (SectionName != NULL) {
1707 printf ("------------------------------------------------------------\n");
1708 printf (" Type: %s\n Size: 0x%08X\n", SectionName, (unsigned) SectionLength);
1709 free (SectionName);
1710 }
1711
1712 switch (Type) {
1713 case EFI_SECTION_RAW:
1714 case EFI_SECTION_PIC:
1715 case EFI_SECTION_TE:
1716 // default is no more information
1717 break;
1718
1719 case EFI_SECTION_PE32:
1720 if (EnableHash) {
1721 ToolInputFileName = "edk2Temp_InputEfi.tmp";
1722 ToolOutputFileName = "edk2Temp_OutputHash.tmp";
1723 RebaseImage(ToolInputFileName, (UINT8*)Ptr + SectionHeaderLen, 0);
1724 PutFileImage (
1725 ToolInputFileName,
1726 (CHAR8*)Ptr + SectionHeaderLen,
1727 SectionLength - SectionHeaderLen
1728 );
1729
1730 SystemCommand = malloc (
1731 strlen (OPENSSL_COMMAND_FORMAT_STRING) +
1732 strlen (OpenSslPath) +
1733 strlen (ToolInputFileName) +
1734 strlen (ToolOutputFileName) +
1735 1
1736 );
1737 if (SystemCommand == NULL) {
1738 Error (NULL, 0, 4001, "Resource", "memory cannot be allocated!");
1739 return EFI_OUT_OF_RESOURCES;
1740 }
1741 sprintf (
1742 SystemCommand,
1743 OPENSSL_COMMAND_FORMAT_STRING,
1744 OpenSslPath,
1745 ToolOutputFileName,
1746 ToolInputFileName
1747 );
1748
1749 if (system (SystemCommand) != EFI_SUCCESS) {
1750 Error (NULL, 0, 3000, "Open SSL command not available. Please verify PATH or set OPENSSL_PATH.", NULL);
1751 }
1752 else {
1753 FILE *fp;
1754 CHAR8 *StrLine;
1755 CHAR8 *NewStr;
1756 UINT32 nFileLen;
1757 if((fp = fopen(ToolOutputFileName,"r")) == NULL) {
1758 Error (NULL, 0, 0004, "Hash the PE32 image failed.", NULL);
1759 }
1760 else {
1761 fseek(fp,0,SEEK_SET);
1762 fseek(fp,0,SEEK_END);
1763 nFileLen = ftell(fp);
1764 fseek(fp,0,SEEK_SET);
1765 StrLine = malloc(nFileLen);
1766 if (StrLine == NULL) {
1767 fclose(fp);
1768 free (SystemCommand);
1769 Error (NULL, 0, 4001, "Resource", "memory cannot be allocated!");
1770 return EFI_OUT_OF_RESOURCES;
1771 }
1772 fgets(StrLine, nFileLen, fp);
1773 NewStr = strrchr (StrLine, '=');
1774 printf (" SHA1: %s\n", NewStr + 1);
1775 free (StrLine);
1776 fclose(fp);
1777 }
1778 }
1779 remove(ToolInputFileName);
1780 remove(ToolOutputFileName);
1781 free (SystemCommand);
1782 }
1783 break;
1784
1785 case EFI_SECTION_USER_INTERFACE:
1786 UIFileName = (CHAR8 *) malloc (UnicodeStrLen (((EFI_USER_INTERFACE_SECTION *) Ptr)->FileNameString) + 1);
1787 if (UIFileName == NULL) {
1788 Error (NULL, 0, 4001, "Resource", "memory cannot be allocated!");
1789 return EFI_OUT_OF_RESOURCES;
1790 }
1791 Unicode2AsciiString (((EFI_USER_INTERFACE_SECTION *) Ptr)->FileNameString, UIFileName);
1792 printf (" String: %s\n", UIFileName);
1793 free (UIFileName);
1794 break;
1795
1796 case EFI_SECTION_FIRMWARE_VOLUME_IMAGE:
1797 Status = PrintFvInfo (Ptr + SectionHeaderLen, TRUE);
1798 if (EFI_ERROR (Status)) {
1799 Error (NULL, 0, 0003, "printing of FV section contents failed", NULL);
1800 return EFI_SECTION_ERROR;
1801 }
1802 break;
1803
1804 case EFI_SECTION_COMPATIBILITY16:
1805 case EFI_SECTION_FREEFORM_SUBTYPE_GUID:
1806 //
1807 // Section does not contain any further header information.
1808 //
1809 break;
1810
1811 case EFI_SECTION_PEI_DEPEX:
1812 case EFI_SECTION_DXE_DEPEX:
1813 case EFI_SECTION_SMM_DEPEX:
1814 DumpDepexSection (Ptr, SectionLength);
1815 break;
1816
1817 case EFI_SECTION_VERSION:
1818 printf (" Build Number: 0x%02X\n", *(UINT16 *)(Ptr + SectionHeaderLen));
1819 printf (" Version Strg: %s\n", (char*) (Ptr + SectionHeaderLen + sizeof (UINT16)));
1820 break;
1821
1822 case EFI_SECTION_COMPRESSION:
1823 UncompressedBuffer = NULL;
1824 if (SectionHeaderLen == sizeof (EFI_COMMON_SECTION_HEADER)) {
1825 RealHdrLen = sizeof(EFI_COMPRESSION_SECTION);
1826 UncompressedLength = ((EFI_COMPRESSION_SECTION *)Ptr)->UncompressedLength;
1827 CompressionType = ((EFI_COMPRESSION_SECTION *)Ptr)->CompressionType;
1828 } else {
1829 RealHdrLen = sizeof(EFI_COMPRESSION_SECTION2);
1830 UncompressedLength = ((EFI_COMPRESSION_SECTION2 *)Ptr)->UncompressedLength;
1831 CompressionType = ((EFI_COMPRESSION_SECTION2 *)Ptr)->CompressionType;
1832 }
1833 CompressedLength = SectionLength - RealHdrLen;
1834 printf (" Uncompressed Length: 0x%08X\n", (unsigned) UncompressedLength);
1835
1836 if (CompressionType == EFI_NOT_COMPRESSED) {
1837 printf (" Compression Type: EFI_NOT_COMPRESSED\n");
1838 if (CompressedLength != UncompressedLength) {
1839 Error (
1840 NULL,
1841 0,
1842 0,
1843 "file is not compressed, but the compressed length does not match the uncompressed length",
1844 NULL
1845 );
1846 return EFI_SECTION_ERROR;
1847 }
1848
1849 UncompressedBuffer = Ptr + RealHdrLen;
1850 } else if (CompressionType == EFI_STANDARD_COMPRESSION) {
1851 GetInfoFunction = EfiGetInfo;
1852 DecompressFunction = EfiDecompress;
1853 printf (" Compression Type: EFI_STANDARD_COMPRESSION\n");
1854
1855 CompressedBuffer = Ptr + RealHdrLen;
1856
1857 Status = GetInfoFunction (CompressedBuffer, CompressedLength, &DstSize, &ScratchSize);
1858 if (EFI_ERROR (Status)) {
1859 Error (NULL, 0, 0003, "error getting compression info from compression section", NULL);
1860 return EFI_SECTION_ERROR;
1861 }
1862
1863 if (DstSize != UncompressedLength) {
1864 Error (NULL, 0, 0003, "compression error in the compression section", NULL);
1865 return EFI_SECTION_ERROR;
1866 }
1867
1868 ScratchBuffer = malloc (ScratchSize);
1869 if (ScratchBuffer == NULL) {
1870 Error (NULL, 0, 4001, "Resource", "memory cannot be allocated!");
1871 return EFI_OUT_OF_RESOURCES;
1872 }
1873 UncompressedBuffer = malloc (UncompressedLength);
1874 if (UncompressedBuffer == NULL) {
1875 free (ScratchBuffer);
1876 Error (NULL, 0, 4001, "Resource", "memory cannot be allocated!");
1877 return EFI_OUT_OF_RESOURCES;
1878 }
1879 Status = DecompressFunction (
1880 CompressedBuffer,
1881 CompressedLength,
1882 UncompressedBuffer,
1883 UncompressedLength,
1884 ScratchBuffer,
1885 ScratchSize
1886 );
1887 free (ScratchBuffer);
1888 if (EFI_ERROR (Status)) {
1889 Error (NULL, 0, 0003, "decompress failed", NULL);
1890 free (UncompressedBuffer);
1891 return EFI_SECTION_ERROR;
1892 }
1893 } else {
1894 Error (NULL, 0, 0003, "unrecognized compression type", "type 0x%X", CompressionType);
1895 return EFI_SECTION_ERROR;
1896 }
1897
1898 Status = ParseSection (UncompressedBuffer, UncompressedLength);
1899
1900 if (CompressionType == EFI_STANDARD_COMPRESSION) {
1901 //
1902 // We need to deallocate Buffer
1903 //
1904 free (UncompressedBuffer);
1905 }
1906
1907 if (EFI_ERROR (Status)) {
1908 Error (NULL, 0, 0003, "failed to parse section", NULL);
1909 return EFI_SECTION_ERROR;
1910 }
1911 break;
1912
1913 case EFI_SECTION_GUID_DEFINED:
1914 if (SectionHeaderLen == sizeof(EFI_COMMON_SECTION_HEADER)) {
1915 EfiGuid = &((EFI_GUID_DEFINED_SECTION *) Ptr)->SectionDefinitionGuid;
1916 DataOffset = ((EFI_GUID_DEFINED_SECTION *) Ptr)->DataOffset;
1917 Attributes = ((EFI_GUID_DEFINED_SECTION *) Ptr)->Attributes;
1918 } else {
1919 EfiGuid = &((EFI_GUID_DEFINED_SECTION2 *) Ptr)->SectionDefinitionGuid;
1920 DataOffset = ((EFI_GUID_DEFINED_SECTION2 *) Ptr)->DataOffset;
1921 Attributes = ((EFI_GUID_DEFINED_SECTION2 *) Ptr)->Attributes;
1922 }
1923 printf (" SectionDefinitionGuid: ");
1924 PrintGuid (EfiGuid);
1925 printf ("\n");
1926 printf (" DataOffset: 0x%04X\n", (unsigned) DataOffset);
1927 printf (" Attributes: 0x%04X\n", (unsigned) Attributes);
1928
1929 ExtractionTool =
1930 LookupGuidedSectionToolPath (
1931 mParsedGuidedSectionTools,
1932 EfiGuid
1933 );
1934
1935 if (ExtractionTool != NULL) {
1936 #ifndef __GNUC__
1937 ToolInputFile = CloneString (tmpnam (NULL));
1938 ToolOutputFile = CloneString (tmpnam (NULL));
1939 #else
1940 char tmp1[] = "/tmp/fileXXXXXX";
1941 char tmp2[] = "/tmp/fileXXXXXX";
1942 int fd1;
1943 int fd2;
1944 fd1 = mkstemp(tmp1);
1945 fd2 = mkstemp(tmp2);
1946 ToolInputFile = CloneString(tmp1);
1947 ToolOutputFile = CloneString(tmp2);
1948 close(fd1);
1949 close(fd2);
1950 #endif
1951
1952 if ((ToolInputFile == NULL) || (ToolOutputFile == NULL)) {
1953 if (ToolInputFile != NULL) {
1954 free (ToolInputFile);
1955 }
1956 if (ToolOutputFile != NULL) {
1957 free (ToolOutputFile);
1958 }
1959 free (ExtractionTool);
1960
1961 Error (NULL, 0, 4001, "Resource", "memory cannot be allocated!");
1962 return EFI_OUT_OF_RESOURCES;
1963 }
1964
1965 //
1966 // Construction 'system' command string
1967 //
1968 SystemCommand = malloc (
1969 strlen (EXTRACT_COMMAND_FORMAT_STRING) +
1970 strlen (ExtractionTool) +
1971 strlen (ToolInputFile) +
1972 strlen (ToolOutputFile) +
1973 1
1974 );
1975 if (SystemCommand == NULL) {
1976 free (ToolInputFile);
1977 free (ToolOutputFile);
1978 free (ExtractionTool);
1979
1980 Error (NULL, 0, 4001, "Resource", "memory cannot be allocated!");
1981 return EFI_OUT_OF_RESOURCES;
1982 }
1983 sprintf (
1984 SystemCommand,
1985 EXTRACT_COMMAND_FORMAT_STRING,
1986 ExtractionTool,
1987 ToolOutputFile,
1988 ToolInputFile
1989 );
1990 free (ExtractionTool);
1991
1992 Status =
1993 PutFileImage (
1994 ToolInputFile,
1995 (CHAR8*) SectionBuffer + DataOffset,
1996 BufferLength - DataOffset
1997 );
1998
1999 system (SystemCommand);
2000 remove (ToolInputFile);
2001 free (ToolInputFile);
2002
2003 Status =
2004 GetFileImage (
2005 ToolOutputFile,
2006 (CHAR8 **)&ToolOutputBuffer,
2007 &ToolOutputLength
2008 );
2009 remove (ToolOutputFile);
2010 free (ToolOutputFile);
2011 free (SystemCommand);
2012 if (EFI_ERROR (Status)) {
2013 Error (NULL, 0, 0004, "unable to read decoded GUIDED section", NULL);
2014 return EFI_SECTION_ERROR;
2015 }
2016
2017 Status = ParseSection (
2018 ToolOutputBuffer,
2019 ToolOutputLength
2020 );
2021 if (EFI_ERROR (Status)) {
2022 Error (NULL, 0, 0003, "parse of decoded GUIDED section failed", NULL);
2023 return EFI_SECTION_ERROR;
2024 }
2025
2026 //
2027 // Check for CRC32 sections which we can handle internally if needed.
2028 //
2029 } else if (!CompareGuid (
2030 EfiGuid,
2031 &gEfiCrc32GuidedSectionExtractionProtocolGuid
2032 )
2033 ) {
2034 //
2035 // CRC32 guided section
2036 //
2037 Status = ParseSection (
2038 SectionBuffer + DataOffset,
2039 BufferLength - DataOffset
2040 );
2041 if (EFI_ERROR (Status)) {
2042 Error (NULL, 0, 0003, "parse of CRC32 GUIDED section failed", NULL);
2043 return EFI_SECTION_ERROR;
2044 }
2045 } else {
2046 //
2047 // We don't know how to parse it now.
2048 //
2049 Error (NULL, 0, 0003, "Error parsing section", \
2050 "EFI_SECTION_GUID_DEFINED cannot be parsed at this time. Tool to decode this section should have been defined in GuidedSectionTools.txt (built in the FV directory).");
2051 return EFI_UNSUPPORTED;
2052 }
2053 break;
2054
2055 default:
2056 //
2057 // Unknown section, return error
2058 //
2059 Error (NULL, 0, 0003, "unrecognized section type found", "section type = 0x%X", Type);
2060 return EFI_SECTION_ERROR;
2061 }
2062
2063 ParsedLength += SectionLength;
2064 //
2065 // We make then next section begin on a 4-byte boundary
2066 //
2067 ParsedLength = GetOccupiedSize (ParsedLength, 4);
2068 }
2069
2070 if (ParsedLength < BufferLength) {
2071 Error (NULL, 0, 0003, "sections do not completely fill the sectioned buffer being parsed", NULL);
2072 return EFI_SECTION_ERROR;
2073 }
2074
2075 return EFI_SUCCESS;
2076 }
2077
2078 EFI_STATUS
2079 DumpDepexSection (
2080 IN UINT8 *Ptr,
2081 IN UINT32 SectionLength
2082 )
2083 /*++
2084
2085 Routine Description:
2086
2087 GC_TODO: Add function description
2088
2089 Arguments:
2090
2091 Ptr - GC_TODO: add argument description
2092 SectionLength - GC_TODO: add argument description
2093
2094 Returns:
2095
2096 EFI_SUCCESS - GC_TODO: Add description for return value
2097
2098 --*/
2099 {
2100 UINT8 GuidBuffer[PRINTED_GUID_BUFFER_SIZE];
2101
2102 //
2103 // Need at least a section header + data
2104 //
2105 if (SectionLength <= sizeof (EFI_COMMON_SECTION_HEADER)) {
2106 return EFI_SUCCESS;
2107 }
2108
2109 Ptr += GetSectionHeaderLength((EFI_COMMON_SECTION_HEADER *)Ptr);
2110 SectionLength -= GetSectionHeaderLength((EFI_COMMON_SECTION_HEADER *)Ptr);
2111 while (SectionLength > 0) {
2112 printf (" ");
2113 switch (*Ptr) {
2114 case EFI_DEP_BEFORE:
2115 printf ("BEFORE\n");
2116 Ptr++;
2117 SectionLength--;
2118 break;
2119
2120 case EFI_DEP_AFTER:
2121 printf ("AFTER\n");
2122 Ptr++;
2123 SectionLength--;
2124 break;
2125
2126 case EFI_DEP_PUSH:
2127 printf ("PUSH\n ");
2128 PrintGuidToBuffer ((EFI_GUID *) (Ptr + 1), GuidBuffer, sizeof (GuidBuffer), TRUE);
2129 printf ("%s ", GuidBuffer);
2130 PrintGuidName (GuidBuffer);
2131 printf ("\n");
2132 //
2133 // PrintGuid ((EFI_GUID *)(Ptr + 1));
2134 //
2135 Ptr += 17;
2136 SectionLength -= 17;
2137 break;
2138
2139 case EFI_DEP_AND:
2140 printf ("AND\n");
2141 Ptr++;
2142 SectionLength--;
2143 break;
2144
2145 case EFI_DEP_OR:
2146 printf ("OR\n");
2147 Ptr++;
2148 SectionLength--;
2149 break;
2150
2151 case EFI_DEP_NOT:
2152 printf ("NOT\n");
2153 Ptr++;
2154 SectionLength--;
2155 break;
2156
2157 case EFI_DEP_TRUE:
2158 printf ("TRUE\n");
2159 Ptr++;
2160 SectionLength--;
2161 break;
2162
2163 case EFI_DEP_FALSE:
2164 printf ("FALSE\n");
2165 Ptr++;
2166 SectionLength--;
2167 break;
2168
2169 case EFI_DEP_END:
2170 printf ("END DEPEX\n");
2171 Ptr++;
2172 SectionLength--;
2173 break;
2174
2175 case EFI_DEP_SOR:
2176 printf ("SOR\n");
2177 Ptr++;
2178 SectionLength--;
2179 break;
2180
2181 default:
2182 printf ("Unrecognized byte in depex: 0x%X\n", *Ptr);
2183 return EFI_SUCCESS;
2184 }
2185 }
2186
2187 return EFI_SUCCESS;
2188 }
2189
2190 EFI_STATUS
2191 PrintGuidName (
2192 IN UINT8 *GuidStr
2193 )
2194 /*++
2195
2196 Routine Description:
2197
2198 GC_TODO: Add function description
2199
2200 Arguments:
2201
2202 GuidStr - GC_TODO: add argument description
2203
2204 Returns:
2205
2206 EFI_SUCCESS - GC_TODO: Add description for return value
2207 EFI_INVALID_PARAMETER - GC_TODO: Add description for return value
2208
2209 --*/
2210 {
2211 GUID_TO_BASENAME *GPtr;
2212 //
2213 // If we have a list of guid-to-basenames, then go through the list to
2214 // look for a guid string match. If found, print the basename to stdout,
2215 // otherwise return a failure.
2216 //
2217 GPtr = mGuidBaseNameList;
2218 while (GPtr != NULL) {
2219 if (_stricmp ((CHAR8*) GuidStr, (CHAR8*) GPtr->Guid) == 0) {
2220 printf ("%s", GPtr->BaseName);
2221 return EFI_SUCCESS;
2222 }
2223
2224 GPtr = GPtr->Next;
2225 }
2226
2227 return EFI_INVALID_PARAMETER;
2228 }
2229
2230 EFI_STATUS
2231 ParseGuidBaseNameFile (
2232 CHAR8 *FileName
2233 )
2234 /*++
2235
2236 Routine Description:
2237
2238 GC_TODO: Add function description
2239
2240 Arguments:
2241
2242 FileName - GC_TODO: add argument description
2243
2244 Returns:
2245
2246 EFI_DEVICE_ERROR - GC_TODO: Add description for return value
2247 EFI_OUT_OF_RESOURCES - GC_TODO: Add description for return value
2248 EFI_SUCCESS - GC_TODO: Add description for return value
2249
2250 --*/
2251 {
2252 FILE *Fptr;
2253 CHAR8 Line[MAX_LINE_LEN];
2254 CHAR8 FormatString[MAX_LINE_LEN];
2255 GUID_TO_BASENAME *GPtr;
2256
2257 if ((Fptr = fopen (LongFilePath (FileName), "r")) == NULL) {
2258 printf ("ERROR: Failed to open input cross-reference file '%s'\n", FileName);
2259 return EFI_DEVICE_ERROR;
2260 }
2261
2262 //
2263 // Generate the format string for fscanf
2264 //
2265 sprintf (
2266 FormatString,
2267 "%%%us %%%us",
2268 (unsigned) sizeof (GPtr->Guid) - 1,
2269 (unsigned) sizeof (GPtr->BaseName) - 1
2270 );
2271
2272 while (fgets (Line, sizeof (Line), Fptr) != NULL) {
2273 //
2274 // Allocate space for another guid/basename element
2275 //
2276 GPtr = malloc (sizeof (GUID_TO_BASENAME));
2277 if (GPtr == NULL) {
2278 fclose (Fptr);
2279 return EFI_OUT_OF_RESOURCES;
2280 }
2281
2282 memset ((char *) GPtr, 0, sizeof (GUID_TO_BASENAME));
2283 if (sscanf (Line, FormatString, GPtr->Guid, GPtr->BaseName) == 2) {
2284 GPtr->Next = mGuidBaseNameList;
2285 mGuidBaseNameList = GPtr;
2286 } else {
2287 //
2288 // Some sort of error. Just continue.
2289 //
2290 free (GPtr);
2291 }
2292 }
2293
2294 fclose (Fptr);
2295 return EFI_SUCCESS;
2296 }
2297
2298 EFI_STATUS
2299 FreeGuidBaseNameList (
2300 VOID
2301 )
2302 /*++
2303
2304 Routine Description:
2305
2306 GC_TODO: Add function description
2307
2308 Arguments:
2309
2310 None
2311
2312 Returns:
2313
2314 EFI_SUCCESS - GC_TODO: Add description for return value
2315
2316 --*/
2317 {
2318 GUID_TO_BASENAME *Next;
2319
2320 while (mGuidBaseNameList != NULL) {
2321 Next = mGuidBaseNameList->Next;
2322 free (mGuidBaseNameList);
2323 mGuidBaseNameList = Next;
2324 }
2325
2326 return EFI_SUCCESS;
2327 }
2328
2329
2330 static
2331 VOID
2332 LoadGuidedSectionToolsTxt (
2333 IN CHAR8* FirmwareVolumeFilename
2334 )
2335 {
2336 CHAR8* PeerFilename;
2337 CHAR8* Places[] = {
2338 NULL,
2339 //NULL,
2340 };
2341 UINTN Index;
2342
2343 Places[0] = FirmwareVolumeFilename;
2344 //Places[1] = mUtilityFilename;
2345
2346 mParsedGuidedSectionTools = NULL;
2347
2348 for (Index = 0; Index < (sizeof(Places)/sizeof(Places[0])); Index++) {
2349 PeerFilename = OsPathPeerFilePath (Places[Index], "GuidedSectionTools.txt");
2350 //printf("Loading %s...\n", PeerFilename);
2351 if (OsPathExists (PeerFilename)) {
2352 mParsedGuidedSectionTools = ParseGuidedSectionToolsFile (PeerFilename);
2353 }
2354 free (PeerFilename);
2355 if (mParsedGuidedSectionTools != NULL) {
2356 return;
2357 }
2358 }
2359 }
2360
2361
2362 void
2363 Usage (
2364 VOID
2365 )
2366 /*++
2367
2368 Routine Description:
2369
2370 GC_TODO: Add function description
2371
2372 Arguments:
2373
2374 None
2375
2376 Returns:
2377
2378 GC_TODO: add return values
2379
2380 --*/
2381 {
2382 //
2383 // Summary usage
2384 //
2385 fprintf (stdout, "Usage: %s [options] <input_file>\n\n", UTILITY_NAME);
2386
2387 //
2388 // Copyright declaration
2389 //
2390 fprintf (stdout, "Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.\n\n");
2391 fprintf (stdout, " Display Tiano Firmware Volume FFS image information\n\n");
2392
2393 //
2394 // Details Option
2395 //
2396 fprintf (stdout, "optional arguments:\n");
2397 fprintf (stdout, " -h, --help\n\
2398 Show this help message and exit\n");
2399 fprintf (stdout, " --version\n\
2400 Show program's version number and exit\n");
2401 fprintf (stdout, " -d [DEBUG], --debug [DEBUG]\n\
2402 Output DEBUG statements, where DEBUG_LEVEL is 0 (min) - 9 (max)\n");
2403 fprintf (stdout, " -v, --verbose\n\
2404 Print informational statements\n");
2405 fprintf (stdout, " -q, --quiet\n\
2406 Returns the exit code, error messages will be displayed\n");
2407 fprintf (stdout, " -s, --silent\n\
2408 Returns only the exit code; informational and error\n\
2409 messages are not displayed\n");
2410 fprintf (stdout, " -x XREF_FILENAME, --xref XREF_FILENAME\n\
2411 Parse the basename to file-guid cross reference file(s)\n");
2412 fprintf (stdout, " -f OFFSET, --offset OFFSET\n\
2413 The offset from the start of the input file to start \n\
2414 processing an FV\n");
2415 fprintf (stdout, " --hash\n\
2416 Generate HASH value of the entire PE image\n");
2417 fprintf (stdout, " --sfo\n\
2418 Reserved for future use\n");
2419 }
2420
EFI Development Kit II mirror for PVE