[mirror_edk2.git] / BaseTools / Source / C / FCE / BinaryParse.c

/** @file\r
\r
 The API to parse the binary.\r
\r
 Copyright (c) 2011-2019, Intel Corporation. All rights reserved.<BR>\r
 SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#ifndef __GNUC__\r
#include "windows.h"\r
#else\r
#include <sys/types.h>\r
#include <dirent.h>\r
#include <unistd.h>\r
#endif\r
#include "BinaryParse.h"\r
#include "BinaryCreate.h"\r
#include "VariableCommon.h"\r
#include "FirmwareVolumeBufferLib.h"\r
\r
extern G_EFI_FD_INFO  gEfiFdInfo;\r
extern EFI_HANDLE     mParsedGuidedSectionTools;\r
extern CHAR8          mInputFdName[MAX_FILENAME_LEN];\r
\r
//\r
// The Guid to sign the position of Vfr and Uni array in FV\r
//\r
EFI_GUID  gVfrArrayAttractGuid                         = EFI_VFR_ATTRACT_GUID;\r
EFI_GUID  gUniStrArrayAttractGuid                      = EFI_UNI_STR_ATTRACT_GUID;\r
EFI_GUID  gEfiSystemNvDataFvGuid                       = EFI_SYSTEM_NVDATA_FV_GUID;\r
EFI_GUID  gEfiCrc32GuidedSectionExtractionProtocolGuid = EFI_CRC32_GUIDED_SECTION_EXTRACTION_PROTOCOL_GUID;\r
\r
/**\r
  Converts a three byte length value into a UINT32.\r
\r
  @param  ThreeByteLength   Pointer to the first of the 3 byte length.\r
\r
  @retval  Length           Size of the section\r
\r
**/\r
static\r
UINT32\r
Get3ByteLength (\r
  IN UINT8     *ThreeByteLength\r
  )\r
{\r
  UINT32  Length;\r
\r
  Length = 0;\r
\r
  if (ThreeByteLength == NULL) {\r
    return 0;\r
  }\r
\r
  Length  = *((UINT32 *) ThreeByteLength);\r
  Length  = Length & 0x00FFFFFF;\r
\r
  return Length;\r
}\r
\r
/**\r
  Generate the unique template filename.\r
**/\r
CHAR8 *\r
GenTempFile (\r
 VOID\r
 )\r
{\r
  CHAR8   *TemString;\r
  TemString = NULL;\r
#ifndef __GNUC__\r
  TemString = CloneString (tmpnam (NULL));\r
#else\r
  CHAR8 tmp[] = "/tmp/fileXXXXXX";\r
  UINTN Fdtmp;\r
  Fdtmp = mkstemp(tmp);\r
  TemString = CloneString(tmp);\r
  close(Fdtmp);\r
#endif\r
  return TemString;\r
}\r
\r
/**\r
  Check whether exist the same Ifr FFS. If not existed, return TRUE.\r
\r
  @param[in]   FfsImage   The pointer to the binary.\r
  @param[in]   FileSize   The size of binary.\r
\r
  @return The string after convert.\r
**/\r
static\r
BOOLEAN\r
NotExistSameFfsIfr (\r
  IN  VOID     *FfsImage\r
)\r
{\r
  UINT32  Index;\r
\r
  Index = 0;\r
\r
  while (gEfiFdInfo.FfsArray[Index] != NULL) {\r
    if (memcmp (gEfiFdInfo.FfsArray[Index], FfsImage, sizeof (EFI_GUID)) == 0) {\r
      return FALSE;\r
    }\r
    Index++;\r
  }\r
  return TRUE;\r
}\r
\r
/**\r
  This function returns the next larger size that meets the alignment\r
  requirement specified.\r
\r
  @param  ActualSize        The size.\r
  @param  Alignment         The desired alignment.\r
\r
  @retval The Occupied length\r
\r
**/\r
static\r
UINT32\r
GetOccupiedSize (\r
  IN UINT32  ActualSize,\r
  IN UINT32  Alignment\r
  )\r
{\r
  UINT32  OccupiedSize;\r
\r
  OccupiedSize = ActualSize;\r
  while ((OccupiedSize & (Alignment - 1)) != 0) {\r
    OccupiedSize++;\r
  }\r
\r
  return OccupiedSize;\r
}\r
\r
\r
/**\r
  Parses FFS Sections, and remove the FFS headers. Tis function olny handle one efi in this FFS.\r
\r
  @param  SectionBuffer     The section base address\r
  @param  BufferLength      The length of FFS.\r
  @param  EfiBufferHeader   The structure dual pointer to the efi informations\r
\r
  @retval  EFI_SUCCESS      The application exited normally.\r
  @retval  EFI_ABORTED       An error occurred.\r
\r
**/\r
EFI_STATUS\r
ParseSection (\r
  IN      BOOLEAN              IsFfsOrEfi,\r
  IN OUT  UINT8                *SectionBuffer,\r
  IN      UINT32               BufferLength,\r
  IN OUT  EFI_SECTION_STRUCT   **EfiBufferHeader\r
  )\r
{\r
  UINT32              ParsedLength;\r
  EFI_SECTION_TYPE    Type;\r
  UINT8               *Ptr;\r
  UINT32              SectionLength;\r
  UINT8               *CompressedBuffer;\r
  UINT32              CompressedLength;\r
  UINT8               *UncompressedBuffer;\r
  UINT32              UncompressedLength;\r
  UINT8               CompressionType;\r
  DECOMPRESS_FUNCTION DecompressFunction;\r
  GETINFO_FUNCTION    GetInfoFunction;\r
  UINT32              ScratchSize;\r
  UINT8               *ScratchBuffer;\r
  EFI_STATUS          Status;\r
  UINT32              DstSize;\r
  CHAR8               *ExtractionTool;\r
  CHAR8               *ToolInputFile;\r
  CHAR8               *ToolOutputFile;\r
  CHAR8               *SystemCommandFormatString;\r
  CHAR8               *SystemCommand;\r
  UINT8               *ToolOutputBuffer;\r
  UINT32              ToolOutputLength;\r
  BOOLEAN             HasDepexSection;\r
\r
  Ptr                       = NULL;\r
  SectionLength             = 0;\r
  CompressedBuffer          = NULL;\r
  CompressedLength          = 0;\r
  UncompressedBuffer        = NULL;\r
  UncompressedLength        = 0;\r
  CompressionType           = 0;\r
  ScratchSize               = 0;\r
  ScratchBuffer             = NULL;\r
  Status                    = EFI_SUCCESS;\r
  DstSize                   = 0;\r
  ExtractionTool            = NULL;\r
  ToolInputFile             = NULL;\r
  ToolOutputFile            = NULL;\r
  SystemCommandFormatString = NULL;\r
  SystemCommand             = NULL;\r
\r
  //\r
  // Jump the FFS header\r
  //\r
  if (IsFfsOrEfi) {\r
    SectionBuffer = SectionBuffer + sizeof (EFI_FFS_FILE_HEADER);\r
    BufferLength  = BufferLength - sizeof (EFI_FFS_FILE_HEADER);\r
  }\r
  ParsedLength     = 0;\r
  HasDepexSection  = FALSE;\r
  ExtractionTool   = NULL;\r
  ToolOutputLength = 0;\r
  ToolOutputBuffer = NULL;\r
\r
  (*EfiBufferHeader)->Length = BufferLength;\r
\r
  while (ParsedLength < BufferLength) {\r
    Ptr           = SectionBuffer + ParsedLength;\r
\r
    SectionLength = Get3ByteLength (((EFI_COMMON_SECTION_HEADER *) Ptr)->Size);\r
    Type          = ((EFI_COMMON_SECTION_HEADER *) Ptr)->Type;\r
\r
    //\r
    // This is sort of an odd check, but is necessary because FFS files are\r
    // padded to a QWORD boundary, meaning there is potentially a whole section\r
    // header worth of 0xFF bytes.\r
    //\r
    if ((SectionLength == 0xffffff) && (Type == 0xff)) {\r
      ParsedLength += 4;\r
      continue;\r
    }\r
\r
    switch (Type) {\r
\r
    case EFI_SECTION_PE32:\r
    case EFI_SECTION_TE:\r
      //\r
      //Got the correct address\r
      //\r
     (*EfiBufferHeader)->BufferBase = (UINTN)(Ptr + sizeof (EFI_COMMON_SECTION_HEADER));\r
      return EFI_SUCCESS;\r
\r
    case EFI_SECTION_RAW:\r
    case EFI_SECTION_PIC:\r
       break;\r
\r
    case EFI_SECTION_USER_INTERFACE:\r
      HasDepexSection = FALSE;\r
      break;\r
\r
    case EFI_SECTION_FIRMWARE_VOLUME_IMAGE:\r
    case EFI_SECTION_COMPATIBILITY16:\r
    case EFI_SECTION_FREEFORM_SUBTYPE_GUID:\r
      break;\r
\r
    case EFI_SECTION_PEI_DEPEX:\r
    case EFI_SECTION_DXE_DEPEX:\r
    case EFI_SECTION_SMM_DEPEX:\r
      HasDepexSection = TRUE;\r
      break;\r
\r
    case EFI_SECTION_VERSION:\r
      break;\r
    case EFI_SECTION_COMPRESSION:\r
      UncompressedBuffer  = NULL;\r
      CompressedLength    = SectionLength - sizeof (EFI_COMPRESSION_SECTION);\r
      UncompressedLength  = ((EFI_COMPRESSION_SECTION *) Ptr)->UncompressedLength;\r
      CompressionType     = ((EFI_COMPRESSION_SECTION *) Ptr)->CompressionType;\r
\r
      if (CompressionType == EFI_NOT_COMPRESSED) {\r
        if (CompressedLength != UncompressedLength) {\r
          Error (\r
            NULL,\r
            0,\r
            0,\r
            "file is not compressed, but the compressed length does not match the uncompressed length",\r
            NULL\r
            );\r
          return EFI_ABORTED;\r
        }\r
\r
        UncompressedBuffer = Ptr + sizeof (EFI_COMPRESSION_SECTION);\r
      } else if (CompressionType == EFI_STANDARD_COMPRESSION) {\r
        GetInfoFunction     = EfiGetInfo;\r
        DecompressFunction  = EfiDecompress;\r
        CompressedBuffer  = Ptr + sizeof (EFI_COMPRESSION_SECTION);\r
\r
        Status = GetInfoFunction (\r
                   CompressedBuffer,\r
                   CompressedLength,\r
                   &DstSize,\r
                   &ScratchSize\r
                   );\r
        if (EFI_ERROR (Status)) {\r
          Error (NULL, 0, 0003, "error getting compression info from compression section", NULL);\r
          return EFI_ABORTED;\r
        }\r
\r
        if (DstSize != UncompressedLength) {\r
          Error (NULL, 0, 0003, "compression error in the compression section", NULL);\r
          return EFI_ABORTED;\r
        }\r
\r
        ScratchBuffer       = malloc (ScratchSize);\r
        if (ScratchBuffer == NULL) {\r
          return EFI_ABORTED;\r
        }\r
        UncompressedBuffer  = malloc (UncompressedLength);\r
        if (UncompressedBuffer == NULL) {\r
          free (ScratchBuffer);\r
          return EFI_ABORTED;\r
        }\r
        memset (UncompressedBuffer, 0, UncompressedLength);\r
\r
        Status = DecompressFunction (\r
                   CompressedBuffer,\r
                   CompressedLength,\r
                   UncompressedBuffer,\r
                   UncompressedLength,\r
                   ScratchBuffer,\r
                   ScratchSize\r
                  );\r
        free (ScratchBuffer);\r
        if (Status != EFI_SUCCESS) {\r
          Error (NULL, 0, 0003, "decompress failed", NULL);\r
          free (UncompressedBuffer);\r
          return EFI_ABORTED;\r
        }\r
      } else {\r
        Error (NULL, 0, 0003, "unrecognized compression type", "type 0x%X", CompressionType);\r
        return EFI_ABORTED;\r
      }\r
\r
      Status = ParseSection (FALSE, UncompressedBuffer, UncompressedLength, EfiBufferHeader);\r
      if (Status != EFI_SUCCESS) {\r
        Error (NULL, 0, 0003, "failed to parse section", NULL);\r
        free (UncompressedBuffer);\r
        UncompressedBuffer = NULL;\r
      } else {\r
        return EFI_SUCCESS;\r
      }\r
      //\r
      // Store the allocate memory address for UncompressedBuffer\r
      //\r
      if (UncompressedBuffer != NULL) {\r
        (*EfiBufferHeader)->UncompressedBuffer[(*EfiBufferHeader)->UnCompressIndex] = (UINTN) UncompressedBuffer;\r
        (*EfiBufferHeader)->UnCompressIndex = (*EfiBufferHeader)->UnCompressIndex + 1;\r
      }\r
      break;\r
\r
    case EFI_SECTION_GUID_DEFINED:\r
      //\r
      // Decompress failed, and then check for CRC32 sections which we can handle internally if needed.\r
      // Maybe this section is no-compressed.\r
      //\r
      if (!CompareGuid (\r
           &((EFI_GUID_DEFINED_SECTION *) Ptr)->SectionDefinitionGuid,\r
           &gEfiCrc32GuidedSectionExtractionProtocolGuid\r
           )) {\r
        //\r
        // CRC32 guided section\r
        //\r
        Status = ParseSection (\r
                   FALSE,\r
                   SectionBuffer + ((EFI_GUID_DEFINED_SECTION *) Ptr)->DataOffset,\r
                   BufferLength - ((EFI_GUID_DEFINED_SECTION *) Ptr)->DataOffset,\r
                   EfiBufferHeader\r
                  );\r
        if (EFI_ERROR (Status)) {\r
          Error (NULL, 0, 0003, "parse of CRC32 GUIDED section failed", NULL);\r
          return EFI_ABORTED;\r
        } else {\r
          return EFI_SUCCESS;\r
        }\r
      } else {\r
        ExtractionTool = LookupGuidedSectionToolPath (\r
                           mParsedGuidedSectionTools,\r
                           &((EFI_GUID_DEFINED_SECTION *) Ptr)->SectionDefinitionGuid\r
                           );\r
\r
        if (ExtractionTool != NULL) {\r
          ToolInputFile  = GenTempFile ();\r
          ToolOutputFile = GenTempFile ();\r
          //\r
          // Construction 'system' command string\r
          //\r
          SystemCommandFormatString = "%s -d -o \"%s\" \"%s\"";\r
          SystemCommand = malloc (\r
                            strlen (SystemCommandFormatString) \\r
                            + strlen (ExtractionTool)          \\r
                            + strlen (ToolInputFile)           \\r
                            + strlen (ToolOutputFile)          \\r
                            + 1\r
                            );\r
          if (SystemCommand == NULL) {\r
            free (ExtractionTool);\r
            free (ToolInputFile);\r
            free (ToolOutputFile);\r
            return EFI_ABORTED;\r
          }\r
          sprintf (\r
            SystemCommand,\r
            "%s -d -o \"%s\" \"%s\"",\r
            ExtractionTool,\r
            ToolOutputFile,\r
            ToolInputFile\r
            );\r
          free (ExtractionTool);\r
\r
          Status = PutFileImage (\r
                     ToolInputFile,\r
                     (CHAR8*) Ptr + ((EFI_GUID_DEFINED_SECTION *) Ptr)->DataOffset,\r
                     SectionLength - ((EFI_GUID_DEFINED_SECTION *) Ptr)->DataOffset\r
                   );\r
\r
          if (HasDepexSection) {\r
            HasDepexSection = FALSE;\r
          }\r
\r
          system (SystemCommand);\r
          remove (ToolInputFile);\r
          free (ToolInputFile);\r
          ToolInputFile = NULL;\r
          free (SystemCommand);\r
          SystemCommand = NULL;\r
\r
          if (EFI_ERROR (Status)) {\r
            Error ("FCE", 0, 0004, "unable to decoded GUIDED section", NULL);\r
            free (ToolOutputFile);\r
            return EFI_ABORTED;\r
          }\r
\r
          Status = GetFileImage (\r
                     ToolOutputFile,\r
                     (CHAR8 **)&ToolOutputBuffer,\r
                     &ToolOutputLength\r
                    );\r
          remove (ToolOutputFile);\r
          free (ToolOutputFile);\r
          ToolOutputFile = NULL;\r
          if (EFI_ERROR (Status)) {\r
            return EFI_ABORTED;\r
          }\r
        }\r
        Status = ParseSection (\r
                  FALSE,\r
                  ToolOutputBuffer,\r
                  ToolOutputLength,\r
                  EfiBufferHeader\r
                  );\r
        if (EFI_ERROR (Status)) {\r
          Error (NULL, 0, 0003, "parse of decoded GUIDED section failed", NULL);\r
          return EFI_ABORTED;\r
        }\r
      }\r
      break;\r
\r
    default:\r
      ;\r
    }\r
    ParsedLength += SectionLength;\r
    //\r
    // We make then next section begin on a 4-byte boundary\r
    //\r
    ParsedLength = GetOccupiedSize (ParsedLength, 4);\r
  }\r
\r
  return EFI_ABORTED;\r
}\r
\r
static\r
BOOLEAN\r
GetNextOffset (\r
  IN UINT8 *Data,\r
  IN EFI_GUID *Guid,\r
  IN UINTN Len,\r
  IN OUT UINTN *Offset\r
  )\r
{\r
  UINTN NextOffset;\r
  if (*Offset >= Len || Len - *Offset <= sizeof (EFI_GUID)) {\r
    return FALSE;\r
  }\r
\r
  for (NextOffset = *Offset; NextOffset < Len - sizeof (EFI_GUID); NextOffset++) {\r
    if (CompareGuid(Guid, (EFI_GUID*)(Data + NextOffset)) == 0) {\r
      *Offset = NextOffset + sizeof(EFI_GUID);\r
      return TRUE;\r
    }\r
  }\r
  return FALSE;\r
}\r
\r
/**\r
  Get the address by Guid.\r
\r
  Parse the FFS image, and find the GUID address.There may be some Guids matching the\r
  searched Guid.\r
\r
  @param Fv                     the Pointer to the image.\r
  @param Guid                   The Guid need to find.\r
  @param Offset                 The dual Pointer to the offset.\r
  @param NumOfMatchGuid         The number of matching Guid offset.\r
\r
  @retval EFI_SUCCESS           The Search was complete successfully\r
  @return EFI_ABORTED           An error occurred\r
**/\r
EFI_STATUS\r
GetAddressByGuid (\r
  IN  VOID        *Fv,\r
  IN  EFI_GUID    *Guid,\r
  IN  UINTN       Len,\r
  OUT UINTN       **Offset,\r
  OUT UINT8       *NumOfMatchGuid\r
  )\r
{\r
  VOID        *LocalFv;\r
  UINT8       Flag;\r
\r
  EFI_RAW_SECTION* Section;\r
  UINT8       *RawData;\r
  VOID*       SectionStart;\r
  UINTN       NextOffset;\r
  UINTN       Key;\r
  UINTN       TotalSectionsSize;\r
  UINTN       SecLen;\r
  UINTN       SecHdr;\r
  EFI_STATUS  Status;\r
\r
  if( (Fv == NULL) || (Fv == NULL) || (Guid == NULL) || Len == 0 ){\r
    return EFI_ABORTED;\r
  }\r
\r
  LocalFv         = Fv;\r
  Flag            = 0;\r
  Section         = NULL;\r
  Key             = 0;\r
\r
  if (NumOfMatchGuid != NULL) {\r
    *NumOfMatchGuid = 0;\r
  }\r
\r
  SectionStart = (VOID*)((UINTN)LocalFv + FvBufGetFfsHeaderSize(LocalFv));\r
  TotalSectionsSize = Len - FvBufGetFfsHeaderSize(LocalFv);\r
  while (TRUE) {\r
    Status = FvBufFindNextSection (\r
               SectionStart,\r
               TotalSectionsSize,\r
               &Key,\r
               (VOID **)&Section\r
               );\r
    if (Section == NULL || EFI_ERROR (Status)) {\r
      break;\r
    }\r
\r
    if (EFI_SECTION_RAW == Section->Type) {\r
      if ((*(UINT32 *)Section->Size & 0xffffff) == 0xffffff) {\r
        SecLen = ((EFI_RAW_SECTION2 *)Section)->ExtendedSize;\r
        SecHdr = sizeof(EFI_RAW_SECTION2);\r
      } else {\r
        SecLen = *(UINT32 *)Section->Size & 0xffffff;\r
        SecHdr = sizeof(EFI_RAW_SECTION);\r
      }\r
      if (SecLen <= SecHdr || SecLen - SecHdr < sizeof(EFI_GUID)) {\r
        continue;\r
      }\r
      RawData = (UINT8 *)Section + SecHdr;\r
      NextOffset = 0;\r
      while (GetNextOffset(RawData, Guid, SecLen - SecHdr, &NextOffset)) {\r
        Flag = 1;\r
        if ((NumOfMatchGuid != NULL) && (Offset != NULL)) {\r
          if (*NumOfMatchGuid == 0) {\r
            *Offset = malloc (sizeof (UINTN) * MAX_MATCH_GUID_NUM);\r
            if (*Offset == NULL) {\r
              return EFI_ABORTED;\r
            }\r
            memset (*Offset, 0, sizeof (UINTN) * MAX_MATCH_GUID_NUM);\r
          }\r
          *(*Offset + *NumOfMatchGuid) = NextOffset + (RawData - (UINT8 *)Fv);\r
          (*NumOfMatchGuid)++;\r
        } else {\r
          return EFI_SUCCESS;\r
        }\r
      }\r
    }\r
  }\r
\r
  if( Flag == 0 ) {\r
    return EFI_ABORTED;\r
  }\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Search the VfrBin Base address.\r
\r
  According the known GUID gVfrArrayAttractGuid to get the base address from FFS.\r
\r
  @param Fv                    the Pointer to the FFS\r
  @param EfiAddr               the Pointer to the EFI in FFS\r
  @param Length                the length of Fv\r
  @param Offset                the Pointer to the Addr (Offset)\r
  @param NumOfMachingOffset    the number of Addr (Offset)\r
\r
  @retval EFI_SUCCESS          Get the address successfully.\r
**/\r
EFI_STATUS\r
SearchVfrBinInFFS (\r
   IN  VOID      *Fv,\r
   IN  VOID      *EfiAddr,\r
   IN  UINTN     Length,\r
   OUT UINTN    **Offset,\r
   OUT UINT8     *NumOfMachingOffset\r
  )\r
{\r
  UINTN        Index;\r
  EFI_STATUS   Status;\r
  UINTN        VirOffValue;\r
\r
  Index       = 0;\r
  Status      = EFI_SUCCESS;\r
  VirOffValue = 0;\r
\r
  if ((Fv == NULL) || (Offset == NULL)) {\r
    return EFI_ABORTED;\r
  }\r
  Status = GetAddressByGuid (\r
             Fv,\r
             &gVfrArrayAttractGuid,\r
             Length,\r
             Offset,\r
             NumOfMachingOffset\r
             );\r
  if (Status != EFI_SUCCESS) {\r
    return EFI_ABORTED;\r
  }\r
\r
  while (Index < *NumOfMachingOffset) {\r
    //\r
    // Got the virOffset after the GUID\r
    //\r
    VirOffValue = *(UINTN *)((UINTN)Fv + *(*Offset + Index));\r
    //\r
    //Transfer the offset to the VA address. One modules may own more VfrBin address.\r
    //\r
    *(*Offset + Index) = (UINTN) EfiAddr + VirOffValue;\r
    Index++;\r
  }\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Search the UniBin Base address.\r
\r
  According the known GUID gUniStrArrayAttractGuid to get the base address from FFS.\r
\r
  @param Fv                    the Pointer to the FFS\r
  @param EfiAddr               the Pointer to the EFI in FFS\r
  @param Length                the length of Fv\r
  @param Offset                the Pointer to the Addr (Offset)\r
\r
  @retval Base address         Get the address successfully.\r
**/\r
EFI_STATUS\r
SearchUniBinInFFS (\r
   IN VOID      *Fv,\r
   IN  VOID     *EfiAddr,\r
   IN  UINTN    Length,\r
   OUT UINTN    **Offset\r
  )\r
{\r
  UINT8        NumOfMachingOffset;\r
  EFI_STATUS   Status;\r
  UINTN        VirOffValue;\r
\r
  NumOfMachingOffset = 0;\r
  Status             = EFI_SUCCESS;\r
  VirOffValue        = 0;\r
\r
  if ((Fv == NULL) || (Offset == NULL)) {\r
    return EFI_ABORTED;\r
  }\r
  Status = GetAddressByGuid (\r
             Fv,\r
             &gUniStrArrayAttractGuid,\r
             Length,\r
             Offset,\r
             &NumOfMachingOffset\r
             );\r
  if (Status != EFI_SUCCESS) {\r
    return EFI_ABORTED;\r
  }\r
  //\r
  //Transfer the offset to the VA address. There is only one UniArray in one modules.\r
  //\r
  if (NumOfMachingOffset == 1) {\r
    VirOffValue  = *(UINTN *)((UINTN)Fv + **Offset);\r
    **Offset     = (UINTN) EfiAddr + VirOffValue;\r
  } else {\r
    printf ("Error. Find more than 1 UniBin in FFS.\n");\r
    return EFI_ABORTED;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
SearchNvStoreDatabaseInFd(\r
  IN VOID     *Fv,\r
  IN UINTN    length\r
  )\r
{\r
  EFI_STATUS   Status;\r
  UINTN        Offset;\r
  PCD_NV_STORE_DEFAULT_BUFFER_HEADER *NvStoreHeader;\r
  Status = EFI_SUCCESS;\r
  Offset = 0;\r
  if (Fv == NULL) {\r
    printf ("The FV is NULL.");\r
    return EFI_ABORTED;\r
  }\r
  while (Offset < (length - sizeof(PCD_NV_STORE_DEFAULT_BUFFER_HEADER))){\r
    NvStoreHeader = (PCD_NV_STORE_DEFAULT_BUFFER_HEADER *)((UINT8*)Fv + Offset);\r
    if (NvStoreHeader->Signature == PCD_NV_STORE_DEFAULT_BUFFER_SIGNATURE) {\r
      gEfiFdInfo.ExistNvStoreDatabase = TRUE;\r
      gEfiFdInfo.NvStoreDatabase = (UINT8 *) NvStoreHeader;\r
      break;\r
    }\r
    Offset++;\r
  }\r
  if (Offset == (length - sizeof(PCD_NV_STORE_DEFAULT_BUFFER_HEADER)) || gEfiFdInfo.ExistNvStoreDatabase != TRUE) {\r
    //printf ("Not found the PcdNvStoreDefaultValueBuffer\n");\r
    return Status;\r
  }\r
  return Status;\r
}\r
\r
/**\r
  Get the address by Guid.\r
\r
  Parse the FD image, and find the GUID address.There may be some Guids matching the\r
  searched Guid.\r
\r
  @param Fv                     the Pointer to the image.\r
  @param Guid                   The Guid need to find.\r
  @param Offset                 The dual Pointer to the offset.\r
  @param NumOfMatchGuid         The number of matching Guid offset.\r
\r
  @retval EFI_SUCCESS           The Search was complete successfully\r
  @return EFI_ABORTED           An error occurred\r
**/\r
EFI_STATUS\r
GetVariableAddressByGuid (\r
  IN  VOID        *Fv,\r
  IN  EFI_GUID    *Guid,\r
  IN  UINTN       Len,\r
  OUT UINTN       **Offset,\r
  OUT UINT8       *NumOfMatchGuid\r
  )\r
{\r
  UINTN       NextOffset;\r
  UINT8       Flag;\r
\r
  if( (Fv == NULL) || (Fv == NULL) || (Guid == NULL) ){\r
    return EFI_ABORTED;\r
  }\r
\r
  Flag            = 0;\r
  NextOffset      = 0;\r
\r
  if (NumOfMatchGuid != NULL) {\r
    *NumOfMatchGuid = 0;\r
  }\r
  while (GetNextOffset(Fv, Guid, Len, &NextOffset)) {\r
    Flag = 1;\r
    if (NumOfMatchGuid != NULL && Offset != NULL) {\r
      if (*NumOfMatchGuid == 0) {\r
        *Offset = malloc (sizeof (UINTN) * MAX_MATCH_GUID_NUM);\r
        if (*Offset == NULL) {\r
          return EFI_ABORTED;\r
        }\r
        memset (*Offset, 0, sizeof (UINTN) * MAX_MATCH_GUID_NUM);\r
      }\r
      *(*Offset + *NumOfMatchGuid) = NextOffset;\r
      (*NumOfMatchGuid)++;\r
    } else {\r
      return EFI_SUCCESS;\r
    }\r
  }\r
\r
  if( Flag == 0 ) {\r
    return EFI_ABORTED;\r
  }\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Search the EFI Variable Base address.\r
\r
  According the known GUID gEfiSystemNvDataFvGuid to get the base address from FFS.\r
\r
  @param Fv                    the Pointer to the FFS\r
  @param Length                the length of Fv\r
  @param Offset                the Pointer to the Addr (Offset)\r
  @param NumOfMachingOffset    the number of IFR array in one FFS\r
\r
  @retval EFI_SUCCESS          Get the address successfully.\r
  @retval EFI_ABORTED          An error occured.\r
**/\r
EFI_STATUS\r
SearchEfiVarInFFS (\r
   IN VOID      *Fv,\r
   IN  UINTN     Length,\r
   OUT UINTN    **Offset,\r
   OUT UINT8    *NumOfMachingOffset\r
  )\r
{\r
  EFI_STATUS   Status;\r
  UINT8        Index;\r
\r
  Status = EFI_SUCCESS;\r
  Index  = 0;\r
\r
  if ((Fv == NULL) || (Offset == NULL)) {\r
    printf ("The FV or offset is NULL.");\r
    return EFI_ABORTED;\r
  }\r
  Status = GetVariableAddressByGuid (\r
             Fv,\r
             &gEfiSystemNvDataFvGuid,\r
             Length,\r
             Offset,\r
             NumOfMachingOffset\r
             );\r
  if (Status != EFI_SUCCESS) {\r
    return EFI_ABORTED;\r
  }\r
  //\r
  //Transfer the offset to the VA address.\r
  //\r
  while (Index < *NumOfMachingOffset) {\r
    *(*Offset + Index) = (UINTN) Fv + *(*Offset + Index);\r
    Index++;\r
  }\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Parse the Ffs header to get the size.\r
\r
  @param  InputFile             The pointer to the input file\r
  @param  FvSize                The pointer to the file size\r
\r
  @return EFI_SUCCESS           Get the file size successfully\r
**/\r
EFI_STATUS\r
ReadFfsHeader (\r
  IN   FILE       *InputFile,\r
  OUT  UINT32     *FvSize\r
  )\r
{\r
  EFI_FFS_FILE_HEADER         FfsHeader;\r
  EFI_FV_FILETYPE             Type;\r
\r
  //\r
  // Check input parameters\r
  //\r
  if ((InputFile == NULL) || (FvSize == NULL)) {\r
    return EFI_ABORTED;\r
  }\r
  //\r
  // Read the header\r
  //\r
  fread (\r
    &FfsHeader,\r
    sizeof (EFI_FFS_FILE_HEADER),\r
    1,\r
    InputFile\r
    );\r
  Type    = FfsHeader.Type;\r
\r
  if (Type == EFI_FV_FILETYPE_DRIVER) {\r
    *FvSize = *(UINT32 *)FfsHeader.Size & 0xffffff;\r
  } else if (Type == EFI_FV_FILETYPE_APPLICATION) {\r
    *FvSize = *(UINT32 *)FfsHeader.Size & 0xffffff;\r
  } else if (Type == EFI_FV_FILETYPE_FREEFORM) {\r
    *FvSize = *(UINT32 *)FfsHeader.Size & 0xffffff;\r
  } else {\r
    return EFI_ABORTED;\r
  }\r
  return EFI_SUCCESS;\r
}\r
\r
/*\r
  Read the length of the whole FD\r
\r
  This function determines the size of the FV.\r
\r
  @param   InputFile        The file that contains the FV image.\r
  @param   FvSize           The size of the FV.\r
\r
  @retval  EFI_SUCCESS      The application exited normally.\r
  @retval  EFI_ABORTED      An error occurred.\r
\r
**/\r
static\r
EFI_STATUS\r
ReadFdHeader (\r
  IN FILE       *InputFile,\r
  OUT UINT32    *FvSize\r
  )\r
{\r
  //\r
  // Check input parameters\r
  //\r
  if ((InputFile == NULL) || (FvSize == NULL)) {\r
    return EFI_ABORTED;\r
  }\r
  *FvSize = 0;\r
  //\r
  // Get the total size of FD file (Fixed the length)\r
  //\r
  fseek(InputFile,0,SEEK_END);\r
  *FvSize = ftell(InputFile);\r
  fseek(InputFile,0,SEEK_SET);\r
\r
  if (*FvSize == 0) {\r
    return EFI_ABORTED;\r
  }\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Read the file to memory.\r
\r
  @param   InputFile        The file that contains the FV image.\r
  @param   Size             The size of the file.\r
\r
  @retval The pointer to the begining position of memory.\r
**/\r
VOID *\r
ReadFileToMemory (\r
  IN CHAR8      *FileName,\r
  OUT UINT32    *Size\r
  )\r
{\r
  FILE                          *InFile;\r
  VOID                          *Address;\r
  UINT32                        BytesRead;\r
  EFI_STATUS                    Status;\r
\r
  InFile          = NULL;\r
  Address         = NULL;\r
  BytesRead       = 0;\r
  Status          = EFI_SUCCESS;\r
\r
  InFile = fopen (FileName,"rb");\r
  if (InFile == NULL) {\r
    return NULL;\r
  }\r
  //\r
  // Determine the size of FV\r
  //\r
  Status = ReadFdHeader (InFile, Size);\r
  if (Status != EFI_SUCCESS) {\r
    fclose (InFile);\r
    return NULL;\r
  }\r
  //\r
  // Allocate a buffer for the FV image\r
  //\r
  Address = malloc (*Size);\r
  if (Address == NULL) {\r
    fclose (InFile);\r
    return NULL;\r
  }\r
  memset (Address, 0, *Size);\r
  //\r
  // Seek to the start of the image, then read the entire FV to the buffer\r
  //\r
  fseek (InFile, 0, SEEK_SET);\r
  BytesRead = fread (Address, 1, *Size, InFile);\r
  fclose (InFile);\r
  if ((UINTN) BytesRead != *Size) {\r
    free (Address);\r
    return NULL;\r
  }\r
  return Address;\r
}\r
\r
/**\r
  Search the EFI variables address in Fd.\r
\r
  Open and read the *.fd to the memory, initialize the global structure.\r
  Update the EFI variables addr and the begining position of memory.\r
\r
  @retval EFI_SUCCESS          Get the address successfully.\r
**/\r
EFI_STATUS\r
GetEfiVariablesAddr (\r
  BOOLEAN UqiIsSet\r
  )\r
{\r
  VOID                          *FdImage;\r
  UINT32                        FdSize;\r
  EFI_STATUS                    Status;\r
  UINTN                         *EfiVarAddr;\r
  UINT8                         NumOfMachingVar;\r
  UINT32                        Index;\r
  BOOLEAN                       GotFlag;\r
  EFI_FIRMWARE_VOLUME_HEADER    *Variable;\r
  BOOLEAN                       AuthencitatedMonotonicOrNot;\r
  BOOLEAN                       AuthencitatedBasedTimeOrNot;\r
  BOOLEAN                       NormalOrNot;\r
\r
  FdImage         = NULL;\r
  FdSize          = 0;\r
  Status          = EFI_SUCCESS;\r
  EfiVarAddr      = NULL;\r
  NumOfMachingVar = 0;\r
  Index           = 0;\r
  GotFlag         = TRUE;\r
  Variable        = NULL;\r
\r
  FdImage = ReadFileToMemory (mInputFdName, &FdSize);\r
  if (FdImage == NULL) {\r
    return EFI_ABORTED;\r
  }\r
  if (!UqiIsSet) {\r
    Status = SearchNvStoreDatabaseInFd(FdImage, FdSize);\r
    if (EFI_ERROR (Status)) {\r
      return EFI_ABORTED;\r
    }\r
  }\r
  Status = SearchEfiVarInFFS (\r
             FdImage,\r
             FdSize,\r
             &EfiVarAddr,\r
             &NumOfMachingVar\r
             );\r
  if (EFI_ERROR (Status)) {\r
    return EFI_ABORTED;\r
  }\r
  //\r
  // Check the signature "_FVH"\r
  //\r
  Index       = 0;\r
  GotFlag     = FALSE;\r
\r
  while (Index < NumOfMachingVar) {\r
    Variable = (EFI_FIRMWARE_VOLUME_HEADER *)(*(EfiVarAddr + Index) - 0x20);\r
    if (Variable->Signature == 0x4856465F) {\r
      AuthencitatedMonotonicOrNot  = CheckMonotonicBasedVarStore ((UINT8 *)Variable + Variable->HeaderLength);\r
      AuthencitatedBasedTimeOrNot  = CheckTimeBasedVarStoreOrNot ((UINT8 *)Variable + Variable->HeaderLength);\r
      NormalOrNot                  = CheckNormalVarStoreOrNot ((UINT8 *)Variable + Variable->HeaderLength);\r
      if (AuthencitatedMonotonicOrNot || AuthencitatedBasedTimeOrNot || NormalOrNot) {\r
        GotFlag = TRUE;\r
        gEfiFdInfo.EfiVariableAddr = (UINTN)Variable;\r
        break;\r
      }\r
    }\r
    Index++;\r
  }\r
  free (EfiVarAddr);\r
  if (!GotFlag) {\r
    return EFI_ABORTED;\r
  }\r
  gEfiFdInfo.Fd              = FdImage;\r
  gEfiFdInfo.FdSize          = FdSize;\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Pick up the FFS which includes IFR section.\r
\r
  Parse all FFS extracted by BfmLib, and save all which includes IFR\r
  Binary to gEfiFdInfo structure.\r
\r
  @retval EFI_SUCCESS          Get the address successfully.\r
  @retval EFI_BUFFER_TOO_SMALL Memory can't be allocated.\r
  @retval EFI_ABORTED          Read FFS Failed.\r
**/\r
EFI_STATUS\r
FindFileInFolder (\r
  IN   CHAR8    *FolderName,\r
  OUT  BOOLEAN  *ExistStorageInBfv,\r
  OUT  BOOLEAN  *SizeOptimized\r
)\r
{\r
  CHAR8           *FileName;\r
  CHAR8           *CurFolderName;\r
  EFI_STATUS      Status;\r
  UINTN           MaxFileNameLen;\r
  UINTN           Index;\r
  CHAR8           FileNameArry[MAX_FILENAME_LEN];\r
  FILE            *FfsFile;\r
  UINTN           FileSize;\r
  VOID            *FfsImage;\r
  UINTN           BytesRead;\r
#ifndef __GNUC__\r
  HANDLE          FindHandle;\r
  WIN32_FIND_DATA FindFileData;\r
#else\r
  struct dirent *pDirent;\r
  DIR *pDir;\r
#endif\r
\r
  FileName       = NULL;\r
  CurFolderName  = NULL;\r
  Status         = EFI_SUCCESS;\r
  MaxFileNameLen = 0;\r
  Index          = 0;\r
  FileSize       = 0;\r
  BytesRead      = 0;\r
  FfsImage       = NULL;\r
  FfsFile        = NULL;\r
\r
  MaxFileNameLen = strlen (FolderName) + MAX_FILENAME_LEN;\r
  CurFolderName  = (CHAR8 *)calloc(\r
                     strlen (FolderName) + strlen (OS_SEP_STR) + strlen ("*.*")+ 1,\r
                     sizeof(CHAR8)\r
                     );\r
  if (CurFolderName == NULL) {\r
    return EFI_BUFFER_TOO_SMALL;\r
  }\r
  strcpy (CurFolderName, FolderName);\r
  strcat (CurFolderName, OS_SEP_STR);\r
  strcat (CurFolderName, "*.*");\r
  FileName = (CHAR8 *)calloc(\r
               MaxFileNameLen,\r
               sizeof(CHAR8)\r
               );\r
  if (FileName == NULL) {\r
    free (CurFolderName);\r
    return EFI_BUFFER_TOO_SMALL;\r
  }\r
\r
#ifndef __GNUC__\r
  if((FindHandle = FindFirstFile(CurFolderName, &FindFileData)) != INVALID_HANDLE_VALUE){\r
    do {\r
      memset (FileName, 0, MaxFileNameLen);\r
      if ((strcmp (FindFileData.cFileName, ".") == 0)\r
      || (strcmp (FindFileData.cFileName, "..") == 0)\r
      ) {\r
        continue;\r
      }\r
      if (strlen(FolderName) + strlen ("\\") + strlen (FindFileData.cFileName) > MAX_FILENAME_LEN - 1) {\r
        Status = EFI_ABORTED;\r
        goto Done;\r
      }\r
      snprintf (FileNameArry, MAX_FILENAME_LEN, "%s%c%s", FolderName, OS_SEP, FindFileData.cFileName);\r
      FfsFile = fopen (FileNameArry, "rb");\r
      if (FfsFile == NULL) {\r
        Status = EFI_ABORTED;\r
        goto Done;\r
      }\r
      Status = ReadFfsHeader (FfsFile, (UINT32 *)&FileSize);\r
      if (EFI_ERROR (Status)) {\r
        fclose (FfsFile);\r
        Status  = EFI_SUCCESS;\r
        continue;\r
      }\r
      //\r
      // Allocate a buffer for the FFS file\r
      //\r
      FfsImage = malloc (FileSize);\r
      if (FfsImage == NULL) {\r
        fclose (FfsFile);\r
        Status = EFI_BUFFER_TOO_SMALL;\r
        goto Done;\r
      }\r
      //\r
      // Seek to the start of the image, then read the entire FV to the buffer\r
      //\r
      fseek (FfsFile, 0, SEEK_SET);\r
      BytesRead = fread (FfsImage, 1, FileSize, FfsFile);\r
      fclose (FfsFile);\r
\r
      if ((UINTN) BytesRead != FileSize) {\r
        free (FfsImage);\r
        Status = EFI_ABORTED;\r
        goto Done;\r
      }\r
      //\r
      // Check whether exists the storage ffs in BFV for multi-platform mode\r
      //\r
      if (CompareGuid(&gEfiFfsBfvForMultiPlatformGuid,(EFI_GUID *) FfsImage) == 0) {\r
        *ExistStorageInBfv            = TRUE;\r
      *SizeOptimized                = FALSE;\r
        gEfiFdInfo.StorageFfsInBfv    = FfsImage;\r
        continue;\r
      }\r
    //\r
      // Check whether exists the optimized storage ffs in BFV for multi-platform mode\r
      //\r
      if (CompareGuid(&gEfiFfsBfvForMultiPlatformGuid2,(EFI_GUID *) FfsImage) == 0) {\r
        *ExistStorageInBfv            = TRUE;\r
    *SizeOptimized                = TRUE;\r
        gEfiFdInfo.StorageFfsInBfv    = FfsImage;\r
        continue;\r
      }\r
      //\r
      // Check whether current FFS includes IFR\r
      //\r
      Status = GetAddressByGuid (\r
                 FfsImage,\r
                 &gVfrArrayAttractGuid,\r
                 FileSize,\r
                 NULL,\r
                 NULL\r
                );\r
      if (EFI_ERROR (Status)) {\r
        free (FfsImage);\r
        Status  = EFI_SUCCESS;\r
      } else {\r
       //\r
       // Check whether existed same IFR binary. If existed, not insert the new one.\r
       //\r
       if (NotExistSameFfsIfr (FfsImage)) {\r
         gEfiFdInfo.FfsArray[Index] = FfsImage;\r
         gEfiFdInfo.Length[Index++] = FileSize;\r
       }\r
      }\r
\r
    } while (FindNextFile (FindHandle, &FindFileData));\r
    FindClose(FindHandle);\r
  } else {\r
    Status = EFI_ABORTED;\r
    goto Done;\r
  }\r
\r
Done:\r
  free (CurFolderName);\r
  free (FileName);\r
\r
#else\r
  if((pDir = opendir(FolderName)) != NULL){\r
    while ((pDirent = readdir(pDir)) != NULL){\r
      memset (FileName, 0, MaxFileNameLen);\r
      if ((strcmp (pDirent->d_name, ".") == 0)\r
      || (strcmp (pDirent->d_name, "..") == 0)\r
      ) {\r
        continue;\r
      }\r
      sprintf (FileNameArry, "%s%c%s", FolderName, OS_SEP, pDirent->d_name);\r
      FfsFile = fopen (FileNameArry, "rb");\r
      Status = ReadFfsHeader (FfsFile, (UINT32 *)&FileSize);\r
      if (EFI_ERROR (Status)) {\r
        fclose (FfsFile);\r
        Status  = EFI_SUCCESS;\r
        continue;\r
      }\r
      //\r
      // Allocate a buffer for the FFS file\r
      //\r
      FfsImage = malloc (FileSize);\r
      if (FfsImage == NULL) {\r
        fclose (FfsFile);\r
        Status = EFI_BUFFER_TOO_SMALL;\r
        goto Done;\r
      }\r
      //\r
      // Seek to the start of the image, then read the entire FV to the buffer\r
      //\r
      fseek (FfsFile, 0, SEEK_SET);\r
      BytesRead = fread (FfsImage, 1, FileSize, FfsFile);\r
      fclose (FfsFile);\r
\r
      if ((UINTN) BytesRead != FileSize) {\r
        free (FfsImage);\r
        Status = EFI_ABORTED;\r
        goto Done;\r
      }\r
      //\r
      // Check whether exists the storage ffs in BFV for multi-platform mode\r
      //\r
      if (CompareGuid(&gEfiFfsBfvForMultiPlatformGuid,(EFI_GUID *) FfsImage) == 0) {\r
        *ExistStorageInBfv            = TRUE;\r
        *SizeOptimized                = FALSE;\r
        gEfiFdInfo.StorageFfsInBfv    = FfsImage;\r
        continue;\r
      }\r
      //\r
      // Check whether exists the optimized storage ffs in BFV for multi-platform mode\r
      //\r
      if (CompareGuid(&gEfiFfsBfvForMultiPlatformGuid2,(EFI_GUID *) FfsImage) == 0) {\r
        *ExistStorageInBfv            = TRUE;\r
        *SizeOptimized                = TRUE;\r
        gEfiFdInfo.StorageFfsInBfv    = FfsImage;\r
        continue;\r
      }\r
      //\r
      // Check whether current FFS includes IFR\r
      //\r
      Status = GetAddressByGuid (\r
                 FfsImage,\r
                 &gVfrArrayAttractGuid,\r
                 FileSize,\r
                 NULL,\r
                 NULL\r
                );\r
      if (EFI_ERROR (Status)) {\r
        free (FfsImage);\r
        Status  = EFI_SUCCESS;\r
      } else {\r
       //\r
       // Check whether existed same IFR binary. If existed, not insert the new one.\r
       //\r
       if (NotExistSameFfsIfr (FfsImage)) {\r
         gEfiFdInfo.FfsArray[Index] = FfsImage;\r
         gEfiFdInfo.Length[Index++] = FileSize;\r
       }\r
      }\r
\r
    }\r
    closedir(pDir);\r
  } else {\r
    Status = EFI_ABORTED;\r
    goto Done;\r
  }\r
\r
Done:\r
  free (CurFolderName);\r
  free (FileName);\r
#endif\r
  return Status;\r
}\r
\r