FileUtils.c

#include "FileUtils.h"
#include <Uefi.h>
#include <Library/UefiLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/BaseLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Protocol/SimpleFileSystem.h>
#include <Protocol/LoadedImage.h>
#include <Guid/FileInfo.h>

EFI_STATUS
ReadFile (
  IN  CHAR16            *FileName,
  OUT VOID              **Buffer,
  OUT UINTN             *FileSize
  )
{
  EFI_STATUS                       Status;
  EFI_LOADED_IMAGE_PROTOCOL        *LoadedImage;
  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL  *FileSystem;
  EFI_FILE_PROTOCOL                *RootDir;
  EFI_FILE_PROTOCOL                *File;

  // Get the loaded image protocol to find our device
  Status = gBS->HandleProtocol (
             gImageHandle,
             &gEfiLoadedImageProtocolGuid,
             (VOID **)&LoadedImage
             );
  if (EFI_ERROR (Status)) return Status;

  // Open the file system on our boot device
  Status = gBS->HandleProtocol (
             LoadedImage->DeviceHandle,
             &gEfiSimpleFileSystemProtocolGuid,
             (VOID **)&FileSystem
             );
  if (EFI_ERROR (Status)) return Status;

  // Open the volume (root directory)
  Status = FileSystem->OpenVolume (FileSystem, &RootDir);
  if (EFI_ERROR (Status)) return Status;

  // Open the file
  Status = RootDir->Open (RootDir, &File, FileName,
                          EFI_FILE_MODE_READ, 0);
  if (EFI_ERROR (Status)) return Status;

  // Get file size
  UINTN      InfoSize = 0;
  EFI_FILE_INFO *FileInfo = NULL;
  Status = File->GetInfo (File, &gEfiFileInfoGuid,
                          &InfoSize, FileInfo);
  if (Status == EFI_BUFFER_TOO_SMALL) {
    FileInfo = AllocatePool (InfoSize);
    Status = File->GetInfo (File, &gEfiFileInfoGuid,
                            &InfoSize, FileInfo);
  }
  if (EFI_ERROR (Status)) {
    File->Close (File);
    return Status;
  }
  *FileSize = (UINTN) FileInfo->FileSize;
  FreePool (FileInfo);

  // Read the whole file
  *Buffer = AllocatePool (*FileSize);
  if (*Buffer == NULL) {
    File->Close (File);
    return EFI_OUT_OF_RESOURCES;
  }
  UINTN ReadSize = *FileSize;
  Status = File->Read (File, &ReadSize, *Buffer);
  File->Close (File);

  if (EFI_ERROR (Status)) {
    FreePool (*Buffer);
    *Buffer = NULL;
  }
  return Status;
}

