fd171542e0
git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@9257 6f19259b-4bc3-4df7-8a09-765794883524
585 lines
11 KiB
C
585 lines
11 KiB
C
/** @file
|
|
|
|
Copyright (c) 2004 - 2008, 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:
|
|
|
|
CommonLib.c
|
|
|
|
Abstract:
|
|
|
|
Common basic Library Functions
|
|
|
|
**/
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <ctype.h>
|
|
#include "CommonLib.h"
|
|
#include "EfiUtilityMsgs.h"
|
|
|
|
VOID
|
|
PeiZeroMem (
|
|
IN VOID *Buffer,
|
|
IN UINTN Size
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Set Buffer to zero for Size bytes.
|
|
|
|
Arguments:
|
|
|
|
Buffer - Memory to set.
|
|
|
|
Size - Number of bytes to set
|
|
|
|
Returns:
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
INT8 *Ptr;
|
|
|
|
Ptr = Buffer;
|
|
while (Size--) {
|
|
*(Ptr++) = 0;
|
|
}
|
|
}
|
|
|
|
VOID
|
|
PeiCopyMem (
|
|
IN VOID *Destination,
|
|
IN VOID *Source,
|
|
IN UINTN Length
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Copy Length bytes from Source to Destination.
|
|
|
|
Arguments:
|
|
|
|
Destination - Target of copy
|
|
|
|
Source - Place to copy from
|
|
|
|
Length - Number of bytes to copy
|
|
|
|
Returns:
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
CHAR8 *Destination8;
|
|
CHAR8 *Source8;
|
|
|
|
Destination8 = Destination;
|
|
Source8 = Source;
|
|
while (Length--) {
|
|
*(Destination8++) = *(Source8++);
|
|
}
|
|
}
|
|
|
|
VOID
|
|
ZeroMem (
|
|
IN VOID *Buffer,
|
|
IN UINTN Size
|
|
)
|
|
{
|
|
PeiZeroMem (Buffer, Size);
|
|
}
|
|
|
|
VOID
|
|
CopyMem (
|
|
IN VOID *Destination,
|
|
IN VOID *Source,
|
|
IN UINTN Length
|
|
)
|
|
{
|
|
PeiCopyMem (Destination, Source, Length);
|
|
}
|
|
|
|
INTN
|
|
CompareGuid (
|
|
IN EFI_GUID *Guid1,
|
|
IN EFI_GUID *Guid2
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Compares to GUIDs
|
|
|
|
Arguments:
|
|
|
|
Guid1 - guid to compare
|
|
Guid2 - guid to compare
|
|
|
|
Returns:
|
|
= 0 if Guid1 == Guid2
|
|
!= 0 if Guid1 != Guid2
|
|
|
|
--*/
|
|
{
|
|
INT32 *g1;
|
|
INT32 *g2;
|
|
INT32 r;
|
|
|
|
//
|
|
// Compare 32 bits at a time
|
|
//
|
|
g1 = (INT32 *) Guid1;
|
|
g2 = (INT32 *) Guid2;
|
|
|
|
r = g1[0] - g2[0];
|
|
r |= g1[1] - g2[1];
|
|
r |= g1[2] - g2[2];
|
|
r |= g1[3] - g2[3];
|
|
|
|
return r;
|
|
}
|
|
|
|
|
|
EFI_STATUS
|
|
GetFileImage (
|
|
IN CHAR8 *InputFileName,
|
|
OUT CHAR8 **InputFileImage,
|
|
OUT UINT32 *BytesRead
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function opens a file and reads it into a memory buffer. The function
|
|
will allocate the memory buffer and returns the size of the buffer.
|
|
|
|
Arguments:
|
|
|
|
InputFileName The name of the file to read.
|
|
InputFileImage A pointer to the memory buffer.
|
|
BytesRead The size of the memory buffer.
|
|
|
|
Returns:
|
|
|
|
EFI_SUCCESS The function completed successfully.
|
|
EFI_INVALID_PARAMETER One of the input parameters was invalid.
|
|
EFI_ABORTED An error occurred.
|
|
EFI_OUT_OF_RESOURCES No resource to complete operations.
|
|
|
|
--*/
|
|
{
|
|
FILE *InputFile;
|
|
UINT32 FileSize;
|
|
|
|
//
|
|
// Verify input parameters.
|
|
//
|
|
if (InputFileName == NULL || strlen (InputFileName) == 0 || InputFileImage == NULL) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
//
|
|
// Open the file and copy contents into a memory buffer.
|
|
//
|
|
//
|
|
// Open the file
|
|
//
|
|
InputFile = fopen (InputFileName, "rb");
|
|
if (InputFile == NULL) {
|
|
Error (NULL, 0, 0001, "Error opening the input file", InputFileName);
|
|
return EFI_ABORTED;
|
|
}
|
|
//
|
|
// Go to the end so that we can determine the file size
|
|
//
|
|
if (fseek (InputFile, 0, SEEK_END)) {
|
|
Error (NULL, 0, 0004, "Error reading the input file", InputFileName);
|
|
fclose (InputFile);
|
|
return EFI_ABORTED;
|
|
}
|
|
//
|
|
// Get the file size
|
|
//
|
|
FileSize = ftell (InputFile);
|
|
if (FileSize == -1) {
|
|
Error (NULL, 0, 0003, "Error parsing the input file", InputFileName);
|
|
fclose (InputFile);
|
|
return EFI_ABORTED;
|
|
}
|
|
//
|
|
// Allocate a buffer
|
|
//
|
|
*InputFileImage = malloc (FileSize);
|
|
if (*InputFileImage == NULL) {
|
|
fclose (InputFile);
|
|
return EFI_OUT_OF_RESOURCES;
|
|
}
|
|
//
|
|
// Reset to the beginning of the file
|
|
//
|
|
if (fseek (InputFile, 0, SEEK_SET)) {
|
|
Error (NULL, 0, 0004, "Error reading the input file", InputFileName);
|
|
fclose (InputFile);
|
|
free (*InputFileImage);
|
|
*InputFileImage = NULL;
|
|
return EFI_ABORTED;
|
|
}
|
|
//
|
|
// Read all of the file contents.
|
|
//
|
|
*BytesRead = fread (*InputFileImage, sizeof (UINT8), FileSize, InputFile);
|
|
if (*BytesRead != sizeof (UINT8) * FileSize) {
|
|
Error (NULL, 0, 0004, "Error reading the input file", InputFileName);
|
|
fclose (InputFile);
|
|
free (*InputFileImage);
|
|
*InputFileImage = NULL;
|
|
return EFI_ABORTED;
|
|
}
|
|
//
|
|
// Close the file
|
|
//
|
|
fclose (InputFile);
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
EFI_STATUS
|
|
PutFileImage (
|
|
IN CHAR8 *OutputFileName,
|
|
IN CHAR8 *OutputFileImage,
|
|
IN UINT32 BytesToWrite
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function opens a file and writes OutputFileImage into the file.
|
|
|
|
Arguments:
|
|
|
|
OutputFileName The name of the file to write.
|
|
OutputFileImage A pointer to the memory buffer.
|
|
BytesToWrite The size of the memory buffer.
|
|
|
|
Returns:
|
|
|
|
EFI_SUCCESS The function completed successfully.
|
|
EFI_INVALID_PARAMETER One of the input parameters was invalid.
|
|
EFI_ABORTED An error occurred.
|
|
EFI_OUT_OF_RESOURCES No resource to complete operations.
|
|
|
|
--*/
|
|
{
|
|
FILE *OutputFile;
|
|
UINT32 BytesWrote;
|
|
|
|
//
|
|
// Verify input parameters.
|
|
//
|
|
if (OutputFileName == NULL || strlen (OutputFileName) == 0 || OutputFileImage == NULL) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
//
|
|
// Open the file and copy contents into a memory buffer.
|
|
//
|
|
//
|
|
// Open the file
|
|
//
|
|
OutputFile = fopen (OutputFileName, "wb");
|
|
if (OutputFile == NULL) {
|
|
Error (NULL, 0, 0001, "Error opening the output file", OutputFileName);
|
|
return EFI_ABORTED;
|
|
}
|
|
|
|
//
|
|
// Write all of the file contents.
|
|
//
|
|
BytesWrote = fwrite (OutputFileImage, sizeof (UINT8), BytesToWrite, OutputFile);
|
|
if (BytesWrote != sizeof (UINT8) * BytesToWrite) {
|
|
Error (NULL, 0, 0002, "Error writing the output file", OutputFileName);
|
|
fclose (OutputFile);
|
|
return EFI_ABORTED;
|
|
}
|
|
//
|
|
// Close the file
|
|
//
|
|
fclose (OutputFile);
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
UINT8
|
|
CalculateChecksum8 (
|
|
IN UINT8 *Buffer,
|
|
IN UINTN Size
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function calculates the value needed for a valid UINT8 checksum
|
|
|
|
Arguments:
|
|
|
|
Buffer Pointer to buffer containing byte data of component.
|
|
Size Size of the buffer
|
|
|
|
Returns:
|
|
|
|
The 8 bit checksum value needed.
|
|
|
|
--*/
|
|
{
|
|
return (UINT8) (0x100 - CalculateSum8 (Buffer, Size));
|
|
}
|
|
|
|
UINT8
|
|
CalculateSum8 (
|
|
IN UINT8 *Buffer,
|
|
IN UINTN Size
|
|
)
|
|
/*++
|
|
|
|
Routine Description::
|
|
|
|
This function calculates the UINT8 sum for the requested region.
|
|
|
|
Arguments:
|
|
|
|
Buffer Pointer to buffer containing byte data of component.
|
|
Size Size of the buffer
|
|
|
|
Returns:
|
|
|
|
The 8 bit checksum value needed.
|
|
|
|
--*/
|
|
{
|
|
UINTN Index;
|
|
UINT8 Sum;
|
|
|
|
Sum = 0;
|
|
|
|
//
|
|
// Perform the byte sum for buffer
|
|
//
|
|
for (Index = 0; Index < Size; Index++) {
|
|
Sum = (UINT8) (Sum + Buffer[Index]);
|
|
}
|
|
|
|
return Sum;
|
|
}
|
|
|
|
UINT16
|
|
CalculateChecksum16 (
|
|
IN UINT16 *Buffer,
|
|
IN UINTN Size
|
|
)
|
|
/*++
|
|
|
|
Routine Description::
|
|
|
|
This function calculates the value needed for a valid UINT16 checksum
|
|
|
|
Arguments:
|
|
|
|
Buffer Pointer to buffer containing byte data of component.
|
|
Size Size of the buffer
|
|
|
|
Returns:
|
|
|
|
The 16 bit checksum value needed.
|
|
|
|
--*/
|
|
{
|
|
return (UINT16) (0x10000 - CalculateSum16 (Buffer, Size));
|
|
}
|
|
|
|
UINT16
|
|
CalculateSum16 (
|
|
IN UINT16 *Buffer,
|
|
IN UINTN Size
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function calculates the UINT16 sum for the requested region.
|
|
|
|
Arguments:
|
|
|
|
Buffer Pointer to buffer containing byte data of component.
|
|
Size Size of the buffer
|
|
|
|
Returns:
|
|
|
|
The 16 bit checksum
|
|
|
|
--*/
|
|
{
|
|
UINTN Index;
|
|
UINT16 Sum;
|
|
|
|
Sum = 0;
|
|
|
|
//
|
|
// Perform the word sum for buffer
|
|
//
|
|
for (Index = 0; Index < Size; Index++) {
|
|
Sum = (UINT16) (Sum + Buffer[Index]);
|
|
}
|
|
|
|
return (UINT16) Sum;
|
|
}
|
|
|
|
EFI_STATUS
|
|
PrintGuid (
|
|
IN EFI_GUID *Guid
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function prints a GUID to STDOUT.
|
|
|
|
Arguments:
|
|
|
|
Guid Pointer to a GUID to print.
|
|
|
|
Returns:
|
|
|
|
EFI_SUCCESS The GUID was printed.
|
|
EFI_INVALID_PARAMETER The input was NULL.
|
|
|
|
--*/
|
|
{
|
|
if (Guid == NULL) {
|
|
Error (NULL, 0, 2000, "Invalid parameter", "PrintGuidToBuffer() called with a NULL value");
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
printf (
|
|
"%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x\n",
|
|
(unsigned) 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 EFI_SUCCESS;
|
|
}
|
|
|
|
EFI_STATUS
|
|
PrintGuidToBuffer (
|
|
IN EFI_GUID *Guid,
|
|
IN OUT UINT8 *Buffer,
|
|
IN UINT32 BufferLen,
|
|
IN BOOLEAN Uppercase
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function prints a GUID to a buffer
|
|
|
|
Arguments:
|
|
|
|
Guid - Pointer to a GUID to print.
|
|
Buffer - Pointer to a user-provided buffer to print to
|
|
BufferLen - Size of the Buffer
|
|
Uppercase - If use upper case.
|
|
|
|
Returns:
|
|
|
|
EFI_SUCCESS The GUID was printed.
|
|
EFI_INVALID_PARAMETER The input was NULL.
|
|
EFI_BUFFER_TOO_SMALL The input buffer was not big enough
|
|
|
|
--*/
|
|
{
|
|
if (Guid == NULL) {
|
|
Error (NULL, 0, 2000, "Invalid parameter", "PrintGuidToBuffer() called with a NULL value");
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
if (BufferLen < PRINTED_GUID_BUFFER_SIZE) {
|
|
Error (NULL, 0, 2000, "Invalid parameter", "PrintGuidToBuffer() called with invalid buffer size");
|
|
return EFI_BUFFER_TOO_SMALL;
|
|
}
|
|
|
|
if (Uppercase) {
|
|
sprintf (
|
|
(CHAR8 *)Buffer,
|
|
"%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X",
|
|
(unsigned) 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]
|
|
);
|
|
} else {
|
|
sprintf (
|
|
(CHAR8 *)Buffer,
|
|
"%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
|
|
(unsigned) 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 EFI_SUCCESS;
|
|
}
|
|
|
|
#ifdef __GNUC__
|
|
|
|
size_t _filelength(int fd)
|
|
{
|
|
struct stat stat_buf;
|
|
fstat(fd, &stat_buf);
|
|
return stat_buf.st_size;
|
|
}
|
|
|
|
#ifndef __CYGWIN__
|
|
char *strlwr(char *s)
|
|
{
|
|
char *p = s;
|
|
for(;*s;s++) {
|
|
*s = tolower(*s);
|
|
}
|
|
return p;
|
|
}
|
|
#endif
|
|
#endif
|