fwimage.c

来自「EFI BIOS是Intel提出的下一代的BIOS标准。这里上传的Edk源代码是」· C语言 代码 · 共 588 行 · 第 1/2 页

/*++

Copyright (c) 2004 - 2006, Intel Corporation                                                         
All rights reserved. This program and the accompanying materials                          
are licensed and made available under the terms and conditions of the BSD License         
which accompanies this distribution.  The full text of the license may be found at        
http://opensource.org/licenses/bsd-license.php                                            
                                                                                          
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             

Module Name:

  fwimage.c

Abstract:

  Converts a pe32/pe32+ image to an FW image type

--*/

#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#include "TianoCommon.h"
#include "EfiImage.h"
#include "EfiUtilityMsgs.c"

#define UTILITY_NAME  "FwImage"

typedef union {
  IMAGE_NT_HEADERS32 PeHeader32;
  IMAGE_NT_HEADERS64 PeHeader64;
} PE_HEADER;

VOID
Usage (
  VOID
  )
{
  printf ("Usage: " UTILITY_NAME "  {-t time-date} {-e} {-r} [APPLICATION|BS_DRIVER|RT_DRIVER|SAL_RT_DRIVER|COMBINED_PEIM_DRIVER|SECURITY_CORE|PEI_CORE|PE32_PEIM|RELOCATABLE_PEIM] peimage [outimage]\n");
  printf ("  -t: Add Time Stamp for output image\n");
  printf ("  -e: Not clear ExceptionTable for output image\n");
  printf ("  -r: Not strip zero pending of .reloc for output image\n");
}

static
STATUS
FReadFile (
  FILE    *in,
  VOID    **Buffer,
  UINTN   *Length
  )
{
  fseek (in, 0, SEEK_END);
  *Length = ftell (in);
  *Buffer = malloc (*Length);
  fseek (in, 0, SEEK_SET);
  fread (*Buffer, *Length, 1, in);
  return STATUS_SUCCESS;
}

static
STATUS
FWriteFile (
  FILE    *out,
  VOID    *Buffer,
  UINTN   Length
  )
{
  fseek (out, 0, SEEK_SET);
  fwrite (Buffer, Length, 1, out);
  if ((ULONG) ftell (out) != Length) {
    Error (NULL, 0, 0, "write error", NULL);
    return STATUS_ERROR;
  }
  free (Buffer);
  return STATUS_SUCCESS;
}

VOID
ZeroExceptionTable (
  IN UINT8                 *FileBuffer,
  IN EFI_IMAGE_DOS_HEADER  *DosHdr,
  IN PE_HEADER             *PeHdr
  )
{
  UINT32                   PdataSize;
  UINT32                   PdataOffset;
  UINT32                   PdataRVASize;
  UINT32                   PdataRVA;
  UINT32                   SectionOffset;
  UINT16                   SectionNumber;
  UINT32                   SectionNameSize;
  EFI_IMAGE_SECTION_HEADER *Section;

  PdataSize     = 0;
  PdataOffset   = 0;
  PdataRVASize  = 0;
  PdataRVA      = 0;
  SectionOffset = 0;

  //
  // Search .pdata section
  //
  if (PeHdr->PeHeader32.OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
    if ((PeHdr->PeHeader32.OptionalHeader.NumberOfRvaAndSizes > IMAGE_DIRECTORY_ENTRY_EXCEPTION) &&
        (PeHdr->PeHeader32.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXCEPTION].VirtualAddress != 0) &&
        (PeHdr->PeHeader32.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXCEPTION].Size != 0)) {

      PdataRVA     = PeHdr->PeHeader32.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXCEPTION].VirtualAddress;
      PdataRVASize = PeHdr->PeHeader32.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXCEPTION].Size;

      PeHdr->PeHeader32.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXCEPTION].VirtualAddress = 0;
      PeHdr->PeHeader32.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXCEPTION].Size = 0;

      SectionOffset = sizeof(PeHdr->PeHeader32);
    }
  } else {
    if ((PeHdr->PeHeader64.OptionalHeader.NumberOfRvaAndSizes > IMAGE_DIRECTORY_ENTRY_EXCEPTION) &&
        (PeHdr->PeHeader64.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXCEPTION].VirtualAddress != 0) &&
        (PeHdr->PeHeader64.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXCEPTION].Size != 0)) {

      PdataRVA     = PeHdr->PeHeader64.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXCEPTION].VirtualAddress;
      PdataRVASize = PeHdr->PeHeader64.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXCEPTION].Size;

      PeHdr->PeHeader64.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXCEPTION].VirtualAddress = 0;
      PeHdr->PeHeader64.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXCEPTION].Size = 0;

      SectionOffset = sizeof(PeHdr->PeHeader64);
    }
  }

  if ((PdataRVASize != 0) && (PdataRVA != 0)) {

    SectionNumber = PeHdr->PeHeader32.FileHeader.NumberOfSections;
    SectionNameSize = sizeof(Section->Name);
    while (SectionNumber > 0) {
      Section = (EFI_IMAGE_SECTION_HEADER *) &FileBuffer[DosHdr->e_lfanew + SectionOffset];
      if (strcmp (Section->Name, ".pdata") == 0) {
        //
        // Zero .pdata Section Header Name
        //
        memset (
          FileBuffer + DosHdr->e_lfanew + SectionOffset,
          0,
          SectionNameSize);

        //
        // Zero .pdata Secton raw data
        //
        PdataOffset = Section->PointerToRawData;
        PdataSize   = Section->SizeOfRawData;
        memset (FileBuffer + PdataOffset, 0, PdataSize);
        break;
      }
      SectionNumber--;
      SectionOffset += sizeof(EFI_IMAGE_SECTION_HEADER);
    }
  }
  
  return ;
}