/**
  Enumerate the entries in a directory, collecting matching names into an array.

  Shared helper for ListDirectories() and ListFiles().

  @param[in]  DirName        Full path of the directory to enumerate (or L"\\" for root).
  @param[in]  WantDirs       TRUE to collect subdirectories, FALSE to collect files.
  @param[out] Names          Array of names (NULL-terminated CHAR16* each). Caller frees
                             each entry and the array with FreePool().
  @param[out] Count          Number of names collected.

  @retval EFI_SUCCESS        Names populated.
  @retval other              Failure from opening/reading the directory.
**/
EFI_STATUS
ListDirEntries (
  IN  CHAR16            *DirName,
  IN  BOOLEAN           WantDirs,
  OUT CHAR16            ***Names,
  OUT UINTN             *Count
  )
{
  EFI_STATUS                       Status;
  EFI_LOADED_IMAGE_PROTOCOL        *LoadedImage;
  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL  *FileSystem;
  EFI_FILE_PROTOCOL                *RootDir;
  EFI_FILE_PROTOCOL                *Dir;
  EFI_FILE_INFO                    *FileInfo;
  UINTN                            InfoSize;
  BOOLEAN                          NoMore;

  *Names = NULL;
  *Count = 0;

  // Get the loaded image protocol to find our device
  Status = gBS->HandleProtocol (
             gImageHandle,
             &gEfiLoadedImageProtocolGuid,
             (VOID **)&LoadedImage
             );
  if (EFI_ERROR (Status)) return Status;

  // Open the file system on our boot device
  Status = gBS->HandleProtocol (
             LoadedImage->DeviceHandle,
             &gEfiSimpleFileSystemProtocolGuid,
             (VOID **)&FileSystem
             );
  if (EFI_ERROR (Status)) return Status;

  // Open the volume (root directory)
  Status = FileSystem->OpenVolume (FileSystem, &RootDir);
  if (EFI_ERROR (Status)) return Status;

  // Open the target directory
  Status = RootDir->Open (RootDir, &Dir, DirName, EFI_FILE_MODE_READ, 0);
  RootDir->Close (RootDir);
  if (EFI_ERROR (Status)) return Status;

  // Loop reading entries until end-of-directory
  InfoSize = 0;
  FileInfo = NULL;
  NoMore  = FALSE;

  while (!NoMore) {
    EFI_FILE_INFO *CurInfo = NULL;
    UINTN         CurSize  = 0;

    // Read one entry. Start small; on EFI_BUFFER_TOO_SMALL the driver reports the
    // required size in InfoSize and does NOT advance the position, so grow and retry.
    InfoSize = 0;
    do {
      if (CurInfo != NULL) {
        FreePool (CurInfo);
        CurInfo = NULL;
      }
      if (InfoSize == 0) {
        CurSize = SIZE_OF_EFI_FILE_INFO + 256;
      } else {
        CurSize = InfoSize;
      }
      CurInfo = AllocatePool (CurSize);
      if (CurInfo == NULL) {
        Dir->Close (Dir);
        return EFI_OUT_OF_RESOURCES;
      }
      InfoSize = CurSize;
      Status   = Dir->Read (Dir, &InfoSize, CurInfo);
    } while (Status == EFI_BUFFER_TOO_SMALL);

    if (EFI_ERROR (Status)) {
      FreePool (CurInfo);
      Dir->Close (Dir);
      return Status;
    }

    // End of directory reached
    if (InfoSize == 0) {
      FreePool (CurInfo);
      NoMore = TRUE;
      break;
    }

    // Skip "." and ".."
    if (StrCmp (CurInfo->FileName, L".") != 0 &&
        StrCmp (CurInfo->FileName, L"..") != 0) {
      BOOLEAN IsDir = ((CurInfo->Attribute & EFI_FILE_DIRECTORY) != 0);
      if (IsDir == WantDirs) {
        // Grow the Names array
        UINTN Len = StrLen (CurInfo->FileName);
        *Names = ReallocatePool (*Count * sizeof (CHAR16 *),
                                (*Count + 1) * sizeof (CHAR16 *),
                                *Names);
        if (*Names == NULL) {
          FreePool (CurInfo);
          Dir->Close (Dir);
          return EFI_OUT_OF_RESOURCES;
        }
        (*Names)[*Count] = AllocateCopyPool ((Len + 1) * sizeof (CHAR16),
                                             CurInfo->FileName);
        if ((*Names)[*Count] == NULL) {
          FreePool (CurInfo);
          Dir->Close (Dir);
          return EFI_OUT_OF_RESOURCES;
        }
        (*Count)++;
      }
    }
    FreePool (CurInfo);
  }

  Dir->Close (Dir);
  return EFI_SUCCESS;
}
/**
  List the subdirectory names directly under a base directory.

  @param[in]  DirName        Full path of the base directory (e.g. L"\EFI" or L"\").
  @param[out] Names          Array of subdirectory names. Caller frees each entry
                             and the array with FreePool().
  @param[out] Count          Number of subdirectories found.

  @retval EFI_SUCCESS        Names populated.
  @retval other              Failure from opening/reading the directory.
**/
EFI_STATUS
ListDirectories (
  IN  CHAR16            *DirName,
  OUT CHAR16            ***Names,
  OUT UINTN             *Count
  )
{
  return ListDirEntries (DirName, TRUE, Names, Count);
}

/**
  List the file names directly under a base directory (excluding subdirectories).

  @param[in]  DirName        Full path of the base directory (e.g. L"\EFI" or L"\").
  @param[out] Names          Array of file names. Caller frees each entry
                             and the array with FreePool().
  @param[out] Count          Number of files found.

  @retval EFI_SUCCESS        Names populated.
  @retval other              Failure from opening/reading the directory.
**/
EFI_STATUS
ListFiles (
  IN  CHAR16            *DirName,
  OUT CHAR16            ***Names,
  OUT UINTN             *Count
  )
{
  return ListDirEntries (DirName, FALSE, Names, Count);
}

/**
  Create a directory under a base directory.

  @param[in]  DirName        Full path of the directory to create, including the new
                             directory's name (e.g. L"\EFI\notes" or L"\mydir").
                             All ancestors must already exist.

  @retval EFI_SUCCESS        Directory created (or already existed).
  @retval other              Failure from opening/creating the directory.
**/
EFI_STATUS
CreateDirectory (
  IN  CHAR16            *DirName
  )
{
  EFI_STATUS                       Status;
  EFI_LOADED_IMAGE_PROTOCOL        *LoadedImage;
  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL  *FileSystem;
  EFI_FILE_PROTOCOL                *RootDir;
  EFI_FILE_PROTOCOL                *Dir;

  // Get the loaded image protocol to find our device
  Status = gBS->HandleProtocol (
             gImageHandle,
             &gEfiLoadedImageProtocolGuid,
             (VOID **)&LoadedImage
             );
  if (EFI_ERROR (Status)) return Status;

  // Open the file system on our boot device
  Status = gBS->HandleProtocol (
             LoadedImage->DeviceHandle,
             &gEfiSimpleFileSystemProtocolGuid,
             (VOID **)&FileSystem
             );
  if (EFI_ERROR (Status)) return Status;

  // Open the volume (root directory)
  Status = FileSystem->OpenVolume (FileSystem, &RootDir);
  if (EFI_ERROR (Status)) return Status;

  // Open (create if missing) the directory
  Status = RootDir->Open (RootDir, &Dir, DirName,
                          EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE | EFI_FILE_MODE_CREATE,
                          EFI_FILE_DIRECTORY);
  RootDir->Close (RootDir);
  if (EFI_ERROR (Status)) return Status;

  Dir->Close (Dir);
  return EFI_SUCCESS;
}

