BaseTools/Source/C/VolInfo/VolInfo.c

   1 /** @file
   2
   3 Copyright (c) 1999 - 2014, Intel Corporation. All rights reserved.<BR>
   4 This program and the accompanying materials
   5 are licensed and made available under the terms and conditions of the BSD License
   6 which accompanies this distribution.  The full text of the license may be found at
   7 http://opensource.org/licenses/bsd-license.php
   8
   9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  11
  12 Module Name:
  13
  14   VolInfo.c
  15
  16 Abstract:
  17
  18   The tool dumps the contents of a firmware volume
  19
  20 **/
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <ctype.h>
  26 #include <assert.h>
  27
  28 #include <FvLib.h>
  29 #include <Common/UefiBaseTypes.h>
  30 #include <Common/UefiCapsule.h>
  31 #include <Common/PiFirmwareFile.h>
  32 #include <Common/PiFirmwareVolume.h>
  33 #include <Guid/PiFirmwareFileSystem.h>
  34 #include <IndustryStandard/PeImage.h>
  35 #include <Protocol/GuidedSectionExtraction.h>
  36
  37 #include "Compress.h"
  38 #include "Decompress.h"
  39 #include "VolInfo.h"
  40 #include "CommonLib.h"
  41 #include "EfiUtilityMsgs.h"
  42 #include "FirmwareVolumeBufferLib.h"
  43 #include "OsPath.h"
  44 #include "ParseGuidedSectionTools.h"
  45 #include "StringFuncs.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      0
  54 #define UTILITY_MINOR_VERSION      83
  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 EFI_STATUS
  81 ParseGuidBaseNameFile (
  82   CHAR8    *FileName
  83   );
  84
  85 EFI_STATUS
  86 FreeGuidBaseNameList (
  87   VOID
  88   );
  89
  90 EFI_STATUS
  91 PrintGuidName (
  92   IN UINT8    *GuidStr
  93   );
  94
  95 EFI_STATUS
  96 ParseSection (
  97   IN UINT8  *SectionBuffer,
  98   IN UINT32 BufferLength
  99   );
 100
 101 EFI_STATUS
 102 DumpDepexSection (
 103   IN UINT8    *Ptr,
 104   IN UINT32   SectionLength
 105   );
 106
 107 STATIC
 108 EFI_STATUS
 109 ReadHeader (
 110   IN FILE       *InputFile,
 111   OUT UINT32    *FvSize,
 112   OUT BOOLEAN   *ErasePolarity
 113   );
 114
 115 STATIC
 116 EFI_STATUS
 117 PrintFileInfo (
 118   EFI_FIRMWARE_VOLUME_HEADER  *FvImage,
 119   EFI_FFS_FILE_HEADER         *FileHeader,
 120   BOOLEAN                     ErasePolarity
 121   );
 122
 123 static
 124 EFI_STATUS
 125 PrintFvInfo (
 126   IN VOID                         *Fv,
 127   IN BOOLEAN                      IsChildFv
 128   );
 129
 130 static
 131 VOID
 132 LoadGuidedSectionToolsTxt (
 133   IN CHAR8* FirmwareVolumeFilename
 134   );
 135
 136 void
 137 Usage (
 138   VOID
 139   );
 140
 141 int
 142 main (
 143   int       argc,
 144   char      *argv[]
 145   )
 146 /*++
 147
 148 Routine Description:
 149
 150   GC_TODO: Add function description
 151
 152 Arguments:
 153
 154   argc  - GC_TODO: add argument description
 155   ]     - GC_TODO: add argument description
 156
 157 Returns:
 158
 159   GC_TODO: add return values
 160
 161 --*/
 162 {
 163   FILE                        *InputFile;
 164   int                         BytesRead;
 165   EFI_FIRMWARE_VOLUME_HEADER  *FvImage;
 166   UINT32                      FvSize;
 167   EFI_STATUS                  Status;
 168   int                         Offset;
 169   BOOLEAN                     ErasePolarity;
 170
 171   SetUtilityName (UTILITY_NAME);
 172   //
 173   // Print utility header
 174   //
 175   printf ("%s Version %d.%d %s, %s\n",
 176     UTILITY_NAME,
 177     UTILITY_MAJOR_VERSION,
 178     UTILITY_MINOR_VERSION,
 179     __BUILD_VERSION,
 180     __DATE__
 181     );
 182
 183   //
 184   // Save, and then skip filename arg
 185   //
 186   mUtilityFilename = argv[0];
 187   argc--;
 188   argv++;
 189
 190   Offset = 0;
 191
 192   //
 193   // If they specified -x xref guid/basename cross-reference files, process it.
 194   // This will print the basename beside each file guid. To use it, specify
 195   // -x xref_filename to processdsc, then use xref_filename as a parameter
 196   // here.
 197   //
 198   while (argc > 2) {
 199     if ((strcmp(argv[0], "-x") == 0) || (strcmp(argv[0], "--xref") == 0)) {
 200       ParseGuidBaseNameFile (argv[1]);
 201       printf("ParseGuidBaseNameFile: %s\n", argv[1]);
 202       argc -= 2;
 203       argv += 2;
 204     } else if (strcmp(argv[0], "--offset") == 0) {
 205       //
 206       // Hex or decimal?
 207       //
 208       if ((argv[1][0] == '0') && (tolower ((int)argv[1][1]) == 'x')) {
 209         if (sscanf (argv[1], "%x", &Offset) != 1) {
 210           Error (NULL, 0, 1003, "Invalid option value", "Offset = %s", argv[1]);
 211           return GetUtilityStatus ();
 212         }
 213       } else {
 214         if (sscanf (argv[1], "%d", &Offset) != 1) {
 215           Error (NULL, 0, 1003, "Invalid option value", "Offset = %s", argv[1]);
 216           return GetUtilityStatus ();
 217         }
 218         //
 219         // See if they said something like "64K"
 220         //
 221         if (tolower ((int)argv[1][strlen (argv[1]) - 1]) == 'k') {
 222           Offset *= 1024;
 223         }
 224       }
 225
 226       argc -= 2;
 227       argv += 2;
 228     } else {
 229       Usage ();
 230       return -1;
 231     }
 232   }
 233   //
 234   // Check for proper number of arguments
 235   //
 236   if (argc != 1) {
 237     Usage ();
 238     return -1;
 239   }
 240   //
 241   // Look for help options
 242   //
 243   if ((strcmp(argv[0], "-h") == 0) || (strcmp(argv[0], "--help") == 0) ||
 244       (strcmp(argv[0], "-?") == 0) || (strcmp(argv[0], "/?") == 0)) {
 245     Usage();
 246     return STATUS_ERROR;
 247   }
 248
 249   //
 250   // Open the file containing the FV
 251   //
 252   InputFile = fopen (LongFilePath (argv[0]), "rb");
 253   if (InputFile == NULL) {
 254     Error (NULL, 0, 0001, "Error opening the input file", argv[0]);
 255     return GetUtilityStatus ();
 256   }
 257   //
 258   // Skip over pad bytes if specified. This is used if they prepend 0xff
 259   // data to the FV image binary.
 260   //
 261   if (Offset != 0) {
 262     fseek (InputFile, Offset, SEEK_SET);
 263   }
 264   //
 265   // Determine size of FV
 266   //
 267   Status = ReadHeader (InputFile, &FvSize, &ErasePolarity);
 268   if (EFI_ERROR (Status)) {
 269     Error (NULL, 0, 0003, "error parsing FV image", "%s Header is invalid", argv[0]);
 270     fclose (InputFile);
 271     return GetUtilityStatus ();
 272   }
 273   //
 274   // Allocate a buffer for the FV image
 275   //
 276   FvImage = malloc (FvSize);
 277   if (FvImage == NULL) {
 278     Error (NULL, 0, 4001, "Resource: Memory can't be allocated", NULL);
 279     fclose (InputFile);
 280     return GetUtilityStatus ();
 281   }
 282   //
 283   // Seek to the start of the image, then read the entire FV to the buffer
 284   //
 285   fseek (InputFile, Offset, SEEK_SET);
 286   BytesRead = fread (FvImage, 1, FvSize, InputFile);
 287   fclose (InputFile);
 288   if ((unsigned int) BytesRead != FvSize) {
 289     Error (NULL, 0, 0004, "error reading FvImage from", argv[0]);
 290     free (FvImage);
 291     return GetUtilityStatus ();
 292   }
 293
 294   LoadGuidedSectionToolsTxt (argv[0]);
 295
 296   PrintFvInfo (FvImage, FALSE);
 297
 298   //
 299   // Clean up
 300   //
 301   free (FvImage);
 302   FreeGuidBaseNameList ();
 303   return GetUtilityStatus ();
 304 }
 305
 306
 307 static
 308 EFI_STATUS
 309 PrintFvInfo (
 310   IN VOID                         *Fv,
 311   IN BOOLEAN                      IsChildFv
 312   )
 313 /*++
 314
 315 Routine Description:
 316
 317   GC_TODO: Add function description
 318
 319 Arguments:
 320
 321   Fv            - Firmware Volume to print information about
 322   IsChildFv     - Flag specifies whether the input FV is a child FV.
 323
 324 Returns:
 325
 326   EFI_STATUS
 327
 328 --*/
 329 {
 330   EFI_STATUS                  Status;
 331   UINTN                       NumberOfFiles;
 332   BOOLEAN                     ErasePolarity;
 333   UINTN                       FvSize;
 334   EFI_FFS_FILE_HEADER         *CurrentFile;
 335   UINTN                       Key;
 336
 337   Status = FvBufGetSize (Fv, &FvSize);
 338
 339   NumberOfFiles = 0;
 340   ErasePolarity =
 341     (((EFI_FIRMWARE_VOLUME_HEADER*)Fv)->Attributes & EFI_FVB2_ERASE_POLARITY) ?
 342       TRUE : FALSE;
 343
 344   //
 345   // Get the first file
 346   //
 347   Key = 0;
 348   Status = FvBufFindNextFile (Fv, &Key, (VOID **) &CurrentFile);
 349   if (EFI_ERROR (Status)) {
 350     Error (NULL, 0, 0003, "error parsing FV image", "cannot find the first file in the FV image");
 351     return GetUtilityStatus ();
 352   }
 353   //
 354   // Display information about files found
 355   //
 356   while (CurrentFile != NULL) {
 357     //
 358     // Increment the number of files counter
 359     //
 360     NumberOfFiles++;
 361
 362     //
 363     // Display info about this file
 364     //
 365     Status = PrintFileInfo (Fv, CurrentFile, ErasePolarity);
 366     if (EFI_ERROR (Status)) {
 367       Error (NULL, 0, 0003, "error parsing FV image", "failed to parse a file in the FV");
 368       return GetUtilityStatus ();
 369     }
 370     //
 371     // Get the next file
 372     //
 373     Status = FvBufFindNextFile (Fv, &Key, (VOID **) &CurrentFile);
 374     if (Status == EFI_NOT_FOUND) {
 375       CurrentFile = NULL;
 376     } else if (EFI_ERROR (Status)) {
 377       Error (NULL, 0, 0003, "error parsing FV image", "cannot find the next file in the FV image");
 378       return GetUtilityStatus ();
 379     }
 380   }
 381
 382   if (IsChildFv) {
 383     printf ("There are a total of %d files in the child FV\n", (int) NumberOfFiles);
 384   } else {
 385     printf ("There are a total of %d files in this FV\n", (int) NumberOfFiles);
 386   }
 387
 388   return EFI_SUCCESS;
 389 }
 390
 391 UINT32
 392 GetOccupiedSize (
 393   IN UINT32  ActualSize,
 394   IN UINT32  Alignment
 395   )
 396 /*++
 397
 398 Routine Description:
 399
 400   This function returns the next larger size that meets the alignment
 401   requirement specified.
 402
 403 Arguments:
 404
 405   ActualSize      The size.
 406   Alignment       The desired alignment.
 407
 408 Returns:
 409
 410   EFI_SUCCESS             Function completed successfully.
 411   EFI_ABORTED             The function encountered an error.
 412
 413 --*/
 414 {
 415   UINT32  OccupiedSize;
 416
 417   OccupiedSize = ActualSize;
 418   while ((OccupiedSize & (Alignment - 1)) != 0) {
 419     OccupiedSize++;
 420   }
 421
 422   return OccupiedSize;
 423 }
 424
 425 static
 426 CHAR8 *
 427 SectionNameToStr (
 428   IN EFI_SECTION_TYPE   Type
 429   )
 430 /*++
 431
 432 Routine Description:
 433
 434   Converts EFI Section names to Strings
 435
 436 Arguments:
 437
 438   Type  - The EFI Section type
 439
 440 Returns:
 441
 442   CHAR8* - Pointer to the String containing the section name.
 443
 444 --*/
 445 {
 446   CHAR8 *SectionStr;
 447   CHAR8 *SectionTypeStringTable[] = {
 448     //
 449     // 0X00
 450     //
 451     "EFI_SECTION_ALL",
 452     //
 453     // 0x01
 454     //
 455     "EFI_SECTION_COMPRESSION",
 456     //
 457     // 0x02
 458     //
 459     "EFI_SECTION_GUID_DEFINED",
 460     //
 461     // 0x03
 462     //
 463     "Unknown section type - Reserved 0x03",
 464     //
 465     // 0x04
 466     //
 467     "Unknown section type - Reserved 0x04",
 468     //
 469     // 0x05
 470     //
 471     "Unknown section type - Reserved 0x05",
 472     //
 473     // 0x06
 474     //
 475     "Unknown section type - Reserved 0x06",
 476     //
 477     // 0x07
 478     //
 479     "Unknown section type - Reserved 0x07",
 480     //
 481     // 0x08
 482     //
 483     "Unknown section type - Reserved 0x08",
 484     //
 485     // 0x09
 486     //
 487     "Unknown section type - Reserved 0x09",
 488     //
 489     // 0x0A
 490     //
 491     "Unknown section type - Reserved 0x0A",
 492     //
 493     // 0x0B
 494     //
 495     "Unknown section type - Reserved 0x0B",
 496     //
 497     // 0x0C
 498     //
 499     "Unknown section type - Reserved 0x0C",
 500     //
 501     // 0x0D
 502     //
 503     "Unknown section type - Reserved 0x0D",
 504     //
 505     // 0x0E
 506     //
 507     "Unknown section type - Reserved 0x0E",
 508     //
 509     // 0x0F
 510     //
 511     "Unknown section type - Reserved 0x0E",
 512     //
 513     // 0x10
 514     //
 515     "EFI_SECTION_PE32",
 516     //
 517     // 0x11
 518     //
 519     "EFI_SECTION_PIC",
 520     //
 521     // 0x12
 522     //
 523     "EFI_SECTION_TE",
 524     //
 525     // 0x13
 526     //
 527     "EFI_SECTION_DXE_DEPEX",
 528     //
 529     // 0x14
 530     //
 531     "EFI_SECTION_VERSION",
 532     //
 533     // 0x15
 534     //
 535     "EFI_SECTION_USER_INTERFACE",
 536     //
 537     // 0x16
 538     //
 539     "EFI_SECTION_COMPATIBILITY16",
 540     //
 541     // 0x17
 542     //
 543     "EFI_SECTION_FIRMWARE_VOLUME_IMAGE ",
 544     //
 545     // 0x18
 546     //
 547     "EFI_SECTION_FREEFORM_SUBTYPE_GUID ",
 548     //
 549     // 0x19
 550     //
 551     "EFI_SECTION_RAW",
 552     //
 553     // 0x1A
 554     //
 555     "Unknown section type - 0x1A",
 556     //
 557     // 0x1B
 558     //
 559     "EFI_SECTION_PEI_DEPEX",
 560     //
 561     // 0x1C
 562     //
 563     "EFI_SECTION_SMM_DEPEX",
 564     //
 565     // 0x1C+
 566     //
 567     "Unknown section type - Reserved - beyond last defined section"
 568   };
 569
 570   if (Type > EFI_SECTION_LAST_SECTION_TYPE) {
 571     Type = EFI_SECTION_LAST_SECTION_TYPE + 1;
 572   }
 573
 574   SectionStr = malloc (100);
 575   if (SectionStr == NULL) {
 576     printf ("Error: Out of memory resources.\n");
 577     return SectionStr;
 578   }
 579   strcpy (SectionStr, SectionTypeStringTable[Type]);
 580   return SectionStr;
 581 }
 582
 583 STATIC
 584 EFI_STATUS
 585 ReadHeader (
 586   IN FILE       *InputFile,
 587   OUT UINT32    *FvSize,
 588   OUT BOOLEAN   *ErasePolarity
 589   )
 590 /*++
 591
 592 Routine Description:
 593
 594   This function determines the size of the FV and the erase polarity.  The
 595   erase polarity is the FALSE value for file state.
 596
 597 Arguments:
 598
 599   InputFile       The file that contains the FV image.
 600   FvSize          The size of the FV.
 601   ErasePolarity   The FV erase polarity.
 602
 603 Returns:
 604
 605   EFI_SUCCESS             Function completed successfully.
 606   EFI_INVALID_PARAMETER   A required parameter was NULL or is out of range.
 607   EFI_ABORTED             The function encountered an error.
 608
 609 --*/
 610 {
 611   EFI_FIRMWARE_VOLUME_HEADER  VolumeHeader;
 612   EFI_FV_BLOCK_MAP_ENTRY      BlockMap;
 613   UINTN                       Signature[2];
 614   UINTN                       BytesRead;
 615   UINT32                      Size;
 616
 617   BytesRead = 0;
 618   Size      = 0;
 619   //
 620   // Check input parameters
 621   //
 622   if (InputFile == NULL || FvSize == NULL || ErasePolarity == NULL) {
 623     Error (__FILE__, __LINE__, 0, "application error", "invalid parameter to function");
 624     return EFI_INVALID_PARAMETER;
 625   }
 626   //
 627   // Read the header
 628   //
 629   fread (&VolumeHeader, sizeof (EFI_FIRMWARE_VOLUME_HEADER) - sizeof (EFI_FV_BLOCK_MAP_ENTRY), 1, InputFile);
 630   BytesRead     = sizeof (EFI_FIRMWARE_VOLUME_HEADER) - sizeof (EFI_FV_BLOCK_MAP_ENTRY);
 631   Signature[0]  = VolumeHeader.Signature;
 632   Signature[1]  = 0;
 633
 634   //
 635   // Print FV header information
 636   //
 637   printf ("Signature:        %s (%X)\n", (char *) Signature, (unsigned) VolumeHeader.Signature);
 638   printf ("Attributes:       %X\n", (unsigned) VolumeHeader.Attributes);
 639
 640   if (VolumeHeader.Attributes & EFI_FVB2_READ_DISABLED_CAP) {
 641     printf ("       EFI_FVB2_READ_DISABLED_CAP\n");
 642   }
 643
 644   if (VolumeHeader.Attributes & EFI_FVB2_READ_ENABLED_CAP) {
 645     printf ("       EFI_FVB2_READ_ENABLED_CAP\n");
 646   }
 647
 648   if (VolumeHeader.Attributes & EFI_FVB2_READ_STATUS) {
 649     printf ("       EFI_FVB2_READ_STATUS\n");
 650   }
 651
 652   if (VolumeHeader.Attributes & EFI_FVB2_WRITE_DISABLED_CAP) {
 653     printf ("       EFI_FVB2_WRITE_DISABLED_CAP\n");
 654   }
 655
 656   if (VolumeHeader.Attributes & EFI_FVB2_WRITE_ENABLED_CAP) {
 657     printf ("       EFI_FVB2_WRITE_ENABLED_CAP\n");
 658   }
 659
 660   if (VolumeHeader.Attributes & EFI_FVB2_WRITE_STATUS) {
 661     printf ("       EFI_FVB2_WRITE_STATUS\n");
 662   }
 663
 664   if (VolumeHeader.Attributes & EFI_FVB2_LOCK_CAP) {
 665     printf ("       EFI_FVB2_LOCK_CAP\n");
 666   }
 667
 668   if (VolumeHeader.Attributes & EFI_FVB2_LOCK_STATUS) {
 669     printf ("       EFI_FVB2_LOCK_STATUS\n");
 670   }
 671
 672   if (VolumeHeader.Attributes & EFI_FVB2_STICKY_WRITE) {
 673     printf ("       EFI_FVB2_STICKY_WRITE\n");
 674   }
 675
 676   if (VolumeHeader.Attributes & EFI_FVB2_MEMORY_MAPPED) {
 677     printf ("       EFI_FVB2_MEMORY_MAPPED\n");
 678   }
 679
 680   if (VolumeHeader.Attributes & EFI_FVB2_ERASE_POLARITY) {
 681     printf ("       EFI_FVB2_ERASE_POLARITY\n");
 682     *ErasePolarity = TRUE;
 683   }
 684
 685 #if (PI_SPECIFICATION_VERSION < 0x00010000)
 686   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT) {
 687     printf ("       EFI_FVB2_ALIGNMENT\n");
 688   }
 689
 690   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_2) {
 691     printf ("       EFI_FVB2_ALIGNMENT_2\n");
 692   }
 693
 694   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_4) {
 695     printf ("       EFI_FVB2_ALIGNMENT_4\n");
 696   }
 697
 698   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_8) {
 699     printf ("       EFI_FVB2_ALIGNMENT_8\n");
 700   }
 701
 702   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_16) {
 703     printf ("       EFI_FVB2_ALIGNMENT_16\n");
 704   }
 705
 706   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_32) {
 707     printf ("       EFI_FVB2_ALIGNMENT_32\n");
 708   }
 709
 710   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_64) {
 711     printf ("        EFI_FVB2_ALIGNMENT_64\n");
 712   }
 713
 714   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_128) {
 715     printf ("        EFI_FVB2_ALIGNMENT_128\n");
 716   }
 717
 718   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_256) {
 719     printf ("        EFI_FVB2_ALIGNMENT_256\n");
 720   }
 721
 722   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_512) {
 723     printf ("        EFI_FVB2_ALIGNMENT_512\n");
 724   }
 725
 726   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_1K) {
 727     printf ("        EFI_FVB2_ALIGNMENT_1K\n");
 728   }
 729
 730   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_2K) {
 731     printf ("        EFI_FVB2_ALIGNMENT_2K\n");
 732   }
 733
 734   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_4K) {
 735     printf ("        EFI_FVB2_ALIGNMENT_4K\n");
 736   }
 737
 738   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_8K) {
 739     printf ("        EFI_FVB2_ALIGNMENT_8K\n");
 740   }
 741
 742   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_16K) {
 743     printf ("        EFI_FVB2_ALIGNMENT_16K\n");
 744   }
 745
 746   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_32K) {
 747     printf ("        EFI_FVB2_ALIGNMENT_32K\n");
 748   }
 749
 750   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_64K) {
 751     printf ("        EFI_FVB2_ALIGNMENT_64K\n");
 752   }
 753
 754 #else
 755
 756   if (VolumeHeader.Attributes & EFI_FVB2_READ_LOCK_CAP) {
 757     printf ("       EFI_FVB2_READ_LOCK_CAP\n");
 758   }
 759
 760   if (VolumeHeader.Attributes & EFI_FVB2_READ_LOCK_STATUS) {
 761     printf ("       EFI_FVB2_READ_LOCK_STATUS\n");
 762   }
 763
 764   if (VolumeHeader.Attributes & EFI_FVB2_WRITE_LOCK_CAP) {
 765     printf ("       EFI_FVB2_WRITE_LOCK_CAP\n");
 766   }
 767
 768   if (VolumeHeader.Attributes & EFI_FVB2_WRITE_LOCK_STATUS) {
 769     printf ("       EFI_FVB2_WRITE_LOCK_STATUS\n");
 770   }
 771
 772   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_1) {
 773     printf ("       EFI_FVB2_ALIGNMENT_1\n");
 774   }
 775
 776   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_2) {
 777     printf ("        EFI_FVB2_ALIGNMENT_2\n");
 778   }
 779
 780   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_4) {
 781     printf ("        EFI_FVB2_ALIGNMENT_4\n");
 782   }
 783
 784   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_8) {
 785     printf ("        EFI_FVB2_ALIGNMENT_8\n");
 786   }
 787
 788   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_16) {
 789     printf ("        EFI_FVB2_ALIGNMENT_16\n");
 790   }
 791
 792   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_32) {
 793     printf ("        EFI_FVB2_ALIGNMENT_32\n");
 794   }
 795
 796   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_64) {
 797     printf ("        EFI_FVB2_ALIGNMENT_64\n");
 798   }
 799
 800   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_128) {
 801     printf ("        EFI_FVB2_ALIGNMENT_128\n");
 802   }
 803
 804   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_256) {
 805     printf ("        EFI_FVB2_ALIGNMENT_256\n");
 806   }
 807
 808   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_512) {
 809     printf ("        EFI_FVB2_ALIGNMENT_512\n");
 810   }
 811
 812   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_1K) {
 813     printf ("        EFI_FVB2_ALIGNMENT_1K\n");
 814   }
 815
 816   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_2K) {
 817     printf ("        EFI_FVB2_ALIGNMENT_2K\n");
 818   }
 819
 820   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_4K) {
 821     printf ("        EFI_FVB2_ALIGNMENT_4K\n");
 822   }
 823
 824   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_8K) {
 825     printf ("        EFI_FVB2_ALIGNMENT_8K\n");
 826   }
 827
 828   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_16K) {
 829     printf ("        EFI_FVB2_ALIGNMENT_16K\n");
 830   }
 831
 832   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_32K) {
 833     printf ("        EFI_FVB2_ALIGNMENT_32K\n");
 834   }
 835
 836   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_64K) {
 837     printf ("        EFI_FVB2_ALIGNMENT_64K\n");
 838   }
 839
 840   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_128K) {
 841     printf ("        EFI_FVB2_ALIGNMENT_128K\n");
 842   }
 843
 844   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_256K) {
 845     printf ("        EFI_FVB2_ALIGNMENT_256K\n");
 846   }
 847
 848   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_512K) {
 849     printf ("        EFI_FVB2_ALIGNMENT_512K\n");
 850   }
 851
 852   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_1M) {
 853     printf ("        EFI_FVB2_ALIGNMENT_1M\n");
 854   }
 855
 856   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_2M) {
 857     printf ("        EFI_FVB2_ALIGNMENT_2M\n");
 858   }
 859
 860   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_4M) {
 861     printf ("        EFI_FVB2_ALIGNMENT_4M\n");
 862   }
 863
 864   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_8M) {
 865     printf ("        EFI_FVB2_ALIGNMENT_8M\n");
 866   }
 867
 868   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_16M) {
 869     printf ("        EFI_FVB2_ALIGNMENT_16M\n");
 870   }
 871
 872   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_32M) {
 873     printf ("        EFI_FVB2_ALIGNMENT_32M\n");
 874   }
 875
 876   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_64M) {
 877     printf ("        EFI_FVB2_ALIGNMENT_64M\n");
 878   }
 879
 880   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_128M) {
 881     printf ("        EFI_FVB2_ALIGNMENT_128M\n");
 882   }
 883
 884   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_64M) {
 885     printf ("        EFI_FVB2_ALIGNMENT_64M\n");
 886   }
 887
 888   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_128M) {
 889     printf ("        EFI_FVB2_ALIGNMENT_128M\n");
 890   }
 891
 892   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_256M) {
 893     printf ("        EFI_FVB2_ALIGNMENT_256M\n");
 894   }
 895
 896   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_512M) {
 897     printf ("        EFI_FVB2_ALIGNMENT_512M\n");
 898   }
 899
 900   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_1G) {
 901     printf ("        EFI_FVB2_ALIGNMENT_1G\n");
 902   }
 903
 904   if (VolumeHeader.Attributes & EFI_FVB2_ALIGNMENT_2G) {
 905     printf ("        EFI_FVB2_ALIGNMENT_2G\n");
 906   }
 907
 908 #endif
 909   printf ("Header Length:         0x%08X\n", VolumeHeader.HeaderLength);
 910   printf ("File System ID:        ");
 911   PrintGuid (&VolumeHeader.FileSystemGuid);
 912   //
 913   // printf ("\n");
 914   //
 915   printf ("Revision:              0x%04X\n", VolumeHeader.Revision);
 916
 917   do {
 918     fread (&BlockMap, sizeof (EFI_FV_BLOCK_MAP_ENTRY), 1, InputFile);
 919     BytesRead += sizeof (EFI_FV_BLOCK_MAP_ENTRY);
 920
 921     if (BlockMap.NumBlocks != 0) {
 922       printf ("Number of Blocks:      0x%08X\n", (unsigned) BlockMap.NumBlocks);
 923       printf ("Block Length:          0x%08X\n", (unsigned) BlockMap.Length);
 924       Size += BlockMap.NumBlocks * BlockMap.Length;
 925     }
 926
 927   } while (!(BlockMap.NumBlocks == 0 && BlockMap.Length == 0));
 928
 929   if (BytesRead != VolumeHeader.HeaderLength) {
 930     printf ("ERROR: Header length not consistent with Block Maps!\n");
 931     return EFI_ABORTED;
 932   }
 933
 934   if (VolumeHeader.FvLength != Size) {
 935     printf ("ERROR: Volume Size not consistant with Block Maps!\n");
 936     return EFI_ABORTED;
 937   }
 938
 939   printf ("Total Volume Size:     0x%08X\n", (unsigned) Size);
 940
 941   *FvSize = Size;
 942
 943   //
 944   // rewind (InputFile);
 945   //
 946   return EFI_SUCCESS;
 947 }
 948
 949 STATIC
 950 EFI_STATUS
 951 PrintFileInfo (
 952   EFI_FIRMWARE_VOLUME_HEADER  *FvImage,
 953   EFI_FFS_FILE_HEADER         *FileHeader,
 954   BOOLEAN                     ErasePolarity
 955   )
 956 /*++
 957
 958 Routine Description:
 959
 960   GC_TODO: Add function description
 961
 962 Arguments:
 963
 964   FvImage       - GC_TODO: add argument description
 965   FileHeader    - GC_TODO: add argument description
 966   ErasePolarity - GC_TODO: add argument description
 967
 968 Returns:
 969
 970   EFI_SUCCESS - GC_TODO: Add description for return value
 971   EFI_ABORTED - GC_TODO: Add description for return value
 972
 973 --*/
 974 {
 975   UINT32              FileLength;
 976   UINT8               FileState;
 977   UINT8               Checksum;
 978   EFI_FFS_FILE_HEADER2 BlankHeader;
 979   EFI_STATUS          Status;
 980   UINT8               GuidBuffer[PRINTED_GUID_BUFFER_SIZE];
 981   UINT32              HeaderSize;
 982 #if (PI_SPECIFICATION_VERSION < 0x00010000)
 983   UINT16              *Tail;
 984 #endif
 985   //
 986   // Check if we have free space
 987   //
 988   HeaderSize = FvBufGetFfsHeaderSize(FileHeader);
 989   if (ErasePolarity) {
 990     memset (&BlankHeader, -1, HeaderSize);
 991   } else {
 992     memset (&BlankHeader, 0, HeaderSize);
 993   }
 994
 995   if (memcmp (&BlankHeader, FileHeader, HeaderSize) == 0) {
 996     return EFI_SUCCESS;
 997   }
 998   //
 999   // Print file information.
1000   //
1001   printf ("============================================================\n");
1002
1003   printf ("File Name:        ");
1004   PrintGuidToBuffer (&FileHeader->Name, GuidBuffer, sizeof (GuidBuffer), TRUE);
1005   printf ("%s  ", GuidBuffer);
1006   PrintGuidName (GuidBuffer);
1007   printf ("\n");
1008
1009   //
1010   //  PrintGuid (&FileHeader->Name);
1011   //  printf ("\n");
1012   //
1013   FileLength = FvBufGetFfsFileSize (FileHeader);
1014   printf ("File Offset:      0x%08X\n", (unsigned) ((UINTN) FileHeader - (UINTN) FvImage));
1015   printf ("File Length:      0x%08X\n", (unsigned) FileLength);
1016   printf ("File Attributes:  0x%02X\n", FileHeader->Attributes);
1017   printf ("File State:       0x%02X\n", FileHeader->State);
1018
1019   //
1020   // Print file state
1021   //
1022   FileState = GetFileState (ErasePolarity, FileHeader);
1023
1024   switch (FileState) {
1025
1026   case EFI_FILE_HEADER_CONSTRUCTION:
1027     printf ("        EFI_FILE_HEADER_CONSTRUCTION\n");
1028     return EFI_SUCCESS;
1029
1030   case EFI_FILE_HEADER_INVALID:
1031     printf ("        EFI_FILE_HEADER_INVALID\n");
1032     return EFI_SUCCESS;
1033
1034   case EFI_FILE_HEADER_VALID:
1035     printf ("        EFI_FILE_HEADER_VALID\n");
1036     Checksum  = CalculateSum8 ((UINT8 *) FileHeader, HeaderSize);
1037     Checksum  = (UINT8) (Checksum - FileHeader->IntegrityCheck.Checksum.File);
1038     Checksum  = (UINT8) (Checksum - FileHeader->State);
1039     if (Checksum != 0) {
1040       printf ("ERROR: Header checksum invalid.\n");
1041       return EFI_ABORTED;
1042     }
1043
1044     return EFI_SUCCESS;
1045
1046   case EFI_FILE_DELETED:
1047     printf ("        EFI_FILE_DELETED\n");
1048
1049   case EFI_FILE_MARKED_FOR_UPDATE:
1050     printf ("        EFI_FILE_MARKED_FOR_UPDATE\n");
1051
1052   case EFI_FILE_DATA_VALID:
1053     printf ("        EFI_FILE_DATA_VALID\n");
1054
1055     //
1056     // Calculate header checksum
1057     //
1058     Checksum  = CalculateSum8 ((UINT8 *) FileHeader, HeaderSize);
1059     Checksum  = (UINT8) (Checksum - FileHeader->IntegrityCheck.Checksum.File);
1060     Checksum  = (UINT8) (Checksum - FileHeader->State);
1061     if (Checksum != 0) {
1062       Error (NULL, 0, 0003, "error parsing FFS file", "FFS file with Guid %s has invalid header checksum", GuidBuffer);
1063       return EFI_ABORTED;
1064     }
1065
1066     FileLength = FvBufGetFfsFileSize (FileHeader);
1067
1068     if (FileHeader->Attributes & FFS_ATTRIB_CHECKSUM) {
1069       //
1070       // Calculate file checksum
1071       //
1072       Checksum  = CalculateSum8 ((UINT8 *)FileHeader + HeaderSize, FileLength - HeaderSize);
1073       Checksum  = Checksum + FileHeader->IntegrityCheck.Checksum.File;
1074       if (Checksum != 0) {
1075         Error (NULL, 0, 0003, "error parsing FFS file", "FFS file with Guid %s has invalid file checksum", GuidBuffer);
1076         return EFI_ABORTED;
1077       }
1078     } else {
1079       if (FileHeader->IntegrityCheck.Checksum.File != FFS_FIXED_CHECKSUM) {
1080         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);
1081         return EFI_ABORTED;
1082       }
1083     }
1084 #if (PI_SPECIFICATION_VERSION < 0x00010000)
1085     //
1086     // Verify tail if present
1087     //
1088     if (FileHeader->Attributes & FFS_ATTRIB_TAIL_PRESENT) {
1089       //
1090       // Verify tail is complement of integrity check field in the header.
1091       //
1092       Tail = (UINT16 *) ((UINTN) FileHeader + GetLength (FileHeader->Size) - sizeof (EFI_FFS_INTEGRITY_CHECK));
1093       if (FileHeader->IntegrityCheck.TailReference != (UINT16)~(*Tail)) {
1094         Error (NULL, 0, 0003, "error parsing FFS file", \
1095         "FFS file with Guid %s failed in the integrity check, tail is not the complement of the header field", GuidBuffer);
1096         return EFI_ABORTED;
1097       }
1098     }
1099  #endif
1100     break;
1101
1102   default:
1103     Error (NULL, 0, 0003, "error parsing FFS file", "FFS file with Guid %s has the invalid/unrecognized file state bits", GuidBuffer);
1104     return EFI_ABORTED;
1105   }
1106
1107   printf ("File Type:        0x%02X  ", FileHeader->Type);
1108
1109   switch (FileHeader->Type) {
1110
1111   case EFI_FV_FILETYPE_RAW:
1112     printf ("EFI_FV_FILETYPE_RAW\n");
1113     break;
1114
1115   case EFI_FV_FILETYPE_FREEFORM:
1116     printf ("EFI_FV_FILETYPE_FREEFORM\n");
1117     break;
1118
1119   case EFI_FV_FILETYPE_SECURITY_CORE:
1120     printf ("EFI_FV_FILETYPE_SECURITY_CORE\n");
1121     break;
1122
1123   case EFI_FV_FILETYPE_PEI_CORE:
1124     printf ("EFI_FV_FILETYPE_PEI_CORE\n");
1125     break;
1126
1127   case EFI_FV_FILETYPE_DXE_CORE:
1128     printf ("EFI_FV_FILETYPE_DXE_CORE\n");
1129     break;
1130
1131   case EFI_FV_FILETYPE_PEIM:
1132     printf ("EFI_FV_FILETYPE_PEIM\n");
1133     break;
1134
1135   case EFI_FV_FILETYPE_DRIVER:
1136     printf ("EFI_FV_FILETYPE_DRIVER\n");
1137     break;
1138
1139   case EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER:
1140     printf ("EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER\n");
1141     break;
1142
1143   case EFI_FV_FILETYPE_APPLICATION:
1144     printf ("EFI_FV_FILETYPE_APPLICATION\n");
1145     break;
1146
1147   case EFI_FV_FILETYPE_SMM:
1148     printf ("EFI_FV_FILETYPE_SMM\n");
1149     break;
1150
1151   case EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE:
1152     printf ("EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE\n");
1153     break;
1154
1155   case EFI_FV_FILETYPE_COMBINED_SMM_DXE:
1156     printf ("EFI_FV_FILETYPE_COMBINED_SMM_DXE\n");
1157     break;
1158
1159   case EFI_FV_FILETYPE_SMM_CORE:
1160     printf ("EFI_FV_FILETYPE_SMM_CORE\n");
1161     break;
1162
1163   case EFI_FV_FILETYPE_FFS_PAD:
1164     printf ("EFI_FV_FILETYPE_FFS_PAD\n");
1165     break;
1166
1167   default:
1168     printf ("\nERROR: Unrecognized file type %X.\n", FileHeader->Type);
1169     return EFI_ABORTED;
1170     break;
1171   }
1172
1173   switch (FileHeader->Type) {
1174
1175   case EFI_FV_FILETYPE_ALL:
1176   case EFI_FV_FILETYPE_RAW:
1177   case EFI_FV_FILETYPE_FFS_PAD:
1178     break;
1179
1180   default:
1181     //
1182     // All other files have sections
1183     //
1184     Status = ParseSection (
1185               (UINT8 *) ((UINTN) FileHeader + HeaderSize),
1186               FvBufGetFfsFileSize (FileHeader) - HeaderSize
1187               );
1188     if (EFI_ERROR (Status)) {
1189       //
1190       // printf ("ERROR: Parsing the FFS file.\n");
1191       //
1192       return EFI_ABORTED;
1193     }
1194     break;
1195   }
1196
1197   return EFI_SUCCESS;
1198 }
1199
1200 EFI_STATUS
1201 ParseSection (
1202   IN UINT8  *SectionBuffer,
1203   IN UINT32 BufferLength
1204   )
1205 /*++
1206
1207 Routine Description:
1208
1209   Parses EFI Sections
1210
1211 Arguments:
1212
1213   SectionBuffer - Buffer containing the section to parse.
1214   BufferLength  - Length of SectionBuffer
1215
1216 Returns:
1217
1218   EFI_SECTION_ERROR - Problem with section parsing.
1219                       (a) compression errors
1220                       (b) unrecognized section
1221   EFI_UNSUPPORTED - Do not know how to parse the section.
1222   EFI_SUCCESS - Section successfully parsed.
1223   EFI_OUT_OF_RESOURCES - Memory allocation failed.
1224
1225 --*/
1226 {
1227   EFI_SECTION_TYPE    Type;
1228   UINT8               *Ptr;
1229   UINT32              SectionLength;
1230   UINT32              SectionHeaderLen;
1231   CHAR8               *SectionName;
1232   EFI_STATUS          Status;
1233   UINT32              ParsedLength;
1234   UINT8               *CompressedBuffer;
1235   UINT32              CompressedLength;
1236   UINT8               *UncompressedBuffer;
1237   UINT32              UncompressedLength;
1238   UINT8               *ToolOutputBuffer;
1239   UINT32              ToolOutputLength;
1240   UINT8               CompressionType;
1241   UINT32              DstSize;
1242   UINT32              ScratchSize;
1243   UINT8               *ScratchBuffer;
1244   DECOMPRESS_FUNCTION DecompressFunction;
1245   GETINFO_FUNCTION    GetInfoFunction;
1246   // CHAR16              *name;
1247   CHAR8               *ExtractionTool;
1248   CHAR8               *ToolInputFile;
1249   CHAR8               *ToolOutputFile;
1250   CHAR8               *SystemCommandFormatString;
1251   CHAR8               *SystemCommand;
1252   EFI_GUID            *EfiGuid;
1253   UINT16              DataOffset;
1254   UINT16              Attributes;
1255   UINT32              RealHdrLen;
1256
1257   ParsedLength = 0;
1258   while (ParsedLength < BufferLength) {
1259     Ptr           = SectionBuffer + ParsedLength;
1260
1261     SectionLength = GetLength (((EFI_COMMON_SECTION_HEADER *) Ptr)->Size);
1262     Type          = ((EFI_COMMON_SECTION_HEADER *) Ptr)->Type;
1263
1264     //
1265     // This is sort of an odd check, but is necessary because FFS files are
1266     // padded to a QWORD boundary, meaning there is potentially a whole section
1267     // header worth of 0xFF bytes.
1268     //
1269     if (SectionLength == 0xffffff && Type == 0xff) {
1270       ParsedLength += 4;
1271       continue;
1272     }
1273
1274     //
1275     // Get real section file size
1276     //
1277     SectionLength = GetSectionFileLength ((EFI_COMMON_SECTION_HEADER *) Ptr);
1278     SectionHeaderLen = GetSectionHeaderLength((EFI_COMMON_SECTION_HEADER *)Ptr);
1279
1280     SectionName = SectionNameToStr (Type);
1281     printf ("------------------------------------------------------------\n");
1282     printf ("  Type:  %s\n  Size:  0x%08X\n", SectionName, (unsigned) SectionLength);
1283     free (SectionName);
1284
1285     switch (Type) {
1286     case EFI_SECTION_RAW:
1287     case EFI_SECTION_PE32:
1288     case EFI_SECTION_PIC:
1289     case EFI_SECTION_TE:
1290       // default is no more information
1291       break;
1292
1293     case EFI_SECTION_USER_INTERFACE:
1294       // name = &((EFI_USER_INTERFACE_SECTION *) Ptr)->FileNameString;
1295       // printf ("  String: %s\n", &name);
1296       break;
1297
1298     case EFI_SECTION_FIRMWARE_VOLUME_IMAGE:
1299       Status = PrintFvInfo (Ptr + SectionHeaderLen, TRUE);
1300       if (EFI_ERROR (Status)) {
1301         Error (NULL, 0, 0003, "printing of FV section contents failed", NULL);
1302         return EFI_SECTION_ERROR;
1303       }
1304       break;
1305
1306     case EFI_SECTION_COMPATIBILITY16:
1307     case EFI_SECTION_FREEFORM_SUBTYPE_GUID:
1308       //
1309       // Section does not contain any further header information.
1310       //
1311       break;
1312
1313     case EFI_SECTION_PEI_DEPEX:
1314     case EFI_SECTION_DXE_DEPEX:
1315     case EFI_SECTION_SMM_DEPEX:
1316       DumpDepexSection (Ptr, SectionLength);
1317       break;
1318
1319     case EFI_SECTION_VERSION:
1320       printf ("  Build Number:  0x%02X\n", *(UINT16 *)(Ptr + SectionHeaderLen));
1321       printf ("  Version Strg:  %s\n", (char*) (Ptr + SectionHeaderLen + sizeof (UINT16)));
1322       break;
1323
1324     case EFI_SECTION_COMPRESSION:
1325       UncompressedBuffer  = NULL;
1326       if (SectionHeaderLen == sizeof (EFI_COMMON_SECTION_HEADER)) {
1327         RealHdrLen = sizeof(EFI_COMPRESSION_SECTION);
1328         UncompressedLength  = ((EFI_COMPRESSION_SECTION *)Ptr)->UncompressedLength;
1329         CompressionType     = ((EFI_COMPRESSION_SECTION *)Ptr)->CompressionType;
1330       } else {
1331         RealHdrLen = sizeof(EFI_COMPRESSION_SECTION2);
1332         UncompressedLength  = ((EFI_COMPRESSION_SECTION2 *)Ptr)->UncompressedLength;
1333         CompressionType     = ((EFI_COMPRESSION_SECTION2 *)Ptr)->CompressionType;
1334       }
1335       CompressedLength    = SectionLength - RealHdrLen;
1336       printf ("  Uncompressed Length:  0x%08X\n", (unsigned) UncompressedLength);
1337
1338       if (CompressionType == EFI_NOT_COMPRESSED) {
1339         printf ("  Compression Type:  EFI_NOT_COMPRESSED\n");
1340         if (CompressedLength != UncompressedLength) {
1341           Error (
1342             NULL,
1343             0,
1344             0,
1345             "file is not compressed, but the compressed length does not match the uncompressed length",
1346             NULL
1347             );
1348           return EFI_SECTION_ERROR;
1349         }
1350
1351         UncompressedBuffer = Ptr + RealHdrLen;
1352       } else if (CompressionType == EFI_STANDARD_COMPRESSION) {
1353         GetInfoFunction     = EfiGetInfo;
1354         DecompressFunction  = EfiDecompress;
1355         printf ("  Compression Type:  EFI_STANDARD_COMPRESSION\n");
1356
1357         CompressedBuffer  = Ptr + RealHdrLen;
1358
1359         Status            = GetInfoFunction (CompressedBuffer, CompressedLength, &DstSize, &ScratchSize);
1360         if (EFI_ERROR (Status)) {
1361           Error (NULL, 0, 0003, "error getting compression info from compression section", NULL);
1362           return EFI_SECTION_ERROR;
1363         }
1364
1365         if (DstSize != UncompressedLength) {
1366           Error (NULL, 0, 0003, "compression error in the compression section", NULL);
1367           return EFI_SECTION_ERROR;
1368         }
1369
1370         ScratchBuffer       = malloc (ScratchSize);
1371         UncompressedBuffer  = malloc (UncompressedLength);
1372         if ((ScratchBuffer == NULL) || (UncompressedBuffer == NULL)) {
1373           return EFI_OUT_OF_RESOURCES;
1374         }
1375         Status = DecompressFunction (
1376                   CompressedBuffer,
1377                   CompressedLength,
1378                   UncompressedBuffer,
1379                   UncompressedLength,
1380                   ScratchBuffer,
1381                   ScratchSize
1382                   );
1383         free (ScratchBuffer);
1384         if (EFI_ERROR (Status)) {
1385           Error (NULL, 0, 0003, "decompress failed", NULL);
1386           free (UncompressedBuffer);
1387           return EFI_SECTION_ERROR;
1388         }
1389       } else {
1390         Error (NULL, 0, 0003, "unrecognized compression type", "type 0x%X", CompressionType);
1391         return EFI_SECTION_ERROR;
1392       }
1393
1394       Status = ParseSection (UncompressedBuffer, UncompressedLength);
1395
1396       if (CompressionType == EFI_STANDARD_COMPRESSION) {
1397         //
1398         // We need to deallocate Buffer
1399         //
1400         free (UncompressedBuffer);
1401       }
1402
1403       if (EFI_ERROR (Status)) {
1404         Error (NULL, 0, 0003, "failed to parse section", NULL);
1405         return EFI_SECTION_ERROR;
1406       }
1407       break;
1408
1409     case EFI_SECTION_GUID_DEFINED:
1410       if (SectionHeaderLen == sizeof(EFI_COMMON_SECTION_HEADER)) {
1411         EfiGuid = &((EFI_GUID_DEFINED_SECTION *) Ptr)->SectionDefinitionGuid;
1412         DataOffset = ((EFI_GUID_DEFINED_SECTION *) Ptr)->DataOffset;
1413         Attributes = ((EFI_GUID_DEFINED_SECTION *) Ptr)->Attributes;
1414       } else {
1415         EfiGuid = &((EFI_GUID_DEFINED_SECTION2 *) Ptr)->SectionDefinitionGuid;
1416         DataOffset = ((EFI_GUID_DEFINED_SECTION2 *) Ptr)->DataOffset;
1417         Attributes = ((EFI_GUID_DEFINED_SECTION2 *) Ptr)->Attributes;
1418       }
1419       printf ("  SectionDefinitionGuid:  ");
1420       PrintGuid (EfiGuid);
1421       printf ("\n");
1422       printf ("  DataOffset:             0x%04X\n", (unsigned) DataOffset);
1423       printf ("  Attributes:             0x%04X\n", (unsigned) Attributes);
1424
1425       ExtractionTool =
1426         LookupGuidedSectionToolPath (
1427           mParsedGuidedSectionTools,
1428           EfiGuid
1429           );
1430
1431       if (ExtractionTool != NULL) {
1432
1433         ToolInputFile = CloneString (tmpnam (NULL));
1434         ToolOutputFile = CloneString (tmpnam (NULL));
1435
1436         //
1437         // Construction 'system' command string
1438         //
1439         SystemCommandFormatString = "%s -d -o %s %s";
1440         SystemCommand = malloc (
1441           strlen (SystemCommandFormatString) +
1442           strlen (ExtractionTool) +
1443           strlen (ToolInputFile) +
1444           strlen (ToolOutputFile) +
1445           1
1446           );
1447         sprintf (
1448           SystemCommand,
1449           SystemCommandFormatString,
1450           ExtractionTool,
1451           ToolOutputFile,
1452           ToolInputFile
1453           );
1454         free (ExtractionTool);
1455
1456         Status =
1457           PutFileImage (
1458             ToolInputFile,
1459             (CHAR8*) SectionBuffer + DataOffset,
1460             BufferLength - DataOffset
1461             );
1462
1463         system (SystemCommand);
1464         remove (ToolInputFile);
1465         free (ToolInputFile);
1466
1467         Status =
1468           GetFileImage (
1469             ToolOutputFile,
1470             (CHAR8 **)&ToolOutputBuffer,
1471             &ToolOutputLength
1472             );
1473         remove (ToolOutputFile);
1474         free (ToolOutputFile);
1475         if (EFI_ERROR (Status)) {
1476           Error (NULL, 0, 0004, "unable to read decoded GUIDED section", NULL);
1477           return EFI_SECTION_ERROR;
1478         }
1479
1480         Status = ParseSection (
1481                   ToolOutputBuffer,
1482                   ToolOutputLength
1483                   );
1484         if (EFI_ERROR (Status)) {
1485           Error (NULL, 0, 0003, "parse of decoded GUIDED section failed", NULL);
1486           return EFI_SECTION_ERROR;
1487         }
1488
1489       //
1490       // Check for CRC32 sections which we can handle internally if needed.
1491       //
1492       } else if (!CompareGuid (
1493                    EfiGuid,
1494                    &gEfiCrc32GuidedSectionExtractionProtocolGuid
1495                    )
1496           ) {
1497         //
1498         // CRC32 guided section
1499         //
1500         Status = ParseSection (
1501                   SectionBuffer + DataOffset,
1502                   BufferLength - DataOffset
1503                   );
1504         if (EFI_ERROR (Status)) {
1505           Error (NULL, 0, 0003, "parse of CRC32 GUIDED section failed", NULL);
1506           return EFI_SECTION_ERROR;
1507         }
1508       } else {
1509         //
1510         // We don't know how to parse it now.
1511         //
1512         Error (NULL, 0, 0003, "Error parsing section", \
1513         "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).");
1514         return EFI_UNSUPPORTED;
1515       }
1516       break;
1517
1518     default:
1519       //
1520       // Unknown section, return error
1521       //
1522       Error (NULL, 0, 0003, "unrecognized section type found", "section type = 0x%X", Type);
1523       return EFI_SECTION_ERROR;
1524     }
1525
1526     ParsedLength += SectionLength;
1527     //
1528     // We make then next section begin on a 4-byte boundary
1529     //
1530     ParsedLength = GetOccupiedSize (ParsedLength, 4);
1531   }
1532
1533   if (ParsedLength < BufferLength) {
1534     Error (NULL, 0, 0003, "sections do not completely fill the sectioned buffer being parsed", NULL);
1535     return EFI_SECTION_ERROR;
1536   }
1537
1538   return EFI_SUCCESS;
1539 }
1540
1541 EFI_STATUS
1542 DumpDepexSection (
1543   IN UINT8    *Ptr,
1544   IN UINT32   SectionLength
1545   )
1546 /*++
1547
1548 Routine Description:
1549
1550   GC_TODO: Add function description
1551
1552 Arguments:
1553
1554   Ptr           - GC_TODO: add argument description
1555   SectionLength - GC_TODO: add argument description
1556
1557 Returns:
1558
1559   EFI_SUCCESS - GC_TODO: Add description for return value
1560
1561 --*/
1562 {
1563   UINT8 GuidBuffer[PRINTED_GUID_BUFFER_SIZE];
1564
1565   //
1566   // Need at least a section header + data
1567   //
1568   if (SectionLength <= sizeof (EFI_COMMON_SECTION_HEADER)) {
1569     return EFI_SUCCESS;
1570   }
1571
1572   Ptr += GetSectionHeaderLength((EFI_COMMON_SECTION_HEADER *)Ptr);
1573   SectionLength -= GetSectionHeaderLength((EFI_COMMON_SECTION_HEADER *)Ptr);
1574   while (SectionLength > 0) {
1575     printf ("        ");
1576     switch (*Ptr) {
1577     case EFI_DEP_BEFORE:
1578       printf ("BEFORE\n");
1579       Ptr++;
1580       SectionLength--;
1581       break;
1582
1583     case EFI_DEP_AFTER:
1584       printf ("AFTER\n");
1585       Ptr++;
1586       SectionLength--;
1587       break;
1588
1589     case EFI_DEP_PUSH:
1590       printf ("PUSH\n        ");
1591       PrintGuidToBuffer ((EFI_GUID *) (Ptr + 1), GuidBuffer, sizeof (GuidBuffer), TRUE);
1592       printf ("%s  ", GuidBuffer);
1593       PrintGuidName (GuidBuffer);
1594       printf ("\n");
1595       //
1596       // PrintGuid ((EFI_GUID *)(Ptr + 1));
1597       //
1598       Ptr += 17;
1599       SectionLength -= 17;
1600       break;
1601
1602     case EFI_DEP_AND:
1603       printf ("AND\n");
1604       Ptr++;
1605       SectionLength--;
1606       break;
1607
1608     case EFI_DEP_OR:
1609       printf ("OR\n");
1610       Ptr++;
1611       SectionLength--;
1612       break;
1613
1614     case EFI_DEP_NOT:
1615       printf ("NOT\n");
1616       Ptr++;
1617       SectionLength--;
1618       break;
1619
1620     case EFI_DEP_TRUE:
1621       printf ("TRUE\n");
1622       Ptr++;
1623       SectionLength--;
1624       break;
1625
1626     case EFI_DEP_FALSE:
1627       printf ("FALSE\n");
1628       Ptr++;
1629       SectionLength--;
1630       break;
1631
1632     case EFI_DEP_END:
1633       printf ("END DEPEX\n");
1634       Ptr++;
1635       SectionLength--;
1636       break;
1637
1638     case EFI_DEP_SOR:
1639       printf ("SOR\n");
1640       Ptr++;
1641       SectionLength--;
1642       break;
1643
1644     default:
1645       printf ("Unrecognized byte in depex: 0x%X\n", *Ptr);
1646       return EFI_SUCCESS;
1647     }
1648   }
1649
1650   return EFI_SUCCESS;
1651 }
1652
1653 EFI_STATUS
1654 PrintGuidName (
1655   IN UINT8    *GuidStr
1656   )
1657 /*++
1658
1659 Routine Description:
1660
1661   GC_TODO: Add function description
1662
1663 Arguments:
1664
1665   GuidStr - GC_TODO: add argument description
1666
1667 Returns:
1668
1669   EFI_SUCCESS - GC_TODO: Add description for return value
1670   EFI_INVALID_PARAMETER - GC_TODO: Add description for return value
1671
1672 --*/
1673 {
1674   GUID_TO_BASENAME  *GPtr;
1675   //
1676   // If we have a list of guid-to-basenames, then go through the list to
1677   // look for a guid string match. If found, print the basename to stdout,
1678   // otherwise return a failure.
1679   //
1680   GPtr = mGuidBaseNameList;
1681   while (GPtr != NULL) {
1682     if (_stricmp ((CHAR8*) GuidStr, (CHAR8*) GPtr->Guid) == 0) {
1683       printf ("%s", GPtr->BaseName);
1684       return EFI_SUCCESS;
1685     }
1686
1687     GPtr = GPtr->Next;
1688   }
1689
1690   return EFI_INVALID_PARAMETER;
1691 }
1692
1693 EFI_STATUS
1694 ParseGuidBaseNameFile (
1695   CHAR8    *FileName
1696   )
1697 /*++
1698
1699 Routine Description:
1700
1701   GC_TODO: Add function description
1702
1703 Arguments:
1704
1705   FileName  - GC_TODO: add argument description
1706
1707 Returns:
1708
1709   EFI_DEVICE_ERROR - GC_TODO: Add description for return value
1710   EFI_OUT_OF_RESOURCES - GC_TODO: Add description for return value
1711   EFI_SUCCESS - GC_TODO: Add description for return value
1712
1713 --*/
1714 {
1715   FILE              *Fptr;
1716   CHAR8             Line[MAX_LINE_LEN];
1717   GUID_TO_BASENAME  *GPtr;
1718
1719   if ((Fptr = fopen (FileName, "r")) == NULL) {
1720     printf ("ERROR: Failed to open input cross-reference file '%s'\n", FileName);
1721     return EFI_DEVICE_ERROR;
1722   }
1723
1724   while (fgets (Line, sizeof (Line), Fptr) != NULL) {
1725     //
1726     // Allocate space for another guid/basename element
1727     //
1728     GPtr = malloc (sizeof (GUID_TO_BASENAME));
1729     if (GPtr == NULL) {
1730       return EFI_OUT_OF_RESOURCES;
1731     }
1732
1733     memset ((char *) GPtr, 0, sizeof (GUID_TO_BASENAME));
1734     if (sscanf (Line, "%s %s", GPtr->Guid, GPtr->BaseName) == 2) {
1735       GPtr->Next        = mGuidBaseNameList;
1736       mGuidBaseNameList = GPtr;
1737     } else {
1738       //
1739       // Some sort of error. Just continue.
1740       //
1741       free (GPtr);
1742     }
1743   }
1744
1745   fclose (Fptr);
1746   return EFI_SUCCESS;
1747 }
1748
1749 EFI_STATUS
1750 FreeGuidBaseNameList (
1751   VOID
1752   )
1753 /*++
1754
1755 Routine Description:
1756
1757   GC_TODO: Add function description
1758
1759 Arguments:
1760
1761   None
1762
1763 Returns:
1764
1765   EFI_SUCCESS - GC_TODO: Add description for return value
1766
1767 --*/
1768 {
1769   GUID_TO_BASENAME  *Next;
1770
1771   while (mGuidBaseNameList != NULL) {
1772     Next = mGuidBaseNameList->Next;
1773     free (mGuidBaseNameList);
1774     mGuidBaseNameList = Next;
1775   }
1776
1777   return EFI_SUCCESS;
1778 }
1779
1780
1781 static
1782 VOID
1783 LoadGuidedSectionToolsTxt (
1784   IN CHAR8* FirmwareVolumeFilename
1785   )
1786 {
1787   CHAR8* PeerFilename;
1788   CHAR8* Places[] = {
1789     NULL,
1790     //NULL,
1791     };
1792   UINTN Index;
1793
1794   Places[0] = FirmwareVolumeFilename;
1795   //Places[1] = mUtilityFilename;
1796
1797   mParsedGuidedSectionTools = NULL;
1798
1799   for (Index = 0; Index < (sizeof(Places)/sizeof(Places[0])); Index++) {
1800     PeerFilename = OsPathPeerFilePath (Places[Index], "GuidedSectionTools.txt");
1801     //printf("Loading %s...\n", PeerFilename);
1802     if (OsPathExists (PeerFilename)) {
1803       mParsedGuidedSectionTools = ParseGuidedSectionToolsFile (PeerFilename);
1804     }
1805     free (PeerFilename);
1806     if (mParsedGuidedSectionTools != NULL) {
1807       return;
1808     }
1809   }
1810 }
1811
1812
1813 void
1814 Usage (
1815   VOID
1816   )
1817 /*++
1818
1819 Routine Description:
1820
1821   GC_TODO: Add function description
1822
1823 Arguments:
1824
1825   None
1826
1827 Returns:
1828
1829   GC_TODO: add return values
1830
1831 --*/
1832 {
1833   //
1834   // Summary usage
1835   //
1836   fprintf (stdout, "Usage: %s [options] <input_file>\n\n", UTILITY_NAME);
1837
1838   //
1839   // Copyright declaration
1840   //
1841   fprintf (stdout, "Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.\n\n");
1842   fprintf (stdout, "  Display Tiano Firmware Volume FFS image information\n\n");
1843
1844   //
1845   // Details Option
1846   //
1847   fprintf (stdout, "Options:\n");
1848   fprintf (stdout, "  -x xref, --xref xref\n\
1849             Parse basename to file-guid cross reference file(s).\n");
1850   fprintf (stdout, "  --offset offset\n\
1851             Offset of file to start processing FV at.\n");
1852   fprintf (stdout, "  -h, --help\n\
1853             Show this help message and exit.\n");
1854
1855 }
1856