From dc7b0dc8d662b3bedece2cf1015e2a94884cb111 Mon Sep 17 00:00:00 2001 From: Shenglei Zhang Date: Wed, 29 May 2019 15:22:32 +0800 Subject: [PATCH] BaseTools/BfmLib: Add a tool BfmLib BmfLib is added for FCE tool. https://bugzilla.tianocore.org/show_bug.cgi?id=1848 Cc: Bob Feng Cc: Liming Gao Signed-off-by: Shenglei Zhang Reviewed-by: Bob Feng --- BaseTools/BinWrappers/PosixLike/BfmLib | 29 + BaseTools/Source/C/BfmLib/BfmLib.c | 4355 ++++++++++++++++++++ BaseTools/Source/C/BfmLib/BinFileManager.c | 1024 +++++ BaseTools/Source/C/BfmLib/BinFileManager.h | 439 ++ BaseTools/Source/C/BfmLib/GNUmakefile | 15 + BaseTools/Source/C/BfmLib/Makefile | 17 + BaseTools/Source/C/GNUmakefile | 1 + BaseTools/Source/C/Makefile | 1 + 8 files changed, 5881 insertions(+) create mode 100755 BaseTools/BinWrappers/PosixLike/BfmLib create mode 100644 BaseTools/Source/C/BfmLib/BfmLib.c create mode 100644 BaseTools/Source/C/BfmLib/BinFileManager.c create mode 100644 BaseTools/Source/C/BfmLib/BinFileManager.h create mode 100644 BaseTools/Source/C/BfmLib/GNUmakefile create mode 100644 BaseTools/Source/C/BfmLib/Makefile diff --git a/BaseTools/BinWrappers/PosixLike/BfmLib b/BaseTools/BinWrappers/PosixLike/BfmLib new file mode 100755 index 0000000000..a244ecc095 --- /dev/null +++ b/BaseTools/BinWrappers/PosixLike/BfmLib @@ -0,0 +1,29 @@ +#!/usr/bin/env bash + +full_cmd=${BASH_SOURCE:-$0} # see http://mywiki.wooledge.org/BashFAQ/028 for a discussion of why $0 is not a good choice here +dir=$(dirname "$full_cmd") +cmd=${full_cmd##*/} + +if [ -n "$WORKSPACE" ] && [ -e "$WORKSPACE/Conf/BaseToolsCBinaries" ] +then + exec "$WORKSPACE/Conf/BaseToolsCBinaries/$cmd" +elif [ -n "$WORKSPACE" ] && [ -e "$EDK_TOOLS_PATH/Source/C" ] +then + if [ ! -e "$EDK_TOOLS_PATH/Source/C/bin/$cmd" ] + then + echo "BaseTools C Tool binary was not found ($cmd)" + echo "You may need to run:" + echo " make -C $EDK_TOOLS_PATH/Source/C" + else + exec "$EDK_TOOLS_PATH/Source/C/bin/$cmd" "$@" + fi +elif [ -e "$dir/../../Source/C/bin/$cmd" ] +then + exec "$dir/../../Source/C/bin/$cmd" "$@" +else + echo "Unable to find the real '$cmd' to run" + echo "This message was printed by" + echo " $0" + exit 127 +fi + diff --git a/BaseTools/Source/C/BfmLib/BfmLib.c b/BaseTools/Source/C/BfmLib/BfmLib.c new file mode 100644 index 0000000000..9dedda3da2 --- /dev/null +++ b/BaseTools/Source/C/BfmLib/BfmLib.c @@ -0,0 +1,4355 @@ +/** @file + + Library to process EFI image. + + Copyright (c) 2011-2019, Intel Corporation. All rights reserved.
+ SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +#include "BinFileManager.h" + +#define EFI_TEST_FFS_ATTRIBUTES_BIT(FvbAttributes, TestAttributes, Bit) \ + ( \ + (BOOLEAN) ( \ + (FvbAttributes & EFI_FVB2_ERASE_POLARITY) ? (((~TestAttributes) & Bit) == Bit) : ((TestAttributes & Bit) == Bit) \ + ) \ + ) + +#ifndef __GNUC__ +#define DECODE_STR "%s -d -o \"%s\" \"%s\" > NUL" +#define ENCODE_STR "%s -e \"%s\" -o \"%s\" > NUL" +#define GENSEC_COMPRESSION "GenSec -s %s -c %s \"%s\" -o \"%s\" > NUL" +#define GENSEC_GUID "GenSec -s %s -r PROCESSING_REQUIRED -g %s \"%s\" -o \"%s\" > NUL" +#define GENSEC_STR "GenSec -s %s \"%s\" -o \"%s\" > NUL" +#define GENSEC_ALIGN "GenSec --sectionalign 16 \"%s\" -o \"%s\" > NUL" +#define GENFV_STR "GenFv -i \"%s\" -o \"%s\" > NUL" +#define GENFV_FVGUID "GenFv -i \"%s\" -o \"%s\" --FvNameGuid %s > NUL" +#define GENFV_FFS "GenFv -f \"%s\" -g %s -o \"%s\" > NUL" +#define GENFFS_STR "GenFfs -t %s -i \"%s\" -g %s -o \"%s\" > NUL" +#define GENFFS_FIX "GenFfs -t %s -i \"%s\" -g %s -x -o \"%s\" > NUL" +#else +#define DECODE_STR "%s -d -o \"%s\" \"%s\" > /dev/null" +#define ENCODE_STR "%s -e \"%s\" -o \"%s\" > /dev/null" +#define GENSEC_COMPRESSION "GenSec -s %s -c %s \"%s\" -o \"%s\" > /dev/null" +#define GENSEC_GUID "GenSec -s %s -r PROCESSING_REQUIRED -g %s \"%s\" -o \"%s\" > /dev/null" +#define GENSEC_STR "GenSec -s %s \"%s\" -o \"%s\" > /dev/null" +#define GENSEC_ALIGN "GenSec --sectionalign 16 \"%s\" -o \"%s\" > /dev/null" +#define GENFV_STR "GenFv -i \"%s\" -o \"%s\" > /dev/null" +#define GENFV_FVGUID "GenFv -i \"%s\" -o \"%s\" --FvNameGuid %s > /dev/null" +#define GENFV_FFS "GenFv -f \"%s\" -g %s -o \"%s\" > /dev/null" +#define GENFFS_STR "GenFfs -t %s -i \"%s\" -g %s -o \"%s\" > /dev/null" +#define GENFFS_FIX "GenFfs -t %s -i \"%s\" -g %s -x -o \"%s\" > /dev/null" +#endif + +#define DECODE_STR_ERR "%s -d -o \"%s\" \"%s\" " +#define ENCODE_STR_ERR "%s -e \"%s\" -o \"%s\" " + +CHAR8 mFirmwareFileSystem2Guid[16] = {0x78, 0xE5, 0x8C, 0x8C, 0x3D, 0x8A, 0x1C, 0x4F, 0x99, 0x35, 0x89, 0x61, 0x85, 0xC3, 0x2D, 0xD3}; + +CHAR8 mFirmwareFileSystem3Guid[16] = {0x7A, 0xC0, 0x73, 0x54, 0xCB, 0x3D, 0xCA, 0x4D, 0xBD, 0x6F, 0x1E, 0x96, 0x89, 0xE7, 0x34, 0x9A }; +extern CHAR8* mGuidToolDefinition; +UINT32 PadSizeOfBfv; + +static CHAR8 *mSectionTypeName[] = { + NULL, // 0x00 - reserved + "EFI_SECTION_COMPRESSION", // 0x01 + "EFI_SECTION_GUID_DEFINED", // 0x02 + NULL, // 0x03 - reserved + NULL, // 0x04 - reserved + NULL, // 0x05 - reserved + NULL, // 0x06 - reserved + NULL, // 0x07 - reserved + NULL, // 0x08 - reserved + NULL, // 0x09 - reserved + NULL, // 0x0A - reserved + NULL, // 0x0B - reserved + NULL, // 0x0C - reserved + NULL, // 0x0D - reserved + NULL, // 0x0E - reserved + NULL, // 0x0F - reserved + "EFI_SECTION_PE32", // 0x10 + "EFI_SECTION_PIC", // 0x11 + "EFI_SECTION_TE", // 0x12 + "EFI_SECTION_DXE_DEPEX", // 0x13 + "EFI_SECTION_VERSION", // 0x14 + "EFI_SECTION_USER_INTERFACE", // 0x15 + "EFI_SECTION_COMPATIBILITY16", // 0x16 + "EFI_SECTION_FIRMWARE_VOLUME_IMAGE", // 0x17 + "EFI_SECTION_FREEFORM_SUBTYPE_GUID", // 0x18 + "EFI_SECTION_RAW", // 0x19 + NULL, // 0x1A + "EFI_SECTION_PEI_DEPEX", // 0x1B + "EFI_SECTION_SMM_DEPEX" // 0x1C +}; + + +static CHAR8 *mFfsFileType[] = { + NULL, // 0x00 + "EFI_FV_FILETYPE_RAW", // 0x01 + "EFI_FV_FILETYPE_FREEFORM", // 0x02 + "EFI_FV_FILETYPE_SECURITY_CORE", // 0x03 + "EFI_FV_FILETYPE_PEI_CORE", // 0x04 + "EFI_FV_FILETYPE_DXE_CORE", // 0x05 + "EFI_FV_FILETYPE_PEIM", // 0x06 + "EFI_FV_FILETYPE_DRIVER", // 0x07 + "EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER", // 0x08 + "EFI_FV_FILETYPE_APPLICATION", // 0x09 + "EFI_FV_FILETYPE_SMM", // 0x0A + "EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE",// 0x0B + "EFI_FV_FILETYPE_COMBINED_SMM_DXE", // 0x0C + "EFI_FV_FILETYPE_SMM_CORE" // 0x0D + }; + +FV_INFORMATION * +LibInitializeFvStruct ( + FV_INFORMATION *Fv +) +{ + UINT32 Index; + + if (Fv == NULL) { + return NULL; + } + + memset (Fv, '\0', sizeof (FV_INFORMATION)); + + for (Index = 0; Index < MAX_NUMBER_OF_FILES_IN_FV; Index ++) { + memset (Fv->FfsAttuibutes[Index].FfsName, '\0', _MAX_PATH); + memset (Fv->FfsAttuibutes[Index].UiName, '\0', _MAX_PATH); + + Fv->FfsAttuibutes[Index].IsLeaf = TRUE; + Fv->FfsAttuibutes[Index].TotalSectionNum = 0; + } + + Fv->PatchData = NULL; + Fv->EncapData = NULL; + Fv->FvNext = NULL; + Fv->FvLevel = 0; + Fv->IsBfvFlag = FALSE; + Fv->IsInputFvFlag = FALSE; + + return Fv; +} + +/** + Generate the unique template filename. +**/ +CHAR8 * +GenTempFile ( + VOID + ) +{ + CHAR8 *TemString; + TemString = NULL; +#ifndef __GNUC__ + TemString = CloneString (tmpnam (NULL)); +#else + CHAR8 tmp[] = "/tmp/fileXXXXXX"; + UINTN Fdtmp; + Fdtmp = mkstemp(tmp); + TemString = CloneString(tmp); + close(Fdtmp); +#endif + return TemString; +} + +EFI_STATUS +LibFindFvInFd ( + IN FILE *InputFile, + IN OUT FIRMWARE_DEVICE **FdData +) +{ + FIRMWARE_DEVICE *LocalFdData; + UINT16 Index; + CHAR8 Ffs2Guid[16]; + CHAR8 SignatureCheck[4]; + CHAR8 Signature[5] = "_FVH"; + FV_INFORMATION *CurrentFv; + FV_INFORMATION *NewFoundFv; + BOOLEAN FirstMatch; + UINT32 FdSize; + UINT16 FvCount; + VOID *FdBuffer; + VOID *FdBufferOri; + UINT32 Count; + + + CurrentFv = NULL; + NewFoundFv = NULL; + FdBuffer = NULL; + FdBufferOri = NULL; + FirstMatch = TRUE; + Index = 0; + FdSize = 0; + FvCount = 0; + Count = 0; + LocalFdData = NULL; + + if (InputFile == NULL) { + return EFI_ABORTED; + } + + // + // Find each FVs in the FD + // + + fseek(InputFile,0,SEEK_SET); + fseek(InputFile,0,SEEK_END); + + FdSize = ftell(InputFile); + + fseek(InputFile,0,SEEK_SET); + // + // Create an FD structure to store useful information. + // + LocalFdData = (FIRMWARE_DEVICE *) calloc (sizeof (FIRMWARE_DEVICE), sizeof(UINT8)); + if (LocalFdData == NULL) { + return EFI_OUT_OF_RESOURCES; + } + LocalFdData->Fv = (FV_INFORMATION *) calloc (sizeof (FV_INFORMATION), sizeof(UINT8)); + if (LocalFdData->Fv == NULL) { + free (LocalFdData); + return EFI_OUT_OF_RESOURCES; + } + LibInitializeFvStruct (LocalFdData->Fv); + + // + // Readout the FD file data to buffer. + // + FdBuffer = malloc (FdSize); + + if (FdBuffer == NULL) { + free (LocalFdData->Fv); + free (LocalFdData); + return EFI_OUT_OF_RESOURCES; + } + + if (fread (FdBuffer, 1, FdSize, InputFile) != FdSize) { + free (LocalFdData->Fv); + free (LocalFdData); + free (FdBuffer); + return EFI_ABORTED; + } + + FdBufferOri = FdBuffer; + + for (Count=0; Count < FdSize - 4; Count++) { + // + // Copy 4 bytes of fd data to check the _FVH signature + // + memcpy (SignatureCheck, FdBuffer, 4); + FdBuffer =(UINT8 *)FdBuffer + 4; + + if (strncmp(SignatureCheck, Signature, 4) == 0){ + // + // Still need to determine the FileSystemGuid in EFI_FIRMWARE_VOLUME_HEADER equal to + // EFI_FIRMWARE_FILE_SYSTEM2_GUID. + // Turn back 28 bytes to find the GUID. + // + FdBuffer = (UINT8 *)FdBuffer - 28; + memcpy (Ffs2Guid, FdBuffer, 16); + + // + // Compare GUID. + // + for (Index = 0; Index < 16; Index ++) { + if (Ffs2Guid[Index] != mFirmwareFileSystem2Guid[Index]) { + break; + } + } + if (Index != 16) { + for (Index = 0; Index < 16; Index ++) { + if (Ffs2Guid[Index] != mFirmwareFileSystem3Guid[Index]) { + break; + } + } + } + + // + // Point to the original address + // + FdBuffer = (UINT8 *)FdBuffer + 28; + + // + // Here we found an FV. + // + if (Index == 16) { + if (FirstMatch) { + LocalFdData->Fv->ImageAddress = (UINTN)((UINT8 *)FdBuffer - (UINT8 *)FdBufferOri) - 0x2c; + CurrentFv = LocalFdData->Fv; + CurrentFv->FvNext = NULL; + // + // Store the FV name by found sequence + // + sprintf(CurrentFv->FvName, "FV%d", FvCount); + + FirstMatch = FALSE; + } else { + NewFoundFv = (FV_INFORMATION *) malloc (sizeof (FV_INFORMATION)); + if (NULL == NewFoundFv) { + free (LocalFdData->Fv); + free (LocalFdData); + free (FdBuffer); + return EFI_OUT_OF_RESOURCES; + } + + LibInitializeFvStruct (NewFoundFv); + + // + // Need to turn back 0x2c bytes + // + NewFoundFv->ImageAddress = (UINTN)((UINT8 *)FdBuffer - (UINT8 *)FdBufferOri) - 0x2c; + + // + // Store the FV name by found sequence + // + sprintf(NewFoundFv->FvName, "FV%d", FvCount); + + // + // Value it to NULL for found FV usage. + // + NewFoundFv->FvNext = NULL; + CurrentFv->FvNext = NewFoundFv; + + // + // Make the CurrentFv point to next FV. + // + CurrentFv = CurrentFv->FvNext; + } + + FvCount ++; + Index = 0; + } + + } + + // + // We need to turn back 3 bytes. + // + FdBuffer = (UINT8 *)FdBuffer - 3; + } + + LocalFdData->Size = FdSize; + + *FdData = LocalFdData; + + free (FdBufferOri); + + return EFI_SUCCESS; +} + +/* + Get size info from FV file. + + @param[in] + @param[out] + + @retval + +*/ +EFI_STATUS +LibGetFvSize ( + IN FILE *InputFile, + OUT UINT32 *FvSize + ) +{ + + UINTN BytesRead; + UINT32 Size; + EFI_FV_BLOCK_MAP_ENTRY BlockMap; + + BytesRead = 0; + Size = 0; + + if (InputFile == NULL || FvSize == NULL) { + return EFI_INVALID_PARAMETER; + } + + fseek (InputFile, sizeof (EFI_FIRMWARE_VOLUME_HEADER) - sizeof (EFI_FV_BLOCK_MAP_ENTRY), SEEK_CUR); + do { + fread (&BlockMap, sizeof (EFI_FV_BLOCK_MAP_ENTRY), 1, InputFile); + BytesRead += sizeof (EFI_FV_BLOCK_MAP_ENTRY); + + if (BlockMap.NumBlocks != 0) { + Size += BlockMap.NumBlocks * BlockMap.Length; + } + } while (!(BlockMap.NumBlocks == 0 && BlockMap.Length == 0)); + + + *FvSize = Size; + + return EFI_SUCCESS; +} + +/** + + Expands the 3 byte size commonly used in Firmware Volume data structures + + @param[in] Size - Address of the 3 byte array representing the size + + @return UINT32 + +**/ +UINT32 +FvBufExpand3ByteSize ( + IN VOID* Size + ) +{ + return (((UINT8*)Size)[2] << 16) + + (((UINT8*)Size)[1] << 8) + + ((UINT8*)Size)[0]; +} + +/** + + Clears out all files from the Fv buffer in memory + + @param[in] Fv - Address of the Fv in memory + + @return EFI_STATUS + +**/ +EFI_STATUS +FvBufGetSize ( + IN VOID *Fv, + OUT UINTN *Size + ) +{ + EFI_FIRMWARE_VOLUME_HEADER *hdr; + EFI_FV_BLOCK_MAP_ENTRY *blk; + + *Size = 0; + hdr = (EFI_FIRMWARE_VOLUME_HEADER*)Fv; + blk = hdr->BlockMap; + + while (blk->Length != 0 || blk->NumBlocks != 0) { + *Size = *Size + (blk->Length * blk->NumBlocks); + if (*Size >= 0x40000000) { + // + // If size is greater than 1GB, then assume it is corrupted + // + return EFI_VOLUME_CORRUPTED; + } + blk++; + } + + if (*Size == 0) { + // + // If size is 0, then assume the volume is corrupted + // + return EFI_VOLUME_CORRUPTED; + } + + return EFI_SUCCESS; +} +/** + + Iterates through the files contained within the firmware volume + + @param[in] Fv - Address of the Fv in memory + @param[in] Key - Should be 0 to get the first file. After that, it should be + passed back in without modifying it's contents to retrieve + subsequent files. + @param[in] File- Output file pointer + File == NULL - invalid parameter + otherwise - *File will be update to the location of the file + + @return EFI_STATUS + EFI_NOT_FOUND + EFI_VOLUME_CORRUPTED + +**/ +EFI_STATUS +FvBufFindNextFile ( + IN VOID *Fv, + IN OUT UINTN *Key, + OUT VOID **File + ) +{ + EFI_FIRMWARE_VOLUME_HEADER *hdr; + EFI_FFS_FILE_HEADER *fhdr; + EFI_FIRMWARE_VOLUME_EXT_HEADER *FwVolExtHeader; + EFI_FVB_ATTRIBUTES_2 FvbAttributes; + UINTN fsize; + EFI_STATUS Status; + UINTN fvSize; + + hdr = (EFI_FIRMWARE_VOLUME_HEADER*)Fv; + fhdr = NULL; + + if (Fv == NULL) { + return EFI_INVALID_PARAMETER; + } + + Status = FvBufGetSize (Fv, &fvSize); + if (EFI_ERROR (Status)) { + return Status; + } + + if (*Key == 0) { + if (hdr->ExtHeaderOffset != 0) { + // + // Searching for files starts on an 8 byte aligned boundary after the end of the Extended Header if it exists. + // + FwVolExtHeader = (EFI_FIRMWARE_VOLUME_EXT_HEADER *) ((UINT8 *) hdr + hdr->ExtHeaderOffset); + *Key = (UINTN)hdr->ExtHeaderOffset + FwVolExtHeader->ExtHeaderSize; + *Key = (UINTN)ALIGN_POINTER (*Key, 8); + } else { + *Key = hdr->HeaderLength; + } + } + + FvbAttributes = hdr->Attributes; + + for( + *Key = (UINTN)ALIGN_POINTER (*Key, 8); + (*Key + sizeof (*fhdr)) < fvSize; + *Key = (UINTN)ALIGN_POINTER (*Key, 8) + ) { + fhdr = (EFI_FFS_FILE_HEADER*) ((UINT8*)hdr + *Key); + fsize = GetFfsFileLength (fhdr); + if (!EFI_TEST_FFS_ATTRIBUTES_BIT( + FvbAttributes, + fhdr->State, + EFI_FILE_HEADER_VALID + ) || + EFI_TEST_FFS_ATTRIBUTES_BIT( + FvbAttributes, + fhdr->State, + EFI_FILE_HEADER_INVALID + ) + ) { + *Key = *Key + 1; + continue; + } else if( + EFI_TEST_FFS_ATTRIBUTES_BIT( + FvbAttributes, + fhdr->State, + EFI_FILE_MARKED_FOR_UPDATE + ) || + EFI_TEST_FFS_ATTRIBUTES_BIT( + FvbAttributes, + fhdr->State, + EFI_FILE_DELETED + ) + ) { + *Key = *Key + fsize; + continue; + } else if (EFI_TEST_FFS_ATTRIBUTES_BIT( + FvbAttributes, + fhdr->State, + EFI_FILE_DATA_VALID + ) + ) { + *File = (UINT8*)hdr + *Key; + *Key = *Key + fsize; + return EFI_SUCCESS; + } + + *Key = *Key + 1; + } + + return EFI_NOT_FOUND; +} + +/* + Generate the leaf FFS files. + +*/ +EFI_STATUS +LibGenFfsFile ( + EFI_FFS_FILE_HEADER2 *CurrentFile, + FV_INFORMATION *CurrentFv, + CHAR8 *FvName, + UINT8 Level, + UINT32 *FfsCount, + BOOLEAN ErasePolarity +) +{ + UINT32 FfsFileSize; + CHAR8 *FfsFileName; + FILE *FfsFile; + CHAR8 *TempDir; + CHAR8 TempBuf[_MAX_PATH]; + + FfsFileSize = 0; + FfsFileName = NULL; + FfsFile = NULL; + TempDir = NULL; + + TempDir = getcwd (NULL, _MAX_PATH); + + if (strlen (TempDir) + strlen (OS_SEP_STR) + strlen (TEMP_DIR_NAME) > _MAX_PATH - 1) { + printf ("The directory is too long \n"); + return EFI_ABORTED; + } + + strncat (TempDir, OS_SEP_STR, _MAX_PATH - strlen (TempDir) - 1); + strncat (TempDir, TEMP_DIR_NAME, _MAX_PATH - strlen (TempDir) - 1); + mkdir(TempDir, S_IRWXU | S_IRWXG | S_IRWXO); + + FfsFileName = (CHAR8 *) malloc (_MAX_PATH); + if (NULL == FfsFileName) { + return EFI_ABORTED; + } + memset (FfsFileName, '\0', _MAX_PATH); + FfsFileSize = GetFfsFileLength ((EFI_FFS_FILE_HEADER *) CurrentFile); + + sprintf ( + TempBuf, + "-Num%d-%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X-Level%d", + *FfsCount, + (unsigned) CurrentFile->Name.Data1, + CurrentFile->Name.Data2, + CurrentFile->Name.Data3, + CurrentFile->Name.Data4[0], + CurrentFile->Name.Data4[1], + CurrentFile->Name.Data4[2], + CurrentFile->Name.Data4[3], + CurrentFile->Name.Data4[4], + CurrentFile->Name.Data4[5], + CurrentFile->Name.Data4[6], + CurrentFile->Name.Data4[7], + Level + ); + if (strlen (TempDir) + strlen (OS_SEP_STR) + strlen (TEMP_DIR_NAME) + strlen(TempBuf) > _MAX_PATH - 1) { + free(FfsFileName); + printf ("The directory is too long \n"); + return EFI_ABORTED; + } + strcpy (FfsFileName, TempDir); + strncat (FfsFileName, OS_SEP_STR, _MAX_PATH - strlen (FfsFileName) - 1); + strncat (FfsFileName, CurrentFv->FvName, _MAX_PATH - strlen (FfsFileName) - 1); + strncat (FfsFileName, TempBuf, _MAX_PATH - strlen (FfsFileName) - 1); + + memcpy (CurrentFv->FfsAttuibutes[*FfsCount].FfsName, FfsFileName, strlen(FfsFileName)); + + // + // Update current FFS files file state. + // + if (ErasePolarity) { + CurrentFile->State = (UINT8)~(CurrentFile->State); + } + + FfsFile = fopen (FfsFileName, "wb+"); + if (FfsFile == NULL) { + free(FfsFileName); + return EFI_ABORTED; + } + + if (fwrite (CurrentFile, 1, FfsFileSize, FfsFile) != FfsFileSize) { + fclose(FfsFile); + free(FfsFileName); + return EFI_ABORTED; + } + + fclose(FfsFile); + free(FfsFileName); + FfsFileName = NULL; + + CurrentFv->FfsNumbers = *FfsCount; + + *FfsCount += 1; + + if (ErasePolarity) { + CurrentFile->State = (UINT8)~(CurrentFile->State); + } + + return EFI_SUCCESS; +} + + +BOOLEAN +LibCheckPadFfsContainFvNameGuid ( + IN FV_INFORMATION *CurrentFv, + IN EFI_FFS_FILE_HEADER2 *CurrentFile +) +{ + UINT32 FfsFileSize; + UINT32 FfsDataSize; + EFI_GUID *FfsData; + ENCAP_INFO_DATA *LocalEncapData; + + LocalEncapData = NULL; + + FfsFileSize = GetFfsFileLength ((EFI_FFS_FILE_HEADER *) CurrentFile); + FfsDataSize = FfsFileSize - GetFfsHeaderLength ((EFI_FFS_FILE_HEADER *) CurrentFile); + FfsData = (EFI_GUID *) ((INT8 *)CurrentFile + GetFfsHeaderLength ((EFI_FFS_FILE_HEADER *) CurrentFile)); + + if (FfsDataSize == 0) { + return TRUE; + } + + LocalEncapData = CurrentFv->EncapData; + + do { + if (LocalEncapData->FvExtHeader != NULL) { + if (CompareGuid(FfsData, &LocalEncapData->FvExtHeader->FvName) == 0) { + return TRUE; + } + } + LocalEncapData = LocalEncapData->NextNode; + } while (LocalEncapData->NextNode != NULL); + + return FALSE; +} + +BOOLEAN +LibCheckPadFfsNotNull ( + IN EFI_FFS_FILE_HEADER2 *CurrentFile +) +{ + UINT32 FfsFileSize; + UINT32 FfsDataSize; + INT8 *FfsData; + + FfsFileSize = GetFfsFileLength ((EFI_FFS_FILE_HEADER *) CurrentFile); + FfsDataSize = FfsFileSize - GetFfsHeaderLength ((EFI_FFS_FILE_HEADER *) CurrentFile); + FfsData = (INT8 *)CurrentFile + GetFfsHeaderLength ((EFI_FFS_FILE_HEADER *) CurrentFile); + + if (FfsDataSize == 0) { + return FALSE; + } + + while (FfsDataSize > 0) { + if (((FfsData[FfsDataSize-1]) & 0xFF) != 0xFF) { + return TRUE; + } + FfsDataSize--; + } + + return FALSE; +} + +/** + Find a maximum length of free space in PAD FFS of Bfv. + + @PadFfsHeader - The header of PAD FFS file + + @return The length of free space + +**/ +UINT32 +GetBfvMaxFreeSpace ( + IN EFI_FFS_FILE_HEADER2 *PadFfsHeader + ) +{ + UINT32 FfsSize; + UINT32 Count; + UINT32 Index; + UINT32 MaxSize; + UINT32 HeaderSize; + + Index = 0; + MaxSize = 0; + + if (PadFfsHeader == NULL) { + return MaxSize; + } + + FfsSize = GetFfsFileLength ((EFI_FFS_FILE_HEADER *) PadFfsHeader); + HeaderSize = GetFfsHeaderLength ((EFI_FFS_FILE_HEADER *) PadFfsHeader); + + for (Count = HeaderSize; Count < FfsSize; Count++) { + if (((((INT8 *)PadFfsHeader)[Count]) & 0xFF) == 0xFF) { + Index++; + } else { + if (Index > MaxSize) { + MaxSize = Index; + } + Index = 0; + } + } + return MaxSize; +} + + +/** + + Get the Offset and data of PAD FFS file in FV file. + This function should be only called for find an PAD FFS contain additional data + (usually will contain FIT table data or reset vector.) + + BFV: + ---------------------- <- Low + | | + | | + ----------------------- + | FFSs ... | + ----------------------- + | | + | | + ----------------------- + | PAD FFS file | + | | + | reset vector | + | | + | FIT table | + ----------------------- + | SEC CORE | <- High + ----------------------- + +**/ + +EFI_STATUS +LibFindResetVectorAndFitTableData( + IN EFI_FIRMWARE_VOLUME_HEADER *FvImage, + IN EFI_FFS_FILE_HEADER2 *CurrentFile, + IN OUT FV_INFORMATION *CurrentFv +) +{ + UINT32 Count1; + UINT32 Count2; + UINT32 FfsFileSize; + BOOLEAN FfsFoundFlag; + UINT32 FfsOffset; + UINT32 DataOffset; + UINT32 HeaderSize; + PATCH_DATA_PAD_FFS *LocalPatchData; + + FfsFileSize = 0; + Count1 = 0; + Count2 = 0; + FfsOffset = 0; + DataOffset = 0; + FfsFoundFlag = FALSE; + LocalPatchData = NULL; + + if (CurrentFv == NULL || CurrentFile == NULL || FvImage == NULL) { + return EFI_ABORTED; + } + + FfsFileSize = GetFfsFileLength ((EFI_FFS_FILE_HEADER *) CurrentFile); + HeaderSize = GetFfsHeaderLength ((EFI_FFS_FILE_HEADER *) CurrentFile); + + for (Count1=0; Count1 < (FvImage->FvLength - FfsFileSize); Count1 ++) { + for (Count2=0; Count2 < FfsFileSize; Count2 ++) { + if (((INT8*)FvImage)[Count1 + Count2] != ((INT8 *) CurrentFile)[Count2]){ + break; + } + } + if (Count2 == FfsFileSize) { + FfsFoundFlag = TRUE; + FfsOffset = Count1; + break; + } + } + + if (FfsFoundFlag) { + // + // Find data in FFS file; + // Will skip FFS header; + // + for (Count1 = HeaderSize; Count1 < FfsFileSize; Count1++) { + if (((((INT8 *)CurrentFile)[Count1]) & 0xFF) != 0xFF) { + DataOffset = FfsOffset + Count1; + break; + } + } + + if (CurrentFv->PatchData == NULL) { + // + // First time found data. + // + CurrentFv->PatchData = (PATCH_DATA_PAD_FFS *) malloc (sizeof (PATCH_DATA_PAD_FFS)); + if (CurrentFv->PatchData == NULL) { + return EFI_ABORTED; + } + + CurrentFv->PatchData->Offset = DataOffset; + CurrentFv->PatchData->Data = malloc(FfsFileSize - Count1); + CurrentFv->PatchData->Length = FfsFileSize - Count1; + CurrentFv->PatchData->NextNode = NULL; + + if (CurrentFv->PatchData->Data == NULL) { + return EFI_ABORTED; + } + + memcpy (CurrentFv->PatchData->Data, (INT8 *)CurrentFile + Count1, FfsFileSize - Count1); + } else { + LocalPatchData = CurrentFv->PatchData; + + while (LocalPatchData->NextNode != NULL) { + LocalPatchData = LocalPatchData->NextNode; + } + + LocalPatchData = (PATCH_DATA_PAD_FFS *) malloc (sizeof (PATCH_DATA_PAD_FFS)); + + if (LocalPatchData == NULL) { + return EFI_ABORTED; + } + + LocalPatchData->Offset = DataOffset; + LocalPatchData->Data = malloc(FfsFileSize - Count1); + LocalPatchData->Length = FfsFileSize - Count1; + LocalPatchData->NextNode = NULL; + + if (LocalPatchData->Data == NULL) { + free (LocalPatchData); + return EFI_ABORTED; + } + + memcpy (LocalPatchData->Data, (INT8 *)CurrentFile + Count1, FfsFileSize - Count1); + while (CurrentFv->PatchData->NextNode != NULL) { + CurrentFv->PatchData = CurrentFv->PatchData->NextNode; + } + CurrentFv->PatchData->NextNode = LocalPatchData; + } + + } else { + return EFI_ABORTED; + } + + return EFI_SUCCESS; +} + +/* + Construct a set of blank chars based on the number. + + @param[in] Count The number of blank chars. + + @return A string contained the blank chars. + +*/ +CHAR8 * +LibConstructBlankChar ( + IN UINT8 Count +) +{ + CHAR8 *RetStr; + UINT8 Index; + + Index = 0; + RetStr = NULL; + + RetStr = (CHAR8 *) malloc (Count +1); + + if (NULL == RetStr) { + return NULL; + } + + memset (RetStr , '\0', Count + 1); + + for (Index=0; Index <= Count -1; Index ++) { + RetStr[Index] = ' '; + } + + return RetStr; + +} + +VOID +Unicode2AsciiString ( + IN CHAR16 *Source, + OUT CHAR8 *Destination + ) + /*++ + + Routine Description: + + Convert a null-terminated unicode string to a null-terminated ascii string. + + Arguments: + + Source - The pointer to the null-terminated input unicode string. + Destination - The pointer to the null-terminated output ascii string. + + Returns: + + N/A + + --*/ +{ + while (*Source != '\0') { + *(Destination++) = (CHAR8) *(Source++); + } + // + // End the ascii with a NULL. + // + *Destination = '\0'; +} + + +/** + + Parses EFI Sections, if the view flag turn on, then will collect FFS section information + and extract FFS files. + + @param[in] SectionBuffer - Buffer containing the section to parse. + @param[in] BufferLength - Length of SectionBuffer + @param[in, out] CurrentFv + @param[in] FvName + @param[in] CurrentFile + @param[in] Level + @param[in, out] FfsCount + @param[in] ViewFlag + @param[in] ErasePolarity + + @retval EFI_SECTION_ERROR - Problem with section parsing. + (a) compression errors + (b) unrecognized section + @retval EFI_UNSUPPORTED - Do not know how to parse the section. + @retval EFI_SUCCESS - Section successfully parsed. + @retval EFI_OUT_OF_RESOURCES - Memory allocation failed. + +--*/ +EFI_STATUS +LibParseSection ( + UINT8 *SectionBuffer, + UINT32 BufferLength, + FV_INFORMATION *CurrentFv, + CHAR8 *FvName, + EFI_FFS_FILE_HEADER2 *CurrentFile, + UINT8 Level, + UINT32 *FfsCount, + BOOLEAN ViewFlag, + BOOLEAN ErasePolarity, + BOOLEAN FfsGeneratedFlag + ) +{ + UINT32 ParsedLength; + UINT8 *Ptr; + UINT32 SectionLength; + UINT32 UiSectionLength; + EFI_SECTION_TYPE Type; + EFI_STATUS Status; + CHAR8 *ExtractionTool; + CHAR8 *ToolInputFile; + CHAR8 *ToolOutputFile; + CHAR8 *SystemCommand; + UINT8 *ToolOutputBuffer; + UINT32 ToolOutputLength; + CHAR16 *UIName; + UINT32 UINameSize; + BOOLEAN HasDepexSection; + UINT32 NumberOfSections; + BOOLEAN IsFfsGenerated; + ENCAP_INFO_DATA *LocalEncapData; + CHAR8 *BlankChar; + UINT8 *UncompressedBuffer; + UINT32 UncompressedLength; + UINT8 *CompressedBuffer; + UINT32 CompressedLength; + UINT8 CompressionType; + DECOMPRESS_FUNCTION DecompressFunction; + GETINFO_FUNCTION GetInfoFunction; + UINT32 DstSize; + UINT32 ScratchSize; + UINT8 *ScratchBuffer; + BOOLEAN EncapDataNeedUpdata; + CHAR8 *TempDir; + CHAR8 *ToolInputFileFullName; + CHAR8 *ToolOutputFileFullName; + UINT8 LargeHeaderOffset; + CHAR8 *UIFileName; + CHAR8 *ToolInputFileName; + CHAR8 *ToolOutputFileName; + + ParsedLength = 0; + ToolOutputLength = 0; + UINameSize = 0; + NumberOfSections = 0; + UncompressedLength = 0; + CompressedLength = 0; + CompressionType = 0; + DstSize = 0; + ScratchSize = 0; + Ptr = NULL; + ExtractionTool = NULL; + ToolInputFile = NULL; + ToolOutputFile = NULL; + SystemCommand = NULL; + ToolOutputBuffer = NULL; + UIName = NULL; + LocalEncapData = NULL; + BlankChar = NULL; + UncompressedBuffer = NULL; + CompressedBuffer = NULL; + ScratchBuffer = NULL; + TempDir = NULL; + ToolInputFileFullName = NULL; + ToolOutputFileFullName = NULL; + ToolInputFileName = NULL; + ToolOutputFileName = NULL; + HasDepexSection = FALSE; + IsFfsGenerated = FfsGeneratedFlag; + EncapDataNeedUpdata = TRUE; + LargeHeaderOffset = 0; + + + while (ParsedLength < BufferLength) { + Ptr = SectionBuffer + ParsedLength; + + SectionLength = FvBufExpand3ByteSize (((EFI_COMMON_SECTION_HEADER *) Ptr)->Size); + Type = ((EFI_COMMON_SECTION_HEADER *) Ptr)->Type; + + // + // This is sort of an odd check, but is necessary because FFS files are + // padded to a QWORD boundary, meaning there is potentially a whole section + // header worth of 0xFF bytes. + // + if (SectionLength == 0xffffff && Type == 0xff) { + ParsedLength += 4; + continue; + } + // + //If Size is 0xFFFFFF then ExtendedSize contains the size of the section. + // + if (SectionLength == 0xffffff) { + SectionLength = ((EFI_COMMON_SECTION_HEADER2 *) Ptr)->ExtendedSize; + LargeHeaderOffset = sizeof (EFI_COMMON_SECTION_HEADER2) - sizeof (EFI_COMMON_SECTION_HEADER); + } + + switch (Type) { + + case EFI_SECTION_FIRMWARE_VOLUME_IMAGE: + EncapDataNeedUpdata = TRUE; + + Level ++; + NumberOfSections ++; + + CurrentFv->FfsAttuibutes[*FfsCount].IsLeaf = FALSE; + + // + // Put in encapsulate data information. + // + LocalEncapData = CurrentFv->EncapData; + while (LocalEncapData->NextNode != NULL) { + if (LocalEncapData->Level == Level) { + EncapDataNeedUpdata = FALSE; + break; + } + LocalEncapData = LocalEncapData->NextNode; + } + + if (EncapDataNeedUpdata) { + // + // Put in this is an FFS with FV section + // + LocalEncapData = CurrentFv->EncapData; + while (LocalEncapData->NextNode != NULL) { + LocalEncapData = LocalEncapData->NextNode; + } + + // + // Construct the new ENCAP_DATA + // + LocalEncapData->NextNode = (ENCAP_INFO_DATA *) malloc (sizeof (ENCAP_INFO_DATA)); + + if (LocalEncapData->NextNode == NULL) { + return EFI_ABORTED; + } + + LocalEncapData = LocalEncapData->NextNode; + + LocalEncapData->Level = Level; + LocalEncapData->Type = BFM_ENCAP_TREE_FV_SECTION; + + // + // We don't need additional data for encapsulate this FFS but type. + // + LocalEncapData->Data = NULL; + LocalEncapData->FvExtHeader = NULL; + LocalEncapData->NextNode = NULL; + } + + Status = LibGetFvInfo ((UINT8*)((EFI_FIRMWARE_VOLUME_IMAGE_SECTION*)Ptr + 1) + LargeHeaderOffset, CurrentFv, FvName, Level, FfsCount, ViewFlag, TRUE); + if (EFI_ERROR (Status)) { + return EFI_SECTION_ERROR; + } + break; + + case EFI_SECTION_COMPRESSION: + Level ++; + NumberOfSections ++; + + EncapDataNeedUpdata = TRUE; + // + // Put in encapsulate data information. + // + LocalEncapData = CurrentFv->EncapData; + while (LocalEncapData->NextNode != NULL) { + if (LocalEncapData->Level == Level) { + EncapDataNeedUpdata = FALSE; + break; + } + LocalEncapData = LocalEncapData->NextNode; + } + + if (EncapDataNeedUpdata) { + // + // Put in this is an FFS with FV section + // + LocalEncapData = CurrentFv->EncapData; + while (LocalEncapData->NextNode != NULL) { + LocalEncapData = LocalEncapData->NextNode; + } + + // + // Construct the new ENCAP_DATA + // + LocalEncapData->NextNode = (ENCAP_INFO_DATA *) malloc (sizeof (ENCAP_INFO_DATA)); + + if (LocalEncapData->NextNode == NULL) { + return EFI_ABORTED; + } + + LocalEncapData = LocalEncapData->NextNode; + + LocalEncapData->Level = Level; + LocalEncapData->Type = BFM_ENCAP_TREE_COMPRESS_SECTION; + + // + // Store the compress type + // + LocalEncapData->Data = malloc (sizeof (UINT8)); + + if (LocalEncapData->Data == NULL) { + return EFI_OUT_OF_RESOURCES; + } + + *(UINT8 *)LocalEncapData->Data = ((EFI_COMPRESSION_SECTION *) (Ptr + LargeHeaderOffset))->CompressionType; + LocalEncapData->FvExtHeader = NULL; + LocalEncapData->NextNode = NULL; + } + + // + // Process compressed section + // + CurrentFv->FfsAttuibutes[*FfsCount].IsLeaf = FALSE; + + UncompressedBuffer = NULL; + CompressedLength = SectionLength - sizeof (EFI_COMPRESSION_SECTION) - LargeHeaderOffset; + UncompressedLength = ((EFI_COMPRESSION_SECTION *) (Ptr + LargeHeaderOffset))->UncompressedLength; + CompressionType = ((EFI_COMPRESSION_SECTION *) (Ptr + LargeHeaderOffset))->CompressionType; + + if (CompressionType == EFI_NOT_COMPRESSED) { + + if (CompressedLength != UncompressedLength) { + printf ("Error. File is not compressed, but the compressed length does not match the uncompressed length.\n"); + return EFI_SECTION_ERROR; + } + + UncompressedBuffer = Ptr + sizeof (EFI_COMPRESSION_SECTION) + LargeHeaderOffset; + } else if (CompressionType == EFI_STANDARD_COMPRESSION) { + GetInfoFunction = EfiGetInfo; + DecompressFunction = EfiDecompress; + + CompressedBuffer = Ptr + sizeof (EFI_COMPRESSION_SECTION) + LargeHeaderOffset; + + Status = GetInfoFunction (CompressedBuffer, CompressedLength, &DstSize, &ScratchSize); + if (EFI_ERROR (Status)) { + return EFI_SECTION_ERROR; + } + + if (DstSize != UncompressedLength) { + return EFI_SECTION_ERROR; + } + + ScratchBuffer = malloc (ScratchSize); + if (ScratchBuffer == NULL) { + return EFI_OUT_OF_RESOURCES; + } + UncompressedBuffer = malloc (UncompressedLength); + + if (UncompressedBuffer == NULL) { + free (ScratchBuffer); + return EFI_OUT_OF_RESOURCES; + } + // + // Decompress the section. + // + Status = DecompressFunction ( + CompressedBuffer, + CompressedLength, + UncompressedBuffer, + UncompressedLength, + ScratchBuffer, + ScratchSize + ); + free (ScratchBuffer); + if (EFI_ERROR (Status)) { + free (UncompressedBuffer); + return EFI_SECTION_ERROR; + } + } else { + return EFI_SECTION_ERROR; + } + + Status = LibParseSection ( UncompressedBuffer, + UncompressedLength, + CurrentFv, + FvName, + CurrentFile, + Level, + FfsCount, + ViewFlag, + ErasePolarity, + IsFfsGenerated); + + if (CompressionType == EFI_STANDARD_COMPRESSION) { + // + // We need to deallocate Buffer + // + free (UncompressedBuffer); + } + + if (EFI_ERROR (Status)) { + return EFI_SECTION_ERROR; + } + + break; + + case EFI_SECTION_GUID_DEFINED: + // + // Process GUID defined + // looks up the appropriate tool to use for extracting + // a GUID defined FV section. + // + Level ++; + NumberOfSections++; + + EncapDataNeedUpdata = TRUE; + // + // Put in encapsulate data information. + // + LocalEncapData = CurrentFv->EncapData; + while (LocalEncapData->NextNode != NULL) { + if (LocalEncapData->Level == Level) { + EncapDataNeedUpdata = FALSE; + break; + } + LocalEncapData = LocalEncapData->NextNode; + } + if (EncapDataNeedUpdata) { + + // + // Put in this is an FFS with FV section + // + LocalEncapData = CurrentFv->EncapData; + while (LocalEncapData->NextNode != NULL) { + LocalEncapData = LocalEncapData->NextNode; + } + + // + // Construct the new ENCAP_DATA + // + LocalEncapData->NextNode = (ENCAP_INFO_DATA *) malloc (sizeof (ENCAP_INFO_DATA)); + + if (LocalEncapData->NextNode == NULL) { + return EFI_ABORTED; + } + + LocalEncapData = LocalEncapData->NextNode; + + LocalEncapData->Level = Level; + LocalEncapData->Type = BFM_ENCAP_TREE_GUIDED_SECTION; + + // + // We don't need additional data for encapsulate this FFS but type. + // + + LocalEncapData->Data = (EFI_GUID *) malloc (sizeof (EFI_GUID)); + + if (LocalEncapData->Data == NULL) { + return EFI_ABORTED; + } + + memcpy (LocalEncapData->Data, &((EFI_GUID_DEFINED_SECTION *) (Ptr + LargeHeaderOffset))->SectionDefinitionGuid, sizeof (EFI_GUID)); + + LocalEncapData->FvExtHeader = NULL; + LocalEncapData->NextNode = NULL; + } + + CurrentFv->FfsAttuibutes[*FfsCount].IsLeaf = FALSE; + + ExtractionTool = + LookupGuidedSectionToolPath ( + mParsedGuidedSectionTools, + &((EFI_GUID_DEFINED_SECTION *) (Ptr + LargeHeaderOffset))->SectionDefinitionGuid + ); + + if ((((EFI_GUID_DEFINED_SECTION *) (Ptr + LargeHeaderOffset))->Attributes & EFI_GUIDED_SECTION_PROCESSING_REQUIRED) == 0) { + // + // Not require process, directly gets data. + // + Status = LibParseSection ( + Ptr + ((EFI_GUID_DEFINED_SECTION *) (Ptr + LargeHeaderOffset))->DataOffset, + SectionLength - ((EFI_GUID_DEFINED_SECTION *) (Ptr + LargeHeaderOffset))->DataOffset, + CurrentFv, + FvName, + CurrentFile, + Level, + FfsCount, + ViewFlag, + ErasePolarity, + IsFfsGenerated + ); + if (ExtractionTool != NULL) { + free (ExtractionTool); + ExtractionTool = NULL; + } + if (EFI_ERROR (Status)) { + return EFI_SECTION_ERROR; + } + } else if (ExtractionTool != NULL) { + + TempDir = getcwd (NULL, _MAX_PATH); + if (strlen (TempDir) + strlen (OS_SEP_STR) + strlen (TEMP_DIR_NAME) > _MAX_PATH - 1) { + printf ("The directory is too long \n"); + free (ExtractionTool); + return EFI_ABORTED; + } + strncat (TempDir, OS_SEP_STR, _MAX_PATH - strlen (TempDir) - 1); + strncat (TempDir, TEMP_DIR_NAME, _MAX_PATH - strlen (TempDir) - 1); + mkdir(TempDir, S_IRWXU | S_IRWXG | S_IRWXO); + + ToolInputFile = GenTempFile (); + ToolOutputFile = GenTempFile (); + ToolInputFileName = strrchr(ToolInputFile, OS_SEP); + ToolOutputFileName = strrchr(ToolOutputFile, OS_SEP); + + ToolInputFileFullName = malloc (strlen("%s%s") + strlen(TempDir) + strlen(ToolInputFileName) + 1); + if (ToolInputFileFullName == NULL) { + free (ExtractionTool); + free (ToolInputFile); + free (ToolOutputFile); + return EFI_OUT_OF_RESOURCES; + } + ToolOutputFileFullName = malloc (strlen("%s%s") + strlen(TempDir) + strlen(ToolOutputFileName) + 1); + if (ToolOutputFileFullName == NULL) { + free (ToolInputFileFullName); + free (ExtractionTool); + free (ToolInputFile); + free (ToolOutputFile); + return EFI_OUT_OF_RESOURCES; + } + + sprintf (ToolInputFileFullName, "%s%s", TempDir, ToolInputFileName); + sprintf (ToolOutputFileFullName, "%s%s", TempDir, ToolOutputFileName); + + // + // Construction 'system' command string + // + SystemCommand = malloc ( + strlen (DECODE_STR) + + strlen (ExtractionTool) + + strlen (ToolInputFileFullName) + + strlen (ToolOutputFileFullName) + + 1 + ); + if (SystemCommand == NULL) { + free (ToolInputFile); + free (ToolOutputFile); + free (ToolInputFileFullName); + free (ToolOutputFileFullName); + free (ExtractionTool); + return EFI_OUT_OF_RESOURCES; + } + sprintf ( + SystemCommand, + DECODE_STR, + ExtractionTool, + ToolOutputFileFullName, + ToolInputFileFullName + ); + + Status = PutFileImage ( + ToolInputFileFullName, + (CHAR8*) Ptr + ((EFI_GUID_DEFINED_SECTION *) (Ptr + LargeHeaderOffset))->DataOffset, + SectionLength - ((EFI_GUID_DEFINED_SECTION *) (Ptr + LargeHeaderOffset))->DataOffset + ); + + if (HasDepexSection) { + HasDepexSection = FALSE; + } + + if (EFI_ERROR (Status)) { + free(SystemCommand); + free (ToolOutputFileFullName); + free (ToolOutputFile); + remove (ToolInputFileFullName); + free (ToolInputFile); + free (ToolInputFileFullName); + return EFI_SECTION_ERROR; + } + + if (system (SystemCommand) != EFI_SUCCESS) { + SystemCommand = malloc ( + strlen (DECODE_STR_ERR) + + strlen (ExtractionTool) + + strlen (ToolInputFileFullName) + + strlen (ToolOutputFileFullName) + + 1 + ); + if (SystemCommand == NULL) { + free (ExtractionTool); + LibRmDir (TempDir); + remove (ToolInputFileFullName); + free (ToolInputFile); + free (ToolInputFileFullName); + free (ToolOutputFileFullName); + free (ToolOutputFile); + return EFI_OUT_OF_RESOURCES; + } + sprintf ( + SystemCommand, + DECODE_STR_ERR, + ExtractionTool, + ToolOutputFileFullName, + ToolInputFileFullName + ); + system (SystemCommand); + printf("Command failed: %s\n", SystemCommand); + free (ExtractionTool); + ExtractionTool = NULL; + LibRmDir (TempDir); + free(SystemCommand); + remove (ToolInputFileFullName); + free (ToolInputFile); + free (ToolInputFileFullName); + free (ToolOutputFileFullName); + free (ToolOutputFile); + return EFI_ABORTED; + } + free (ExtractionTool); + ExtractionTool = NULL; + free (SystemCommand); + remove (ToolInputFileFullName); + free (ToolInputFile); + free (ToolInputFileFullName); + ToolInputFile = NULL; + ToolInputFileFullName = NULL; + + + Status = GetFileImage ( + ToolOutputFileFullName, + (CHAR8 **)&ToolOutputBuffer, + &ToolOutputLength + ); + remove (ToolOutputFileFullName); + free (ToolOutputFile); + free (ToolOutputFileFullName); + ToolOutputFile = NULL; + ToolOutputFileFullName = NULL; + + if (EFI_ERROR (Status)) { + return EFI_SECTION_ERROR; + } + + Status = LibParseSection ( + ToolOutputBuffer, + ToolOutputLength, + CurrentFv, + FvName, + CurrentFile, + Level, + FfsCount, + ViewFlag, + ErasePolarity, + IsFfsGenerated + ); + if (EFI_ERROR (Status)) { + return EFI_SECTION_ERROR; + } + } else { + // + // We don't know how to parse it now. + // + if (ExtractionTool != NULL) { + free (ExtractionTool); + ExtractionTool = NULL; + } + printf(" EFI_SECTION_GUID_DEFINED cannot be parsed at this time. Tool to decode this section should have been defined in %s file.\n", mGuidToolDefinition); + printf(" Its GUID is: "); + PrintGuid(&(((EFI_GUID_DEFINED_SECTION *)(Ptr + LargeHeaderOffset))->SectionDefinitionGuid)); + return EFI_UNSUPPORTED; + } + + break; + + // + //Leaf sections + // + case EFI_SECTION_RAW: + NumberOfSections ++; + CurrentFv->FfsAttuibutes[*FfsCount].Level = Level; + if (!ViewFlag) { + if (!IsFfsGenerated) { + LibGenFfsFile(CurrentFile, CurrentFv, FvName, Level, FfsCount, ErasePolarity); + IsFfsGenerated = TRUE; + } + } + + break; + case EFI_SECTION_PE32: + NumberOfSections ++; + CurrentFv->FfsAttuibutes[*FfsCount].Level = Level; + if (!ViewFlag) { + if (!IsFfsGenerated) { + LibGenFfsFile(CurrentFile, CurrentFv, FvName, Level, FfsCount, ErasePolarity); + IsFfsGenerated = TRUE; + } + } + + break; + case EFI_SECTION_PIC: + NumberOfSections ++; + CurrentFv->FfsAttuibutes[*FfsCount].Level = Level; + if (!ViewFlag) { + if (!IsFfsGenerated) { + LibGenFfsFile(CurrentFile, CurrentFv, FvName, Level, FfsCount, ErasePolarity); + IsFfsGenerated = TRUE; + } + } + + break; + case EFI_SECTION_TE: + NumberOfSections ++; + CurrentFv->FfsAttuibutes[*FfsCount].Level = Level; + if (!ViewFlag) { + if (!IsFfsGenerated) { + LibGenFfsFile(CurrentFile, CurrentFv, FvName, Level, FfsCount, ErasePolarity); + IsFfsGenerated = TRUE; + } + } + break; + + case EFI_SECTION_COMPATIBILITY16: + NumberOfSections ++; + CurrentFv->FfsAttuibutes[*FfsCount].Level = Level; + + if (!ViewFlag) { + if (!IsFfsGenerated) { + LibGenFfsFile(CurrentFile, CurrentFv, FvName, Level, FfsCount, ErasePolarity); + IsFfsGenerated = TRUE; + } + } + break; + + case EFI_SECTION_FREEFORM_SUBTYPE_GUID: + NumberOfSections ++; + CurrentFv->FfsAttuibutes[*FfsCount].Level = Level; + if (!ViewFlag) { + if (!IsFfsGenerated) { + LibGenFfsFile(CurrentFile, CurrentFv, FvName, Level, FfsCount, ErasePolarity); + IsFfsGenerated = TRUE; + } + } + break; + + case EFI_SECTION_VERSION: + NumberOfSections ++; + CurrentFv->FfsAttuibutes[*FfsCount].Level = Level; + break; + case EFI_SECTION_PEI_DEPEX: + NumberOfSections ++; + CurrentFv->FfsAttuibutes[*FfsCount].Level = Level; + HasDepexSection = TRUE; + break; + case EFI_SECTION_DXE_DEPEX: + NumberOfSections ++; + CurrentFv->FfsAttuibutes[*FfsCount].Level = Level; + HasDepexSection = TRUE; + break; + case EFI_SECTION_SMM_DEPEX: + NumberOfSections ++; + CurrentFv->FfsAttuibutes[*FfsCount].Level = Level; + HasDepexSection = TRUE; + break; + + case EFI_SECTION_USER_INTERFACE: + NumberOfSections ++; + CurrentFv->FfsAttuibutes[*FfsCount].Level = Level; + + UiSectionLength = FvBufExpand3ByteSize (((EFI_USER_INTERFACE_SECTION *) Ptr)->CommonHeader.Size); + if (UiSectionLength == 0xffffff) { + UiSectionLength = ((EFI_USER_INTERFACE_SECTION2 *) Ptr)->CommonHeader.ExtendedSize; + UINameSize = UiSectionLength - sizeof(EFI_COMMON_SECTION_HEADER2); + } else { + UINameSize = UiSectionLength - sizeof(EFI_COMMON_SECTION_HEADER); + } + + UIName = (CHAR16 *) malloc (UINameSize + 2); + if (UIName != NULL) { + memset (UIName, '\0', UINameSize + 2); + if (UiSectionLength >= 0xffffff) { + memcpy(UIName, ((EFI_USER_INTERFACE_SECTION2 *) Ptr)->FileNameString, UINameSize); + } else { + memcpy(UIName, ((EFI_USER_INTERFACE_SECTION *) Ptr)->FileNameString, UINameSize); + } + } else { + return EFI_ABORTED; + } + + BlankChar = LibConstructBlankChar( CurrentFv->FvLevel * 2); + if (BlankChar == NULL) { + free (UIName); + return EFI_ABORTED; + } + + if (ViewFlag) { + UIFileName = malloc (UINameSize + 2); + if (UIFileName == NULL) { + free(BlankChar); + free(UIName); + return EFI_OUT_OF_RESOURCES; + } + Unicode2AsciiString (UIName, UIFileName); + fprintf(stdout, "%sFile \"%s\"\n", BlankChar, UIFileName); + free(UIFileName); + } + + free (BlankChar); + BlankChar = NULL; + + // + // If Ffs file has been generated, then the FfsCount should decrease 1. + // + if (IsFfsGenerated) { + memcpy (CurrentFv->FfsAttuibutes[*FfsCount -1].UiName, UIName, UINameSize); + } else { + memcpy (CurrentFv->FfsAttuibutes[*FfsCount].UiName, UIName, UINameSize); + } + HasDepexSection = FALSE; + free(UIName); + UINameSize = 0; + + break; + default: + break; + } + + ParsedLength += SectionLength; + // + // We make then next section begin on a 4-byte boundary + // + ParsedLength = GetOccupiedSize (ParsedLength, 4); + } + + if (ParsedLength < BufferLength) { + return EFI_SECTION_ERROR; + } + + return EFI_SUCCESS; +} + +/** + + Add function description + + FvImage - add argument description + FileHeader - add argument description + ErasePolarity - add argument description + + EFI_SUCCESS - Add description for return value + EFI_ABORTED - Add description for return value + +**/ +EFI_STATUS +LibGetFileInfo ( + EFI_FIRMWARE_VOLUME_HEADER *FvImage, + EFI_FFS_FILE_HEADER2 *CurrentFile, + BOOLEAN ErasePolarity, + FV_INFORMATION *CurrentFv, + CHAR8 *FvName, + UINT8 Level, + UINT32 *FfsCount, + BOOLEAN ViewFlag + ) +{ + UINT32 FileLength; + UINT8 FileState; + UINT8 Checksum; + EFI_FFS_FILE_HEADER2 BlankHeader; + EFI_STATUS Status; + ENCAP_INFO_DATA *LocalEncapData; + BOOLEAN EncapDataNeedUpdateFlag; + UINT32 FfsFileHeaderSize; + + Status = EFI_SUCCESS; + + LocalEncapData = NULL; + EncapDataNeedUpdateFlag = TRUE; + + FfsFileHeaderSize = GetFfsHeaderLength ((EFI_FFS_FILE_HEADER *) CurrentFile); + FileLength = GetFfsFileLength ((EFI_FFS_FILE_HEADER *) CurrentFile); + + // + // Check if we have free space + // + if (ErasePolarity) { + memset (&BlankHeader, -1, FfsFileHeaderSize); + } else { + memset (&BlankHeader, 0, FfsFileHeaderSize); + } + + // + // Is this FV blank? + // + if (memcmp (&BlankHeader, CurrentFile, FfsFileHeaderSize) == 0) { + return EFI_SUCCESS; + } + + // + // Print file information. + // + FileState = GetFileState (ErasePolarity, (EFI_FFS_FILE_HEADER *)CurrentFile); + + if (FileState == EFI_FILE_DATA_VALID) { + // + // Calculate header checksum + // + Checksum = CalculateSum8 ((UINT8 *) CurrentFile, FfsFileHeaderSize); + Checksum = (UINT8) (Checksum - CurrentFile->IntegrityCheck.Checksum.File); + Checksum = (UINT8) (Checksum - CurrentFile->State); + if (Checksum != 0) { + return EFI_ABORTED; + } + + if (CurrentFile->Attributes & FFS_ATTRIB_CHECKSUM) { + // + // Calculate file checksum + // + Checksum = CalculateSum8 ((UINT8 *) ((UINTN)CurrentFile + FfsFileHeaderSize), FileLength - FfsFileHeaderSize); + Checksum = Checksum + CurrentFile->IntegrityCheck.Checksum.File; + if (Checksum != 0) { + return EFI_ABORTED; + } + } else { + if (CurrentFile->IntegrityCheck.Checksum.File != FFS_FIXED_CHECKSUM) { + return EFI_ABORTED; + } + } + } else { + return EFI_ABORTED; + } + + Level += 1; + + if (CurrentFile->Type != EFI_FV_FILETYPE_ALL) { + + // + // Put in encapsulate data information. + // + LocalEncapData = CurrentFv->EncapData; + while (LocalEncapData->NextNode != NULL) { + if (LocalEncapData->Level == Level) { + EncapDataNeedUpdateFlag = FALSE; + break; + } + LocalEncapData = LocalEncapData->NextNode; + } + + if (EncapDataNeedUpdateFlag) { + // + // Construct the new ENCAP_DATA + // + LocalEncapData->NextNode = (ENCAP_INFO_DATA *) malloc (sizeof (ENCAP_INFO_DATA)); + + if (LocalEncapData->NextNode == NULL) { + printf ("Out of resource, memory allocation failed. \n"); + return EFI_ABORTED; + } + + LocalEncapData = LocalEncapData->NextNode; + + LocalEncapData->Level = Level; + LocalEncapData->Type = BFM_ENCAP_TREE_FFS; + LocalEncapData->FvExtHeader = NULL; + + // + // Store the header of FFS file. + // + LocalEncapData->Data = malloc (FfsFileHeaderSize); + if (LocalEncapData->Data == NULL) { + printf ("Out of resource, memory allocation failed. \n"); + return EFI_ABORTED; + } + + memcpy (LocalEncapData->Data, CurrentFile, FfsFileHeaderSize); + + LocalEncapData->NextNode = NULL; + } + + if ( CurrentFile->Type == EFI_FV_FILETYPE_FREEFORM ){ + CurrentFv->FfsAttuibutes[*FfsCount].Level = Level; + if (!ViewFlag) { + LibGenFfsFile(CurrentFile, CurrentFv, FvName, Level, FfsCount, ErasePolarity); + } + }else if ( CurrentFile->Type == EFI_FV_FILETYPE_RAW){ + CurrentFv->FfsAttuibutes[*FfsCount].Level = Level; + if (!ViewFlag){ + LibGenFfsFile(CurrentFile, CurrentFv, FvName, Level, FfsCount, ErasePolarity); + } + } else if ( CurrentFile->Type == EFI_FV_FILETYPE_SECURITY_CORE){ + CurrentFv->FfsAttuibutes[*FfsCount].Level = Level; + // + // If an FV contain SECCORE, this FV will be considered as BFV. + // + CurrentFv->IsBfvFlag = TRUE; + if (!ViewFlag){ + LibGenFfsFile(CurrentFile, CurrentFv, FvName, Level, FfsCount, ErasePolarity); + } + } else if( CurrentFile->Type == EFI_FV_FILETYPE_FFS_PAD){ + // + // First check whether the FFS file contain FvExtended FvNameGuid information. + // + if (!LibCheckPadFfsContainFvNameGuid (CurrentFv, CurrentFile)) { + // + // Then check whether the PAD file have no additional data or not. + // + if (LibCheckPadFfsNotNull (CurrentFile)) { + CurrentFv->FfsAttuibutes[*FfsCount].Level = Level; + // + // Get the size of PAD in BFV + // + PadSizeOfBfv = GetBfvMaxFreeSpace (CurrentFile); + if (!ViewFlag){ + // + //LibGenFfsFile(CurrentFile, CurrentFv, FvName, Level, FfsCount, ErasePolarity); + // + Status = LibFindResetVectorAndFitTableData (FvImage, CurrentFile, CurrentFv); + if (EFI_ERROR (Status)) { + printf ("Find reset vector and FIT table data failed. \n"); + return EFI_ABORTED; + } + } + } + } + } else { + // + // All other files have sections + // + Status = LibParseSection ( + (UINT8 *) ((UINTN) CurrentFile + FfsFileHeaderSize), + FileLength - FfsFileHeaderSize, + CurrentFv, + FvName, + CurrentFile, + Level, + FfsCount, + ViewFlag, + ErasePolarity, + FALSE + ); + } + if (EFI_ERROR (Status)) { + printf ("Error while parse the FFS file.\n"); + return EFI_ABORTED; + } + } + + return EFI_SUCCESS; +} + +/** + + Get firmware information. Including the FV headers, + + @param[in] Fv - Firmware Volume to get information from + + @return EFI_STATUS + +**/ +EFI_STATUS +LibGetFvInfo ( + IN VOID *Fv, + IN OUT FV_INFORMATION *CurrentFv, + IN CHAR8 *FvName, + IN UINT8 Level, + IN UINT32 *FfsCount, + IN BOOLEAN ViewFlag, + IN BOOLEAN IsChildFv + ) +{ + EFI_STATUS Status; + UINTN NumberOfFiles; + BOOLEAN ErasePolarity; + UINTN FvSize; + EFI_FFS_FILE_HEADER2 *CurrentFile; + UINTN Key; + ENCAP_INFO_DATA *LocalEncapData; + EFI_FIRMWARE_VOLUME_EXT_HEADER *ExtHdrPtr; + + NumberOfFiles = 0; + Key = 0; + LocalEncapData = NULL; + CurrentFile = NULL; + + Level += 1; + CurrentFv->FvLevel += 1; + + Status = FvBufGetSize (Fv, &FvSize); + + ErasePolarity = (((EFI_FIRMWARE_VOLUME_HEADER*)Fv)->Attributes & EFI_FVB2_ERASE_POLARITY) ? TRUE : FALSE; + + if (!IsChildFv) { + // + // Write FV header information into CurrentFv struct. + // + CurrentFv->FvHeader = (EFI_FIRMWARE_VOLUME_HEADER *) malloc (sizeof (EFI_FIRMWARE_VOLUME_HEADER)); + + if (CurrentFv->FvHeader == NULL) { + return EFI_ABORTED; + } + + // + // Get the FV Header information + // + memcpy (CurrentFv->FvHeader, Fv, sizeof (EFI_FIRMWARE_VOLUME_HEADER)); + CurrentFv->FvExtHeader = NULL; + + // + // Exist Extend FV header. + // + if (CurrentFv->FvHeader->ExtHeaderOffset != 0){ + CurrentFv->FvExtHeader = (EFI_FIRMWARE_VOLUME_EXT_HEADER *) malloc (sizeof (EFI_FIRMWARE_VOLUME_EXT_HEADER)); + + if (CurrentFv->FvExtHeader == NULL) { + printf ("Out of resource, memory allocation failed. \n"); + return EFI_ABORTED; + } + + // + // Get the FV extended Header information + // + memcpy (CurrentFv->FvExtHeader, (VOID *)((UINTN)Fv + CurrentFv->FvHeader->ExtHeaderOffset), sizeof (EFI_FIRMWARE_VOLUME_EXT_HEADER)); + if (mFvGuidIsSet) { + if (CompareGuid (&CurrentFv->FvExtHeader->FvName, &mFvNameGuid) == 0) { + CurrentFv->IsInputFvFlag = TRUE; + } + } + + } + + } + + // + // Put encapsulate information into structure. + // + if (CurrentFv->EncapData == NULL && !IsChildFv) { + // + // First time in, the root FV + // + CurrentFv->EncapData = (ENCAP_INFO_DATA *) malloc (sizeof (ENCAP_INFO_DATA)); + + if (CurrentFv->EncapData == NULL) { + return EFI_ABORTED; + } + CurrentFv->EncapData->FvExtHeader = NULL; + CurrentFv->EncapData->Level = Level; + CurrentFv->EncapData->Type = BFM_ENCAP_TREE_FV; + CurrentFv->EncapData->Data = (EFI_FIRMWARE_VOLUME_HEADER *) malloc (sizeof (EFI_FIRMWARE_VOLUME_HEADER)); + + if (CurrentFv->EncapData->Data == NULL) { + return EFI_ABORTED; + } + + memcpy (CurrentFv->EncapData->Data, Fv, sizeof (EFI_FIRMWARE_VOLUME_HEADER)); + + if (((EFI_FIRMWARE_VOLUME_HEADER *)(CurrentFv->EncapData->Data))->ExtHeaderOffset != 0) { + ExtHdrPtr = (VOID *)((UINTN)Fv + ((EFI_FIRMWARE_VOLUME_HEADER *)(CurrentFv->EncapData->Data))->ExtHeaderOffset); + CurrentFv->EncapData->FvExtHeader = (EFI_FIRMWARE_VOLUME_EXT_HEADER *) malloc (ExtHdrPtr->ExtHeaderSize); + + if (CurrentFv->EncapData->FvExtHeader == NULL) { + printf ("Out of resource, memory allocation failed. \n"); + return EFI_ABORTED; + } + + // + // Get the FV extended Header information + // + memcpy(CurrentFv->EncapData->FvExtHeader, (VOID *)((UINTN)Fv + ((EFI_FIRMWARE_VOLUME_HEADER *)(CurrentFv->EncapData->Data))->ExtHeaderOffset), ExtHdrPtr->ExtHeaderSize); + if (mFvGuidIsSet) { + if (CompareGuid (&CurrentFv->EncapData->FvExtHeader->FvName, &mFvNameGuid) == 0) { + CurrentFv->IsInputFvFlag = TRUE; + } + } + + } + + CurrentFv->EncapData->NextNode = NULL; + + } else if (CurrentFv->EncapData == NULL) { + return EFI_ABORTED; + } else if (IsChildFv) { + + LocalEncapData = CurrentFv->EncapData; + + while (LocalEncapData->NextNode != NULL) { + LocalEncapData = LocalEncapData->NextNode; + } + + // + // Construct the new ENCAP_DATA + // + LocalEncapData->NextNode = (ENCAP_INFO_DATA *) malloc (sizeof (ENCAP_INFO_DATA)); + + if (LocalEncapData->NextNode == NULL) { + return EFI_ABORTED; + } + + LocalEncapData = LocalEncapData->NextNode; + + LocalEncapData->Level = Level; + LocalEncapData->Type = BFM_ENCAP_TREE_FV; + LocalEncapData->Data = (EFI_FIRMWARE_VOLUME_HEADER *) malloc (sizeof (EFI_FIRMWARE_VOLUME_HEADER)); + LocalEncapData->FvExtHeader = NULL; + + if (LocalEncapData->Data == NULL) { + return EFI_ABORTED; + } + + memcpy (LocalEncapData->Data, Fv, sizeof (EFI_FIRMWARE_VOLUME_HEADER)); + + if (((EFI_FIRMWARE_VOLUME_HEADER *)(LocalEncapData->Data))->ExtHeaderOffset != 0) { + ExtHdrPtr = (VOID *)((UINTN)Fv + ((EFI_FIRMWARE_VOLUME_HEADER *)(LocalEncapData->Data))->ExtHeaderOffset); + LocalEncapData->FvExtHeader = (EFI_FIRMWARE_VOLUME_EXT_HEADER *)malloc(ExtHdrPtr->ExtHeaderSize); + + if (LocalEncapData->FvExtHeader == NULL) { + printf ("Out of resource, memory allocation failed. \n"); + return EFI_ABORTED; + } + + // + // Get the FV extended Header information + // + memcpy(LocalEncapData->FvExtHeader, (VOID *)((UINTN)Fv + ((EFI_FIRMWARE_VOLUME_HEADER *)(LocalEncapData->Data))->ExtHeaderOffset), ExtHdrPtr->ExtHeaderSize); + } + + LocalEncapData->NextNode = NULL; + + } + + + // + // Get the first file + // + Status = FvBufFindNextFile (Fv, &Key, (VOID **) &CurrentFile); + if (Status == EFI_NOT_FOUND) { + CurrentFile = NULL; + } else if (EFI_ERROR (Status)) { + printf ("Failed to find the first file from Fv. \n"); + return Status; + } + + while (CurrentFile != NULL) { + + // + // Increment the number of files counter + // + NumberOfFiles++; + + // + // Store FFS file Header information + // + CurrentFv->FfsHeader[*FfsCount].Attributes = CurrentFile->Attributes; + CurrentFv->FfsHeader[*FfsCount].IntegrityCheck = CurrentFile->IntegrityCheck; + CurrentFv->FfsHeader[*FfsCount].Name = CurrentFile->Name; + CurrentFv->FfsHeader[*FfsCount].Size[0] = CurrentFile->Size[0]; + CurrentFv->FfsHeader[*FfsCount].Size[1] = CurrentFile->Size[1]; + CurrentFv->FfsHeader[*FfsCount].Size[2] = CurrentFile->Size[2]; + CurrentFv->FfsHeader[*FfsCount].State = CurrentFile->State; + CurrentFv->FfsHeader[*FfsCount].Type = CurrentFile->Type; + CurrentFv->FfsHeader[*FfsCount].ExtendedSize = CurrentFile->ExtendedSize; + + // + // Display info about this file + // + Status = LibGetFileInfo (Fv, CurrentFile, ErasePolarity, CurrentFv, FvName, Level, FfsCount, ViewFlag); + if (EFI_ERROR (Status)) { + return Status; + } + + // + // Get the next file + // + Status = FvBufFindNextFile (Fv, &Key, (VOID **) &CurrentFile); + if (Status == EFI_NOT_FOUND) { + CurrentFile = NULL; + } else if (EFI_ERROR (Status)) { + return Status; + } + } + + return EFI_SUCCESS; +} + + +EFI_STATUS +LibGenExtFile( + CONST EFI_FIRMWARE_VOLUME_EXT_HEADER *ExtPtr, + FILE *InfFile +) +{ + CHAR8 *TempDir; + FILE *ExtFile; + CHAR8 OutputExtFile[_MAX_PATH]; + CHAR8 Line[512]; + size_t Len; + + TempDir = NULL; + + TempDir = getcwd(NULL, _MAX_PATH); + + if (strlen (TempDir) + strlen (OS_SEP_STR) + strlen (TEMP_DIR_NAME) > _MAX_PATH - 1) { + printf ("The directory is too long \n"); + return EFI_ABORTED; + } + + strncat (TempDir, OS_SEP_STR, _MAX_PATH - strlen (TempDir) - 1); + strncat (TempDir, TEMP_DIR_NAME, _MAX_PATH - strlen (TempDir) - 1); + mkdir(TempDir, S_IRWXU | S_IRWXG | S_IRWXO); + + sprintf( + Line, + "%c%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X%d.ext", + OS_SEP, + (unsigned)ExtPtr->FvName.Data1, + ExtPtr->FvName.Data2, + ExtPtr->FvName.Data3, + ExtPtr->FvName.Data4[0], + ExtPtr->FvName.Data4[1], + ExtPtr->FvName.Data4[2], + ExtPtr->FvName.Data4[3], + ExtPtr->FvName.Data4[4], + ExtPtr->FvName.Data4[5], + ExtPtr->FvName.Data4[6], + ExtPtr->FvName.Data4[7], + ExtPtr->ExtHeaderSize + ); + if (strlen (TempDir) + strlen (Line) > _MAX_PATH - 1) { + printf ("The directory is too long \n"); + return EFI_ABORTED; + } + strncpy (OutputExtFile, TempDir, _MAX_PATH - 1); + OutputExtFile[_MAX_PATH - 1] = 0; + strncat (OutputExtFile, Line, _MAX_PATH - strlen (OutputExtFile) - 1); + + + ExtFile = fopen(OutputExtFile, "wb+"); + if (ExtFile == NULL) { + return EFI_ABORTED; + } + + if (fwrite(ExtPtr, 1, ExtPtr->ExtHeaderSize, ExtFile) != ExtPtr->ExtHeaderSize) { + fclose(ExtFile); + return EFI_ABORTED; + } + + fclose(ExtFile); + + strcpy (Line, "EFI_FV_EXT_HEADER_FILE_NAME = "); + if (strlen (Line) + strlen (OutputExtFile) + 1 > sizeof(Line) / sizeof (CHAR8) - 1) { + printf ("The directory is too long \n"); + return EFI_ABORTED; + } + strncat (Line, OutputExtFile, sizeof(Line) / sizeof (CHAR8) - strlen (Line) - 1); + strncat (Line, "\n", sizeof(Line) / sizeof (CHAR8) - strlen (Line) - 1); + Len = strlen(Line); + if (fwrite(Line, 1, Len, InfFile) != Len) { + return EFI_ABORTED; + } + + return EFI_SUCCESS; +} + + +/** + + This function returns the next larger size that meets the alignment + requirement specified. + + @param[in] ActualSize The size. + @param[in] Alignment The desired alignment. + + @retval EFI_SUCCESS Function completed successfully. + @retval EFI_ABORTED The function encountered an error. + +**/ +UINT32 +GetOccupiedSize ( + IN UINT32 ActualSize, + IN UINT32 Alignment + ) +{ + UINT32 OccupiedSize; + + OccupiedSize = ActualSize; + while ((OccupiedSize & (Alignment - 1)) != 0) { + OccupiedSize++; + } + + return OccupiedSize; +} + +/** + Converts ASCII characters to Unicode. + Assumes that the Unicode characters are only these defined in the ASCII set. + + String - Pointer to string that is written to FILE. + UniString - Pointer to unicode string + + The address to the ASCII string - same as AsciiStr. + +**/ +VOID +LibAscii2Unicode ( + IN CHAR8 *String, + OUT CHAR16 *UniString + ) +{ + while (*String != '\0') { + *(UniString++) = (CHAR16) *(String++); + } + // + // End the UniString with a NULL. + // + *UniString = '\0'; +} + + +EFI_STATUS +LibCreateGuidedSectionOriginalData( + IN CHAR8* FileIn, + IN CHAR8* ToolName, + IN CHAR8* FileOut +) +{ + CHAR8* SystemCommand; + + SystemCommand = NULL; + + if (FileIn == NULL || + ToolName == NULL || + FileOut == NULL) { + return EFI_INVALID_PARAMETER; + } + + SystemCommand = malloc ( + strlen (ENCODE_STR) + + strlen (FileIn) + + strlen (ToolName) + + strlen (FileOut) + + 1 + ); + + if (NULL == SystemCommand) { + return EFI_ABORTED; + } + + sprintf ( + SystemCommand, + ENCODE_STR, + ToolName, + FileIn, + FileOut + ); + + if (system (SystemCommand) != EFI_SUCCESS) { + SystemCommand = malloc ( + strlen (ENCODE_STR_ERR) + + strlen (FileIn) + + strlen (ToolName) + + strlen (FileOut) + + 1 + ); + if (NULL == SystemCommand) { + return EFI_ABORTED; + } + sprintf ( + SystemCommand, + ENCODE_STR_ERR, + ToolName, + FileIn, + FileOut + ); + system (SystemCommand); + printf("Command failed: %s\n", SystemCommand); + free(SystemCommand); + return EFI_ABORTED; + } + free(SystemCommand); + + return EFI_SUCCESS; +} + +/** + + This function convert the FV header's attribute to a string. The converted string + will be put into an INF file as the input of GenFV. + + @param[in] Attr FV header's attribute. + @param[out] InfFile InfFile contain FV header attribute information. + + @retval EFI_SUCCESS. + @retval EFI_INVLID_PARAMETER + @retval EFI_OUT_OF_RESOURCES + +**/ +EFI_STATUS +LibFvHeaderAttributeToStr ( + IN EFI_FVB_ATTRIBUTES_2 Attr, + IN FILE* InfFile +) +{ + CHAR8 *LocalStr; + + LocalStr = NULL; + + LocalStr = (CHAR8 *) malloc (1024 * 4); + + if (LocalStr == NULL) { + printf ("Out of resource, memory allocation failed. \n"); + return EFI_OUT_OF_RESOURCES; + } + + memset (LocalStr, '\0', 1024 * 4); + + if (Attr == 0 || InfFile == NULL) { + free (LocalStr); + return EFI_INVALID_PARAMETER; + } + + strncat (LocalStr, "[attributes] \n", sizeof("[attributes] \n")); + + if (Attr & EFI_FVB2_READ_DISABLED_CAP) { + strncat (LocalStr, "EFI_READ_DISABLED_CAP = TRUE \n", sizeof ("EFI_READ_DISABLED_CAP = TRUE \n")); + } + + if (Attr & EFI_FVB2_READ_ENABLED_CAP) { + strncat (LocalStr, "EFI_READ_ENABLED_CAP = TRUE \n", sizeof ("EFI_READ_ENABLED_CAP = TRUE \n")); + } + + if (Attr & EFI_FVB2_READ_STATUS) { + strncat (LocalStr, "EFI_READ_STATUS = TRUE \n", sizeof ("EFI_READ_STATUS = TRUE \n")); + } + + if (Attr & EFI_FVB2_WRITE_DISABLED_CAP) { + strncat (LocalStr, "EFI_WRITE_DISABLED_CAP = TRUE \n", sizeof ("EFI_WRITE_DISABLED_CAP = TRUE \n")); + } + + if (Attr & EFI_FVB2_WRITE_ENABLED_CAP) { + strncat (LocalStr, "EFI_WRITE_ENABLED_CAP = TRUE \n", sizeof ("EFI_WRITE_ENABLED_CAP = TRUE \n")); + } + + if (Attr & EFI_FVB2_WRITE_STATUS) { + strncat (LocalStr, "EFI_WRITE_STATUS = TRUE \n", sizeof ("EFI_WRITE_STATUS = TRUE \n")); + } + + if (Attr & EFI_FVB2_LOCK_CAP) { + strncat (LocalStr, "EFI_LOCK_CAP = TRUE \n", sizeof ("EFI_LOCK_CAP = TRUE \n")); + } + + if (Attr & EFI_FVB2_LOCK_STATUS) { + strncat (LocalStr, "EFI_LOCK_STATUS = TRUE \n", sizeof ("EFI_LOCK_STATUS = TRUE \n")); + } + + if (Attr & EFI_FVB2_STICKY_WRITE) { + strncat (LocalStr, "EFI_STICKY_WRITE = TRUE \n", sizeof ("EFI_STICKY_WRITE = TRUE \n")); + } + + if (Attr & EFI_FVB2_MEMORY_MAPPED) { + strncat (LocalStr, "EFI_MEMORY_MAPPED = TRUE \n", sizeof ("EFI_MEMORY_MAPPED = TRUE \n")); + } + + if (Attr & EFI_FVB2_ERASE_POLARITY) { + strncat (LocalStr, "EFI_ERASE_POLARITY = 1 \n", sizeof ("EFI_ERASE_POLARITY = 1 \n")); + } + + if (Attr & EFI_FVB2_READ_LOCK_CAP) { + strncat (LocalStr, "EFI_READ_LOCK_CAP = TRUE \n", sizeof ("EFI_READ_LOCK_CAP = TRUE \n")); + } + + if (Attr & EFI_FVB2_READ_LOCK_STATUS) { + strncat (LocalStr, "EFI_READ_LOCK_STATUS = TRUE \n", sizeof ("EFI_READ_LOCK_STATUS = TRUE \n")); + } + + if (Attr & EFI_FVB2_WRITE_LOCK_CAP) { + strncat (LocalStr, "EFI_WRITE_LOCK_CAP = TRUE \n", sizeof ("EFI_WRITE_LOCK_CAP = TRUE \n")); + } + + if (Attr & EFI_FVB2_WRITE_LOCK_STATUS) { + strncat (LocalStr, "EFI_WRITE_LOCK_STATUS = TRUE \n", sizeof ("EFI_WRITE_LOCK_STATUS = TRUE \n")); + } + + if (Attr & EFI_FVB2_LOCK_STATUS) { + strncat (LocalStr, "EFI_READ_LOCK_STATUS = TRUE \n", sizeof ("EFI_READ_LOCK_STATUS = TRUE \n")); + } + + // + // Alignment + // + if (Attr & EFI_FVB2_ALIGNMENT_1) { + strncat (LocalStr, "EFI_FVB2_ALIGNMENT_1 = TRUE \n", sizeof ("EFI_FVB2_ALIGNMENT_1 = TRUE \n")); + } else if (Attr & EFI_FVB2_ALIGNMENT_2) { + strncat (LocalStr, "EFI_FVB2_ALIGNMENT_2 = TRUE \n", sizeof ("EFI_FVB2_ALIGNMENT_2 = TRUE \n")); + } else if (Attr & EFI_FVB2_ALIGNMENT_4) { + strncat (LocalStr, "EFI_FVB2_ALIGNMENT_4 = TRUE \n", sizeof ("EFI_FVB2_ALIGNMENT_4 = TRUE \n")); + } else if (Attr & EFI_FVB2_ALIGNMENT_8) { + strncat (LocalStr, "EFI_FVB2_ALIGNMENT_8 = TRUE \n", sizeof ("EFI_FVB2_ALIGNMENT_8 = TRUE \n")); + } else if (Attr & EFI_FVB2_ALIGNMENT_16) { + strncat (LocalStr, "EFI_FVB2_ALIGNMENT_16 = TRUE \n", sizeof ("EFI_FVB2_ALIGNMENT_16 = TRUE \n")); + } else if (Attr & EFI_FVB2_ALIGNMENT_32) { + strncat (LocalStr, "EFI_FVB2_ALIGNMENT_32 = TRUE \n", sizeof ("EFI_FVB2_ALIGNMENT_32 = TRUE \n")); + } else if (Attr & EFI_FVB2_ALIGNMENT_64) { + strncat (LocalStr, "EFI_FVB2_ALIGNMENT_64 = TRUE \n", sizeof ("EFI_FVB2_ALIGNMENT_64 = TRUE \n")); + } else if (Attr & EFI_FVB2_ALIGNMENT_128) { + strncat (LocalStr, "EFI_FVB2_ALIGNMENT_128 = TRUE \n", sizeof ("EFI_FVB2_ALIGNMENT_128 = TRUE \n")); + } else if (Attr & EFI_FVB2_ALIGNMENT_256) { + strncat (LocalStr, "EFI_FVB2_ALIGNMENT_256 = TRUE \n", sizeof ("EFI_FVB2_ALIGNMENT_256 = TRUE \n")); + } else if (Attr & EFI_FVB2_ALIGNMENT_512) { + strncat (LocalStr, "EFI_FVB2_ALIGNMENT_512 = TRUE \n", sizeof ("EFI_FVB2_ALIGNMENT_512 = TRUE \n")); + } else if (Attr & EFI_FVB2_ALIGNMENT_1K) { + strncat (LocalStr, "EFI_FVB2_ALIGNMENT_1K = TRUE \n", sizeof ("EFI_FVB2_ALIGNMENT_1K = TRUE \n")); + } else if (Attr & EFI_FVB2_ALIGNMENT_2K) { + strncat (LocalStr, "EFI_FVB2_ALIGNMENT_2K = TRUE \n", sizeof ("EFI_FVB2_ALIGNMENT_2K = TRUE \n")); + } else if (Attr & EFI_FVB2_ALIGNMENT_4K) { + strncat (LocalStr, "EFI_FVB2_ALIGNMENT_4K = TRUE \n", sizeof ("EFI_FVB2_ALIGNMENT_4K = TRUE \n")); + } else if (Attr & EFI_FVB2_ALIGNMENT_8K) { + strncat (LocalStr, "EFI_FVB2_ALIGNMENT_8K = TRUE \n", sizeof ("EFI_FVB2_ALIGNMENT_8K = TRUE \n")); + } else if (Attr & EFI_FVB2_ALIGNMENT_16K) { + strncat (LocalStr, "EFI_FVB2_ALIGNMENT_16K = TRUE \n", sizeof ("EFI_FVB2_ALIGNMENT_16K = TRUE \n")); + } else if (Attr & EFI_FVB2_ALIGNMENT_32K) { + strncat (LocalStr, "EFI_FVB2_ALIGNMENT_32K = TRUE \n", sizeof ("EFI_FVB2_ALIGNMENT_32K = TRUE \n")); + } else if (Attr & EFI_FVB2_ALIGNMENT_64K) { + strncat (LocalStr, "EFI_FVB2_ALIGNMENT_64K = TRUE \n", sizeof ("EFI_FVB2_ALIGNMENT_64K = TRUE \n")); + } else if (Attr & EFI_FVB2_ALIGNMENT_128K) { + strncat (LocalStr, "EFI_FVB2_ALIGNMENT_128K = TRUE \n", sizeof ("EFI_FVB2_ALIGNMENT_128K = TRUE \n")); + } else if (Attr & EFI_FVB2_ALIGNMENT_256K) { + strncat (LocalStr, "EFI_FVB2_ALIGNMENT_256K = TRUE \n", sizeof ("EFI_FVB2_ALIGNMENT_256K = TRUE \n")); + } else if (Attr & EFI_FVB2_ALIGNMENT_512K) { + strncat (LocalStr, "EFI_FVB2_ALIGNMENT_512K = TRUE \n", sizeof ("EFI_FVB2_ALIGNMENT_512K = TRUE \n")); + } else if (Attr & EFI_FVB2_ALIGNMENT_1M) { + strncat (LocalStr, "EFI_FVB2_ALIGNMENT_1M = TRUE \n", sizeof ("EFI_FVB2_ALIGNMENT_1M = TRUE \n")); + } else if (Attr & EFI_FVB2_ALIGNMENT_2M) { + strncat (LocalStr, "EFI_FVB2_ALIGNMENT_2M = TRUE \n", sizeof ("EFI_FVB2_ALIGNMENT_2M = TRUE \n")); + } else if (Attr & EFI_FVB2_ALIGNMENT_4M) { + strncat (LocalStr, "EFI_FVB2_ALIGNMENT_4M = TRUE \n", sizeof ("EFI_FVB2_ALIGNMENT_4M = TRUE \n")); + } else if (Attr & EFI_FVB2_ALIGNMENT_8M) { + strncat (LocalStr, "EFI_FVB2_ALIGNMENT_8M = TRUE \n", sizeof ("EFI_FVB2_ALIGNMENT_8M = TRUE \n")); + } else if (Attr & EFI_FVB2_ALIGNMENT_16M) { + strncat (LocalStr, "EFI_FVB2_ALIGNMENT_16M = TRUE \n", sizeof ("EFI_FVB2_ALIGNMENT_16M = TRUE \n")); + } else if (Attr & EFI_FVB2_ALIGNMENT_32M) { + strncat (LocalStr, "EFI_FVB2_ALIGNMENT_32M = TRUE \n", sizeof ("EFI_FVB2_ALIGNMENT_32M = TRUE \n")); + } else if (Attr & EFI_FVB2_ALIGNMENT_64M) { + strncat (LocalStr, "EFI_FVB2_ALIGNMENT_64M = TRUE \n", sizeof ("EFI_FVB2_ALIGNMENT_64M = TRUE \n")); + } else if (Attr & EFI_FVB2_ALIGNMENT_128M) { + strncat (LocalStr, "EFI_FVB2_ALIGNMENT_128M = TRUE \n", sizeof ("EFI_FVB2_ALIGNMENT_128M = TRUE \n")); + } else if (Attr & EFI_FVB2_ALIGNMENT_256M) { + strncat (LocalStr, "EFI_FVB2_ALIGNMENT_256M = TRUE \n", sizeof ("EFI_FVB2_ALIGNMENT_256M = TRUE \n")); + } else if (Attr & EFI_FVB2_ALIGNMENT_512M) { + strncat (LocalStr, "EFI_FVB2_ALIGNMENT_512M = TRUE \n", sizeof ("EFI_FVB2_ALIGNMENT_512M = TRUE \n")); + } else if (Attr & EFI_FVB2_ALIGNMENT_1G) { + strncat (LocalStr, "EFI_FVB2_ALIGNMENT_1G = TRUE \n", sizeof ("EFI_FVB2_ALIGNMENT_1G = TRUE \n")); + } else if (Attr & EFI_FVB2_ALIGNMENT_2G) { + strncat (LocalStr, "EFI_FVB2_ALIGNMENT_2G = TRUE \n", sizeof ("EFI_FVB2_ALIGNMENT_2G = TRUE \n")); + } + + if (fwrite (LocalStr, 1, (size_t) strlen (LocalStr), InfFile) != (size_t) strlen (LocalStr)) { + printf ("Error while write data to %p file. \n", (void*)InfFile); + free (LocalStr); + return EFI_ABORTED; + } + + free (LocalStr); + + return EFI_SUCCESS; +} + + +/** + This function fill the FV inf files option field. + + @param[in] BlockMap FV header's attribute. + @param[out] InfFile InfFile contain FV header attribute information. + + @retval EFI_SUCCESS. + @retval EFI_INVLID_PARAMETER + +**/ +EFI_STATUS +LibFvHeaderOptionToStr ( + IN EFI_FV_BLOCK_MAP_ENTRY *BlockMap, + IN FILE* InfFile, + IN BOOLEAN IsRootFv +) +{ + CHAR8 *LocalStr; + CHAR8 *BlockSize; + CHAR8 *NumOfBlocks; + + LocalStr = NULL; + BlockSize = NULL; + NumOfBlocks = NULL; + + if (BlockMap == NULL || InfFile == NULL) { + return EFI_INVALID_PARAMETER; + } + + // + // This section will not over 1024 bytes and each line will never over 128 bytes. + // + LocalStr = (CHAR8 *) malloc (1024); + BlockSize = (CHAR8 *) malloc (128); + NumOfBlocks = (CHAR8 *) malloc (128); + + if (LocalStr == NULL || + BlockSize == NULL || + NumOfBlocks == NULL) { + if (LocalStr != NULL) { + free (LocalStr); + } + if (BlockSize != NULL) { + free (BlockSize); + } + if (NumOfBlocks != NULL) { + free (NumOfBlocks); + } + return EFI_OUT_OF_RESOURCES; + } + + memset (LocalStr, '\0', 1024); + memset (BlockSize, '\0', 128); + memset (NumOfBlocks, '\0', 128); + + strncat (LocalStr, "[options] \n", sizeof("[Options] \n")); + + sprintf (BlockSize, "EFI_BLOCK_SIZE = 0x%x \n", BlockMap->Length); + strncat (LocalStr, BlockSize, strlen(BlockSize)); + + if (IsRootFv) { + sprintf (NumOfBlocks, "EFI_NUM_BLOCKS = 0x%x \n", BlockMap->NumBlocks); + strncat (LocalStr, NumOfBlocks, strlen(NumOfBlocks)); + } + + if (fwrite (LocalStr, 1, (size_t) strlen (LocalStr), InfFile) != (size_t) strlen (LocalStr)) { + free (LocalStr); + free (BlockSize); + free (NumOfBlocks); + return EFI_ABORTED; + } + + free (LocalStr); + free (BlockSize); + free (NumOfBlocks); + + return EFI_SUCCESS; +} + +/** + This function fill the FV inf files option field. + + @param[in] FfsName Ffs file path/name. + @param[out] InfFile InfFile contain FV header attribute information + @param[in] FirstIn Is the first time call this function? If yes, should create [files] section. + + @retval EFI_SUCCESS. + @retval EFI_INVLID_PARAMETER + +**/ +EFI_STATUS +LibAddFfsFileToFvInf ( + IN CHAR8 *FfsName, + IN FILE* InfFile, + IN BOOLEAN FirstIn +) +{ + + CHAR8 *LocalStr; + + LocalStr = NULL; + + if (FfsName == NULL || InfFile == NULL) { + return EFI_INVALID_PARAMETER; + } + + if (strlen(FfsName) == 0) { + return EFI_SUCCESS; + } + + LocalStr = (CHAR8 *) malloc (_MAX_PATH); + + if (LocalStr == NULL) { + printf ("Out of resource, memory allocation failed. \n"); + return EFI_OUT_OF_RESOURCES; + } + + memset (LocalStr, '\0', _MAX_PATH); + + if (FirstIn) { + sprintf (LocalStr, "[files] \nEFI_FILE_NAME = %s \n", FfsName); + } else { + sprintf (LocalStr, "EFI_FILE_NAME = %s \n", FfsName); + } + + if (fwrite (LocalStr, 1, (size_t) strlen (LocalStr), InfFile) != (size_t) strlen (LocalStr)) { + printf ("Error while write data to %p file. \n", (void*)InfFile); + free (LocalStr); + return EFI_ABORTED; + } + + free (LocalStr); + + return EFI_SUCCESS; +} + + +/** + Convert EFI file to PE or TE section + + @param[in] InputFilePath .efi file, it's optional unless process PE/TE section. + @param[in] Type PE or TE and UI/Version + @param[in] OutputFilePath .te or .pe file + @param[in] UiString String for generate UI section usage, this parameter is optional + unless Type is EFI_SECTION_USER_INTERFACE. + @param[in] VerString String for generate Version section usage, this parameter is optional + unless Type is EFI_SECTION_VERSION. + + @retval EFI_SUCCESS + +**/ +EFI_STATUS +LibCreateFfsSection ( + IN CHAR8* InputFilePath, OPTIONAL + IN CHAR8* Sections, OPTIONAL + IN UINT8 Type, + IN CHAR8* OutputFilePath, + IN CHAR8* UiString, OPTIONAL + IN CHAR8* VerString, OPTIONAL + IN CHAR8* GuidToolGuid, OPTIONAL + IN CHAR8* CompressType OPTIONAL + ) +{ + CHAR8* SystemCommand; + SystemCommand = NULL; + + // + // Call GenSec tool to generate FFS section. + // + + // + // -s SectionType. + // + if (Type != 0) { + switch (Type) { + // + // Process compression section + // + case EFI_SECTION_COMPRESSION: + SystemCommand = malloc ( + strlen (GENSEC_COMPRESSION) + + strlen (mSectionTypeName[Type]) + + strlen (CompressType) + + strlen (InputFilePath) + + strlen (OutputFilePath) + + 1 + ); + if (NULL == SystemCommand) { + return EFI_OUT_OF_RESOURCES; + } + sprintf ( + SystemCommand, + GENSEC_COMPRESSION, + mSectionTypeName[Type], + CompressType, + InputFilePath, + OutputFilePath + ); + if (system (SystemCommand) != EFI_SUCCESS) { + free(SystemCommand); + return EFI_ABORTED; + } + free(SystemCommand); + break; + + // + // Process GUID defined section + // + case EFI_SECTION_GUID_DEFINED: + SystemCommand = malloc ( + strlen (GENSEC_GUID) + + strlen (mSectionTypeName[Type]) + + strlen (GuidToolGuid) + + strlen (InputFilePath) + + strlen (OutputFilePath) + + 1 + ); + if (NULL == SystemCommand) { + return EFI_OUT_OF_RESOURCES; + } + sprintf ( + SystemCommand, + GENSEC_GUID, + mSectionTypeName[Type], + GuidToolGuid, + InputFilePath, + OutputFilePath + ); + if (system (SystemCommand) != EFI_SUCCESS) { + free(SystemCommand); + return EFI_ABORTED; + } + free(SystemCommand); + break; + + case EFI_SECTION_FIRMWARE_VOLUME_IMAGE: + SystemCommand = malloc ( + strlen (GENSEC_STR) + + strlen (mSectionTypeName[Type]) + + strlen (InputFilePath) + + strlen (OutputFilePath) + + 1 + ); + if (NULL == SystemCommand) { + return EFI_OUT_OF_RESOURCES; + } + sprintf ( + SystemCommand, + GENSEC_STR, + mSectionTypeName[Type], + InputFilePath, + OutputFilePath + ); + if (system (SystemCommand) != EFI_SUCCESS) { + free(SystemCommand); + return EFI_ABORTED; + } + free(SystemCommand); + break; + + case EFI_SECTION_RAW: + SystemCommand = malloc ( + strlen (GENSEC_STR) + + strlen (mSectionTypeName[Type]) + + strlen (InputFilePath) + + strlen (OutputFilePath) + + 1 + ); + if (NULL == SystemCommand) { + return EFI_OUT_OF_RESOURCES; + } + sprintf ( + SystemCommand, + GENSEC_STR, + mSectionTypeName[Type], + InputFilePath, + OutputFilePath + ); + if (system (SystemCommand) != EFI_SUCCESS) { + free(SystemCommand); + return EFI_ABORTED; + } + free(SystemCommand); + break; + + default: + printf ("Please specify the section type while call GenSec tool.\n"); + return EFI_UNSUPPORTED; + } + } else { + // + // Create Dummy section. + // + SystemCommand = malloc ( + strlen (GENSEC_ALIGN) + + strlen (InputFilePath) + + strlen (OutputFilePath) + + 1 + ); + if (NULL == SystemCommand) { + return EFI_OUT_OF_RESOURCES; + } + sprintf ( + SystemCommand, + GENSEC_ALIGN, + InputFilePath, + OutputFilePath + ); + if (system (SystemCommand) != EFI_SUCCESS) { + free(SystemCommand); + return EFI_ABORTED; + } + free(SystemCommand); + + } + + return EFI_SUCCESS; +} + +/** + Encapsulate FFSs to FV + + @param[in] InputFilePath Section file will be read into this FFS file. This option is required. + @param[in] OutputFilePath The created PI firmware file name. This option is required. + @param[in] BlockSize BlockSize is one HEX or DEC format value required by FV image. + @param[in] FileTakeSize + + @retval EFI_SUCCESS + +**/ +EFI_STATUS +LibEncapsulateFfsToFv ( + IN CHAR8* InfFilePath, + IN CHAR8* InputFFSs, + IN CHAR8* OutputFilePath, + IN CHAR8* FvGuidName + ) +{ + + CHAR8* SystemCommand; + CHAR8* FfsGuid = "8c8ce578-8a3d-4f1c-9935-896185c32dd3"; + + SystemCommand = NULL; + + if (OutputFilePath == NULL || + InfFilePath == NULL ) { + return EFI_INVALID_PARAMETER; + } + + if (InfFilePath != NULL) { + if (FvGuidName == NULL) { + SystemCommand = malloc ( + strlen (GENFV_STR) + + strlen (InfFilePath) + + strlen (OutputFilePath) + + 1 + ); + if (NULL == SystemCommand) { + return EFI_OUT_OF_RESOURCES; + } + + sprintf ( + SystemCommand, + GENFV_STR, + InfFilePath, // -i + OutputFilePath // -o + ); + + if (system (SystemCommand) != EFI_SUCCESS) { + free(SystemCommand); + return EFI_ABORTED; + } + free(SystemCommand); + } else { + // + // Have FvGuidName in it. + // + SystemCommand = malloc ( + strlen (GENFV_FVGUID) + + strlen (InfFilePath) + + strlen (OutputFilePath) + + strlen (FvGuidName) + + 1 + ); + if (NULL == SystemCommand) { + return EFI_OUT_OF_RESOURCES; + } + + sprintf ( + SystemCommand, + GENFV_FVGUID, + InfFilePath, // -i + OutputFilePath, // -o + FvGuidName // FvNameGuid + ); + if (system (SystemCommand) != EFI_SUCCESS) { + free(SystemCommand); + return EFI_ABORTED; + } + free(SystemCommand); + + } + } + + if (InputFFSs != NULL) { + SystemCommand = malloc ( + strlen (GENFV_FFS) + + strlen (InputFFSs) + + strlen (FfsGuid) + + strlen (OutputFilePath) + + 100 + ); + if (NULL == SystemCommand) { + return EFI_OUT_OF_RESOURCES; + } + + sprintf ( + SystemCommand, + GENFV_FFS, + InputFFSs, // -f + FfsGuid, // -g + OutputFilePath // -o + ); + if (system (SystemCommand) != EFI_SUCCESS) { + free(SystemCommand); + return EFI_ABORTED; + } + free(SystemCommand); + } + + return EFI_SUCCESS; +} + + +/** + + Convert a GUID to a string. + + + @param[in] Guid - Pointer to GUID to print. + + + @return The string after convert. + +**/ +CHAR8 * +LibBfmGuidToStr ( + IN EFI_GUID *Guid +) +{ + CHAR8 * Buffer; + + Buffer = NULL; + + if (Guid == NULL) { + printf ("The guid is NULL while convert guid to string! \n"); + return NULL; + } + + Buffer = (CHAR8 *) malloc (36 + 1); + + if (Buffer == NULL) { + printf ("Error while allocate resource! \n"); + return NULL; + } + memset (Buffer, '\0', 36 + 1); + + sprintf ( + Buffer, + "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x", + Guid->Data1, + Guid->Data2, + Guid->Data3, + Guid->Data4[0], + Guid->Data4[1], + Guid->Data4[2], + Guid->Data4[3], + Guid->Data4[4], + Guid->Data4[5], + Guid->Data4[6], + Guid->Data4[7] + ); + + return Buffer; +} + +/** + Encapsulate an FFS section file to an FFS file. + + @param[in] Type Type is one FV file type defined in PI spec, which is one type of EFI_FV_FILETYPE_RAW, EFI_FV_FILETYPE_FREEFORM, + EFI_FV_FILETYPE_SECURITY_CORE, EFI_FV_FILETYPE_PEIM, EFI_FV_FILETYPE_PEI_CORE, EFI_FV_FILETYPE_DXE_CORE, + EFI_FV_FILETYPE_DRIVER, EFI_FV_FILETYPE_APPLICATION, EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER, + EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE. This option is required. + @param[in] InputFilePath Section file will be read into this FFS file. This option is required. + @param[in] OutputFilePath The created PI firmware file name. This option is required. + @param[in] FileGuid FileGuid is the unique identifier for this FFS file. This option is required. + @param[in] Fixed Set fixed attribute in FFS file header to indicate that the file may not be moved from its present location. + @param[in] SectionAlign FileAlign specifies FFS file alignment, which only support the following alignment: 8,16,128,512,1K,4K,32K,64K. + + @retval EFI_SUCCESS + +**/ +EFI_STATUS +LibEncapSectionFileToFFS ( + IN UINT8 Type, + IN CHAR8* InputFilePath, + IN CHAR8* OutputFilePath, + IN EFI_GUID FileGuid, + IN BOOLEAN Fixed, + IN UINT32 SectionAlign + ) +{ + CHAR8* SystemCommand; + CHAR8* GuidStr; + + SystemCommand = NULL; + GuidStr = NULL; + + GuidStr = LibBfmGuidToStr(&FileGuid); + + if (NULL == GuidStr) { + return EFI_OUT_OF_RESOURCES; + } + + if (Type == EFI_FV_FILETYPE_RAW) { + SystemCommand = malloc ( + strlen (GENFFS_STR) + + strlen (mFfsFileType[Type]) + + strlen (InputFilePath) + + strlen (GuidStr) + + strlen (OutputFilePath) + + 1 + ); + if (NULL == SystemCommand) { + free (GuidStr); + return EFI_OUT_OF_RESOURCES; + } + sprintf ( + SystemCommand, + GENFFS_STR, + mFfsFileType[Type], // -t + InputFilePath, // -i + GuidStr, // -g + OutputFilePath // -o + ); + + if (system (SystemCommand) != EFI_SUCCESS) { + free(SystemCommand); + free (GuidStr); + return EFI_ABORTED; + } + free(SystemCommand); + + } else { + // + // -t Type + // -i InputFilePath + // -o OutPutFilePath + // -g FileGuid + // -x Fixed + // -n SectionAlign + // + if (Fixed) { + SystemCommand = malloc ( + strlen (GENFFS_FIX) + + strlen (mFfsFileType[Type]) + + strlen (InputFilePath) + + strlen (GuidStr) + + strlen (OutputFilePath) + + 1 + ); + if (NULL == SystemCommand) { + free (GuidStr); + return EFI_OUT_OF_RESOURCES; + } + sprintf ( + SystemCommand, + GENFFS_FIX, + mFfsFileType[Type], // -t + InputFilePath, // -i + GuidStr, // -g + OutputFilePath // -o + ); + if (system (SystemCommand) != EFI_SUCCESS) { + free(SystemCommand); + free (GuidStr); + return EFI_ABORTED; + } + free(SystemCommand); + } else { + SystemCommand = malloc ( + strlen (GENFFS_STR) + + strlen (mFfsFileType[Type]) + + strlen (InputFilePath) + + strlen (GuidStr) + + strlen (OutputFilePath) + + 1 + ); + if (NULL == SystemCommand) { + free (GuidStr); + return EFI_OUT_OF_RESOURCES; + } + sprintf ( + SystemCommand, + GENFFS_STR, + mFfsFileType[Type], // -t + InputFilePath, // -i + GuidStr, // -g + OutputFilePath // -o + ); + if (system (SystemCommand) != EFI_SUCCESS) { + free(SystemCommand); + free (GuidStr); + return EFI_ABORTED; + } + free(SystemCommand); + } + } + free (GuidStr); + return EFI_SUCCESS; +} + +EFI_STATUS +LibCreateNewFdCopy( + IN CHAR8* OldFd, + IN CHAR8* NewFd +) +{ + CHAR8* SystemCommand; + SystemCommand = NULL; + + + if (OldFd == NULL || + NewFd == NULL) { + return EFI_INVALID_PARAMETER; + } + + // + // Create a copy the new file. + // + + SystemCommand = malloc ( + strlen (COPY_STR) + + strlen (OldFd) + + strlen (NewFd) + + 1 + ); + if (NULL == SystemCommand) { + return EFI_OUT_OF_RESOURCES; + } + + sprintf ( + SystemCommand, + COPY_STR, + OldFd, + NewFd + ); + + if (system (SystemCommand) != EFI_SUCCESS) { + free(SystemCommand); + return EFI_ABORTED; + } + free(SystemCommand); + + return EFI_SUCCESS; +} + + +/** + This function will assemble the filename, directory and extend and return the combined string. + Like FileName = file1, Dir = c:\temp extend = txt, the output string will be: + c:\temp\file1.txt. + + @param[in] + @param[in] + @param[in] + + @retrun A string contain all the input information. + +**/ +CHAR8 * +LibFilenameStrExtended ( + IN CHAR8 *FileName, + IN CHAR8 *Dir, + IN CHAR8 *Extend +) +{ + CHAR8 *RetStr; + + RetStr = NULL; + + if (FileName == NULL) { + return NULL; + } + + if (Dir == NULL || Extend == NULL) { + return FileName; + } + + RetStr = (CHAR8 *) malloc (strlen (FileName) + + strlen (Dir) + + strlen (Extend) + + strlen ("%s%s.%s") + + 1); + if (NULL == RetStr) { + return NULL; + } + + memset (RetStr, '\0', (strlen (FileName) + strlen (Dir) + strlen (Extend) + strlen("%s%s.%s") + 1)); + + sprintf (RetStr, "%s%s.%s", Dir, FileName, Extend); + + return RetStr; +} + +/** + Delete a directory and files in it. + + @param[in] DirName Name of the directory need to be deleted. + + @return EFI_INVALID_PARAMETER + @return EFI_SUCCESS +**/ +EFI_STATUS +LibRmDir ( + IN CHAR8* DirName +) +{ + CHAR8* SystemCommand; + SystemCommand = NULL; + + + if (DirName == NULL) { + return EFI_INVALID_PARAMETER; + } + + if (access (DirName, 0) == -1){ + return EFI_SUCCESS; + } + + // + // Delete a directory and files in it + // + SystemCommand = malloc ( + strlen (RMDIR_STR) + + strlen (DirName) + + 1 + ); + if (NULL == SystemCommand) { + return EFI_OUT_OF_RESOURCES; + } + + sprintf ( + SystemCommand, + RMDIR_STR, + DirName + ); + + if (system (SystemCommand) != EFI_SUCCESS) { + free(SystemCommand); + return EFI_ABORTED; + } + free(SystemCommand); + + return EFI_SUCCESS; +} + +/** + Delete a file. + + @param[in] FileName Name of the file need to be deleted. + + @return EFI_INVALID_PARAMETER + @return EFI_SUCCESS +**/ +EFI_STATUS +LibBfmDeleteFile( + IN CHAR8 *FileName +) +{ + CHAR8* SystemCommand; + + SystemCommand = NULL; + + + if (FileName == NULL) { + return EFI_INVALID_PARAMETER; + } + + + // + // Delete a file. + // + SystemCommand = malloc ( + strlen (DEL_STR) + + strlen (FileName) + + 1 + ); + if (NULL == SystemCommand) { + return EFI_OUT_OF_RESOURCES; + } + sprintf ( + SystemCommand, + DEL_STR, + FileName + ); + + if (system (SystemCommand) != EFI_SUCCESS) { + free(SystemCommand); + return EFI_ABORTED; + } + free(SystemCommand); + + return EFI_SUCCESS; + +} + + +/** + + Free the whole Fd data structure. + + @param[in] Fd The pointer point to the Fd data structure. + +**/ +VOID +LibBfmFreeFd ( + FIRMWARE_DEVICE *Fd + ) +{ + FV_INFORMATION *CurrentFv; + FV_INFORMATION *TempFv; + ENCAP_INFO_DATA *EncapData1; + ENCAP_INFO_DATA *EncapData2; + + CurrentFv = NULL; + TempFv = NULL; + EncapData1 = NULL; + EncapData2 = NULL; + + if (Fd == NULL) { + return; + } + + CurrentFv = Fd->Fv; + + do { + TempFv = CurrentFv; + CurrentFv = CurrentFv->FvNext; + + if (TempFv->FvHeader != NULL) { + free (TempFv->FvHeader); + } + if (TempFv->FvExtHeader != NULL) { + free (TempFv->FvExtHeader); + } + + // + // Free encapsulate data; + // + EncapData1 = TempFv->EncapData; + + while (EncapData1 != NULL) { + + EncapData2 = EncapData1; + EncapData1 = EncapData1->NextNode; + + if (EncapData2->Data != NULL) { + free (EncapData2->Data); + } + if (EncapData2->FvExtHeader != NULL) { + free(EncapData2->FvExtHeader); + } + free (EncapData2); + EncapData2 = NULL; + } + + EncapData1 = NULL; + + free (TempFv); + TempFv = NULL; + + } while (CurrentFv != NULL); + + CurrentFv = NULL; + free (Fd); + Fd = NULL; + + return; +} + +/** + Generate the compressed section with specific type. + Type could be EFI_STANDARD_COMPRESSION or EFI_NOT_COMPRESSED + + @param[in] InputFileName File name of the raw data. + @param[in] OutPutFileName File name of the sectioned data. + @param[in] CompressionType The compression type. + + @return EFI_INVALID_PARAMETER + @return EFI_ABORTED + @return EFI_OUT_OF_RESOURCES + @return EFI_SUCCESS + +**/ +EFI_STATUS +LibGenCompressedSection ( + CHAR8 *InputFileName, + CHAR8 *OutPutFileName, + UINT8 CompressionType +) +{ + FILE *UnCompressFile; + FILE *CompressedFile; + VOID *UnCompressedBuffer; + VOID *CompressedBuffer; + UINT32 UnCompressedSize; + UINT32 CompressedSize; + CHAR8 *TempName; + CHAR8 *TemDir; + CHAR8 *TemString; + EFI_STATUS Status; + + UnCompressFile = NULL; + CompressedFile = NULL; + UnCompressedBuffer = NULL; + CompressedBuffer = NULL; + TempName = NULL; + TemDir = NULL; + TemString = NULL; + UnCompressedSize = 0; + CompressedSize = 0; + + if ( InputFileName == NULL || + OutPutFileName == NULL) { + printf ("Error while generate compressed section!\n"); + return EFI_INVALID_PARAMETER; + } + + if (CompressionType == EFI_STANDARD_COMPRESSION) { + UnCompressFile = fopen (InputFileName, "rb"); + if (UnCompressFile == NULL) { + printf ("Error while open file %s \n", InputFileName); + return EFI_ABORTED; + } + + TemDir = getcwd (NULL, _MAX_PATH); + if (strlen (TemDir) + strlen (OS_SEP_STR) + strlen (TEMP_DIR_NAME) > _MAX_PATH - 1) { + printf ("The directory is too long \n"); + fclose (UnCompressFile); + return EFI_ABORTED; + } + strncat (TemDir, OS_SEP_STR, _MAX_PATH - strlen (TemDir) - 1); + strncat (TemDir, TEMP_DIR_NAME, _MAX_PATH - strlen (TemDir) - 1); + TemString = GenTempFile (); + TempName= LibFilenameStrExtended (strrchr(TemString, OS_SEP), TemDir, "comp"); + free (TemString); + TemString = NULL; + if (TempName == NULL) { + fclose(UnCompressFile); + return EFI_ABORTED; + } + + CompressedFile = fopen (TempName, "wb+"); + if (CompressedFile == NULL) { + printf ("Error while open file %s \n", TempName); + fclose(UnCompressFile); + free (TempName); + return EFI_ABORTED; + } + // + // Get the original file size; + // + fseek(UnCompressFile,0,SEEK_SET); + fseek(UnCompressFile,0,SEEK_END); + + UnCompressedSize = ftell(UnCompressFile); + + fseek(UnCompressFile,0,SEEK_SET); + + UnCompressedBuffer = malloc (UnCompressedSize); + + if (UnCompressedBuffer == NULL) { + printf ("Out of resource, memory allocation failed. \n"); + fclose (CompressedFile); + fclose(UnCompressFile); + free (TempName); + return EFI_OUT_OF_RESOURCES; + } + + CompressedBuffer = malloc (UnCompressedSize); + + if (CompressedBuffer == NULL) { + printf ("Out of resource, memory allocation failed. \n"); + free (UnCompressedBuffer); + fclose (CompressedFile); + fclose(UnCompressFile); + free (TempName); + return EFI_OUT_OF_RESOURCES; + } + + if (fread (UnCompressedBuffer, 1, (size_t) UnCompressedSize, UnCompressFile) == (size_t) UnCompressedSize) { + CompressedSize = UnCompressedSize; + + Status = EfiCompress ( UnCompressedBuffer, + UnCompressedSize, + CompressedBuffer, + &CompressedSize); + + if (EFI_ERROR(Status)) { + printf("Error while do compress operation! \n"); + free (UnCompressedBuffer); + free (CompressedBuffer); + fclose (CompressedFile); + fclose(UnCompressFile); + free (TempName); + return EFI_ABORTED; + } + + if (CompressedSize > UnCompressedSize) { + printf("Error while do compress operation! \n"); + free (UnCompressedBuffer); + free (CompressedBuffer); + fclose (CompressedFile); + fclose(UnCompressFile); + free (TempName); + return EFI_ABORTED; + } + } else { + printf("Error while reading file %s! \n", InputFileName); + free (UnCompressedBuffer); + free (CompressedBuffer); + fclose (CompressedFile); + fclose(UnCompressFile); + free (TempName); + return EFI_ABORTED; + } + + // + // Write the compressed data into output file + // + if (fwrite (CompressedBuffer, 1, (size_t) CompressedSize, CompressedFile) != (size_t) CompressedSize) { + printf ("Error while writing %s file. \n", OutPutFileName); + free (UnCompressedBuffer); + free (CompressedBuffer); + fclose(UnCompressFile); + fclose (CompressedFile); + free (TempName); + return EFI_ABORTED; + } + + fclose(UnCompressFile); + fclose (CompressedFile); + free (UnCompressedBuffer); + free (CompressedBuffer); + + // + // Call GenSec tool to generate the compressed section. + // + LibCreateFfsSection(TempName, NULL, EFI_SECTION_COMPRESSION, OutPutFileName, NULL, NULL, NULL, "PI_STD"); + free (TempName); + TempName = NULL; + + } else if (CompressionType == EFI_NOT_COMPRESSED) { + + LibCreateFfsSection(InputFileName, NULL, EFI_SECTION_COMPRESSION, OutPutFileName, NULL, NULL, NULL, "PI_NONE"); + + } else { + printf ("Error while generate compressed section, unknown compression type! \n"); + return EFI_INVALID_PARAMETER; + } + return EFI_SUCCESS; +} + +#define BUILD_IN_TOOL_COUNT 4 + +EFI_HANDLE +LibPreDefinedGuidedTools ( + VOID +) +{ + EFI_GUID Guid; + STRING_LIST *Tool; + GUID_SEC_TOOL_ENTRY *FirstGuidTool; + GUID_SEC_TOOL_ENTRY *LastGuidTool; + GUID_SEC_TOOL_ENTRY *NewGuidTool; + UINT8 Index; + EFI_STATUS Status; + + CHAR8 PreDefinedGuidedTool[BUILD_IN_TOOL_COUNT][255] = { + "a31280ad-481e-41b6-95e8-127f4c984779 TIANO TianoCompress", + "ee4e5898-3914-4259-9d6e-dc7bd79403cf LZMA LzmaCompress", + "fc1bcdb0-7d31-49aa-936a-a4600d9dd083 CRC32 GenCrc32", + "3d532050-5cda-4fd0-879e-0f7f630d5afb BROTLI BrotliCompress" + }; + + + Tool = NULL; + FirstGuidTool = NULL; + LastGuidTool = NULL; + NewGuidTool = NULL; + Index = 0; + + for (Index = 0; Index < BUILD_IN_TOOL_COUNT; Index++) { + Tool = SplitStringByWhitespace (PreDefinedGuidedTool[Index]); + if ((Tool != NULL) && + (Tool->Count == 3) + ) { + Status = StringToGuid (Tool->Strings[0], &Guid); + if (!EFI_ERROR (Status)) { + NewGuidTool = malloc (sizeof (GUID_SEC_TOOL_ENTRY)); + if (NewGuidTool != NULL) { + memcpy (&(NewGuidTool->Guid), &Guid, sizeof (Guid)); + NewGuidTool->Name = CloneString(Tool->Strings[1]); + NewGuidTool->Path = CloneString(Tool->Strings[2]); + NewGuidTool->Next = NULL; + } else { + printf ( "Fail to allocate memory. \n"); + if (Tool != NULL) { + FreeStringList (Tool); + } + return NULL; + } + if (FirstGuidTool == NULL) { + FirstGuidTool = NewGuidTool; + } else { + LastGuidTool->Next = NewGuidTool; + } + LastGuidTool = NewGuidTool; + } + } else { + fprintf (stdout, "Error"); + } + if (Tool != NULL) { + FreeStringList (Tool); + Tool = NULL; + } + } + return FirstGuidTool; +} + +EFI_STATUS +LibLocateFvViaFvId ( + IN FIRMWARE_DEVICE *FdData, + IN CHAR8 *FvId, + IN OUT FV_INFORMATION **FvInFd +) +{ + UINT8 FvIndex1; + UINT8 FvIndex2; + BOOLEAN FvFoundFlag; + + FvIndex1 = 0; + FvIndex2 = 0; + FvFoundFlag = FALSE; + + if (FdData == NULL || FvId == NULL) { + printf ( "Error while find FV in FD. \n"); + return EFI_INVALID_PARAMETER; + } + + *FvInFd = FdData->Fv; + + FvIndex1 = (UINT8) atoi (FvId + 2); + + while (FvInFd != NULL) { + if (((*FvInFd)->FvName) != NULL) { + FvIndex2 = (UINT8) atoi ((*FvInFd)->FvName + 2); + + if ((FvIndex2 <= FvIndex1) && (((*FvInFd)->FvLevel + FvIndex2) -1 >= FvIndex1)) { + FvFoundFlag = TRUE; + break; + } + if ((*FvInFd)->FvNext == 0) { + break; + } + *FvInFd = (*FvInFd)->FvNext; + } + } + + // + // The specified FV id has issue, can not find the FV in FD. + // + if (!FvFoundFlag) { + printf ( "Error while find FV in FD. \n"); + return EFI_ABORTED; + } + + return EFI_SUCCESS; + +} + + +EFI_STATUS +LibPatchResetVectorAndFitTableData ( +IN CHAR8 *OutputFileName, +IN PATCH_DATA_PAD_FFS *PatchData +) +{ + FILE* NewFvFile; + UINT64 NewFvLength; + UINT8 *Buffer; + UINT32 Count; + + + Count = 0; + Buffer = NULL; + NewFvFile = NULL; + + if (OutputFileName == NULL || PatchData == NULL) { + return EFI_ABORTED; + } + + NewFvFile = fopen (OutputFileName, "rb+"); + if (NewFvFile == NULL) { + return EFI_ABORTED; + } + + fseek(NewFvFile, 0, SEEK_SET); + fseek(NewFvFile, 0, SEEK_END); + + NewFvLength = ftell(NewFvFile); + + do { + + // + // The FV length should larger than Offset. + // + if (NewFvLength < PatchData->Offset) { + fclose (NewFvFile); + return EFI_ABORTED; + } + + fseek(NewFvFile,PatchData->Offset,SEEK_SET); + + Buffer = (UINT8 *) malloc (PatchData->Length); + + if (Buffer == NULL) { + fclose (NewFvFile); + return EFI_ABORTED; + } + + if (fread (Buffer, 1, (size_t) PatchData->Length, NewFvFile) != (size_t) PatchData->Length) { + fclose (NewFvFile); + free(Buffer); + return EFI_ABORTED; + } + + // + // The area used to patch data should be filled by 0xff. + // + for (Count = 0; Count< PatchData->Length; Count++) { + if (Buffer[Count] != 0xff){ + fclose (NewFvFile); + free(Buffer); + return EFI_ABORTED; + } + } + + free(Buffer); + + fseek(NewFvFile,PatchData->Offset,SEEK_SET); + + if (fwrite (PatchData->Data, 1, (size_t) PatchData->Length, NewFvFile) != (size_t) PatchData->Length) { + fclose (NewFvFile); + return EFI_ABORTED; + } + + PatchData = PatchData->NextNode; + } while (PatchData != NULL); + + fclose (NewFvFile); + + return EFI_SUCCESS; +} + +EFI_STATUS +LibEncapNewFvFile( + IN FV_INFORMATION *FvInFd, + IN CHAR8 *TemDir, + OUT CHAR8 **OutputFile +) +{ + EFI_STATUS Status; + UINT32 ParentType; + UINT8 ParentLevel; + UINT32 Type; + UINT8 Level; + CHAR8 *InfFileName; + FILE *InfFile; + ENCAP_INFO_DATA *LocalEncapData; + BOOLEAN FfsFoundFlag; + UINT32 Index; + CHAR8 *ExtractionTool; + BOOLEAN IsLastLevelFfs; + BOOLEAN IsLeafFlagIgnore; + BOOLEAN FirstInFlag; + CHAR8 *InputFileName; + CHAR8 *OutputFileName; + CHAR8 *FvGuidName; + + Index = 0; + ParentType = 0; + ParentLevel = 0; + Type = 0; + Level = 0; + FfsFoundFlag = FALSE; + ExtractionTool = NULL; + InputFileName = NULL; + OutputFileName = NULL; + IsLastLevelFfs = TRUE; + IsLeafFlagIgnore = FALSE; + FirstInFlag = TRUE; + FvGuidName = NULL; + + // + // Encapsulate from the lowest FFS file level. + // + LocalEncapData = FvInFd->EncapData; + Level = LocalEncapData->Level; + Type = LocalEncapData->Type; + + // + // Get FV Name GUID + // + + while (LocalEncapData != NULL) { + // + // Has changed. + // + if (LocalEncapData->Level > Level) { + if (LocalEncapData->Type == BFM_ENCAP_TREE_FFS) { + ParentLevel = Level; + ParentType = Type; + } + + Level = LocalEncapData->Level; + Type = LocalEncapData->Type; + } + + if (LocalEncapData->NextNode != NULL) { + LocalEncapData = LocalEncapData->NextNode; + } else { + break; + } + } + + do { + switch (ParentType) { + case BFM_ENCAP_TREE_FV: + + // + // Generate FV.inf attributes. + // + InfFileName = LibFilenameStrExtended (strrchr(GenTempFile (), OS_SEP), TemDir, "inf"); + + InfFile = fopen (InfFileName, "wt+"); + + if (InfFile == NULL) { + printf ("Could not open inf file %s to store FV information. \n", InfFileName); + return EFI_ABORTED; + } + + LocalEncapData = FvInFd->EncapData; + while (LocalEncapData->NextNode != NULL) { + if (LocalEncapData->Level == ParentLevel) { + break; + } + LocalEncapData = LocalEncapData->NextNode; + } + + if (((EFI_FIRMWARE_VOLUME_HEADER *)(LocalEncapData->Data))->ExtHeaderOffset != 0) { + // + // FV GUID Name memory allocation + // + FvGuidName = (CHAR8 *) malloc (255); + + if (FvGuidName == NULL) { + printf ("Out of resource, memory allocation failed. \n"); + fclose (InfFile); + return EFI_ABORTED; + } + + memset(FvGuidName, '\0', 255); + + sprintf( + FvGuidName, + "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X\n", + LocalEncapData->FvExtHeader->FvName.Data1, + LocalEncapData->FvExtHeader->FvName.Data2, + LocalEncapData->FvExtHeader->FvName.Data3, + LocalEncapData->FvExtHeader->FvName.Data4[0], + LocalEncapData->FvExtHeader->FvName.Data4[1], + LocalEncapData->FvExtHeader->FvName.Data4[2], + LocalEncapData->FvExtHeader->FvName.Data4[3], + LocalEncapData->FvExtHeader->FvName.Data4[4], + LocalEncapData->FvExtHeader->FvName.Data4[5], + LocalEncapData->FvExtHeader->FvName.Data4[6], + LocalEncapData->FvExtHeader->FvName.Data4[7] + ); + + } else { + FvGuidName = NULL; + } + + + if (ParentLevel == 1) { + Status = LibFvHeaderOptionToStr(((EFI_FIRMWARE_VOLUME_HEADER *)LocalEncapData->Data)->BlockMap, InfFile, TRUE); + } else { + Status = LibFvHeaderOptionToStr(((EFI_FIRMWARE_VOLUME_HEADER *)LocalEncapData->Data)->BlockMap, InfFile, FALSE); + } + + + if (EFI_ERROR (Status)) { + printf ("Generate FV INF file [Options] section failed.\n"); + fclose (InfFile); + if (FvGuidName != NULL) { + free (FvGuidName); + } + return Status; + } + + Status = LibFvHeaderAttributeToStr(((EFI_FIRMWARE_VOLUME_HEADER *)LocalEncapData->Data)->Attributes, InfFile); + + if (EFI_ERROR (Status)) { + printf ("Generate FV header attribute failed.\n"); + if (FvGuidName != NULL) { + free (FvGuidName); + } + fclose (InfFile); + return Status; + } + if (LocalEncapData->FvExtHeader != NULL) { + Status = LibGenExtFile(LocalEncapData->FvExtHeader, InfFile); + if (FvGuidName != NULL) { + free (FvGuidName); + } + if (EFI_ERROR(Status)) { + printf("Generate FV EXT header failed.\n"); + fclose (InfFile); + return Status; + } + FvGuidName = NULL; + } + + // + // Found FFSs from Fv structure. + // + FfsFoundFlag = FALSE; + for (Index = 0; Index <= FvInFd->FfsNumbers; Index++) { + + // + // For the last level FFS, the level below FFSs we should not care the IsLeaf Flag. + // + if (IsLastLevelFfs) { + IsLeafFlagIgnore = TRUE; + } else { + IsLeafFlagIgnore = FvInFd->FfsAttuibutes[Index].IsLeaf; + } + + if (FvInFd->FfsAttuibutes[Index].Level >= ParentLevel + 1 && IsLeafFlagIgnore) { + if (FirstInFlag) { + Status = LibAddFfsFileToFvInf (FvInFd->FfsAttuibutes[Index].FfsName, InfFile, TRUE); + + if (EFI_ERROR (Status)) { + printf ("Error while generate FV inf file [files] section. \n"); + fclose (InfFile); + return Status; + } + + FvInFd->FfsAttuibutes[Index].Level = 0; + FirstInFlag = FALSE; + } else { + Status = LibAddFfsFileToFvInf (FvInFd->FfsAttuibutes[Index].FfsName, InfFile, FALSE); + + if (EFI_ERROR (Status)) { + printf ("Error while generate FV inf file [files] section. \n"); + fclose (InfFile); + return Status; + } + + FvInFd->FfsAttuibutes[Index].Level = 0; + } + FfsFoundFlag = TRUE; + } + // + // Also add the sub FV + // + if (FvInFd->FfsAttuibutes[Index].Level - 1 == ParentLevel+ 1) { + LocalEncapData = FvInFd->EncapData; + while (LocalEncapData->NextNode != NULL) { + if (LocalEncapData->Level == ParentLevel + 2) { + break; + } + LocalEncapData = LocalEncapData->NextNode; + } + + if (LocalEncapData->Type == BFM_ENCAP_TREE_GUIDED_SECTION) { + Status = LibAddFfsFileToFvInf (FvInFd->FfsAttuibutes[Index].FfsName, InfFile, FALSE); + + if (EFI_ERROR (Status)) { + printf ("Error while generate FV inf file [files] section.\n"); + fclose (InfFile); + return Status; + } + + FvInFd->FfsAttuibutes[Index].Level = 0; + } + + } + } + + IsLastLevelFfs = FALSE; + FirstInFlag = TRUE; + if (!FfsFoundFlag) { + Status = LibAddFfsFileToFvInf (OutputFileName, InfFile, TRUE); + if (EFI_ERROR (Status)) { + printf ("Error while generate FV inf file [files] section.\n"); + fclose (InfFile); + return Status; + } + } + /* + if (OutputFileName != NULL && FfsFoundFlag) { + Status = LibAddFfsFileToFvInf (OutputFileName, InfFile, FALSE); + + if (EFI_ERROR (Status)) { + //Error ("FMMT", 0, 0004, "error while encapsulate FD Image", "Generate FV inf file [files] section failed!"); + return Status; + } + } + */ + // + // Create FV + // + fclose (InfFile); + OutputFileName= LibFilenameStrExtended (strrchr(GenTempFile (), OS_SEP), TemDir, "FV"); + Status = LibEncapsulateFfsToFv (InfFileName, NULL, OutputFileName, FvGuidName); + if (FvGuidName != NULL) { + free (FvGuidName); + } + if (EFI_ERROR (Status)) { + return Status; + } + + // + // Patch FIT Table Data or reset vector data if exist. + // + if ((FvInFd->PatchData != NULL) && (1 == ParentLevel)) { + Status = LibPatchResetVectorAndFitTableData(OutputFileName, FvInFd->PatchData); + if (EFI_ERROR (Status)) { + printf ("Error while patch FIT Table Data or reset vector data. \n"); + return Status; + } + } + + break; + case BFM_ENCAP_TREE_FFS: + if (OutputFileName != NULL) { + InputFileName = OutputFileName; + OutputFileName= LibFilenameStrExtended (strrchr(GenTempFile (), OS_SEP), TemDir, "ffs"); + + LocalEncapData = FvInFd->EncapData; + while (LocalEncapData->NextNode != NULL) { + if (LocalEncapData->Level == Level) { + break; + } + LocalEncapData = LocalEncapData->NextNode; + } + + Status = LibEncapSectionFileToFFS(EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE, InputFileName, OutputFileName, ((EFI_FFS_FILE_HEADER *)LocalEncapData->Data)->Name, FALSE, 0); + + if (EFI_ERROR (Status)) { + printf ("Error while generate FFS file. \n"); + return Status; + } + } + break; + case BFM_ENCAP_TREE_GUIDED_SECTION: + // + // Create the guided section original data, do compress operation. + // + InputFileName = OutputFileName; + OutputFileName= LibFilenameStrExtended (strrchr(GenTempFile (), OS_SEP), TemDir, "compressed"); + + // + // Use the guided section header guid to find out compress application name. + // + LocalEncapData = FvInFd->EncapData; + while (LocalEncapData->NextNode != NULL) { + if (LocalEncapData->Level == ParentLevel) { + break; + } + LocalEncapData = LocalEncapData->NextNode; + } + + ExtractionTool = + LookupGuidedSectionToolPath ( + mParsedGuidedSectionTools, + (EFI_GUID *)LocalEncapData->Data + ); + + Status = LibCreateGuidedSectionOriginalData (InputFileName, ExtractionTool, OutputFileName); + + if (EFI_ERROR (Status)) { + printf ("Error while compress guided data. \n"); + return Status; + } + + InputFileName = OutputFileName; + OutputFileName= LibFilenameStrExtended (strrchr(GenTempFile (), OS_SEP), TemDir, "guided"); + + Status = LibCreateFfsSection(InputFileName, NULL, EFI_SECTION_GUID_DEFINED, OutputFileName, NULL, NULL, LibBfmGuidToStr((EFI_GUID *)LocalEncapData->Data), NULL); + + if (EFI_ERROR (Status)) { + printf ("Error while generate guided section. \n"); + return Status; + } + + break; + case BFM_ENCAP_TREE_COMPRESS_SECTION: + if (OutputFileName != NULL) { + InputFileName = OutputFileName; + + OutputFileName= LibFilenameStrExtended (strrchr(GenTempFile (), OS_SEP), TemDir, "comsec"); + + LocalEncapData = FvInFd->EncapData; + while (LocalEncapData->NextNode != NULL) { + if (LocalEncapData->Level == ParentLevel) { + break; + } + LocalEncapData = LocalEncapData->NextNode; + } + + Status = LibGenCompressedSection (InputFileName, OutputFileName, *(UINT8 *)(LocalEncapData->Data)); + + if (EFI_ERROR (Status)) { + printf ("Error while generate compressed section. \n"); + return Status; + } + } + break; + case BFM_ENCAP_TREE_FV_SECTION: + InputFileName = OutputFileName; + OutputFileName= LibFilenameStrExtended (strrchr(GenTempFile (), OS_SEP), TemDir, "sec"); + + Status = LibCreateFfsSection(InputFileName, NULL, EFI_SECTION_FIRMWARE_VOLUME_IMAGE, OutputFileName, NULL, NULL, NULL, NULL); + + if (EFI_ERROR (Status)) { + printf ("Error while generate FV section. \n"); + return Status; + } + + InputFileName = OutputFileName; + OutputFileName= LibFilenameStrExtended (strrchr(GenTempFile (), OS_SEP), TemDir, "sec"); + + // + // Make it alignment. + // + Status = LibCreateFfsSection(InputFileName, NULL, 0, OutputFileName, NULL, NULL, NULL, NULL); + + if (EFI_ERROR (Status)) { + printf ("Error while generate FV section. \n"); + return Status; + } + + break; + default: + printf("Don't know how to encapsulate the FD file! \n"); + return EFI_ABORTED; + } + + + // + // Find next level and encapsulate type + // + ParentLevel -= 1; + LocalEncapData = FvInFd->EncapData; + while (LocalEncapData->NextNode != NULL) { + if (LocalEncapData->Level == ParentLevel) { + ParentType = LocalEncapData->Type; + break; + } + LocalEncapData = LocalEncapData->NextNode; + } + } while (ParentLevel != 0); + + + *OutputFile = OutputFileName; + + return EFI_SUCCESS; + +} + +EFI_STATUS +LibLocateBfv( + IN FIRMWARE_DEVICE *FdData, + IN OUT CHAR8 **FvId, + IN OUT FV_INFORMATION **FvInFd +) +{ + UINT8 FvIndex1; + UINT8 FvIndex2; + BOOLEAN FvFoundFlag; + + FvIndex1 = 0; + FvIndex2 = 0; + FvFoundFlag = FALSE; + + if (FdData == NULL || FvId == NULL || FvInFd == NULL) { + return EFI_ABORTED; + } + + *FvId = (*FvInFd)->FvName; + + FvIndex1 = (UINT8) atoi ((*FvInFd)->FvName + 2); + + *FvInFd = FdData->Fv; + + while (FvInFd != NULL) { + if (((*FvInFd)->FvName) != NULL) { + FvIndex2 = (UINT8) atoi ((*FvInFd)->FvName + 2); + + if ((FvIndex2 <= FvIndex1) && (((*FvInFd)->FvLevel + FvIndex2) -1 >= FvIndex1)) { + FvFoundFlag = TRUE; + break; + } + if ((*FvInFd)->FvNext == 0) { + break; + } + *FvInFd = (*FvInFd)->FvNext; + } + } + + // + // The specified FV id has issue, can not find the FV in FD. + // + if (!FvFoundFlag) { + return EFI_ABORTED; + } + + return EFI_SUCCESS; +} + +/** + + Get the length of a file. + + @param[in] FileName The name of a file. + + @retval The length of file. + +**/ +UINT64 +GetFileSize ( + IN CHAR8 *FileName +) +{ + FILE* File; + UINT64 Length; + + File = NULL; + + if (FileName == NULL) { + return 0; + } + File = fopen(FileName, "r"); + + if (File == NULL) { + return 0; + } + fseek(File, 0L, SEEK_END); + Length = ftell(File); + fclose(File); + + return Length; +} + +/** + + Get the length of BFV PAD file. + + @retval The length of PAD file. + +**/ +UINT32 +GetBfvPadSize ( + VOID +) +{ + return PadSizeOfBfv; +} + diff --git a/BaseTools/Source/C/BfmLib/BinFileManager.c b/BaseTools/Source/C/BfmLib/BinFileManager.c new file mode 100644 index 0000000000..8c8b67bd37 --- /dev/null +++ b/BaseTools/Source/C/BfmLib/BinFileManager.c @@ -0,0 +1,1024 @@ +/** @file + + The main entry of BFM tool. + + Copyright (c) 2011-2019, Intel Corporation. All rights reserved.
+ SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +#include "BinFileManager.h" + +BOOLEAN mFvGuidIsSet = FALSE; +EFI_GUID mFvNameGuid = {0}; +CHAR8* mFvNameGuidString = NULL; +CHAR8* mGuidToolDefinition = "GuidToolDefinitionConf.ini"; + +// +// Store GUIDed Section guid->tool mapping +// +EFI_HANDLE mParsedGuidedSectionTools = NULL; + + +/** + Search the config file from the path list. + + Split the path from env PATH, and then search the cofig + file from these paths. The priority is from left to + right of PATH string. When met the first Config file, it + will break and return the pointer to the full file name. + + @param PathList the pointer to the path list. + @param FileName the pointer to the file name. + + @retval The pointer to the file name. + @return NULL An error occurred. +**/ +CHAR8 * +SearchConfigFromPathList ( + IN CHAR8 *PathList, + IN CHAR8 *FileName +) +{ + CHAR8 *CurDir; + CHAR8 *FileNamePath; + + CurDir = NULL; + FileNamePath = NULL; +#ifndef __GNUC__ + CurDir = strtok (PathList,";"); +#else + CurDir = strtok (PathList,":"); +#endif + while (CurDir != NULL) { + FileNamePath = (char *)calloc( + strlen (CurDir) + strlen (OS_SEP_STR) +strlen (FileName) + 1, + sizeof(char) + ); + if (FileNamePath == NULL) { + return NULL; + } + sprintf(FileNamePath, "%s%c%s", CurDir, OS_SEP, FileName); + if (access (FileNamePath, 0) != -1) { + return FileNamePath; + } +#ifndef __GNUC__ + CurDir = strtok(NULL, ";"); +#else + CurDir = strtok(NULL, ":"); +#endif + free (FileNamePath); + FileNamePath = NULL; + } + return NULL; +} + +/** + + Show the FD image layout information. Only display the modules with UI name. + + @param[in] FdInName Input FD binary/image file name; + @param[in] FvName The FV ID in the FD file; + @param[in] ViewFlag Is this call for view or other operate(add/del/replace) + @param[in] FdData The Fd data structure store the FD information. + + @retval EFI_SUCCESS + @retval EFI_INVALID_PARAMETER + @retval EFI_ABORTED + +**/ +EFI_STATUS +BfmImageView ( + IN CHAR8* FdInName, + IN CHAR8* FvName, + IN BOOLEAN ViewFlag, + IN FIRMWARE_DEVICE **FdData +) +{ + EFI_STATUS Status; + FIRMWARE_DEVICE *LocalFdData; + FV_INFORMATION *CurrentFv; + FILE *InputFile; + UINT32 FvSize; + UINTN BytesRead; + EFI_FIRMWARE_VOLUME_HEADER *FvImage; + UINT32 FfsCount; + UINT8 FvCount; + UINT8 LastFvNumber; + + LocalFdData = NULL; + CurrentFv = NULL; + FvImage = NULL; + FvSize = 0; + BytesRead = 0; + FfsCount = 0; + FvCount = 0; + LastFvNumber = 0; + + // + // Check the FD file name/path. + // + if (FdInName == NULL) { + return EFI_INVALID_PARAMETER; + } + + // + // Open the file containing the FV + // + InputFile = fopen (FdInName, "rb"); + if (InputFile == NULL) { + return EFI_INVALID_PARAMETER; + } + + Status = LibFindFvInFd (InputFile, &LocalFdData); + + if (EFI_ERROR(Status)) { + fclose (InputFile); + return EFI_ABORTED; + } + + CurrentFv = LocalFdData->Fv; + + do { + + memset (CurrentFv->FvName, '\0', _MAX_PATH); + + if (LastFvNumber == 0) { + sprintf (CurrentFv->FvName, "FV%d", LastFvNumber); + } else { + sprintf (CurrentFv->FvName, "FV%d", LastFvNumber); + } + + // + // Determine size of FV + // + if (fseek (InputFile, CurrentFv->ImageAddress, SEEK_SET) != 0) { + fclose (InputFile); + LibBfmFreeFd( LocalFdData); + return EFI_ABORTED; + } + + Status = LibGetFvSize(InputFile, &FvSize); + if (EFI_ERROR (Status)) { + fclose (InputFile); + return EFI_ABORTED; + } + + // + // Seek to the start of the image, then read the entire FV to the buffer + // + fseek (InputFile, CurrentFv->ImageAddress, SEEK_SET); + + FvImage = (EFI_FIRMWARE_VOLUME_HEADER *) malloc (FvSize); + + if (FvImage == NULL) { + fclose (InputFile); + LibBfmFreeFd( LocalFdData); + return EFI_ABORTED; + } + + BytesRead = fread (FvImage, 1, FvSize, InputFile); + if ((unsigned int) BytesRead != FvSize) { + free (FvImage); + fclose (InputFile); + LibBfmFreeFd( LocalFdData); + return EFI_ABORTED; + } + + // + // Collect FV information each by each. + // + Status = LibGetFvInfo (FvImage, CurrentFv, FvName, 0, &FfsCount, ViewFlag, FALSE); + free (FvImage); + FvImage = NULL; + if (EFI_ERROR (Status)) { + fclose (InputFile); + LibBfmFreeFd( LocalFdData); + return Status; + } + FvCount = CurrentFv->FvLevel; + LastFvNumber = LastFvNumber+FvCount; + + FfsCount = 0; + + CurrentFv = CurrentFv->FvNext; + + } while (CurrentFv != NULL); + + if (!ViewFlag) { + *FdData = LocalFdData; + } else { + LibBfmFreeFd( LocalFdData); + } + + fclose (InputFile); + + return EFI_SUCCESS; +} + +/** + Add an FFS file into a specify FV. + + @param[in] FdInName Input FD binary/image file name; + @param[in] NewFile The name of the file add in; + @param[in] FdOutName Name of output fd file. + + @retval EFI_SUCCESS + @retval EFI_INVALID_PARAMETER + @retval EFI_ABORTED + +**/ +EFI_STATUS +BfmImageAdd ( + IN CHAR8* FdInName, + IN CHAR8* NewFile, + IN CHAR8* FdOutName +) +{ + EFI_STATUS Status; + FIRMWARE_DEVICE *FdData; + FV_INFORMATION *FvInFd; + ENCAP_INFO_DATA *LocalEncapData; + ENCAP_INFO_DATA *LocalEncapDataTemp; + FILE* NewFdFile; + FILE* NewFvFile; + UINT64 NewFvLength; + UINT64 NewFfsLength; + VOID* Buffer; + CHAR8 *TemDir; + UINT8 FvEncapLevel; + UINT8 NewAddedFfsLevel; + BOOLEAN FfsLevelFoundFlag; + CHAR8 *OutputFileName; + CHAR8 *FvId; + BOOLEAN FirstInFlag; + BOOLEAN FvGuidExisted; + + NewFvLength = 0; + FvEncapLevel = 0; + NewAddedFfsLevel = 0; + + FfsLevelFoundFlag = FALSE; + FirstInFlag = TRUE; + FdData = NULL; + FvInFd = NULL; + LocalEncapData = NULL; + NewFdFile = NULL; + NewFvFile = NULL; + Buffer = NULL; + TemDir = NULL; + LocalEncapDataTemp = NULL; + OutputFileName = NULL; + FvId = NULL; + FvGuidExisted = FALSE; + + // + // Get the size of ffs file to be inserted. + // + NewFfsLength = GetFileSize(NewFile); + + Status = BfmImageView (FdInName, NULL, FALSE, &FdData); + + if (EFI_ERROR (Status)) { + printf ("Error while parse %s FD image.\n", FdInName); + return Status; + } + // + // Check the FvGuid whether exists or not when the BIOS hasn't default setting. + // If the FV image with -g GUID can't be found, the storage is still saved into the BFV and report warning message. + // + FvInFd = FdData->Fv; + do { + if (mFvGuidIsSet && FvInFd->IsInputFvFlag) { + FvGuidExisted = TRUE; + break; + } + FvInFd = FvInFd->FvNext; + } while (FvInFd != NULL); + + if (mFvGuidIsSet && !FvGuidExisted) { + printf ("Fv image with the specified FV Name Guid %s can't be found in current FD.\n", mFvNameGuidString); + LibBfmFreeFd(FdData); + return EFI_ABORTED; + } + // + // Iterate to write FFS to each BFV. + // + FvInFd = FdData->Fv; + do { + if ((FvGuidExisted && mFvGuidIsSet && FvInFd->IsInputFvFlag) || ((!FvGuidExisted || (!mFvGuidIsSet)) && FvInFd->IsBfvFlag)) { + + Status = LibLocateBfv (FdData, &FvId, &FvInFd); + + if (EFI_ERROR (Status)) { + printf("Error while locate BFV from FD.\n"); + LibBfmFreeFd(FdData); + return Status; + } + + // + // Determine the new added ffs file level in the FV. + // + LocalEncapData = FvInFd->EncapData; + + while (LocalEncapData != NULL && !FfsLevelFoundFlag ) { + if (LocalEncapData->Type == BFM_ENCAP_TREE_FV) { + if (FvEncapLevel == ((UINT8) atoi (FvId + 2) - (UINT8) atoi (FvInFd->FvName + 2))) { + // + // Found the FFS level in this FV. + // + LocalEncapDataTemp = LocalEncapData; + while (LocalEncapDataTemp != NULL) { + if (LocalEncapDataTemp->Type == BFM_ENCAP_TREE_FFS) { + NewAddedFfsLevel = LocalEncapDataTemp->Level; + FfsLevelFoundFlag = TRUE; + break; + } + if (LocalEncapDataTemp->NextNode != NULL) { + LocalEncapDataTemp = LocalEncapDataTemp->NextNode; + } else { + break; + } + } + } + FvEncapLevel ++; + } + + if (LocalEncapData->NextNode == NULL) { + break; + } else { + LocalEncapData = LocalEncapData->NextNode; + } + } + + // + // Add the new file into FV. + // + FvInFd->FfsNumbers += 1; + if (strlen (NewFile) > _MAX_PATH - 1) { + printf ("The NewFile name is too long \n"); + LibBfmFreeFd(FdData); + return EFI_ABORTED; + } + strncpy (FvInFd->FfsAttuibutes[FvInFd->FfsNumbers].FfsName, NewFile, _MAX_PATH - 1); + FvInFd->FfsAttuibutes[FvInFd->FfsNumbers].FfsName[_MAX_PATH - 1] = 0; + FvInFd->FfsAttuibutes[FvInFd->FfsNumbers].Level = NewAddedFfsLevel; + + TemDir = getcwd (NULL, _MAX_PATH); + if (strlen (TemDir) + strlen (OS_SEP_STR) + strlen (TEMP_DIR_NAME) > _MAX_PATH - 1) { + printf ("The directory is too long \n"); + LibBfmFreeFd(FdData); + return EFI_ABORTED; + } + strncat (TemDir, OS_SEP_STR, _MAX_PATH - strlen (TemDir) - 1); + strncat (TemDir, TEMP_DIR_NAME, _MAX_PATH - strlen (TemDir) - 1); + mkdir(TemDir, S_IRWXU | S_IRWXG | S_IRWXO); + Status = LibEncapNewFvFile (FvInFd, TemDir, &OutputFileName); + + if (EFI_ERROR (Status)) { + printf("Error. The boot firmware volume (BFV) has only the spare space 0x%lx bytes. But the default setting data takes 0x%llx bytes, which can't be inserted into BFV. \n",(unsigned long) GetBfvPadSize (), (unsigned long long)NewFfsLength); + LibBfmFreeFd(FdData); + return Status; + } + + if (FirstInFlag) { + // + // Write New Fv file into the NewFd file. + // + Status = LibCreateNewFdCopy (FdInName, FdOutName); + if (EFI_ERROR (Status)) { + printf("Error while copy from %s to %s file. \n", FdInName, FdOutName); + LibBfmFreeFd(FdData); + return Status; + } + FirstInFlag = FALSE; + } + + NewFdFile = fopen (FdOutName, "rb+"); + if (NewFdFile == NULL) { + printf("Error while create FD file %s. \n", FdOutName); + LibBfmFreeFd(FdData); + return EFI_ABORTED; + } + + NewFvFile = fopen (OutputFileName, "rb+"); + + if (NewFvFile == NULL) { + printf("Error while create Fv file %s. \n", OutputFileName); + fclose(NewFdFile); + LibBfmFreeFd(FdData); + return EFI_ABORTED; + } + + fseek(NewFvFile,0,SEEK_SET); + fseek(NewFvFile,0,SEEK_END); + + NewFvLength = ftell(NewFvFile); + + fseek(NewFvFile,0,SEEK_SET); + + Buffer = malloc ((size_t)NewFvLength); + + if (Buffer == NULL) { + printf ("Error while allocate resource! \n"); + fclose(NewFdFile); + fclose(NewFvFile); + LibBfmFreeFd(FdData); + return EFI_ABORTED; + } + + if (fread (Buffer, 1, (size_t) NewFvLength, NewFvFile) != (size_t) NewFvLength) { + printf("Error while reading Fv file %s. \n", OutputFileName); + free (Buffer); + fclose(NewFdFile); + fclose(NewFvFile); + LibBfmFreeFd(FdData); + return EFI_ABORTED; + } + + fseek(NewFdFile, FvInFd->ImageAddress, SEEK_SET); + fseek(NewFdFile, FvInFd->ImageAddress, SEEK_SET); + + if (NewFvLength <= FvInFd->FvHeader->FvLength) { + if (fwrite (Buffer, 1, (size_t) NewFvLength, NewFdFile) != (size_t) NewFvLength) { + printf("Error while writing FD file %s. \n", FdOutName); + fclose(NewFdFile); + fclose (NewFvFile); + free (Buffer); + LibBfmFreeFd(FdData); + return EFI_ABORTED; + } + } else { + printf("Error. The new size of BFV is 0x%llx bytes, which is larger than the previous size of BFV 0x%llx bytes. \n", (unsigned long long) NewFvLength, (unsigned long long) FvInFd->FvHeader->FvLength); + free (Buffer); + fclose(NewFdFile); + fclose(NewFvFile); + LibBfmFreeFd(FdData); + return EFI_ABORTED; + } + + fclose(NewFdFile); + fclose(NewFvFile); + free (Buffer); + Buffer = NULL; + + } + FvInFd = FvInFd->FvNext; + } while (FvInFd != NULL); + + + LibBfmFreeFd(FdData); + + if (TemDir == NULL) { + if (mFvGuidIsSet) { + printf ("Fv image with the specified FV Name Guid %s can't be found.\n", mFvNameGuidString); + } else { + printf ("BFV image can't be found.\n"); + } + return EFI_NOT_FOUND; + } + + Status = LibRmDir (TemDir); + + if (EFI_ERROR (Status)) { + printf("Error while remove temporary directory. \n"); + return Status; + } + + return EFI_SUCCESS; +} + + +/** + Replace an FFS file into a specify FV. + + @param[in] FdInName Input FD binary/image file name; + @param[in] NewFile The name of the file add in; + @param[in] FdOutName Name of output fd file. + + @retval EFI_SUCCESS + @retval EFI_INVALID_PARAMETER + @retval EFI_ABORTED + +**/ +EFI_STATUS +BfmImageReplace ( + IN CHAR8* FdInName, + IN CHAR8* NewFile, + IN CHAR8* FdOutName +) +{ + EFI_STATUS Status; + FIRMWARE_DEVICE *FdData; + FV_INFORMATION *FvInFd; + FILE* NewFdFile; + FILE* NewFvFile; + UINT64 NewFvLength; + UINT64 NewFfsLength; + VOID* Buffer; + CHAR8 *TemDir; + CHAR8 *OutputFileName; + CHAR8 *FvId; + BOOLEAN FirstInFlag; + UINT32 Index; + BOOLEAN FvToBeUpdate; + BOOLEAN FdIsUpdate; + ENCAP_INFO_DATA *LocalEncapData; + ENCAP_INFO_DATA *LocalEncapDataTemp; + UINT8 FvEncapLevel; + UINT8 NewAddedFfsLevel; + BOOLEAN FfsLevelFoundFlag; + EFI_GUID EfiNewAddToBfvGuid; + FILE* FfsFile; + UINTN BytesRead; + BOOLEAN ReplaceSameFv; + BOOLEAN FvGuidExisted; + + NewFvLength = 0; + FdIsUpdate = FALSE; + FirstInFlag = TRUE; + FdData = NULL; + FvInFd = NULL; + NewFdFile = NULL; + NewFvFile = NULL; + Buffer = NULL; + TemDir = NULL; + OutputFileName = NULL; + FvId = NULL; + FfsFile = NULL; + BytesRead = 0; + ReplaceSameFv = FALSE; + FvGuidExisted = FALSE; + + // + // Get the size of ffs file to be inserted. + // + NewFfsLength = GetFileSize(NewFile); + // + // Get FFS GUID + // + FfsFile = fopen (NewFile, "rb"); + if (FfsFile == NULL) { + printf ("Error while read %s.\n", NewFile); + return EFI_ABORTED; + } + fseek (FfsFile, 0, SEEK_SET); + BytesRead = fread (&EfiNewAddToBfvGuid, 1, sizeof(EFI_GUID), FfsFile); + fclose (FfsFile); + if (BytesRead != sizeof(EFI_GUID)) { + printf ("Error while read the GUID from %s.\n", NewFile); + return EFI_ABORTED; + } + Status = BfmImageView (FdInName, NULL, FALSE, &FdData); + + if (EFI_ERROR (Status)) { + printf ("Error while parse %s FD image.\n", FdInName); + return Status; + } + + // + // Check the FvGuid whether exists or not when the BIOS has default setting. + // 1. No option means the storage is saved into the same FV image. + // 2. The FV image with -g GUID can't be found. The storage is still saved into the same FV image and report warning message. + // + if (!mFvGuidIsSet) { + ReplaceSameFv = TRUE; + } + FvInFd = FdData->Fv; + do { + if (mFvGuidIsSet && FvInFd->IsInputFvFlag) { + FvGuidExisted = TRUE; + break; + } + FvInFd = FvInFd->FvNext; + } while (FvInFd != NULL); + + if (mFvGuidIsSet && !FvGuidExisted) { + printf ("Fv image with the specified FV Name Guid %s can't be found in current FD.\n", mFvNameGuidString); + ReplaceSameFv = TRUE; + LibBfmFreeFd(FdData); + return EFI_ABORTED; + } + // + // Interate to insert or replace default setting to Fv + // + FvInFd = FdData->Fv; + do { + FvToBeUpdate = FALSE; + if (mFvGuidIsSet && FvInFd->IsInputFvFlag) { + FvToBeUpdate = TRUE; + } + + Status = LibLocateBfv (FdData, &FvId, &FvInFd); + + if (EFI_ERROR (Status)) { + printf("Error while locate BFV from FD.\n"); + LibBfmFreeFd(FdData); + return Status; + } + + Index = 0; + while (Index <= FvInFd->FfsNumbers) { + // + // Locate the multi-platform ffs in Fv and then replace or delete it. + // + if (!CompareGuid(&FvInFd->FfsHeader[Index].Name, &EfiNewAddToBfvGuid)) { + if (ReplaceSameFv) { + FvToBeUpdate = TRUE; + } + break; + } + Index ++; + } + + if (FvToBeUpdate || (Index <= FvInFd->FfsNumbers)) { + if (FvToBeUpdate) { + FdIsUpdate = TRUE; + if (Index <= FvInFd->FfsNumbers) { + // + // Override original default data by New File + // + if (strlen (NewFile) > _MAX_PATH - 1) { + printf ("The NewFile name is too long \n"); + LibBfmFreeFd(FdData); + return EFI_ABORTED; + } + strncpy (FvInFd->FfsAttuibutes[Index].FfsName, NewFile, _MAX_PATH - 1); + FvInFd->FfsAttuibutes[Index].FfsName[_MAX_PATH - 1] = 0; + } else { + FfsLevelFoundFlag = FALSE; + FvEncapLevel = 0; + NewAddedFfsLevel = 0; + // + // Determine the new added ffs file level in the FV. + // + LocalEncapData = FvInFd->EncapData; + + while (LocalEncapData != NULL && !FfsLevelFoundFlag ) { + if (LocalEncapData->Type == BFM_ENCAP_TREE_FV) { + if (FvEncapLevel == ((UINT8) atoi (FvId + 2) - (UINT8) atoi (FvInFd->FvName + 2))) { + // + // Found the FFS level in this FV. + // + LocalEncapDataTemp = LocalEncapData; + while (LocalEncapDataTemp != NULL) { + if (LocalEncapDataTemp->Type == BFM_ENCAP_TREE_FFS) { + NewAddedFfsLevel = LocalEncapDataTemp->Level; + FfsLevelFoundFlag = TRUE; + break; + } + if (LocalEncapDataTemp->NextNode != NULL) { + LocalEncapDataTemp = LocalEncapDataTemp->NextNode; + } else { + break; + } + } + } + FvEncapLevel ++; + } + + if (LocalEncapData->NextNode == NULL) { + break; + } else { + LocalEncapData = LocalEncapData->NextNode; + } + } + + // + // Add the new file into FV. + // + FvInFd->FfsNumbers += 1; + memcpy (FvInFd->FfsAttuibutes[FvInFd->FfsNumbers].FfsName, NewFile, _MAX_PATH); + FvInFd->FfsAttuibutes[FvInFd->FfsNumbers].Level = NewAddedFfsLevel; + } + } else { + // + // Remove original default data from FV. + // + FvInFd->FfsAttuibutes[Index].FfsName[0] = '\0'; + } + + if (TemDir == NULL) { + TemDir = getcwd (NULL, _MAX_PATH); + if (strlen (TemDir) + strlen (OS_SEP_STR)+ strlen (TEMP_DIR_NAME) > _MAX_PATH - 1) { + printf ("The directory is too long \n"); + LibBfmFreeFd(FdData); + return EFI_ABORTED; + } + strncat (TemDir, OS_SEP_STR, _MAX_PATH - strlen (TemDir) - 1); + strncat (TemDir, TEMP_DIR_NAME, _MAX_PATH - strlen (TemDir) - 1); + mkdir(TemDir, S_IRWXU | S_IRWXG | S_IRWXO); + } + + Status = LibEncapNewFvFile (FvInFd, TemDir, &OutputFileName); + + if (EFI_ERROR (Status)) { + printf("Error. The boot firmware volume (BFV) has only the spare space 0x%lx bytes. But the default setting data takes 0x%llx bytes, which can't be inserted into BFV. \n", (unsigned long) GetBfvPadSize (), (unsigned long long) NewFfsLength); + LibBfmFreeFd(FdData); + return Status; + } + + if (FirstInFlag) { + // + // Write New Fv file into the NewFd file. + // + Status = LibCreateNewFdCopy (FdInName, FdOutName); + if (EFI_ERROR (Status)) { + printf("Error while copy from %s to %s file. \n", FdInName, FdOutName); + LibBfmFreeFd(FdData); + return Status; + } + FirstInFlag = FALSE; + } + + NewFdFile = fopen (FdOutName, "rb+"); + if (NewFdFile == NULL) { + printf("Error while create FD file %s. \n", FdOutName); + LibBfmFreeFd(FdData); + return EFI_ABORTED; + } + + NewFvFile = fopen (OutputFileName, "rb+"); + + if (NewFvFile == NULL) { + printf("Error while create Fv file %s. \n", OutputFileName); + LibBfmFreeFd(FdData); + fclose (NewFdFile); + return EFI_ABORTED; + } + + fseek(NewFvFile,0,SEEK_SET); + fseek(NewFvFile,0,SEEK_END); + + NewFvLength = ftell(NewFvFile); + + fseek(NewFvFile,0,SEEK_SET); + + Buffer = malloc ((size_t)NewFvLength); + + if (Buffer == NULL) { + LibBfmFreeFd(FdData); + fclose (NewFdFile); + fclose (NewFvFile); + return EFI_ABORTED; + } + + if (fread (Buffer, 1, (size_t) NewFvLength, NewFvFile) != (size_t) NewFvLength) { + printf("Error while read Fv file %s. \n", OutputFileName); + LibBfmFreeFd(FdData); + free (Buffer); + fclose (NewFdFile); + fclose (NewFvFile); + return EFI_ABORTED; + } + + fseek(NewFdFile, FvInFd->ImageAddress, SEEK_SET); + fseek(NewFdFile, FvInFd->ImageAddress, SEEK_SET); + + if (NewFvLength <= FvInFd->FvHeader->FvLength) { + if (fwrite (Buffer, 1, (size_t) NewFvLength, NewFdFile) != (size_t) NewFvLength) { + printf("Error while write FD file %s. \n", FdOutName); + fclose(NewFdFile); + fclose (NewFvFile); + LibBfmFreeFd(FdData); + free (Buffer); + return EFI_ABORTED; + } + } else { + printf("Error. The new size of BFV is 0x%llx bytes, which is larger than the previous size of BFV 0x%llx bytes. \n", (unsigned long long) NewFvLength, (unsigned long long) FvInFd->FvHeader->FvLength); + free (Buffer); + LibBfmFreeFd(FdData); + fclose (NewFdFile); + fclose (NewFvFile); + return EFI_ABORTED; + } + + fclose(NewFdFile); + fclose(NewFvFile); + free (Buffer); + Buffer = NULL; + + } + FvInFd = FvInFd->FvNext; + } while (FvInFd != NULL); + + LibBfmFreeFd(FdData); + + if (TemDir == NULL || !FdIsUpdate) { + if (mFvGuidIsSet) { + printf ("Fv image with the specified FV Name Guid %s can't be found.\n", mFvNameGuidString); + } else { + printf ("BFV image can't be found.\n"); + } + return EFI_NOT_FOUND; + } + + Status = LibRmDir (TemDir); + + if (EFI_ERROR (Status)) { + printf("Error while remove temporary directory. \n"); + return Status; + } + + return EFI_SUCCESS; +} + +/** + + The main entry of BFM tool. + +**/ +int main( + int Argc, + char *Argv[] +) +{ + EFI_STATUS Status; + FIRMWARE_DEVICE *FdData; + CHAR8 *InFilePath; + CHAR8 FullGuidToolDefinition[_MAX_PATH]; + CHAR8 *FileName; + UINTN FileNameIndex; + CHAR8 *PathList; + UINTN EnvLen; + CHAR8 *NewPathList; + + FdData = NULL; + PathList = NULL; + NewPathList = NULL; + EnvLen = 0; + + if (Argc <= 1) { + return -1; + } + FileName = Argv[0]; + // + // Save, skip filename arg + // + Argc--; + Argv++; + + if ((stricmp(Argv[0], "-v") == 0)) { + // + // Check the revison of BfmLib + // BfmLib -v + // + printf("%s\n", __BUILD_VERSION); + return 1; + + } + // + // Workaroud: the first call to this function + // returns a file name ends with dot + // +#ifndef __GNUC__ + tmpnam (NULL); +#else + CHAR8 tmp[] = "/tmp/fileXXXXXX"; + UINTN Fdtmp; + Fdtmp = mkstemp(tmp); + close(Fdtmp); +#endif + // + // Get the same path with the application itself + // + if (strlen (FileName) > _MAX_PATH - 1) { + Error (NULL, 0, 2000, "Parameter: Input file name is too long", NULL); + return -1; + } + strncpy (FullGuidToolDefinition, FileName, _MAX_PATH - 1); + FullGuidToolDefinition[_MAX_PATH - 1] = 0; + FileNameIndex = strlen (FullGuidToolDefinition); + while (FileNameIndex != 0) { + FileNameIndex --; + if (FullGuidToolDefinition[FileNameIndex] == OS_SEP) { + FullGuidToolDefinition[FileNameIndex] = 0; + break; + } + } + // + // Build the path list for Config file scan. The priority is below. + // 1. Scan the current path + // 2. Scan the same path with the application itself + // 3. Scan the current %PATH% of OS environment + // 4. Use the build-in default configuration + // + PathList = getenv("PATH"); + if (PathList == NULL) { + Error (NULL, 0, 1001, "Option: Environment variable 'PATH' does not exist", NULL); + return -1; + } + EnvLen = strlen(PathList); + NewPathList = (char *)calloc( + strlen (".") + + strlen (";") + + strlen (FullGuidToolDefinition) + + strlen (";") + + EnvLen + + 1, + sizeof(char) + ); + if (NewPathList == NULL) { + Error (NULL, 0, 4001, "Resource: Memory can't be allocated", NULL); + PathList = NULL; + free (PathList); + return -1; + } +#ifndef __GNUC__ + sprintf (NewPathList, "%s;%s;%s", ".", FullGuidToolDefinition, PathList); +#else + sprintf (NewPathList, "%s:%s:%s", ".", FullGuidToolDefinition, PathList); +#endif + + PathList = NULL; + free (PathList); + // + // Load Guid Tools definition + // + InFilePath = SearchConfigFromPathList(NewPathList, mGuidToolDefinition); + free (NewPathList); + if (InFilePath != NULL) { + printf ("\nThe Guid Tool Definition of BfmLib comes from the '%s'. \n", InFilePath); + mParsedGuidedSectionTools = ParseGuidedSectionToolsFile (InFilePath); + free (InFilePath); + } else { + // + // Use the pre-defined standard guided tools. + // + printf ("\nThe Guid Tool Definition of BfmLib comes from the build-in default configuration. \n"); + mParsedGuidedSectionTools = LibPreDefinedGuidedTools (); + } + + // + // BfmLib -e FdName.Fd + // + if ((stricmp(Argv[0], "-e") == 0)) { + + if (Argc != 2) { + return -1; + } + // + // Extract FFS files. + // + Status = BfmImageView (Argv[1], NULL, FALSE, &FdData); + + if (EFI_ERROR (Status)) { + return -1; + } + + if (FdData == NULL) { + return -1; + } + + LibBfmFreeFd(FdData); + + } else if ((stricmp(Argv[0], "-i") == 0)) { + // + // Insert FFS files to BFV + // BfmLib -i InFdName.Fd FfsName.ffs OutFdName.Fd -g FvNameGuid + // + if (Argc == 6) { + mFvGuidIsSet = TRUE; + mFvNameGuidString = Argv[5]; + StringToGuid (Argv[5], &mFvNameGuid); + Argc -= 2; + } + if (Argc != 4) { + return -1; + } + Status = BfmImageAdd(Argv[1], Argv[2], Argv[3]); + + if (EFI_ERROR (Status)) { + return -1; + } + + } else if ((stricmp(Argv[0], "-r") == 0)) { + // + // Replace FFS files in BFV + // BfmLib -r InFdName.Fd FfsName.ffs OutFdName.Fd -g FvNameGuid + // + if (Argc == 6) { + mFvGuidIsSet = TRUE; + mFvNameGuidString = Argv[5]; + StringToGuid (Argv[5], &mFvNameGuid); + Argc -= 2; + } + if (Argc != 4) { + return -1; + } + Status = BfmImageReplace (Argv[1], Argv[2], Argv[3]); + + if (EFI_ERROR (Status)) { + return -1; + } + + } else { + // + // Invalid parameter. + // + return -1; + } + + return 1; +} + diff --git a/BaseTools/Source/C/BfmLib/BinFileManager.h b/BaseTools/Source/C/BfmLib/BinFileManager.h new file mode 100644 index 0000000000..ea27f2e8f2 --- /dev/null +++ b/BaseTools/Source/C/BfmLib/BinFileManager.h @@ -0,0 +1,439 @@ +/** @file + + The header of BinFileManager.c. + +Copyright (c) 2011-2019, Intel Corporation. All rights reserved.
+SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +#ifndef _BIN_FILE_MANAGER_ +#define _BIN_FILE_MANAGER_ + +#ifdef __GNUC__ +#include +#else +#include +#include +#endif +#include +#include +#include +#include +#include +#include +#include + +#include "CommonLib.h" +#include "EfiUtilityMsgs.h" +#include "ParseGuidedSectionTools.h" +#include "StringFuncs.h" +#include "Compress.h" +#include "Decompress.h" +#include "ParseInf.h" + +#ifndef _MAX_PATH +#define _MAX_PATH 500 +#endif + +#ifdef __GNUC__ +#define OS_SEP '/' +#define OS_SEP_STR "/" +#define COPY_STR "cp \"%s\" \"%s\" > /dev/null" +#define RMDIR_STR "rm -r \"%s\" > /dev/null" +#define DEL_STR "rm \"%s\" > /dev/null" +#else +#define OS_SEP '\\' +#define OS_SEP_STR "\\" +#define COPY_STR "copy \"%s\" \"%s\" > NUL" +#define RMDIR_STR "rmdir /S /Q \"%s\" > NUL" +#define DEL_STR "del \"%s\" > NUL" +#endif + +#define TEMP_DIR_NAME "Temp" +#define UTILITY_NAME "Binary File Manager (BFM)" +#define UTILITY_SHORT_NAME "BFM" +#define UTILITY_MAJOR_VERSION 0 +#define UTILITY_MINOR_VERSION 1 +#define MAX_BASENAME_LEN 60 // not good to HardCode, but let's be reasonable +#define EFI_SECTION_ERROR EFIERR (100) +// +// The maximum number of Pad file guid entries. +// +#define MAX_NUMBER_OF_PAD_FILE_GUIDS 1024 + +// +// The maximum number of block map entries supported by the library +// +#define MAX_NUMBER_OF_FV_BLOCKS 100 + + +// +// The maximum number of sections in an FFS file. +// +#define MAX_NUMBER_OF_SECTION_IN_FFS 100 + +// +// The maximum number of files in the FV supported by the library +// +#define MAX_NUMBER_OF_FILES_IN_FV 1000 +#define MAX_NUMBER_OF_FILES_IN_CAP 1000 + + + +/// +/// If present, this must be the first and only opcode, +/// EFI_DEP_BEFORE is only used by DXE driver. +/// +#define EFI_DEP_BEFORE 0x00 + +/// +/// If present, this must be the first and only opcode, +/// EFI_DEP_AFTER is only used by DXE driver. +/// +#define EFI_DEP_AFTER 0x01 + +#define EFI_DEP_PUSH 0x02 +#define EFI_DEP_AND 0x03 +#define EFI_DEP_OR 0x04 +#define EFI_DEP_NOT 0x05 +#define EFI_DEP_TRUE 0x06 +#define EFI_DEP_FALSE 0x07 +#define EFI_DEP_END 0x08 + + +/// +/// If present, this must be the first opcode, +/// EFI_DEP_SOR is only used by DXE driver. +/// +#define EFI_DEP_SOR 0x09 + +// +// INF file strings +// +#define OPTIONS_SECTION_STRING "[options]" +#define ATTRIBUTES_SECTION_STRING "[attributes]" +#define FILES_SECTION_STRING "[files]" +#define FV_BASE_ADDRESS_STRING "[FV_BASE_ADDRESS]" + +// +// Options section +// +#define EFI_FV_BASE_ADDRESS_STRING "EFI_BASE_ADDRESS" +#define EFI_FV_FILE_NAME_STRING "EFI_FILE_NAME" +#define EFI_NUM_BLOCKS_STRING "EFI_NUM_BLOCKS" +#define EFI_BLOCK_SIZE_STRING "EFI_BLOCK_SIZE" +#define EFI_GUID_STRING "EFI_GUID" +#define EFI_FV_FILESYSTEMGUID_STRING "EFI_FV_GUID" +#define EFI_FV_NAMEGUID_STRING "EFI_FVNAME_GUID" +#define EFI_CAPSULE_GUID_STRING "EFI_CAPSULE_GUID" +#define EFI_CAPSULE_HEADER_SIZE_STRING "EFI_CAPSULE_HEADER_SIZE" +#define EFI_CAPSULE_FLAGS_STRING "EFI_CAPSULE_FLAGS" +#define EFI_CAPSULE_VERSION_STRING "EFI_CAPSULE_VERSION" + +#define EFI_FV_TOTAL_SIZE_STRING "EFI_FV_TOTAL_SIZE" +#define EFI_FV_TAKEN_SIZE_STRING "EFI_FV_TAKEN_SIZE" +#define EFI_FV_SPACE_SIZE_STRING "EFI_FV_SPACE_SIZE" + + +typedef UINT32 BFM_ENCAP_TYPE; + +#define MAX_LEVEL_IN_FV_FILE 32 + +// +// Types of BFM_ENCAP_TREENODE_TYPE +// +#define BFM_ENCAP_TREE_FV 0x1 +#define BFM_ENCAP_TREE_FFS 0x2 +#define BFM_ENCAP_TREE_GUIDED_SECTION 0x3 +#define BFM_ENCAP_TREE_COMPRESS_SECTION 0x4 +#define BFM_ENCAP_TREE_FV_SECTION 0x5 + +extern EFI_HANDLE mParsedGuidedSectionTools; +extern BOOLEAN mFvGuidIsSet; +extern EFI_GUID mFvNameGuid; + +// +// Structure to keep a list of GUID-To-BaseNames +// +typedef struct _GUID_TO_BASENAME { + struct _GUID_TO_BASENAME *Next; + INT8 Guid[PRINTED_GUID_BUFFER_SIZE]; + INT8 BaseName[MAX_BASENAME_LEN]; +} GUID_TO_BASENAME; + +typedef struct _GUID_SEC_TOOL_ENTRY { + EFI_GUID Guid; + CHAR8* Name; + CHAR8* Path; + struct _GUID_SEC_TOOL_ENTRY *Next; +} GUID_SEC_TOOL_ENTRY; + +// +// Private data types +// +// +// Component information +// +typedef struct { + UINTN Size; + CHAR8 ComponentName[_MAX_PATH]; +} COMPONENT_INFO; + +typedef struct { + CHAR8 FfsName[_MAX_PATH]; + + // + // UI Name for this FFS file, if has. + // + CHAR16 UiName[_MAX_PATH]; + + // + // Total section number in this FFS. + // + UINT32 TotalSectionNum; + + // + // Describe the position of the FFS file. + // + UINT8 Level; + // + // If this FFS has no encapsulate section, this flag will set to True. + // + BOOLEAN IsLeaf; + // + // Section type for each section in FFS. + // + EFI_SECTION_TYPE SectionType[MAX_NUMBER_OF_SECTION_IN_FFS]; + +}FFS_ATTRIBUTES; + + +typedef struct __ENCAP_INFO_DATA{ + // + // Now Level + // + UINT8 Level; + + // + // Encapsulate type. + // + BFM_ENCAP_TYPE Type; + + // + // Data, if it's FV, should be FV header. + // + VOID *Data; + + // + // if FV ExtHeaderOffset not to zero, should also have FvExtHeader information + // + EFI_FIRMWARE_VOLUME_EXT_HEADER *FvExtHeader; + + + // + // Next node. + // + struct __ENCAP_INFO_DATA *NextNode; +}ENCAP_INFO_DATA; + + +// +// Contain Offset and Data for PAD FFS contain reset vector or FIT data. +// +typedef struct _PATCH_DATA_PAD_FFS { + // + // The offset of data relative to FV start address; + // + UINT32 Offset; + // + // Data + // + VOID *Data; + // + // Length of Data + // + UINT32 Length; + // + // Next node. + // + struct _PATCH_DATA_PAD_FFS *NextNode; +} PATCH_DATA_PAD_FFS; + + +// +// FV and capsule information holder +// +typedef struct _FV_INFOMATION{ + EFI_FIRMWARE_VOLUME_HEADER *FvHeader; + EFI_FIRMWARE_VOLUME_EXT_HEADER *FvExtHeader; + UINT32 ImageAddress; + UINT32 FfsNumbers; + CHAR8 FvName[_MAX_PATH]; + EFI_FV_BLOCK_MAP_ENTRY FvBlocks[MAX_NUMBER_OF_FV_BLOCKS]; + FFS_ATTRIBUTES FfsAttuibutes[MAX_NUMBER_OF_FILES_IN_FV]; + EFI_FFS_FILE_HEADER2 FfsHeader[MAX_NUMBER_OF_FILES_IN_FV]; + struct _FV_INFOMATION *FvNext; + ENCAP_INFO_DATA *EncapData; + UINT8 FvLevel; + PATCH_DATA_PAD_FFS *PatchData; + BOOLEAN IsBfvFlag; + BOOLEAN IsInputFvFlag; + +} FV_INFORMATION; + +typedef struct _FIRMWARE_DEVICE { + /// + /// Size of FD file + /// + UINT32 Size; + FV_INFORMATION *Fv; +} FIRMWARE_DEVICE; + +VOID +Usage ( + VOID +); + + +CHAR8 * +GenTempFile ( + VOID +); + +EFI_STATUS +LibFindFvInFd ( + IN FILE *InputFile, + IN OUT FIRMWARE_DEVICE **FdData +); + +/** + + Add function description + + @param[in] Fv - Firmware Volume to get information from + + @return EFI_STATUS + +**/ +EFI_STATUS +LibGetFvInfo ( + IN VOID *Fv, + IN OUT FV_INFORMATION *CurrentFv, + IN CHAR8 *FvName, + IN UINT8 Level, + IN UINT32 *FfsCount, + IN BOOLEAN ViewFlag, + IN BOOLEAN IsChildFv + ); + +/* + Get size info from FV file. + + @param[in] + @param[out] + + @retval + +*/ +EFI_STATUS +LibGetFvSize ( + IN FILE *InputFile, + OUT UINT32 *FvSize + ); + + /** + + This function returns the next larger size that meets the alignment + requirement specified. + + @param[in] ActualSize The size. + @param[in] Alignment The desired alignment. + + @retval EFI_SUCCESS Function completed successfully. + @retval EFI_ABORTED The function encountered an error. + +**/ +UINT32 +GetOccupiedSize ( + IN UINT32 ActualSize, + IN UINT32 Alignment + ); + +EFI_STATUS +LibCreateNewFdCopy( + IN CHAR8* OldFd, + IN CHAR8* NewFd + ); + +/** + Delete a directory and files in it. + + @param[in] DirName Name of the directory need to be deleted. + + @return EFI_INVALID_PARAMETER + @return EFI_SUCCESS +**/ +EFI_STATUS +LibRmDir ( + IN CHAR8* DirName + ); + + +/** + + Free the whole Fd data structure. + + @param[in] Fd The pointer point to the Fd data structure. + +**/ +VOID +LibBfmFreeFd ( + FIRMWARE_DEVICE *Fd +); + +EFI_HANDLE +LibPreDefinedGuidedTools ( + VOID +); + +EFI_STATUS +LibEncapNewFvFile( + IN FV_INFORMATION *FvInFd, + IN CHAR8 *TemDir, + OUT CHAR8 **OutputFile +); + +EFI_STATUS +LibLocateBfv( + IN FIRMWARE_DEVICE *FdData, + IN OUT CHAR8 **FvId, + IN OUT FV_INFORMATION **FvInFd +); + +/** + + Get the length of a file. + + @param[in] FileName The name of a file. + + @retval The length of file. + +**/ +UINT64 +GetFileSize ( + IN CHAR8 *FileName +); + +/** + + Get the length of BFV PAD file. + + @retval The length of PAD file. + +**/ +UINT32 +GetBfvPadSize ( + VOID +); +#endif diff --git a/BaseTools/Source/C/BfmLib/GNUmakefile b/BaseTools/Source/C/BfmLib/GNUmakefile new file mode 100644 index 0000000000..a2c2f41a1b --- /dev/null +++ b/BaseTools/Source/C/BfmLib/GNUmakefile @@ -0,0 +1,15 @@ +## @file +# GNU/Linux makefile for 'BfmLib' module build. +# +# Copyright (c) 2011-2019, Intel Corporation. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause-Patent +# +MAKEROOT ?= .. + +APPNAME = BfmLib + +LIBS = -lCommon + +OBJECTS = BinFileManager.o BfmLib.o + +include $(MAKEROOT)/Makefiles/app.makefile diff --git a/BaseTools/Source/C/BfmLib/Makefile b/BaseTools/Source/C/BfmLib/Makefile new file mode 100644 index 0000000000..2b7483b10f --- /dev/null +++ b/BaseTools/Source/C/BfmLib/Makefile @@ -0,0 +1,17 @@ +## @file +# +# Windows makefile for 'BfmLib' module build. +# +# Copyright (c) 2011-2019, Intel Corporation. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause-Patent# +## +!INCLUDE ..\Makefiles\ms.common + +APPNAME = BfmLib + +LIBS = $(LIB_PATH)\Common.lib + +OBJECTS = BinFileManager.obj BfmLib.obj + +!INCLUDE ..\Makefiles\ms.app + diff --git a/BaseTools/Source/C/GNUmakefile b/BaseTools/Source/C/GNUmakefile index 37bcce519c..824f0306e6 100644 --- a/BaseTools/Source/C/GNUmakefile +++ b/BaseTools/Source/C/GNUmakefile @@ -47,6 +47,7 @@ VFRAUTOGEN = VfrCompile/VfrLexer.h APPLICATIONS = \ BrotliCompress \ VfrCompile \ + BfmLib \ EfiRom \ GenFfs \ GenFv \ diff --git a/BaseTools/Source/C/Makefile b/BaseTools/Source/C/Makefile index 217fc2b91d..a6d39eb864 100644 --- a/BaseTools/Source/C/Makefile +++ b/BaseTools/Source/C/Makefile @@ -12,6 +12,7 @@ LIBRARIES = Common APPLICATIONS = \ VfrCompile \ BrotliCompress \ + BfmLib \ EfiRom \ GenCrc32 \ GenFfs \ -- 2.39.2