mirror of
https://github.com/CloverHackyColor/CloverBootloader.git
synced 2024-12-12 14:36:56 +01:00
88a2a69734
Revert a FreePool mistakenly commented out.
1245 lines
36 KiB
C
1245 lines
36 KiB
C
/** @file
|
|
|
|
Module Name:
|
|
|
|
FSInject.c
|
|
|
|
FSInject driver - Replaces EFI_SIMPLE_FILE_SYSTEM_PROTOCOL on target volume
|
|
and injects content of specified source folder on source (injection) volume
|
|
into target folder in target volume.
|
|
|
|
initial version - dmazar
|
|
|
|
**/
|
|
|
|
#include <Library/BaseLib.h>
|
|
#include <Library/UefiLib.h>
|
|
#include <Library/UefiBootServicesTableLib.h>
|
|
#include <Library/UefiRuntimeServicesTableLib.h>
|
|
#include <Library/BaseMemoryLib.h>
|
|
#include <Library/MemoryAllocationLib.h>
|
|
#include <Library/DebugLib.h>
|
|
#include <Library/PrintLib.h>
|
|
#include <Library/MemLogLib.h>
|
|
|
|
#include <Protocol/SimpleFileSystem.h>
|
|
|
|
#include <Guid/GlobalVariable.h>
|
|
#include <Guid/FileInfo.h>
|
|
#include <Guid/FileSystemInfo.h>
|
|
#include <Guid/FileSystemVolumeLabelInfo.h>
|
|
|
|
#include <Protocol/FSInjectProtocol.h>
|
|
|
|
#include "FSInject.h"
|
|
|
|
//#include "../../Version.h"
|
|
//CONST CHAR8* CloverRevision = REVISION_STR;
|
|
|
|
|
|
// DBG_TO: 0=no debug, 1=serial, 2=console
|
|
// serial requires
|
|
// [PcdsFixedAtBuild]
|
|
// gEfiMdePkgTokenSpaceGuid.PcdDebugPropertyMask|0x07
|
|
// gEfiMdePkgTokenSpaceGuid.PcdDebugPrintErrorLevel|0xFFFFFFFF
|
|
// in package DSC file
|
|
#define DBG_TO 3
|
|
|
|
#if DBG_TO == 3
|
|
#define DBG(...) MemLog(FALSE, 0, __VA_ARGS__)
|
|
#elif DBG_TO == 2
|
|
#define DBG(...) AsciiPrint(__VA_ARGS__)
|
|
#elif DBG_TO == 1
|
|
#define DBG(...) DebugPrint(1, __VA_ARGS__)
|
|
#else
|
|
#define DBG(...)
|
|
#endif
|
|
|
|
|
|
#define TEST 0
|
|
#if TEST
|
|
#include "Test.h"
|
|
#endif
|
|
|
|
#define EfiGuidStrMapLen 4
|
|
/** Map of known guids and friendly names. Searchable with GuidStr() */
|
|
struct {
|
|
EFI_GUID *Guid;
|
|
CHAR16 *Str;
|
|
} EfiGuidStrMap[EfiGuidStrMapLen] = {
|
|
{NULL, L"Tmp buffer AE074D26-6E9E-11E1-A5B8-9BFC4824019B"},
|
|
{&gEfiFileInfoGuid, L"gEfiFileInfoGuid"},
|
|
{&gEfiFileSystemInfoGuid, L"gEfiFileSystemInfoGuid"},
|
|
{&gEfiFileSystemVolumeLabelInfoIdGuid, L"gEfiFileSystemVolumeLabelInfoIdGuid"}
|
|
};
|
|
|
|
/** Returns GUID as string, with friendly name for known guids. */
|
|
CHAR16*
|
|
EFIAPI
|
|
GuidStr(IN EFI_GUID *Guid)
|
|
{
|
|
UINTN i;
|
|
CHAR16 *Str = NULL;
|
|
|
|
for(i = 1; i < EfiGuidStrMapLen; i++) {
|
|
if (CompareGuid(EfiGuidStrMap[i].Guid, Guid)) {
|
|
Str = EfiGuidStrMap[i].Str;
|
|
break;
|
|
}
|
|
}
|
|
if (Str == NULL) {
|
|
UnicodeSPrint(EfiGuidStrMap[0].Str, 47 * 2, L"%g", Guid);
|
|
Str = EfiGuidStrMap[0].Str;
|
|
}
|
|
return Str;
|
|
}
|
|
|
|
/** Returns pointer to last Char in String or NULL. */
|
|
CHAR16*
|
|
EFIAPI
|
|
GetStrLastChar(IN CHAR16 *String)
|
|
{
|
|
CHAR16 *Pos;
|
|
|
|
if (String == NULL || *String == L'\0') {
|
|
return NULL;
|
|
}
|
|
|
|
// go to end
|
|
Pos = String;
|
|
while (*Pos != L'\0') {
|
|
Pos++;
|
|
}
|
|
Pos--;
|
|
return Pos;
|
|
}
|
|
|
|
/** Returns pointer to last occurence of Char in String or NULL. */
|
|
CHAR16*
|
|
EFIAPI
|
|
GetStrLastCharOccurence(IN CHAR16 *String, IN CHAR16 Char)
|
|
{
|
|
CHAR16 *Pos;
|
|
|
|
if (String == NULL || *String == L'\0') {
|
|
return NULL;
|
|
}
|
|
|
|
// go to end
|
|
Pos = String;
|
|
while (*Pos != L'\0') {
|
|
Pos++;
|
|
}
|
|
// search for Char
|
|
while (*Pos != Char && Pos != String) {
|
|
Pos--;
|
|
}
|
|
return (*Pos == Char) ? Pos : NULL;
|
|
}
|
|
|
|
/** Returns upper case version of char - valid only for ASCII chars in unicode. */
|
|
CHAR16
|
|
EFIAPI
|
|
ToUpperChar(IN CHAR16 Chr)
|
|
{
|
|
CHAR8 C;
|
|
|
|
if (Chr > 0x100) return Chr;
|
|
C = (CHAR8)Chr;
|
|
return ((C >= 'a' && C <= 'z') ? C - ('a' - 'A') : C);
|
|
}
|
|
|
|
|
|
/** Returns 0 if two strings are equal, !=0 otherwise. Compares just first 8 bits of chars (valid for ASCII), case insensitive.. */
|
|
UINTN
|
|
EFIAPI
|
|
StrCmpiBasic(IN CHAR16 *String1, IN CHAR16 *String2)
|
|
{
|
|
CHAR16 Chr1;
|
|
CHAR16 Chr2;
|
|
|
|
DBG("Cmpi('%s', '%s') ", String1, String2);
|
|
|
|
if (String1 == NULL || String2 == NULL) {
|
|
return 1;
|
|
}
|
|
if (*String1 == L'\0' && *String2 == L'\0') {
|
|
return 0;
|
|
}
|
|
if (*String1 == L'\0' || *String2 == L'\0') {
|
|
return 1;
|
|
}
|
|
|
|
Chr1 = ToUpperChar(*String1);
|
|
Chr2 = ToUpperChar(*String2);
|
|
while ((*String1 != L'\0') && (Chr1 == Chr2)) {
|
|
String1++;
|
|
String2++;
|
|
Chr1 = ToUpperChar(*String1);
|
|
Chr2 = ToUpperChar(*String2);
|
|
}
|
|
|
|
DBG("=%s ", (Chr1 - Chr2) ? L"NEQ" : L"EQ");
|
|
return Chr1 - Chr2;
|
|
}
|
|
|
|
/** Returns TRUE if String1 starts with String2, FALSE otherwise. Compares just first 8 bits of chars (valid for ASCII), case insensitive.. */
|
|
BOOLEAN
|
|
EFIAPI
|
|
StriStartsWithBasic(IN CHAR16 *String1, IN CHAR16 *String2)
|
|
{
|
|
CHAR16 Chr1;
|
|
CHAR16 Chr2;
|
|
BOOLEAN Result;
|
|
|
|
DBG("StriStarts('%s', '%s') ", String1, String2);
|
|
|
|
if (String1 == NULL || String2 == NULL) {
|
|
return FALSE;
|
|
}
|
|
if (*String1 == L'\0' && *String2 == L'\0') {
|
|
return TRUE;
|
|
}
|
|
if (*String1 == L'\0' || *String2 == L'\0') {
|
|
return FALSE;
|
|
}
|
|
|
|
Chr1 = ToUpperChar(*String1);
|
|
Chr2 = ToUpperChar(*String2);
|
|
while ((Chr1 != L'\0') && (Chr2 != L'\0') && (Chr1 == Chr2)) {
|
|
String1++;
|
|
String2++;
|
|
Chr1 = ToUpperChar(*String1);
|
|
Chr2 = ToUpperChar(*String2);
|
|
}
|
|
|
|
Result = ((Chr1 == L'\0') && (Chr2 == L'\0'))
|
|
|| ((Chr1 != L'\0') && (Chr2 == L'\0'));
|
|
|
|
DBG("=%s \n", Result ? L"TRUE" : L"FALSE");
|
|
return Result;
|
|
}
|
|
|
|
/** Composes file name from Parent and FName. Allocates memory for result which should be released by caller. */
|
|
CHAR16*
|
|
EFIAPI
|
|
GetNormalizedFName(IN CHAR16 *Parent, IN CHAR16 *FName)
|
|
{
|
|
CHAR16 *TmpStr;
|
|
CHAR16 *TmpStr2;
|
|
UINTN Len;
|
|
|
|
DBG("NormFName('%s' + '%s')", Parent, FName);
|
|
// case: FName starts with \ "\System\Xx"
|
|
// we'll just use it as is, but we are wrong if "\System\Xx\..\Yy\.\Zz" or similar
|
|
if (FName[0] == L'\\') {
|
|
FName = AllocateCopyPool(StrSize(FName), FName); // reusing FName
|
|
}
|
|
|
|
// case: FName is "."
|
|
// we'll just copy Parent assuming Parent is normalized, which will be the case if this func will be correct once
|
|
else if (FName[0] == L'.' && FName[1] == L'\0') {
|
|
FName = AllocateCopyPool(StrSize(Parent), Parent);
|
|
}
|
|
|
|
// case: FName is ".."
|
|
// we'll extract Parent's parent - also assuming Parent is normalized
|
|
else if (FName[0] == L'.' && FName[1] == L'.' && FName[2] == L'\0') {
|
|
TmpStr = GetStrLastCharOccurence(Parent, L'\\');
|
|
// if there is L'\\' and not at the beginning ...
|
|
if (TmpStr != NULL && TmpStr != Parent) {
|
|
*TmpStr = L'\0'; // terminating Parent; will return L'\\' back
|
|
FName = AllocateCopyPool(StrSize(Parent), Parent);
|
|
*TmpStr = L'\\'; // return L'\\' back to Parent
|
|
} else {
|
|
// caller is doing something wrong - we'll default to L"\\"
|
|
FName = AllocateCopyPool(StrSize(L"\\"), L"\\");
|
|
}
|
|
}
|
|
|
|
// other cases: for now just do Parent + \ + FName
|
|
// but check if Parent already ends with backslash
|
|
else {
|
|
Len = StrSize(Parent) + StrSize(FName); // has place for extra char (\\) if needed
|
|
TmpStr = AllocateZeroPool(Len);
|
|
StrCpyS(TmpStr, Len/sizeof(CHAR16), Parent);
|
|
TmpStr2 = GetStrLastChar(Parent);
|
|
if (TmpStr2 == NULL || *TmpStr2 != L'\\') {
|
|
StrCatS(TmpStr, Len/sizeof(CHAR16), L"\\");
|
|
}
|
|
StrCatS(TmpStr, Len/sizeof(CHAR16), FName);
|
|
DBG("='%s' ", TmpStr);
|
|
return TmpStr;
|
|
}
|
|
DBG("='%s' ", FName);
|
|
return FName;
|
|
}
|
|
|
|
/** If FName starts with TgtDir, then extracts the rest from FName and copies it to SrcDir and returns it. Or NULL.
|
|
* Caller is responsible for releasing memory for returned string.
|
|
* Example: TgtDir="\S\L\E", SrcDir="\efi\10.7", FName="\S\L\E\Xx.kext\Contents\Info.plist"
|
|
* This should return "\efi\10.7\Xx.kext\Contents\Info.plist"
|
|
*/
|
|
CHAR16*
|
|
EFIAPI
|
|
GetInjectionFName(IN CHAR16 *TgtDir, IN CHAR16 *SrcDir, IN CHAR16 *FName)
|
|
{
|
|
CHAR16 Chr1;
|
|
CHAR16 Chr2;
|
|
CHAR16 *Str1;
|
|
CHAR16 *Str2;
|
|
UINTN Size;
|
|
|
|
DBG("InjFName('%s', '%s', '%s')", TgtDir, SrcDir, FName);
|
|
if (TgtDir == NULL || SrcDir == NULL || FName == NULL) {
|
|
DBG("=NULL0 ");
|
|
return NULL;
|
|
}
|
|
// check if FName starts with TgtDir, kind of case insensitive (only ASCII chars)
|
|
Str1 = TgtDir;
|
|
Str2 = FName;
|
|
Chr1 = ToUpperChar(*Str1);
|
|
Chr2 = ToUpperChar(*Str2);
|
|
while ((*Str1 != L'\0') && (Chr1 == Chr2)) {
|
|
Str1++;
|
|
Str2++;
|
|
Chr1 = ToUpperChar(*Str1);
|
|
Chr2 = ToUpperChar(*Str2);
|
|
}
|
|
// if FName starts with TgtDir, then *Str1 should be '\0'
|
|
if (*Str1 != L'\0') {
|
|
DBG("=NULL1 ");
|
|
return NULL;
|
|
}
|
|
// if FName is a file inside TgtDir, then *Str2 should be == '\\'
|
|
if (*Str2 != L'\\') {
|
|
DBG("=NULL2 ");
|
|
return NULL;
|
|
}
|
|
// we are at '\\' with Str2 - copy from here to the end to SrcDir
|
|
// determine the buffer size for new string
|
|
Size = StrSize(SrcDir) + StrSize(Str2) - 2;
|
|
Str1 = AllocateZeroPool(Size);
|
|
if (Str1 != NULL) {
|
|
StrCpyS(Str1, Size/sizeof(CHAR16), SrcDir);
|
|
StrCatS(Str1, Size/sizeof(CHAR16), Str2);
|
|
}
|
|
DBG("='%s' ", Str1);
|
|
return Str1;
|
|
}
|
|
|
|
/** Openes EFI_FILE_PROTOCOL on given VolumeFS for given FName. */
|
|
EFI_FILE_PROTOCOL*
|
|
EFIAPI
|
|
OpenFileProtocol(
|
|
IN EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *VolumeFS,
|
|
IN CHAR16 *FName,
|
|
IN UINT64 OpenMode,
|
|
IN UINT64 Attributes
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
EFI_FILE_PROTOCOL *RootFP;
|
|
EFI_FILE_PROTOCOL *FP;
|
|
|
|
// open volume
|
|
Status = VolumeFS->OpenVolume(VolumeFS, &RootFP);
|
|
if (EFI_ERROR(Status)) {
|
|
DBG("Can not OpenVolume: %r ", Status);
|
|
return NULL;
|
|
}
|
|
// open file/dir
|
|
Status = RootFP->Open(RootFP, &FP, FName, OpenMode, Attributes);
|
|
if (EFI_ERROR(Status)) {
|
|
DBG("Can not Open '%s': %r ", FName, Status);
|
|
FP = NULL;
|
|
}
|
|
RootFP->Close(RootFP);
|
|
return FP;
|
|
}
|
|
|
|
/**************************************************************************************
|
|
* FSI_FILE_PROTOCOL - our implementation of EFI_FILE_PROTOCOL
|
|
**************************************************************************************/
|
|
|
|
FSI_FILE_PROTOCOL* EFIAPI CreateFSInjectFP(VOID);
|
|
|
|
/** EFI_FILE_PROTOCOL.Open - Opens a new file relative to the source file's location. */
|
|
EFI_STATUS
|
|
EFIAPI
|
|
FSI_FP_Open(
|
|
IN EFI_FILE_PROTOCOL *This,
|
|
OUT EFI_FILE_PROTOCOL **NewHandle,
|
|
IN CHAR16 *FileName,
|
|
IN UINT64 OpenMode,
|
|
IN UINT64 Attributes
|
|
)
|
|
{
|
|
EFI_STATUS Status = EFI_DEVICE_ERROR;
|
|
CHAR16 *NewFName;
|
|
CHAR16 *InjFName = NULL;
|
|
FSI_FILE_PROTOCOL *FSIThis;
|
|
FSI_FILE_PROTOCOL *FSINew;
|
|
FSI_STRING_LIST *StringList;
|
|
FSI_STRING_LIST_ENTRY *StringEntry;
|
|
|
|
DBG("FSI_FP %p.Open('%s', %x, %x) ", This, FileName, OpenMode, Attributes);
|
|
FSIThis = FSI_FROM_FILE_PROTOCOL(This);
|
|
NewFName = GetNormalizedFName(FSIThis->FName, FileName);
|
|
|
|
StringList = FSIThis->FSI_FS->Blacklist;
|
|
if (StringList != NULL && !IsListEmpty(&StringList->List)) {
|
|
// blocking files in Blacklist
|
|
for (StringEntry = (FSI_STRING_LIST_ENTRY *)GetFirstNode(&StringList->List);
|
|
!IsNull (&StringList->List, &StringEntry->List);
|
|
StringEntry = (FSI_STRING_LIST_ENTRY *)GetNextNode(&StringList->List, &StringEntry->List)
|
|
)
|
|
{
|
|
if (StriStartsWithBasic(NewFName, StringEntry->String)) {
|
|
DBG("Blacklisted\n");
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
}
|
|
}
|
|
|
|
// create our FP implementation
|
|
FSINew = CreateFSInjectFP();
|
|
if (FSINew == NULL) {
|
|
Status = EFI_OUT_OF_RESOURCES;
|
|
DBG("CreateFSInjectFP Status=%r\n", Status);
|
|
return Status;
|
|
}
|
|
FSINew->FSI_FS = FSIThis->FSI_FS; // saving reference to parent FS protocol
|
|
FSINew->FName =NewFName;
|
|
FSINew->TgtFP = NULL;
|
|
FSINew->SrcFP = NULL;
|
|
|
|
// mach_kernel - if exists in SrcDir, then inject this one
|
|
if (StrCmpiBasic(NewFName, L"\\mach_kernel") == 0) {
|
|
DBG("mach_kernel ");
|
|
if (FSIThis->FSI_FS->SrcDir != NULL && FSIThis->FSI_FS->SrcFS != NULL) {
|
|
InjFName = GetInjectionFName(L"\0", FSIThis->FSI_FS->SrcDir, NewFName);
|
|
if (InjFName != NULL) {
|
|
// if this one exists inside injection dir - should be opened with SrcFP
|
|
FSINew->SrcFP = OpenFileProtocol(FSIThis->FSI_FS->SrcFS, InjFName, OpenMode, Attributes);
|
|
if (FSINew->SrcFP != NULL) {
|
|
FSINew->FromTgt = FALSE;
|
|
DBG("Opened with SrcFP ");
|
|
goto SuccessExit;
|
|
} else {
|
|
DBG(" no injection, SrcFP->Open=%r ", Status);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// S/L/Kernels/kernel - if exists in SrcDir, then inject this one
|
|
if (StrCmpiBasic(NewFName, L"\\System\\Library\\Kernels\\kernel") == 0) {
|
|
DBG("kernel ");
|
|
if (FSIThis->FSI_FS->SrcDir != NULL && FSIThis->FSI_FS->SrcFS != NULL) {
|
|
InjFName = GetInjectionFName(L"\0", FSIThis->FSI_FS->SrcDir, L"\\kernel");
|
|
if (InjFName != NULL) {
|
|
// if this one exists inside injection dir - should be opened with SrcFP
|
|
FSINew->SrcFP = OpenFileProtocol(FSIThis->FSI_FS->SrcFS, InjFName, OpenMode, Attributes);
|
|
if (FSINew->SrcFP != NULL) {
|
|
FSINew->FromTgt = FALSE;
|
|
DBG("Opened with SrcFP ");
|
|
goto SuccessExit;
|
|
} else {
|
|
DBG(" no injection, SrcFP->Open=%r ", Status);
|
|
}
|
|
}
|
|
InjFName = GetInjectionFName(L"\0", FSIThis->FSI_FS->SrcDir, L"\\mach_kernel");
|
|
if (InjFName != NULL) {
|
|
// if this one exists inside injection dir - should be opened with SrcFP
|
|
FSINew->SrcFP = OpenFileProtocol(FSIThis->FSI_FS->SrcFS, InjFName, OpenMode, Attributes);
|
|
if (FSINew->SrcFP != NULL) {
|
|
FSINew->FromTgt = FALSE;
|
|
DBG("Opened with SrcFP ");
|
|
goto SuccessExit;
|
|
} else {
|
|
DBG(" no injection, SrcFP->Open=%r ", Status);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// try with target
|
|
if (FSIThis->TgtFP != NULL) {
|
|
// call original target implementation to get NewHandle
|
|
Status = FSIThis->TgtFP->Open(FSIThis->TgtFP, NewHandle, NewFName, OpenMode, Attributes);
|
|
if (EFI_ERROR(Status)) {
|
|
DBG("TgtFP->Open=%r ", Status);
|
|
} else {
|
|
DBG("Opened with TgtFP ");
|
|
FSINew->FromTgt = TRUE;
|
|
// save new orig target handle
|
|
FSINew->TgtFP = *NewHandle;
|
|
}
|
|
}
|
|
|
|
// if write protected - return now
|
|
if (Status == EFI_WRITE_PROTECTED) {
|
|
goto ErrorExit;
|
|
}
|
|
|
|
// handle injection if needed
|
|
if (EFI_ERROR(Status) && FSIThis->FSI_FS->SrcDir != NULL && FSIThis->FSI_FS->SrcFS != NULL) {
|
|
// if not found and injection requested: try injection dir
|
|
InjFName = GetInjectionFName(FSIThis->FSI_FS->TgtDir, FSIThis->FSI_FS->SrcDir, NewFName);
|
|
if (InjFName != NULL) {
|
|
// this one exists inside injection dir - should be opened with SrcFP
|
|
FSINew->FromTgt = FALSE;
|
|
FSINew->SrcFP = OpenFileProtocol(FSIThis->FSI_FS->SrcFS, InjFName, OpenMode, Attributes);
|
|
if (FSINew->SrcFP == NULL) {
|
|
Status = EFI_DEVICE_ERROR;
|
|
DBG("SrcFP->Open=%r ", Status);
|
|
} else {
|
|
Status = EFI_SUCCESS;
|
|
DBG("Opened with SrcFP ");
|
|
// ok - we are injecting kexts with FSInject driver because user requested
|
|
// it with NoCaches or because boot.efi refused to load kernelcache for some reason.
|
|
// let's inform Clover's kext injection that it does not have to do
|
|
// in-memory kext injection.
|
|
{
|
|
STATIC UINT8 KextsInjected = 0;
|
|
|
|
if (KextsInjected == 0) {
|
|
gRT->SetVariable(L"FSInject.KextsInjected",
|
|
&gEfiGlobalVariableGuid,
|
|
EFI_VARIABLE_BOOTSERVICE_ACCESS,
|
|
sizeof(KextsInjected),
|
|
&KextsInjected
|
|
);
|
|
//AsciiPrint("\nFSInject.KextsInjected\n");
|
|
//gBS->Stall(3000000);
|
|
}
|
|
KextsInjected++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (EFI_ERROR(Status) && FSIThis->TgtFP == NULL) {
|
|
// this happens when we are called on FP that is opened with SrcFP (we do not have TgtFP)
|
|
// and then with FName ".." (in shell), and when resulting dir in actually on TgtFP.
|
|
// need to open it with TgtFP
|
|
FSINew->TgtFP = OpenFileProtocol(FSIThis->FSI_FS->TgtFS, NewFName, OpenMode, Attributes);
|
|
if (FSINew->TgtFP != NULL) {
|
|
Status = EFI_SUCCESS;
|
|
DBG("Opened with TgtFP ");
|
|
FSINew->FromTgt = TRUE;
|
|
} else {
|
|
Status = EFI_DEVICE_ERROR;
|
|
DBG("TgtFS->OpenVolume Status=%r\n", Status);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// if still error - quit
|
|
if (EFI_ERROR(Status)) {
|
|
goto ErrorExit;
|
|
}
|
|
|
|
// we are here with EFI_SUCCESS
|
|
|
|
// check if this is injection point (target dir where we should inject)
|
|
if (FSINew->TgtFP != NULL && FSINew->FSI_FS->SrcFS != NULL && FSINew->FSI_FS->SrcDir != NULL
|
|
&& StrCmpiBasic(FSINew->FSI_FS->TgtDir, FSINew->FName) == 0)
|
|
{
|
|
// it is - open injection dir also
|
|
// this FP will have both TgtFP and SrcFP - can be used for test later
|
|
// in case of error, it will be NULL - all should run fine then, but without injection
|
|
FSINew->SrcFP = OpenFileProtocol(FSINew->FSI_FS->SrcFS, FSINew->FSI_FS->SrcDir, EFI_FILE_MODE_READ, 0);
|
|
if (FSINew->SrcFP != NULL) {
|
|
DBG("Opened also with SrcFP ");
|
|
} else {
|
|
DBG("Error opening with SrcFP ");
|
|
}
|
|
}
|
|
|
|
|
|
SuccessExit:
|
|
// set our implementation as a result
|
|
*NewHandle = &(FSINew->FP);
|
|
|
|
DBG("= EFI_SUCCESS, NewHandle=%p, FName='%s'\n", *NewHandle, FSINew->FName);
|
|
return EFI_SUCCESS;
|
|
|
|
ErrorExit:
|
|
if (FSINew->FName != NULL) FreePool(FSINew->FName);
|
|
if (FSINew != NULL) FreePool(FSINew);
|
|
DBG("= %r\n", Status);
|
|
return Status;
|
|
}
|
|
|
|
/** EFI_FILE_PROTOCOL.Close - Closes a specified file handle. */
|
|
EFI_STATUS
|
|
EFIAPI
|
|
FSI_FP_Close(IN EFI_FILE_PROTOCOL *This)
|
|
{
|
|
EFI_STATUS Status = EFI_SUCCESS;
|
|
FSI_FILE_PROTOCOL *FSIThis;
|
|
|
|
DBG("FSI_FP %p.Close() ", This);
|
|
|
|
FSIThis = FSI_FROM_FILE_PROTOCOL(This);
|
|
|
|
if (FSIThis->TgtFP != NULL) {
|
|
// close target FP
|
|
Status = FSIThis->TgtFP->Close(FSIThis->TgtFP);
|
|
FSIThis->TgtFP = NULL;
|
|
}
|
|
if (FSIThis->SrcFP != NULL) {
|
|
// close source (injection) FP
|
|
FSIThis->SrcFP->Close(FSIThis->SrcFP);
|
|
FSIThis->SrcFP = NULL;
|
|
}
|
|
DBG("FName='%s' ", FSIThis->FName);
|
|
if (FSIThis->FName != NULL) {
|
|
FreePool(FSIThis->FName);
|
|
FSIThis->FName = NULL;
|
|
}
|
|
FreePool(FSIThis);
|
|
DBG("= %r\n", Status);
|
|
return Status;
|
|
}
|
|
|
|
/** EFI_FILE_PROTOCOL.Delete - Close and delete the file handle. */
|
|
EFI_STATUS
|
|
EFIAPI
|
|
FSI_FP_Delete(IN EFI_FILE_PROTOCOL *This)
|
|
{
|
|
EFI_STATUS Status = EFI_WARN_DELETE_FAILURE;
|
|
FSI_FILE_PROTOCOL *FSIThis;
|
|
|
|
DBG("FSI_FP %p.Delete()\n", This);
|
|
|
|
FSIThis = FSI_FROM_FILE_PROTOCOL(This);
|
|
|
|
if (FSIThis->TgtFP != NULL) {
|
|
// do it with target FP
|
|
Status = FSIThis->TgtFP->Delete(FSIThis->TgtFP);
|
|
FSIThis->TgtFP = NULL;
|
|
}
|
|
if (FSIThis->SrcFP != NULL) {
|
|
// close source FP
|
|
FSIThis->SrcFP->Close(FSIThis->SrcFP);
|
|
FSIThis->SrcFP = NULL;
|
|
}
|
|
if (FSIThis->FName != NULL) {
|
|
FreePool(FSIThis->FName);
|
|
FSIThis->FName = NULL;
|
|
}
|
|
FreePool(FSIThis);
|
|
DBG("= %r\n", Status);
|
|
return Status;
|
|
}
|
|
|
|
/** EFI_FILE_PROTOCOL.Read - Reads data from a file. */
|
|
EFI_STATUS
|
|
EFIAPI
|
|
FSI_FP_Read(
|
|
IN EFI_FILE_PROTOCOL *This,
|
|
IN OUT UINTN *BufferSize,
|
|
OUT VOID *Buffer
|
|
)
|
|
{
|
|
EFI_STATUS Status = EFI_DEVICE_ERROR;
|
|
FSI_FILE_PROTOCOL *FSIThis;
|
|
#if DBG_TO
|
|
EFI_FILE_INFO *FInfo;
|
|
#endif
|
|
UINTN BufferSizeOrig;
|
|
CHAR8 *String;
|
|
FSI_STRING_LIST *StringList;
|
|
FSI_STRING_LIST_ENTRY *StringEntry;
|
|
VOID *TmpBuffer;
|
|
UINTN OrigBufferSize = *BufferSize;
|
|
|
|
DBG("FSI_FP %p.Read(%d, %p) ", This, *BufferSize, Buffer);
|
|
|
|
FSIThis = FSI_FROM_FILE_PROTOCOL(This);
|
|
if (FSIThis->TgtFP != NULL && FSIThis->SrcFP != NULL) {
|
|
// this is injection point
|
|
// first read dir entries from Src and then from Tgt
|
|
BufferSizeOrig = *BufferSize;
|
|
Status = FSIThis->SrcFP->Read(FSIThis->SrcFP, BufferSize, Buffer);
|
|
if (*BufferSize == 0) {
|
|
// no more in Src - read from Tgt
|
|
*BufferSize = BufferSizeOrig;
|
|
Status = FSIThis->TgtFP->Read(FSIThis->TgtFP, BufferSize, Buffer);
|
|
}
|
|
} else if (FSIThis->TgtFP != NULL) {
|
|
// do it with target FP
|
|
Status = FSIThis->TgtFP->Read(FSIThis->TgtFP, BufferSize, Buffer);
|
|
StringList = FSIThis->FSI_FS->ForceLoadKexts;
|
|
if (Status == EFI_INVALID_PARAMETER && *BufferSize == 0) {
|
|
// On some systems FS driver seems to have alignment restrictions on given buffer.
|
|
// UEFIs buffers allocated with standard AllocatePool seem to be aligned properly and reads
|
|
// to them always succeed, so we'll try to overcome this by using new allocated buffer.
|
|
TmpBuffer = AllocateZeroPool(OrigBufferSize);
|
|
*BufferSize = OrigBufferSize;
|
|
Status = FSIThis->TgtFP->Read(FSIThis->TgtFP, BufferSize, TmpBuffer);
|
|
if (Status == EFI_SUCCESS && *BufferSize > 0) {
|
|
CopyMem(Buffer, TmpBuffer, *BufferSize);
|
|
}
|
|
FreePool(TmpBuffer);
|
|
}
|
|
if (Status == EFI_SUCCESS && StringList != NULL && FSIThis->FName != NULL) {
|
|
// check ForceLoadKexts
|
|
for (StringEntry = (FSI_STRING_LIST_ENTRY *)GetFirstNode(&StringList->List);
|
|
!IsNull (&StringList->List, &StringEntry->List);
|
|
StringEntry = (FSI_STRING_LIST_ENTRY *)GetNextNode(&StringList->List, &StringEntry->List)
|
|
)
|
|
{
|
|
if (StrStr(FSIThis->FName, StringEntry->String) != NULL) {
|
|
//Print(L"\nGot: %s\n", FSIThis->FName);
|
|
String = AsciiStrStr((CHAR8*)Buffer, "<string>Safe Boot</string>");
|
|
if (String != NULL) {
|
|
CopyMem(String, "<string>Root</string> ", 26);
|
|
Print(L"\nForced load: %s\n", FSIThis->FName);
|
|
//gBS->Stall(5000000);
|
|
} else {
|
|
String = AsciiStrStr((CHAR8*)Buffer, "<string>Network-Root</string>");
|
|
if (String != NULL) {
|
|
CopyMem(String, "<string>Root</string> ", 29);
|
|
Print(L"\nForced load: %s\n", FSIThis->FName);
|
|
//gBS->Stall(5000000);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if (FSIThis->SrcFP != NULL) {
|
|
// do it with source FP
|
|
Status = FSIThis->SrcFP->Read(FSIThis->SrcFP, BufferSize, Buffer);
|
|
if (Status == EFI_INVALID_PARAMETER && *BufferSize == 0) {
|
|
// On some systems FS driver seems to have alignment restrictions on given buffer.
|
|
// UEFIs buffers allocated with standard AllocatePool seem to be aligned properly and reads
|
|
// to them always succeed, so we'll try to overcome this by using new allocated buffer.
|
|
TmpBuffer = AllocateZeroPool(OrigBufferSize);
|
|
*BufferSize = OrigBufferSize;
|
|
Status = FSIThis->SrcFP->Read(FSIThis->SrcFP, BufferSize, TmpBuffer);
|
|
if (Status == EFI_SUCCESS && *BufferSize > 0) {
|
|
CopyMem(Buffer, TmpBuffer, *BufferSize);
|
|
}
|
|
FreePool(TmpBuffer);
|
|
}
|
|
}
|
|
#if DBG_TO
|
|
if (Status == EFI_SUCCESS && FSIThis->IsDir && *BufferSize > 0) {
|
|
FInfo = (EFI_FILE_INFO *)Buffer;
|
|
DBG("= %r, *BufferSize=%d, dir entry FileName='%s'\n", Status, *BufferSize, FInfo->FileName);
|
|
} else {
|
|
DBG("= %r, *BufferSize=%d\n", Status, *BufferSize);
|
|
}
|
|
#endif
|
|
return Status;
|
|
}
|
|
|
|
/** EFI_FILE_PROTOCOL.Write - Writes data to a file. */
|
|
EFI_STATUS
|
|
EFIAPI
|
|
FSI_FP_Write(
|
|
IN EFI_FILE_PROTOCOL *This,
|
|
IN OUT UINTN *BufferSize,
|
|
IN VOID *Buffer
|
|
)
|
|
{
|
|
EFI_STATUS Status = EFI_DEVICE_ERROR;
|
|
FSI_FILE_PROTOCOL *FSIThis;
|
|
|
|
DBG("FSI_FP %p.Write(%d, %p) ", This, *BufferSize, Buffer);
|
|
|
|
FSIThis = FSI_FROM_FILE_PROTOCOL(This);
|
|
|
|
if (FSIThis->TgtFP != NULL) {
|
|
// do it with target FP
|
|
Status = FSIThis->TgtFP->Write(FSIThis->TgtFP, BufferSize, Buffer);
|
|
} else if (FSIThis->SrcFP != NULL) {
|
|
// do it with source FP
|
|
Status = FSIThis->SrcFP->Write(FSIThis->SrcFP, BufferSize, Buffer);
|
|
}
|
|
DBG("= %r, *BufferSize=%d\n", Status, *BufferSize);
|
|
return Status;
|
|
}
|
|
|
|
/** EFI_FILE_PROTOCOL.SetPosition - Sets a file's current position. */
|
|
EFI_STATUS
|
|
EFIAPI
|
|
FSI_FP_SetPosition(
|
|
IN EFI_FILE_PROTOCOL *This,
|
|
IN UINT64 Position
|
|
)
|
|
{
|
|
EFI_STATUS Status = EFI_DEVICE_ERROR;
|
|
FSI_FILE_PROTOCOL *FSIThis;
|
|
|
|
DBG("FSI_FP %p.SetPosition(%d) ", This, Position);
|
|
|
|
FSIThis = FSI_FROM_FILE_PROTOCOL(This);
|
|
|
|
if (FSIThis->TgtFP != NULL) {
|
|
// do it with target FP
|
|
Status = FSIThis->TgtFP->SetPosition(FSIThis->TgtFP, Position);
|
|
}
|
|
if (FSIThis->SrcFP != NULL) {
|
|
// and with Src
|
|
Status = FSIThis->SrcFP->SetPosition(FSIThis->SrcFP, Position);
|
|
}
|
|
DBG("= %r\n", Status);
|
|
return Status;
|
|
}
|
|
|
|
/** EFI_FILE_PROTOCOL.GetPosition - Returns a file's current position. */
|
|
EFI_STATUS
|
|
EFIAPI
|
|
FSI_FP_GetPosition(
|
|
IN EFI_FILE_PROTOCOL *This,
|
|
IN UINT64 *Position
|
|
)
|
|
{
|
|
EFI_STATUS Status = EFI_DEVICE_ERROR;
|
|
FSI_FILE_PROTOCOL *FSIThis;
|
|
|
|
DBG("FSI_FP %p.GetPosition() ", This);
|
|
|
|
FSIThis = FSI_FROM_FILE_PROTOCOL(This);
|
|
|
|
if (FSIThis->TgtFP != NULL) {
|
|
// do it with target FP
|
|
Status = FSIThis->TgtFP->GetPosition(FSIThis->TgtFP, Position);
|
|
} else if (FSIThis->SrcFP != NULL) {
|
|
// do it with source FP
|
|
Status = FSIThis->SrcFP->GetPosition(FSIThis->SrcFP, Position);
|
|
}
|
|
DBG("= %r, Position=%d\n", Status, Position);
|
|
return Status;
|
|
}
|
|
|
|
/** EFI_FILE_PROTOCOL.GetInfo - Returns information about a file. */
|
|
EFI_STATUS
|
|
EFIAPI
|
|
FSI_FP_GetInfo(
|
|
IN EFI_FILE_PROTOCOL *This,
|
|
IN EFI_GUID *InformationType,
|
|
IN OUT UINTN *BufferSize,
|
|
OUT VOID *Buffer
|
|
)
|
|
{
|
|
EFI_STATUS Status = EFI_DEVICE_ERROR;
|
|
FSI_FILE_PROTOCOL *FSIThis;
|
|
EFI_FILE_INFO *FInfo;
|
|
|
|
DBG("FSI_FP %p.GetInfo(%s, %d, %p) ", This, GuidStr(InformationType), *BufferSize, Buffer);
|
|
|
|
FSIThis = FSI_FROM_FILE_PROTOCOL(This);
|
|
|
|
if (FSIThis->TgtFP != NULL) {
|
|
// do it with target FP
|
|
Status = FSIThis->TgtFP->GetInfo(FSIThis->TgtFP, InformationType, BufferSize, Buffer);
|
|
if (Status == EFI_SUCCESS && CompareGuid(InformationType, &gEfiFileInfoGuid)) {
|
|
FInfo = (EFI_FILE_INFO *)Buffer;
|
|
FSIThis->IsDir = FInfo->Attribute & EFI_FILE_DIRECTORY;
|
|
}
|
|
} else if (FSIThis->SrcFP != NULL) {
|
|
// do it with source FP
|
|
Status = FSIThis->SrcFP->GetInfo(FSIThis->SrcFP, InformationType, BufferSize, Buffer);
|
|
if (Status == EFI_SUCCESS && CompareGuid(InformationType, &gEfiFileInfoGuid)) {
|
|
FInfo = (EFI_FILE_INFO *)Buffer;
|
|
FSIThis->IsDir = FInfo->Attribute & EFI_FILE_DIRECTORY;
|
|
}
|
|
}
|
|
DBG("= %r, BufferSize=%d\n", Status, *BufferSize);
|
|
return Status;
|
|
}
|
|
|
|
/** EFI_FILE_PROTOCOL.SetInfo - Sets information about a file. */
|
|
EFI_STATUS
|
|
EFIAPI
|
|
FSI_FP_SetInfo(
|
|
IN EFI_FILE_PROTOCOL *This,
|
|
IN EFI_GUID *InformationType,
|
|
IN UINTN BufferSize,
|
|
IN VOID *Buffer
|
|
)
|
|
{
|
|
EFI_STATUS Status = EFI_DEVICE_ERROR;
|
|
FSI_FILE_PROTOCOL *FSIThis;
|
|
|
|
DBG("FSI_FP %p.SetInfo(%s, %d, %p) ", This, GuidStr(InformationType), BufferSize, Buffer);
|
|
|
|
FSIThis = FSI_FROM_FILE_PROTOCOL(This);
|
|
|
|
if (FSIThis->TgtFP != NULL) {
|
|
// do it with target FP
|
|
Status = FSIThis->TgtFP->SetInfo(FSIThis->TgtFP, InformationType, BufferSize, Buffer);
|
|
} else if (FSIThis->SrcFP != NULL) {
|
|
// do it with source FP
|
|
Status = FSIThis->SrcFP->SetInfo(FSIThis->SrcFP, InformationType, BufferSize, Buffer);
|
|
}
|
|
DBG("= %r\n", Status);
|
|
return Status;
|
|
}
|
|
|
|
/** EFI_FILE_PROTOCOL.Flush - Flushes all modified data associated with a file to a device. */
|
|
EFI_STATUS
|
|
EFIAPI
|
|
FSI_FP_Flush(
|
|
IN EFI_FILE_PROTOCOL *This
|
|
)
|
|
{
|
|
EFI_STATUS Status = EFI_DEVICE_ERROR;
|
|
FSI_FILE_PROTOCOL *FSIThis;
|
|
|
|
DBG("FSI_FP %p.Flush() ", This);
|
|
|
|
FSIThis = FSI_FROM_FILE_PROTOCOL(This);
|
|
|
|
if (FSIThis->TgtFP != NULL) {
|
|
// do it with target FP
|
|
Status = FSIThis->TgtFP->Flush(FSIThis->TgtFP);
|
|
} else if (FSIThis->SrcFP != NULL) {
|
|
// do it with source FP
|
|
Status = FSIThis->SrcFP->Flush(FSIThis->SrcFP);
|
|
}
|
|
DBG("= %r\n", Status);
|
|
return Status;
|
|
}
|
|
|
|
/** Creates our FSI_FILE_PROTOCOL. */
|
|
FSI_FILE_PROTOCOL*
|
|
EFIAPI
|
|
CreateFSInjectFP(VOID)
|
|
{
|
|
FSI_FILE_PROTOCOL *FSINew;
|
|
|
|
// wrap it into our implementation
|
|
FSINew = AllocateZeroPool(sizeof(FSI_FILE_PROTOCOL));
|
|
if (FSINew == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
FSINew->Signature = FSI_FILE_PROTOCOL_SIGNATURE;
|
|
FSINew->FP.Revision = EFI_FILE_PROTOCOL_REVISION;
|
|
FSINew->FP.Open = FSI_FP_Open;
|
|
FSINew->FP.Close = FSI_FP_Close;
|
|
FSINew->FP.Delete = FSI_FP_Delete;
|
|
FSINew->FP.Read = FSI_FP_Read;
|
|
FSINew->FP.Write = FSI_FP_Write;
|
|
FSINew->FP.GetPosition = FSI_FP_GetPosition;
|
|
FSINew->FP.SetPosition = FSI_FP_SetPosition;
|
|
FSINew->FP.GetInfo = FSI_FP_GetInfo;
|
|
FSINew->FP.SetInfo = FSI_FP_SetInfo;
|
|
FSINew->FP.Flush = FSI_FP_Flush;
|
|
|
|
FSINew->FSI_FS = NULL;
|
|
FSINew->FName = NULL;
|
|
FSINew->IsDir = FALSE;
|
|
FSINew->TgtFP = NULL;
|
|
FSINew->SrcFP = NULL;
|
|
FSINew->FromTgt = FALSE;
|
|
|
|
return FSINew;
|
|
}
|
|
|
|
|
|
|
|
/**************************************************************************************
|
|
* FSI_SIMPLE_FILE_SYSTEM_PROTOCOL - our implementation of EFI_SIMPLE_FILE_SYSTEM_PROTOCOL
|
|
**************************************************************************************/
|
|
|
|
/**
|
|
* EFI_SIMPLE_FILE_SYSTEM_PROTOCOL.OpenVolume implementation.
|
|
*/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
FSI_SFS_OpenVolume(
|
|
IN EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *This,
|
|
OUT EFI_FILE_PROTOCOL **Root
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
FSI_SIMPLE_FILE_SYSTEM_PROTOCOL *FSIThis;
|
|
FSI_FILE_PROTOCOL *FSINew;
|
|
|
|
DBG("FSI_FS %p.OpenVolume() ", This);
|
|
FSIThis = FSI_FROM_SIMPLE_FILE_SYSTEM(This);
|
|
|
|
// do it with target FS
|
|
Status = FSIThis->TgtFS->OpenVolume(FSIThis->TgtFS, Root);
|
|
if (EFI_ERROR(Status)) {
|
|
DBG("TgtFS->OpenVolume Status=%r\n", Status);
|
|
return Status;
|
|
}
|
|
|
|
// wrap it into our implementation
|
|
FSINew = CreateFSInjectFP();
|
|
if (FSINew == NULL) {
|
|
Status = EFI_OUT_OF_RESOURCES;
|
|
DBG("CreateFSInjectFP: %r\n", Status);
|
|
return Status;
|
|
}
|
|
FSINew->FSI_FS = FSIThis; // saving reference to parent FS protocol
|
|
FSINew->FName = AllocateCopyPool(StrSize(L"\\"), L"\\");
|
|
FSINew->TgtFP = *Root;
|
|
FSINew->SrcFP = NULL;
|
|
FSINew->FromTgt = TRUE;
|
|
|
|
// set it as result
|
|
*Root = &FSINew->FP;
|
|
DBG("= %r, returning Root=%p\n", Status, *Root);
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
|
|
/**************************************************************************************
|
|
* FSINJECTION_PROTOCOL
|
|
**************************************************************************************/
|
|
|
|
/**
|
|
* FSINJECTION_PROTOCOL.Install implementation.
|
|
*/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
FSInjectionInstall (
|
|
IN EFI_HANDLE TgtHandle,
|
|
IN CHAR16 *TgtDir,
|
|
IN EFI_HANDLE SrcHandle,
|
|
IN CHAR16 *SrcDir,
|
|
IN FSI_STRING_LIST *Blacklist,
|
|
IN FSI_STRING_LIST *ForceLoadKexts
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *TgtFS;
|
|
EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *SrcFS;
|
|
FSI_SIMPLE_FILE_SYSTEM_PROTOCOL *OurFS;
|
|
|
|
|
|
DBG("FSInjectionInstall ...\n");
|
|
|
|
// get existing target EFI_SIMPLE_FILE_SYSTEM_PROTOCOL
|
|
Status = gBS->OpenProtocol(TgtHandle, &gEfiSimpleFileSystemProtocolGuid, (void **)&TgtFS, gImageHandle, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL);
|
|
if (EFI_ERROR(Status)) {
|
|
DBG("- target OpenProtocol(gEfiSimpleFileSystemProtocolGuid): %r\n", Status);
|
|
return Status;
|
|
}
|
|
|
|
// get existing source EFI_SIMPLE_FILE_SYSTEM_PROTOCOL
|
|
Status = gBS->OpenProtocol(SrcHandle, &gEfiSimpleFileSystemProtocolGuid, (void **)&SrcFS, gImageHandle, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL);
|
|
if (EFI_ERROR(Status)) {
|
|
DBG("- source OpenProtocol(gEfiSimpleFileSystemProtocolGuid): %r\n", Status);
|
|
return Status;
|
|
}
|
|
|
|
// create our implementation
|
|
OurFS = AllocateZeroPool(sizeof(FSI_SIMPLE_FILE_SYSTEM_PROTOCOL));
|
|
if (OurFS == NULL) {
|
|
Status = EFI_OUT_OF_RESOURCES;
|
|
DBG("- AllocateZeroPool(FSI_SIMPLE_FILE_SYSTEM_PROTOCOL): %r\n", Status);
|
|
return Status;
|
|
}
|
|
OurFS->Signature = FSI_SIMPLE_FILE_SYSTEM_PROTOCOL_SIGNATURE;
|
|
OurFS->FS.Revision = EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_REVISION;
|
|
OurFS->FS.OpenVolume = FSI_SFS_OpenVolume;
|
|
OurFS->TgtHandle = TgtHandle;
|
|
OurFS->TgtFS = TgtFS;
|
|
OurFS->TgtDir = AllocateCopyPool(StrSize(TgtDir), TgtDir);
|
|
if (OurFS->TgtDir == NULL) {
|
|
Status = EFI_OUT_OF_RESOURCES;
|
|
DBG("- AllocateCopyPool for TgtDir: %r\n", Status);
|
|
goto ErrorExit;
|
|
}
|
|
OurFS->SrcHandle = SrcHandle;
|
|
OurFS->SrcFS = SrcFS;
|
|
// we can run without SrcDir - no injection, but blocking caches for example
|
|
if (SrcDir != NULL) {
|
|
OurFS->SrcDir = AllocateCopyPool(StrSize(SrcDir), SrcDir);
|
|
if (OurFS->SrcDir == NULL) {
|
|
Status = EFI_OUT_OF_RESOURCES;
|
|
DBG("- AllocateCopyPool for TgtDir or SrcDir: %r\n", Status);
|
|
goto ErrorExit;
|
|
}
|
|
}
|
|
|
|
if (Blacklist != NULL && !IsListEmpty(&Blacklist->List)) {
|
|
OurFS->Blacklist = Blacklist;
|
|
}
|
|
|
|
if (ForceLoadKexts != NULL && !IsListEmpty(&ForceLoadKexts->List)) {
|
|
OurFS->ForceLoadKexts = ForceLoadKexts;
|
|
}
|
|
|
|
// replace existing tagret EFI_SIMPLE_FILE_SYSTEM_PROTOCOL with out implementation
|
|
Status = gBS->ReinstallProtocolInterface(TgtHandle, &gEfiSimpleFileSystemProtocolGuid, TgtFS, &OurFS->FS);
|
|
if (EFI_ERROR(Status)) {
|
|
DBG("- ReinstallProtocolInterface(): %r\n", Status);
|
|
return Status;
|
|
}
|
|
|
|
DBG("- Our FSI_SIMPLE_FILE_SYSTEM_PROTOCOL installed on handle: %X\n", TgtHandle);
|
|
return EFI_SUCCESS;
|
|
|
|
ErrorExit:
|
|
if (OurFS->TgtDir != NULL) FreePool(OurFS->TgtDir);
|
|
if (OurFS->SrcDir != NULL) FreePool(OurFS->SrcDir);
|
|
FreePool(OurFS);
|
|
return Status;
|
|
}
|
|
|
|
|
|
/**
|
|
* FSINJECTION_PROTOCOL.CreateStringList() implementation.
|
|
*/
|
|
FSI_STRING_LIST *
|
|
EFIAPI
|
|
FSInjectionCreateStringList(VOID)
|
|
{
|
|
FSI_STRING_LIST *List;
|
|
|
|
List = AllocateZeroPool(sizeof(FSI_STRING_LIST));
|
|
if (List != NULL) {
|
|
InitializeListHead(&List->List);
|
|
}
|
|
return List;
|
|
}
|
|
|
|
|
|
/**
|
|
* FSINJECTION_PROTOCOL.AddStringToList() implementation.
|
|
*/
|
|
FSI_STRING_LIST *
|
|
EFIAPI
|
|
FSInjectionAddStringToList(FSI_STRING_LIST *List, CHAR16 *String)
|
|
{
|
|
FSI_STRING_LIST_ENTRY *Entry;
|
|
UINTN StringSize;
|
|
|
|
if (List == NULL || String == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
StringSize = StrSize(String); // num of bytes, including null terminator
|
|
|
|
Entry = AllocateZeroPool(sizeof(FSI_STRING_LIST_ENTRY) + StringSize);
|
|
if (Entry != NULL) {
|
|
StrCpyS(Entry->String, StringSize/sizeof(CHAR16), String);
|
|
InsertTailList(&List->List, &Entry->List);
|
|
}
|
|
return Entry != NULL ? List : NULL;
|
|
}
|
|
|
|
|
|
/**
|
|
* Installs FSINJECTION_PROTOCOL to na new handle/
|
|
*/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
InstallFSInjectionProtocol (VOID)
|
|
{
|
|
EFI_STATUS Status;
|
|
FSINJECTION_PROTOCOL *FSInjection;
|
|
EFI_HANDLE FSIHandle;
|
|
|
|
// install FSINJECTION_PROTOCOL to new handle
|
|
FSInjection = AllocateZeroPool(sizeof(FSINJECTION_PROTOCOL));
|
|
if (FSInjection == NULL) {
|
|
DBG("Can not allocate memory for FSINJECTION_PROTOCOL\n");
|
|
return EFI_OUT_OF_RESOURCES;
|
|
}
|
|
|
|
FSInjection->Install = FSInjectionInstall;
|
|
FSInjection->CreateStringList = FSInjectionCreateStringList;
|
|
FSInjection->AddStringToList = FSInjectionAddStringToList;
|
|
FSIHandle = NULL; // install to new handle
|
|
Status = gBS->InstallMultipleProtocolInterfaces(&FSIHandle, &gFSInjectProtocolGuid, FSInjection, NULL);
|
|
if (EFI_ERROR(Status)) {
|
|
DBG("InstallFSInjectionProtocol: error installing FSINJECTION_PROTOCOL, Status = %r\n", Status);
|
|
}
|
|
return Status;
|
|
}
|
|
|
|
|
|
|
|
/**************************************************************************************
|
|
* Entry point
|
|
**************************************************************************************/
|
|
|
|
/**
|
|
* FSInjection entry point. Installs FSINJECTION_PROTOCOL.
|
|
*/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
FSInjectEntrypoint (
|
|
IN EFI_HANDLE ImageHandle,
|
|
IN EFI_SYSTEM_TABLE *SystemTable
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
#if TEST
|
|
FSI_STRING_LIST *Blacklist;
|
|
#endif
|
|
|
|
Status = InstallFSInjectionProtocol();
|
|
if (EFI_ERROR(Status)) {
|
|
return Status;
|
|
}
|
|
|
|
#if TEST
|
|
Blacklist = FSInjectionCreateStringList();
|
|
|
|
// Caution! Do not add this list. If add this list, will see "Kernel cache load error (0xe)". This is just a guideline.
|
|
// by Sherlocks, 2017.11
|
|
|
|
// Installed/createinstallmedia
|
|
//FSInjectionAddStringToList(Blacklist, L"\\System\\Library\\PrelinkedKernels\\prelinkedkernel"); // 10.10+/10.13.4+
|
|
|
|
// Recovery
|
|
//FSInjectionAddStringToList(Blacklist, L"\\com.apple.recovery.boot\\kernelcache"); // 10.7 - 10.10
|
|
//FSInjectionAddStringToList(Blacklist, L"\\com.apple.recovery.boot\\prelinkedkernel"); // 10.11+
|
|
|
|
// BaseSytem/InstallESD
|
|
//FSInjectionAddStringToList(Blacklist, L"\\kernelcache"); // 10.7 - 10.9/(10.7/10.8)
|
|
|
|
// 1st stage - createinstallmedia
|
|
//FSInjectionAddStringToList(Blacklist, L"\\.IABootFiles\\kernelcache"); // 10.9/10.10
|
|
//FSInjectionAddStringToList(Blacklist, L"\\.IABootFiles\\prelinkedkernel"); // 10.11 - 10.13.3
|
|
|
|
// 2nd stage - InstallESD/AppStore/startosinstall
|
|
//FSInjectionAddStringToList(Blacklist, L"\\Mac OS X Install Data\\kernelcache"); // 10.7
|
|
//FSInjectionAddStringToList(Blacklist, L"\\OS X Install Data\\kernelcache"); // 10.8 - 10.10
|
|
//FSInjectionAddStringToList(Blacklist, L"\\OS X Install Data\\prelinkedkernel"); // 10.11
|
|
//FSInjectionAddStringToList(Blacklist, L"\\macOS Install Data\\prelinkedkernel"); // 10.12 - 10.12.3
|
|
//FSInjectionAddStringToList(Blacklist, L"\\macOS Install Data\\Locked Files\\Boot Files\\prelinkedkernel"); // 10.12.4+
|
|
|
|
// 2nd stage - Fusion Drive
|
|
//FSInjectionAddStringToList(Blacklist, L"\\com.apple.boot.R\\System\\Library\\PrelinkedKernels\\prelinkedkernel"); // 10.11
|
|
//FSInjectionAddStringToList(Blacklist, L"\\com.apple.boot.P\\System\\Library\\PrelinkedKernels\\prelinkedkernel"); // 10.11
|
|
//FSInjectionAddStringToList(Blacklist, L"\\com.apple.boot.S\\System\\Library\\PrelinkedKernels\\prelinkedkernel"); // 10.11
|
|
//FSInjectionAddStringToList(Blacklist, L"\\com.apple.boot.R\\prelinkedkernel"); // 10.12+
|
|
//FSInjectionAddStringToList(Blacklist, L"\\com.apple.boot.P\\prelinkedkernel"); // 10.12+
|
|
//FSInjectionAddStringToList(Blacklist, L"\\com.apple.boot.S\\prelinkedkernel"); // 10.12+
|
|
|
|
// NetInstall
|
|
//FSInjectionAddStringToList(Blacklist, L"\\NetInstall macOS High Sierra.nbi\\i386\\x86_64\\kernelcache");
|
|
|
|
|
|
// Block Caches list
|
|
// InstallDVD/Installed
|
|
FSInjectionAddStringToList(Blacklist, L"\\System\\Library\\Caches\\com.apple.kext.caches\\Startup\\Extensions.mkext"); // 10.6
|
|
FSInjectionAddStringToList(Blacklist, L"\\System\\Library\\Extensions.mkext"); // 10.6
|
|
FSInjectionAddStringToList(Blacklist, L"\\System\\Library\\Caches\\com.apple.kext.caches\\Startup\\kernelcache"); // 10.6/10.6 - 10.9
|
|
|
|
Status = InstallTestFSinjection(L"\\Users\\dmazar", L"\\efi\\kext\\10_7", Blacklist, NULL);
|
|
if (EFI_ERROR(Status)) {
|
|
return Status;
|
|
}
|
|
#endif
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|