/**
  Create (or overwrite) a file and write data to it.

  @param[in]  FileName       Full path of the file to write (e.g. L"\notes.txt").
  @param[in]  Buffer         Data to write.
  @param[in]  BufferSize     Number of bytes in Buffer.

  @retval EFI_SUCCESS        File written.
  @retval other              Failure from opening/creating the file or writing.
**/
EFI_STATUS
WriteFile (
  IN  CHAR16            *FileName,
  IN  VOID              *Buffer,
  IN  UINTN             BufferSize
  )
{
  EFI_STATUS                       Status;
  EFI_LOADED_IMAGE_PROTOCOL        *LoadedImage;
  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL  *FileSystem;
  EFI_FILE_PROTOCOL                *RootDir;
  EFI_FILE_PROTOCOL                *File;
  UINTN                            WriteSize;

  // Get the loaded image protocol to find our device
  Status = gBS->HandleProtocol (
             gImageHandle,
             &gEfiLoadedImageProtocolGuid,
             (VOID **)&LoadedImage
             );
  if (EFI_ERROR (Status)) return Status;

  // Open the file system on our boot device
  Status = gBS->HandleProtocol (
             LoadedImage->DeviceHandle,
             &gEfiSimpleFileSystemProtocolGuid,
             (VOID **)&FileSystem
             );
  if (EFI_ERROR (Status)) return Status;

  // Open the volume (root directory)
  Status = FileSystem->OpenVolume (FileSystem, &RootDir);
  if (EFI_ERROR (Status)) return Status;

  // Open (create/truncate) the file for writing
  Status = RootDir->Open (RootDir, &File, FileName,
                          EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE | EFI_FILE_MODE_CREATE,
                          0);
  RootDir->Close (RootDir);
  if (EFI_ERROR (Status)) return Status;

  // Write the data
  WriteSize = BufferSize;
  Status = File->Write (File, &WriteSize, Buffer);
  File->Close (File);

  if (EFI_ERROR (Status)) return Status;
  if (WriteSize != BufferSize) return EFI_DEVICE_ERROR;

  return EFI_SUCCESS;
}

/**
  Delete a file at the given path.

  @param[in]  FilePath  Full path of the file to delete (e.g. L"\notes.txt").

  @retval EFI_SUCCESS   File deleted.
  @retval other         Failure from opening/deleting the file.
**/
EFI_STATUS
DeleteFile (
  IN  CHAR16  *FilePath
  )
{
  EFI_STATUS                       Status;
  EFI_LOADED_IMAGE_PROTOCOL        *LoadedImage;
  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL  *FileSystem;
  EFI_FILE_PROTOCOL                *RootDir;
  EFI_FILE_PROTOCOL                *File;

  Status = gBS->HandleProtocol (
                 gImageHandle,
                 &gEfiLoadedImageProtocolGuid,
                 (VOID **)&LoadedImage
                 );
  if (EFI_ERROR (Status)) return Status;

  Status = gBS->HandleProtocol (
                 LoadedImage->DeviceHandle,
                 &gEfiSimpleFileSystemProtocolGuid,
                 (VOID **)&FileSystem
                 );
  if (EFI_ERROR (Status)) return Status;

  Status = FileSystem->OpenVolume (FileSystem, &RootDir);
  if (EFI_ERROR (Status)) return Status;

  Status = RootDir->Open (RootDir, &File, FilePath,
                          EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE | EFI_FILE_MODE_CREATE,
                          0);
  if (EFI_ERROR (Status)) {
    RootDir->Close (RootDir);
    return Status;
  }

  Status = File->Delete (File);
  RootDir->Close (RootDir);
  return Status;
}

/**
  Validate a filename for FAT32 compatibility.

  Rules enforced:
    - Non-NULL, non-empty
    - Length <= 255 characters
    - No illegal characters: " * / \ : ? < > |
    - No trailing dots or spaces

  @param[in]  FileName  The filename string to validate.

  @retval TRUE   The filename is valid.
  @retval FALSE  The filename is invalid.
**/
bool
IsValidFileName (
  IN  CHAR16  *FileName
  )
{
  UINTN Len;
  UINTN I;

  if (FileName == NULL) {
    return false;
  }

  Len = StrLen (FileName);
  if (Len == 0 || Len > 255) {
    return false;
  }

  if (FileName[Len - 1] == L'.' || FileName[Len - 1] == L' ') {
    return false;
  }

  for (I = 0; I < Len; I++) {
    CHAR16 Ch = FileName[I];
    if (Ch == L'"' || Ch == L'*' || Ch == L'/' || Ch == L'\\' ||
        Ch == L':' || Ch == L'?'  || Ch == L'<' || Ch == L'>' ||
        Ch == L'|') {
      return false;
    }
  }

  return true;
}