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