VOID
StripZeroPendingReloc (
  IN UINT8                 *FileBuffer,
  IN OUT UINTN             *FileLength,
  IN EFI_IMAGE_DOS_HEADER  *DosHdr,
  IN PE_HEADER             *PeHdr
  )
{
  EFI_IMAGE_OPTIONAL_HEADER32  *Optional32;
  EFI_IMAGE_OPTIONAL_HEADER64  *Optional64;
  EFI_IMAGE_SECTION_HEADER     *SectionHeader;
  UINTN                        AllignedRelocSize;
  UINTN                        Index;

  if (PeHdr->PeHeader32.OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
    Optional32 = (EFI_IMAGE_OPTIONAL_HEADER32 *)&PeHdr->PeHeader32.OptionalHeader;
    if ((Optional32->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC) &&
        (Optional32->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC].Size != 0)) {
      SectionHeader = (EFI_IMAGE_SECTION_HEADER *)(FileBuffer + DosHdr->e_lfanew + sizeof(UINT32) + sizeof (EFI_IMAGE_FILE_HEADER) + PeHdr->PeHeader32.FileHeader.SizeOfOptionalHeader);
      for (Index = 0; Index < PeHdr->PeHeader32.FileHeader.NumberOfSections; Index++, SectionHeader++) {
        //
        // Look for the Section Header that starts as the same virtual address as the Base Relocation Data Directory
        //
        if (strcmp (SectionHeader->Name, ".reloc") == 0) {
          SectionHeader->Misc.VirtualSize = Optional32->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC].Size;

          AllignedRelocSize = (Optional32->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC].Size +
                               Optional32->FileAlignment - 1) & (~(Optional32->FileAlignment - 1));
          //
          // Check to see if there is zero padding at the end of the base relocations
          //
          if (AllignedRelocSize < SectionHeader->SizeOfRawData) {
            //
            // Check to see if the base relocations are at the end of the file
            //
            if (SectionHeader->PointerToRawData + SectionHeader->SizeOfRawData == Optional32->SizeOfImage) {
              //
              // All the required conditions are met to strip the zero padding of the end of the base relocations section
              //
              Optional32->SizeOfImage           -= (SectionHeader->SizeOfRawData - AllignedRelocSize);
              Optional32->SizeOfInitializedData -= (SectionHeader->SizeOfRawData - AllignedRelocSize);
              SectionHeader->SizeOfRawData       = AllignedRelocSize;
              *FileLength                        = Optional32->SizeOfImage;
            }
          }
        }
      }
    }
  } else {
    Optional64 = (EFI_IMAGE_OPTIONAL_HEADER64 *)&PeHdr->PeHeader64.OptionalHeader;
    if ((Optional64->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC) &&
        (Optional64->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC].Size != 0)) {
      SectionHeader = (EFI_IMAGE_SECTION_HEADER *)(FileBuffer + DosHdr->e_lfanew + sizeof(UINT32) + sizeof (EFI_IMAGE_FILE_HEADER) + PeHdr->PeHeader64.FileHeader.SizeOfOptionalHeader);
      for (Index = 0; Index < PeHdr->PeHeader64.FileHeader.NumberOfSections; Index++, SectionHeader++) {
        //
        // Look for the Section Header that starts as the same virtual address as the Base Relocation Data Directory
        //
        if (strcmp (SectionHeader->Name, ".reloc") == 0) {
          SectionHeader->Misc.VirtualSize = Optional64->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC].Size;

          AllignedRelocSize = (Optional64->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC].Size +
                               Optional64->FileAlignment - 1) & (~(Optional64->FileAlignment - 1));
          //
          // Check to see if there is zero padding at the end of the base relocations
          //
          if (AllignedRelocSize < SectionHeader->SizeOfRawData) {
            //
            // Check to see if the base relocations are at the end of the file
            //
            if (SectionHeader->PointerToRawData + SectionHeader->SizeOfRawData == Optional64->SizeOfImage) {
              //
              // All the required conditions are met to strip the zero padding of the end of the base relocations section
              //
              Optional64->SizeOfImage           -= (SectionHeader->SizeOfRawData - AllignedRelocSize);
              Optional64->SizeOfInitializedData -= (SectionHeader->SizeOfRawData - AllignedRelocSize);
              SectionHeader->SizeOfRawData       = AllignedRelocSize;
              *FileLength                        = Optional64->SizeOfImage;
            }
          }
        }
      }
    }
  }
}

int
main (
  int  argc,
  char *argv[]
  )
/*++

Routine Description:

  Main function.

Arguments:

  argc - Number of command line parameters.
  argv - Array of pointers to command line parameter strings.

Returns:

  STATUS_SUCCESS - Utility exits successfully.
  STATUS_ERROR   - Some error occurred during execution.

--*/
{
  ULONG                        Type;
  PUCHAR                       Ext;
  PUCHAR                       p;
  PUCHAR                       pe;
  PUCHAR                       OutImageName;
  UCHAR                        outname[500];
  FILE                         *fpIn;
  FILE                         *fpOut;
  EFI_IMAGE_DOS_HEADER         *DosHdr;
  PE_HEADER                    *PeHdr;
  time_t                       TimeStamp;
  struct tm                    TimeStruct;
  EFI_IMAGE_DOS_HEADER         BackupDosHdr;
  ULONG                        Index;
  BOOLEAN                      TimeStampPresent;
  BOOLEAN                      NeedClearExceptionTable;
  BOOLEAN                      NeedStripZeroPendingReloc;
  UINT8                        *FileBuffer;
  UINTN                        FileLength;